-
-
- {saveError &&
{saveError}
}
+
+
+
+ Up to
+ {' '}
+ {MEMBER_PROFILE_LIMITS.fullName}
+ {' '}
+ characters.
+
+
+
+
+
+ Up to
+ {' '}
+ {MEMBER_PROFILE_LIMITS.phoneNumber}
+ {' '}
+ characters.
+
+
+ {saveError && (
+
{saveError}
+ )}
);
diff --git a/src/services/account/accountService.test.ts b/src/services/account/accountService.test.ts
new file mode 100644
index 00000000..2d9b6d46
--- /dev/null
+++ b/src/services/account/accountService.test.ts
@@ -0,0 +1,96 @@
+/* eslint-env jest */
+
+import {
+ doc, serverTimestamp, updateDoc,
+} from 'firebase/firestore';
+import { getFunctions, httpsCallable } from 'firebase/functions';
+import {
+ ensureMyProfile,
+ updateMyProfile,
+ validateMemberProfileFields,
+} from './accountService';
+
+jest.mock('firebase/firestore', () => ({
+ doc: jest.fn(() => ({ path: 'members/synthetic-user' })),
+ getDoc: jest.fn(),
+ updateDoc: jest.fn(),
+ serverTimestamp: jest.fn(() => ({ __serverTimestamp: true })),
+}));
+
+jest.mock('firebase/functions', () => ({
+ getFunctions: jest.fn(() => ({ name: 'synthetic-functions' })),
+ httpsCallable: jest.fn(),
+}));
+
+const firestore = { name: 'synthetic-firestore' } as any;
+const app = { name: 'synthetic-app' } as any;
+
+describe('account profile service', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ (doc as jest.Mock).mockReturnValue({ path: 'members/synthetic-user' });
+ (serverTimestamp as jest.Mock).mockReturnValue({ __serverTimestamp: true });
+ (getFunctions as jest.Mock).mockReturnValue({ name: 'synthetic-functions' });
+ (updateDoc as jest.Mock).mockResolvedValue(undefined);
+ });
+
+ test('calls the profile bootstrap with an empty request and returns uniform readiness', async () => {
+ const callable = jest.fn().mockResolvedValue({ data: { ready: true } });
+ (httpsCallable as jest.Mock).mockReturnValue(callable);
+
+ await expect(ensureMyProfile(app)).resolves.toEqual({ ready: true });
+
+ expect(getFunctions).toHaveBeenCalledWith(app);
+ expect(httpsCallable).toHaveBeenCalledWith(
+ { name: 'synthetic-functions' },
+ 'ensureMemberProfile',
+ );
+ expect(callable).toHaveBeenCalledWith({});
+ });
+
+ test('writes only normalized name, phone, and a server timestamp', async () => {
+ await updateMyProfile(firestore, 'synthetic-user', {
+ fullName: ' Synthetic Member ',
+ phoneNumber: ' 555-0100 ',
+ });
+
+ expect(doc).toHaveBeenCalledWith(firestore, 'members', 'synthetic-user');
+ expect(updateDoc).toHaveBeenCalledWith(
+ { path: 'members/synthetic-user' },
+ {
+ fullName: 'Synthetic Member',
+ phoneNumber: '555-0100',
+ updatedAt: { __serverTimestamp: true },
+ },
+ );
+ expect(serverTimestamp).toHaveBeenCalledTimes(1);
+ });
+
+ test('accepts the exact 200 and 40 unit boundaries, including emoji', async () => {
+ const fullName = '🏃'.repeat(100);
+ const phoneNumber = '📞'.repeat(20);
+
+ expect(validateMemberProfileFields({ fullName, phoneNumber })).toEqual({
+ valid: true,
+ fields: { fullName, phoneNumber },
+ });
+ await expect(updateMyProfile(
+ firestore,
+ 'synthetic-user',
+ { fullName, phoneNumber },
+ )).resolves.toBeUndefined();
+ expect(updateDoc).toHaveBeenCalledTimes(1);
+ });
+
+ test.each([
+ ['an ASCII name', { fullName: 'n'.repeat(201), phoneNumber: '' }, 'Full name'],
+ ['an emoji name', { fullName: '🏃'.repeat(101), phoneNumber: '' }, 'Full name'],
+ ['an ASCII phone', { fullName: '', phoneNumber: '1'.repeat(41) }, 'Phone'],
+ ['an emoji phone', { fullName: '', phoneNumber: '📞'.repeat(21) }, 'Phone'],
+ ])('rejects %s over the Rules limit before Firestore', async (_label, fields, field) => {
+ await expect(updateMyProfile(firestore, 'synthetic-user', fields))
+ .rejects.toThrow(`${field} must be`);
+ expect(updateDoc).not.toHaveBeenCalled();
+ expect(serverTimestamp).not.toHaveBeenCalled();
+ });
+});
diff --git a/src/services/account/accountService.ts b/src/services/account/accountService.ts
index 07ba6723..40f12134 100644
--- a/src/services/account/accountService.ts
+++ b/src/services/account/accountService.ts
@@ -5,6 +5,46 @@ import { FirebaseApp } from 'firebase/app';
import { getFunctions, httpsCallable } from 'firebase/functions';
import { Member, MemberEditableFields } from '../../types/member';
+export const MEMBER_PROFILE_LIMITS = {
+ fullName: 200,
+ phoneNumber: 40,
+} as const;
+
+export interface ValidatedMemberProfileFields {
+ fullName: string;
+ phoneNumber: string;
+}
+
+export type MemberProfileValidation =
+ | { valid: true; fields: ValidatedMemberProfileFields }
+ | { valid: false; message: string };
+
+export function validateMemberProfileFields(
+ fields: MemberEditableFields,
+): MemberProfileValidation {
+ const fullName = fields.fullName.trim();
+ const phoneNumber = fields.phoneNumber.trim();
+ if (fullName.length > MEMBER_PROFILE_LIMITS.fullName) {
+ return { valid: false, message: 'Full name must be 200 characters or fewer.' };
+ }
+ if (phoneNumber.length > MEMBER_PROFILE_LIMITS.phoneNumber) {
+ return { valid: false, message: 'Phone must be 40 characters or fewer.' };
+ }
+ return { valid: true, fields: { fullName, phoneNumber } };
+}
+
+export async function ensureMyProfile(
+ app: FirebaseApp,
+): Promise<{ ready: true }> {
+ const functions = getFunctions(app);
+ const callable = httpsCallable
, { ready: true }>(
+ functions,
+ 'ensureMemberProfile',
+ );
+ const result = await callable({});
+ return result.data;
+}
+
export async function getMyProfile(db: Firestore, uid: string): Promise {
const ref = doc(db, 'members', uid);
const snap = await getDoc(ref);
@@ -29,10 +69,14 @@ export async function updateMyProfile(
uid: string,
fields: MemberEditableFields,
): Promise {
+ const validation = validateMemberProfileFields(fields);
+ if (!validation.valid) throw new Error(validation.message);
+ const { fullName, phoneNumber } = validation.fields;
+
const ref = doc(db, 'members', uid);
await updateDoc(ref, {
- fullName: fields.fullName.trim() || null,
- phoneNumber: fields.phoneNumber.trim() || '',
+ fullName: fullName || null,
+ phoneNumber,
updatedAt: serverTimestamp(),
});
}
diff --git a/tests/firestore-rules/members.test.js b/tests/firestore-rules/members.test.js
index 3c407971..465571dd 100644
--- a/tests/firestore-rules/members.test.js
+++ b/tests/firestore-rules/members.test.js
@@ -97,6 +97,38 @@ describe('members collection', () => {
}));
});
+ test('profile Unicode boundaries match the browser validator', async () => {
+ await seed('members/u1', SAMPLE_MEMBER);
+ const me = await db({ uid: 'u1', role: 'unverified' });
+
+ await assertSucceeds(me.doc('members/u1').update({
+ // Firestore Rules and browser maxlength both count these astral
+ // symbols as two UTF-16 units. Keep the client validation aligned
+ // with the behavior proven by this emulator suite.
+ fullName: '🏃'.repeat(100),
+ phoneNumber: '📞'.repeat(20),
+ updatedAt: new Date(),
+ }));
+ });
+
+ test.each([
+ ['a Unicode name over the 200-unit limit', {
+ fullName: '🏃'.repeat(101),
+ phoneNumber: '',
+ }],
+ ['a Unicode phone over the 40-unit limit', {
+ fullName: '',
+ phoneNumber: '📞'.repeat(21),
+ }],
+ ])('user CANNOT set %s', async (_label, fields) => {
+ await seed('members/u1', SAMPLE_MEMBER);
+ const me = await db({ uid: 'u1', role: 'unverified' });
+ await assertFails(me.doc('members/u1').update({
+ ...fields,
+ updatedAt: new Date(),
+ }));
+ });
+
test('user CANNOT update a missing profile document', async () => {
const me = await db({ uid: 'u1', role: 'unverified' });
await assertFails(me.doc('members/u1').update({