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

package/src/__deprecated__/constants/index.ts

@@ -0,0 +1,9 @@
+export * from './checkpoint-type';
+export * from './hardware';
+export * from './kart-status';
+export * from './module-name';
+export * from './payment-provider';
+export * from './payment-status';
+export * from './permission';
+export * from './user-role';
+export * from './racing-team-role';

package/src/__deprecated__/types/checkpoint/CheckpointType.ts

@@ -1,4 +1,4 @@
-import { CHECKPOINT_TYPE } from '../../../constants';
+import { CHECKPOINT_TYPE } from '../../constants';
 import type { ObjectValues } from '../utils';
 
 export type CheckpointType = ObjectValues<typeof CHECKPOINT_TYPE>;

package/src/__deprecated__/types/damage/DamageName.ts

@@ -1,4 +1,4 @@
-import { DAMAGE_EFFECT } from '../../../constants/hardware/damage';
+import { DAMAGE_EFFECT } from '../../constants/hardware/damage';
 import { ObjectValues } from '../utils';
 
 export type DamageEffectName = ObjectValues<typeof DAMAGE_EFFECT>;

package/src/__deprecated__/types/hardware/ModuleName.ts

@@ -1,4 +1,4 @@
-import { MODULE_NAME } from '../../../constants';
+import { MODULE_NAME } from '../../constants';
 import type { ObjectValues } from '../utils';
 
 export type ModuleName = ObjectValues<typeof MODULE_NAME>;

package/src/__deprecated__/types/hardware/flag/FlagMediaName.ts

@@ -1,4 +1,4 @@
-import { FLAG_MEDIA_NAME } from '../../../../constants/hardware/flag-media-name';
+import { FLAG_MEDIA_NAME } from '../../../constants/hardware/flag-media-name';
 import type { ObjectValues } from '../../utils';
 
 export type FlagMediaName = ObjectValues<typeof FLAG_MEDIA_NAME> | number;

package/src/__deprecated__/types/hardware/flag/FlagStatus.ts

@@ -1,4 +1,4 @@
-import { FLAG_STATUS } from '../../../../constants';
+import { FLAG_STATUS } from '../../../constants';
 import type { ObjectValues } from '../../utils';
 
 export type FlagStatus = ObjectValues<typeof FLAG_STATUS>;

package/src/__deprecated__/types/hardware/lights/LightsEffect.ts

@@ -1,4 +1,4 @@
-import { LIGHTS_EFFECT } from '../../../../constants';
+import { LIGHTS_EFFECT } from '../../../constants';
 import type { ObjectValues } from '../../utils';
 
 export type LightsEffect = ObjectValues<typeof LIGHTS_EFFECT>;

package/src/__deprecated__/types/hardware/rgb/RGBStatus.ts

@@ -1,4 +1,4 @@
-import { RGB_STATUS } from '../../../../constants/hardware/rgb-status';
+import { RGB_STATUS } from '../../../constants/hardware/rgb-status';
 import type { ObjectValues } from '../../utils';
 
 export type RGBStatus = ObjectValues<typeof RGB_STATUS>;

package/src/__deprecated__/types/hardware/screen/ScreenFinishViewInput.ts

@@ -1,4 +1,4 @@
-import { KART_FINAL_STATE } from '../../../../constants';
+import { KART_FINAL_STATE } from '../../../constants';
 import { ObjectValues } from '../../utils';
 import { ScreenCurrentTotal } from './ScreenViewBaseConfig';
 

package/src/__deprecated__/types/hardware/screen/ScreenStatus.ts

@@ -1,4 +1,4 @@
-import { SCREEN_STATUS } from '../../../../constants';
+import { SCREEN_STATUS } from '../../../constants';
 import { ObjectValues } from '../../utils';
 
 export type ScreenStatus = ObjectValues<typeof SCREEN_STATUS>;

package/src/__deprecated__/types/hardware/screen/ScreenView.ts

@@ -1,4 +1,4 @@
-import { SCREEN_VIEW } from '../../../../constants';
+import { SCREEN_VIEW } from '../../../constants';
 import { ObjectValues } from '../../utils';
 
 export type ScreenView = ObjectValues<typeof SCREEN_VIEW>;

package/src/__deprecated__/types/hardware/speed/SpeedStatus.ts

@@ -1,4 +1,4 @@
-import { SPEED_STATUS } from '../../../../constants/hardware';
+import { SPEED_STATUS } from '../../../constants/hardware';
 import { ObjectValues } from '../../utils';
 
 export type SpeedStatus = ObjectValues<typeof SPEED_STATUS>;

package/src/__deprecated__/types/kart/KartStatus.ts

@@ -1,4 +1,4 @@
-import { KART_STATUS } from '../../../constants';
+import { KART_STATUS } from '../../constants';
 import type { ObjectValues } from '../utils';
 
 export type KartStatus = ObjectValues<typeof KART_STATUS>;

package/src/__deprecated__/types/racingTeam/RacingTeamMembership.schema.ts

@@ -1,7 +1,7 @@
 // libs/common/src/schemas/racing-team-membership.ts
 
 import { z } from 'zod';
-import { RACING_TEAM_ROLE } from '../../../constants';
+import { RACING_TEAM_ROLE } from '../../constants';
 
 export const joinRequestSchema = z.object({
   id: z.string(),

package/src/__deprecated__/types/role/Permission.ts

@@ -1,4 +1,4 @@
-import { PERMISSION } from '../../../constants';
+import { PERMISSION } from '../../constants';
 import type { ObjectValues } from '../utils';
 
 export type Permission = ObjectValues<typeof PERMISSION>;

package/src/__deprecated__/types/role/UserRole.ts

@@ -1,4 +1,4 @@
-import { USER_ROLE } from '../../../constants';
+import { USER_ROLE } from '../../constants';
 import type { ObjectValues } from '../utils';
 
 export type UserRole = ObjectValues<typeof USER_ROLE>;

package/src/__deprecated__/types/ticketing/GameTurn.schema.ts

@@ -32,9 +32,9 @@ export const GameTurnCheckSchema = z.enum([
 export const GameTurnSchema = z.object({
   id: z.string(),
   purchaseId: z.string(),
-  leaderUsername: z.string(),
+  leaderPlayerId: z.string(),
   gameTickets: z.array(z.string()),
-  usernames: z.array(z.string()),
+  playerIds: z.array(z.string()),
   status: GameTurnStatusSchema,
   tasks: z.array(GameTurnTaskSchema),
   createdAt: z.date(),

package/src/__deprecated__/types/ticketing/PaymentProvider.ts

@@ -1,4 +1,4 @@
-import { PAYMENT_PROVIDERS, PAYMENT_STATUSES } from '../../../constants';
+import { PAYMENT_PROVIDERS, PAYMENT_STATUSES } from '../../constants';
 
 export type PaymentProviderName = (typeof PAYMENT_PROVIDERS)[keyof typeof PAYMENT_PROVIDERS];
 

package/src/__deprecated__/types/ticketing/ticketing.schemas.ts

@@ -29,7 +29,6 @@ export const GameTicketSchema = z.object({
   id: z.string(),
   purchaseId: z.string(),
   gameTurnId: z.string(),
-  ownerUsername: z.string(),
   userType: TicketUserTypeSchema,
   status: GameTicketStatusSchema,
   type: TicketTypeSchema.default(TICKET_TYPE.RACE),

package/src/__deprecated__/types/user/user.schema.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { USER_ROLE } from '../../../constants/user-role';
+import { USER_ROLE } from '../../constants/user-role';
 import { UserTypeSchema } from './user-type.schema';
 
 export const UserRoleSchema = z.enum([USER_ROLE.SUPER_ADMIN, USER_ROLE.PLAYER, USER_ROLE.OPERATOR] as const);

package/src/domains/damage/Damage.schema.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
-import { flagMediaNameSchema, kartEffectSchema } from '../hardware';
+import { flagMediaNameSchema } from '../hardware/flag/Flag.schema';
+import { kartEffectSchema } from '../hardware/kart-effect/KartEffect.schema';
 import { soundNameSchema } from '../sounds';
 import { DAMAGE_EFFECT, DAMAGE_TARGET } from './Damage.const';
 

package/src/domains/hardware/KartHardwareState.schema.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
-import { checkpointTypeSchema } from '../checkpoint';
-import { flagStatusSchema } from './flag';
-import { rgbStatusSchema } from './rgb';
-import { screenStatusSchema } from './screen';
-import { speedStatusSchema } from './speed';
+import { checkpointTypeSchema } from '../checkpoint/Checkpoint.schema';
+import { flagStatusSchema } from './flag/Flag.schema';
+import { rgbStatusSchema } from './rgb/RGB.schema';
+import { screenStatusSchema } from './screen/Screen.schema';
+import { speedStatusSchema } from './speed/Speed.schema';
 
 export const kartHardwareStateSchema = z.object({
   speed: z

package/src/domains/hardware/screen/Screen.schema.ts

@@ -1,10 +1,9 @@
 import { z } from 'zod';
 
-import { damageEffectNameSchema } from '../../damage';
-import { kartHardwareStateSchema } from '../../hardware';
+import { damageEffectNameSchema } from '../../damage/Damage.schema';
 import { powerUpNameSchema } from '../../powerUp/PowerUpAttributes.schema';
 import { SCREEN_STATUS, SCREEN_VIEW } from './Screen.const';
-import { KART_FINAL_STATE } from '../../kart';
+import { KART_FINAL_STATE } from '../../kart/Kart.const';
 
 export const screenStatusSchema = z.enum(SCREEN_STATUS);
 export const screenViewSchema = z.enum(SCREEN_VIEW);
@@ -79,10 +78,6 @@ export const screenFinishViewInputSchema = z.object({
   finalState: kartFinalStateSchema.optional(),
 });
 
-export const screenDebugViewInputSchema = kartHardwareStateSchema.extend({
-  kartNumber: z.number(),
-});
-
 export const screenHomeViewInputSchema = z.object({
   kartNumber: z.number().nullable().optional(),
 });

package/src/domains/hardware/screen/Screen.types.ts

@@ -4,7 +4,6 @@ import {
   countDownNextViewRaceSchema,
   screenBattleViewConfigSchema,
   screenCountdownParamsSchema,
-  screenDebugViewInputSchema,
   screenFinishViewInputSchema,
   screenGameTimeLeftSchema,
   screenHomeViewInputSchema,
@@ -18,6 +17,8 @@ import {
   updateRaceViewInputSchema,
 } from './Screen.schema';
 
+import { screenDebugViewInputSchema } from './ScreenDebug.schema';
+
 export type ScreenStatus = z.infer<typeof screenStatusSchema>;
 export type ScreenView = z.infer<typeof screenViewSchema>;
 export type ScreenModuleStatus = z.infer<typeof screenModuleStatusSchema>;

package/src/domains/hardware/screen/ScreenDebug.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { kartHardwareStateSchema } from '../KartHardwareState.schema';
+
+export const screenDebugViewInputSchema = kartHardwareStateSchema.extend({
+  kartNumber: z.number(),
+});

package/src/domains/hardware/screen/index.ts

@@ -1,3 +1,4 @@
 export * from './Screen.const';
 export * from './Screen.schema';
+export * from './ScreenDebug.schema';
 export * from './Screen.types';

package/src/domains/index.ts

@@ -9,7 +9,9 @@ export * from './hardware';
 export * from './kart';
 export * from './kartTracking';
 export * from './powerUp';
+export * from './player';
 export * from './racingTeam';
+export * from './session';
 export * from './socket';
 export * from './ticketing';
 export * from './user';

package/src/domains/kart/Kart.schema.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { colorNameSchema } from '../color';
 import { damageEffectNameSchema } from '../damage';
 import { gameTypeSchema } from '../game';
-import { kartHardwareStateSchema } from '../hardware';
+import { kartHardwareStateSchema } from '../hardware/KartHardwareState.schema';
 import { powerUpNameSchema } from '../powerUp/PowerUpAttributes.schema';
 import { KART_STATUS } from './Kart.const';
 

package/src/domains/player/Player.const.ts

@@ -0,0 +1,4 @@
+export const PLAYER_TYPE = {
+  ADULT: 'ADULT',
+  MINOR: 'MINOR', // Managed by a Guardian
+} as const;

package/src/domains/player/Player.schema.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { PLAYER_TYPE } from './Player.const';
+
+export const playerTypeSchema = z.enum(PLAYER_TYPE);
+
+export const playerWaiverStatusSchema = z.object({
+  isSigned: z.boolean().default(false),
+  waiverId: z.uuidv4().nullable().optional(),
+  templateVersion: z.string().optional(),
+  expiresAt: z.date().nullable().optional(),
+});
+
+export const playerStatsSchema = z.object({
+  totalRaces: z.number().int().default(0),
+  bestTimeMs: z.number().int().nullable().optional(),
+  xp: z.number().int().default(0),
+});
+
+export const playerSchema = z.object({
+  id: z.uuidv4(),
+  nickname: z.string().min(2).max(20),
+  avatarUrl: z.url().optional(),
+  birthDate: z.date(),
+  type: playerTypeSchema.default(PLAYER_TYPE.ADULT),
+
+  ownerUserId: z.uuidv4().nullable().optional(),
+  isGuest: z.boolean().default(true),
+  waiver: playerWaiverStatusSchema,
+
+  // TODO: Add the stats here, to aovid extra queries
+  stats: playerStatsSchema.optional().nullable(),
+
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+
+export const createPlayerSchema = playerSchema
+  .pick({
+    nickname: true,
+    type: true,
+  })
+  .extend({
+    birthDate: z.coerce.date(),
+  });
+
+export const signWaiverSchema = z.object({
+  signature: z.string().optional(), // Base64 or simply a boolean acceptance. Let's make it flexible.
+  accepted: z.literal(true), // They must explicitly pass accepted: true
+});
+
+export const createMinorPlayerSchema = z.object({
+  nickname: z.string().min(2).max(20),
+  birthDate: z.coerce.date(),
+  // For a minor, the signature is implicitly granted by the tutor calling this endpoint
+});

package/src/domains/player/Player.types.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { playerSchema, playerStatsSchema, playerTypeSchema, playerWaiverStatusSchema } from './Player.schema';
+
+export type PlayerType = z.infer<typeof playerTypeSchema>;
+export type PlayerStats = z.infer<typeof playerStatsSchema>;
+export type PlayerWaiverStatus = z.infer<typeof playerWaiverStatusSchema>;
+
+export type Player = z.infer<typeof playerSchema>;

package/src/domains/player/index.ts

@@ -0,0 +1,3 @@
+export * from './Player.const';
+export * from './Player.schema';
+export * from './Player.types';

package/src/domains/role/Role.const.ts

@@ -18,4 +18,5 @@ export const USER_ROLE = {
   SUPER_ADMIN: 'SUPER_ADMIN',
   OPERATOR: 'OPERATOR',
   PLAYER: 'PLAYER',
+  CASHIER: 'CASHIER',
 } as const;

package/src/domains/session/Session.const.ts

@@ -0,0 +1,7 @@
+export const SESSION_STATUS = {
+  CREATED: 'CREATED',
+  READY: 'READY',
+  STARTED: 'STARTED',
+  FINISHED: 'FINISHED',
+  CANCELLED: 'CANCELLED',
+} as const;

package/src/domains/session/Session.schema.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { SESSION_STATUS } from './Session.const';
+import { gameTypeSchema } from '../game/Game.schema';
+
+export const sessionStatusSchema = z.enum(SESSION_STATUS);
+
+export const sessionTicketSchema = z.object({
+  quantity: z.number().int().positive(),
+  type: gameTypeSchema,
+});
+
+export const gameSessionSchema = z.object({
+  code: z.string().length(6), // 6-char alphanumeric
+  contactPhone: z.string().optional(),
+  userId: z.string().optional().nullable(),
+
+  tickets: z.array(sessionTicketSchema),
+  playerIds: z.array(z.uuidv4()),
+  linkedPurchaseId: z.string().optional(),
+
+  status: sessionStatusSchema.default(SESSION_STATUS.CREATED),
+
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+
+export const createSessionInputSchema = z.object({
+  contactPhone: z.string().optional(),
+  userId: z.string().optional().nullable(),
+  tickets: z.array(sessionTicketSchema).min(1),
+});
+
+export const joinSessionSchema = z.object({
+  nickname: z.string().min(2),
+  birthDate: z.coerce.date(),
+});
+
+export const createGameTurnInputSchema = z.object({
+  assignments: z
+    .array(
+      z.object({
+        ticketId: z.string(),
+        playerId: z.uuidv4(),
+      }),
+    )
+    .min(1),
+});
+
+export const assignSessionTicketsInputSchema = z.object({
+  assignments: z
+    .array(
+      z.object({
+        ticketId: z.string(),
+        playerId: z.uuidv4(),
+      }),
+    )
+    .min(1),
+});

package/src/domains/session/Session.types.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import {
+  assignSessionTicketsInputSchema,
+  createSessionInputSchema,
+  gameSessionSchema,
+  sessionStatusSchema,
+  sessionTicketSchema,
+} from './Session.schema';
+
+export type SessionStatus = z.infer<typeof sessionStatusSchema>;
+export type SessionTicket = z.infer<typeof sessionTicketSchema>;
+export type GameSession = z.infer<typeof gameSessionSchema>;
+export type CreateSessionInput = z.infer<typeof createSessionInputSchema>;
+export type AssignSessionTicketsInput = z.infer<typeof assignSessionTicketsInputSchema>;

package/src/domains/session/index.ts

@@ -0,0 +1,3 @@
+export * from './Session.const';
+export * from './Session.schema';
+export * from './Session.types';

package/src/domains/ticketing/Ticketing.const.ts

@@ -42,3 +42,9 @@ export const GAME_TURN_TASK_STATUS = {
   PENDING: 'pending',
   COMPLETED: 'completed',
 } as const;
+
+export const PURCHASE_STATUS = {
+  PENDING: 'pending',
+  PAID: 'paid',
+  CANCELLED: 'cancelled',
+} as const;

package/src/domains/ticketing/Ticketing.schema.ts

@@ -5,9 +5,11 @@ import {
   GAME_TURN_STATUS,
   GAME_TURN_TASK_STATUS,
   GAME_TURN_TASK_TYPE,
+  PURCHASE_STATUS,
   TICKET_TYPE,
   TICKET_USER_TYPE,
 } from './Ticketing.const';
+import { gameTypeSchema } from '../game';
 
 export const gameTicketStatusSchema = z.enum(GAME_TICKET_STATUS);
 export const ticketUserTypeSchema = z.enum(TICKET_USER_TYPE);
@@ -15,11 +17,11 @@ export const ticketTypeSchema = z.enum(TICKET_TYPE);
 export const ticketSummarySchema = z.record(ticketTypeSchema, z.number());
 
 export const gameTicketSchema = z.object({
-  id: z.string(),
+  id: z.uuidv4(),
   purchaseId: z.string(),
-  gameTurnId: z.string(),
-  ownerUsername: z.string(),
-  userType: ticketUserTypeSchema,
+  sessionId: z.string().optional().nullable(),
+  gameTurnId: z.string().optional().nullable(),
+  playerId: z.uuidv4().optional().nullable(),
   status: gameTicketStatusSchema,
   type: ticketTypeSchema.default(TICKET_TYPE.RACE),
   createdAt: z.date(),
@@ -27,34 +29,38 @@ export const gameTicketSchema = z.object({
   completedAt: z.date().optional(),
 });
 
+export const purchaseStatusSchema = z.enum(PURCHASE_STATUS);
+
+export const purchaseItemSchema = z.object({
+  ticketType: gameTypeSchema,
+  quantity: z.number().int().positive(),
+  priceCents: z.number().int().nonnegative(),
+});
+
 export const purchaseSchema = z.object({
-  id: z.string(),
+  id: z.uuidv4(),
   purchaseNumber: z.number(),
-  buyerUserId: z.string(),
-  totalTickets: z.number(),
-  purchaseDate: z.date(),
-  ticketType: ticketTypeSchema.default(TICKET_TYPE.RACE),
+
+  // Buyer can be null for Guest/On-Site purchases
+  buyerUserId: z.string().optional().nullable(),
+
+  items: z.array(purchaseItemSchema),
+  totalAmountCents: z.number().min(0),
+  status: purchaseStatusSchema.default(PURCHASE_STATUS.PENDING),
+
+  // Deprecated fields (kept for backward compatibility if needed, or remove if safe)
+  totalTickets: z.number().optional(),
+  ticketType: ticketTypeSchema.optional(),
+
   paymentData: z.any().optional(),
   createdAt: z.date(),
   updatedAt: z.date(),
 });
 
-export const createPurchasePublicSchema = purchaseSchema
-  .pick({
-    ticketType: true,
-  })
-  .extend({
-    ticketCount: z.number(),
-  });
-
-export const createPurchaseInternalSchema = purchaseSchema
-  .pick({
-    ticketType: true,
-    buyerUserId: true,
-  })
-  .extend({
-    ticketCount: z.number(),
-  });
+export const createPurchaseInputSchema = z.object({
+  buyerUserId: z.string().optional(),
+  items: z.array(purchaseItemSchema).min(1),
+});
 
 export const gameTurnStatusSchema = z.enum(GAME_TURN_STATUS);
 
@@ -76,9 +82,9 @@ export const gameTurnTaskSchema = z.object({
 export const gameTurnSchema = z.object({
   id: z.string(),
   purchaseId: z.string(),
-  leaderUsername: z.string(),
+  leaderPlayerId: z.string(),
   gameTickets: z.array(z.string()),
-  usernames: z.array(z.string()),
+  playerIds: z.array(z.string()),
   status: gameTurnStatusSchema,
   tasks: z.array(gameTurnTaskSchema),
   createdAt: z.date(),

package/src/domains/ticketing/Ticketing.types.ts

@@ -1,7 +1,6 @@
 import { z } from 'zod';
 import {
-  createPurchaseInternalSchema,
-  createPurchasePublicSchema,
+  createPurchaseInputSchema,
   gameTicketSchema,
   gameTicketStatusSchema,
   gameTurnCheckSchema,
@@ -23,8 +22,7 @@ export type TicketUserType = z.infer<typeof ticketUserTypeSchema>;
 export type TicketSummary = z.infer<typeof ticketSummarySchema>;
 
 export type Purchase = z.infer<typeof purchaseSchema>;
-export type CreatePurchasePublicInput = z.infer<typeof createPurchasePublicSchema>;
-export type CreatePurchaseInternalInput = z.infer<typeof createPurchaseInternalSchema>;
+export type CreatePurchaseInput = z.infer<typeof createPurchaseInputSchema>;
 
 export type GameTicket = z.infer<typeof gameTicketSchema>;
 

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

@@ -4,16 +4,69 @@ import { USER_TYPE } from './User.const';
 
 export const userTypeSchema = z.enum(USER_TYPE);
 
-export const userSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  username: z.string(),
-  email: z.email(),
-  phone: z.string().optional(),
+export const PHONE_REGEX = /^([+]?[\\s0-9]+)?(\\d{3}|[(]?[0-9]+[)])?([-]?[\\s]?[0-9])+$/;
+const MIN_PASSWORD_LENGTH = 6;
+
+const baseUserObj = z.object({
+  id: z.uuidv4(),
+
+  email: z.email().toLowerCase().optional(),
+
+  phoneNumber: z.string().regex(PHONE_REGEX, 'Invalid phone number format').optional(),
+
+  // --- ACCESS CONTROL ---
   role: userRoleSchema,
   type: userTypeSchema,
+
+  isActive: z.boolean().default(true),
+  // TODO: Implement mechanism to validate users later by email or phone
+  isEmailVerified: z.boolean().default(false),
+  isPhoneVerified: z.boolean().default(false),
+
+  defaultPlayerId: z.uuidv4().optional(),
+
+  createdAt: z.date(),
+  lastLoginAt: z.date().optional(),
+});
+
+export const userSchema = baseUserObj.refine((data) => data.email || data.phoneNumber, {
+  message: 'User must have either an email or a phone number',
+  path: ['email', 'phoneNumber'],
 });
 
-export const userWithPasswordSchema = userSchema.extend({
-  password: z.string(),
+export const userWithPasswordSchema = userSchema.and(
+  z.object({
+    password: z.string().min(MIN_PASSWORD_LENGTH),
+  }),
+);
+
+export const userRegistrationInputSchema = baseUserObj
+  .pick({
+    email: true,
+    phoneNumber: true,
+  })
+  .extend({
+    name: z.string().optional(),
+    password: z.string().min(6),
+    nickname: z.string().min(2),
+    birthDate: z.coerce.date(),
+  })
+  .refine((data) => data.email || data.phoneNumber, {
+    message: 'User must have either an email or a phone number',
+    path: ['email', 'phoneNumber'],
+  });
+
+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' },
+    ),
+  password: z.string().min(MIN_PASSWORD_LENGTH, `Password must be at least ${MIN_PASSWORD_LENGTH} characters`),
 });