@battle-racing/br-common-lib 4.3.0 → 4.5.0

package/src/domains/user/User.schema.ts

@@ -7,12 +7,27 @@ export const userTypeSchema = z.enum(USER_TYPE);
 export const PHONE_REGEX = /^([+]?[\\s0-9]+)?(\\d{3}|[(]?[0-9]+[)])?([-]?[\\s]?[0-9])+$/;
 const MIN_PASSWORD_LENGTH = 6;
 
+export const emailOrPhoneSchema = z
+  .string()
+  .min(1, 'Email or phone is required')
+  .refine(
+    (val) => {
+      const isEmail = z.email().safeParse(val).success;
+      const isPhone = PHONE_REGEX.test(val);
+      return isEmail || isPhone;
+    },
+    { message: 'Must be a valid email or phone number' },
+  );
+
 const baseUserObj = z.object({
   id: z.uuidv4(),
 
-  email: z.email().toLowerCase().optional(),
+  name: z.string(),
+  lastName: z.string(),
+
+  email: z.email().toLowerCase().optional().nullable(),
 
-  phoneNumber: z.string().regex(PHONE_REGEX, 'Invalid phone number format').optional(),
+  phoneNumber: z.string().regex(PHONE_REGEX, 'Invalid phone number format').optional().nullable(),
 
   // --- ACCESS CONTROL ---
   role: userRoleSchema,
@@ -34,19 +49,52 @@ export const userSchema = baseUserObj.refine((data) => data.email || data.phoneN
   path: ['email', 'phoneNumber'],
 });
 
+/**
+ * The schema for the user returned on login
+ */
+export const authUserSchema = baseUserObj.extend({
+  authToken: z.string(),
+});
+
 export const userWithPasswordSchema = userSchema.and(
   z.object({
     password: z.string().min(MIN_PASSWORD_LENGTH),
   }),
 );
 
+export const userInitialRegistrationSchema = z.object({
+  emailOrPhone: emailOrPhoneSchema,
+  password: z.string().min(MIN_PASSWORD_LENGTH, `Password must be at least ${MIN_PASSWORD_LENGTH} characters`),
+});
+
+export const userVerifySchema = z.object({
+  emailOrPhone: emailOrPhoneSchema,
+  code: z.string().min(6, 'Code must be at least 6 characters').max(10, 'Code is too long'),
+});
+
+export const userCompleteProfileSchema = baseUserObj
+  .pick({
+    name: true,
+  })
+  .extend({
+    lastName: z.string().optional(),
+    nickname: z.string().min(2),
+    birthDate: z.coerce.date(),
+    waiverSignature: z.boolean().refine((val) => val === true, {
+      message: 'You must accept the waiver signature',
+    }),
+    teamName: z.string().optional(),
+  });
+
+// Deprecated in favor of multi-step registration
 export const userRegistrationInputSchema = baseUserObj
   .pick({
+    name: true,
+    lastName: true,
     email: true,
     phoneNumber: true,
   })
   .extend({
-    name: z.string().optional(),
     password: z.string().min(6),
     nickname: z.string().min(2),
     birthDate: z.coerce.date(),
@@ -57,16 +105,6 @@ export const userRegistrationInputSchema = baseUserObj
   });
 
 export const userLoginInputSchema = z.object({
-  emailOrPhone: z
-    .string()
-    .min(1, 'Email or phone is required')
-    .refine(
-      (val) => {
-        const isEmail = z.email().safeParse(val).success;
-        const isPhone = PHONE_REGEX.test(val);
-        return isEmail || isPhone;
-      },
-      { message: 'Must be a valid email or phone number' },
-    ),
+  emailOrPhone: emailOrPhoneSchema,
   password: z.string().min(MIN_PASSWORD_LENGTH, `Password must be at least ${MIN_PASSWORD_LENGTH} characters`),
 });

package/src/domains/user/User.types.ts

@@ -1,6 +1,20 @@
 import { z } from 'zod';
-import { userSchema, userTypeSchema, userWithPasswordSchema } from './User.schema';
+import {
+  userSchema,
+  userTypeSchema,
+  userWithPasswordSchema,
+  userInitialRegistrationSchema,
+  userVerifySchema,
+  userCompleteProfileSchema,
+  userLoginInputSchema,
+  authUserSchema,
+} from './User.schema';
 
 export type UserType = z.infer<typeof userTypeSchema>;
 export type User = z.infer<typeof userSchema>;
 export type UserWithPassword = z.infer<typeof userWithPasswordSchema>;
+export type AuthUser = z.infer<typeof authUserSchema>;
+export type UserInitialRegistration = z.infer<typeof userInitialRegistrationSchema>;
+export type UserVerify = z.infer<typeof userVerifySchema>;
+export type UserCompleteProfile = z.infer<typeof userCompleteProfileSchema>;
+export type UserLogin = z.infer<typeof userLoginInputSchema>;