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

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

@@ -0,0 +1,54 @@
+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,
+  })
+  .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,8 @@
+export const SESSION_STATUS = {
+  REGISTRATION: 'REGISTRATION',
+  TURN_CREATION: 'TURN_CREATION',
+  READY: 'READY',
+  STARTED: 'STARTED',
+  FINISHED: 'FINISHED',
+  CANCELLED: 'CANCELLED',
+} as const;

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

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+import { SESSION_STATUS } from './Session.const';
+import { gameTypeSchema } from '../game/Game.schema';
+import { playerSchema } from '../player/Player.schema';
+import { gameTicketSchema, gameTurnSchema } from '../ticketing/Ticketing.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({
+  id: z.uuidv4(),
+  code: z.string().length(6), // 6-char alphanumeric
+  contactPhone: z.string().optional(),
+  userId: z.string().optional().nullable(),
+
+  tickets: z.array(gameTicketSchema).optional(),
+  playerIds: z.array(z.uuidv4()),
+  linkedPurchaseId: z.string().optional(),
+
+  status: sessionStatusSchema.default(SESSION_STATUS.REGISTRATION),
+
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+
+export const gameSessionWithPlayersSchema = gameSessionSchema.extend({
+  players: z.array(playerSchema),
+  turns: z.array(gameTurnSchema).optional(),
+});
+
+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 updateSessionStatusSchema = z.object({
+  status: sessionStatusSchema,
+});
+
+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),
+});
+
+export const bulkCreateGameTurnSchema = z.object({
+  turns: z.array(createGameTurnInputSchema).min(1),
+});

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

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import {
+  assignSessionTicketsInputSchema,
+  createSessionInputSchema,
+  gameSessionSchema,
+  gameSessionWithPlayersSchema,
+  joinSessionSchema,
+  bulkCreateGameTurnSchema,
+  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 GameSessionWithPlayers = z.infer<typeof gameSessionWithPlayersSchema>;
+export type CreateSessionInput = z.infer<typeof createSessionInputSchema>;
+export type AssignSessionTicketsInput = z.infer<typeof assignSessionTicketsInputSchema>;
+export type JoinSessionInput = z.infer<typeof joinSessionSchema>;
+export type BulkCreateGameTurnInput = z.infer<typeof bulkCreateGameTurnSchema>;

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,42 @@ 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(),
+  guestName: z.string().optional().nullable(),
+  guestContact: 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(),
+  guestName: z.string().optional(),
+  guestContact: z.string().optional(),
+  items: z.array(purchaseItemSchema).min(1),
+});
 
 export const gameTurnStatusSchema = z.enum(GAME_TURN_STATUS);
 
@@ -76,9 +86,10 @@ export const gameTurnTaskSchema = z.object({
 export const gameTurnSchema = z.object({
   id: z.string(),
   purchaseId: z.string(),
-  leaderUsername: z.string(),
+  sessionId: z.string().optional(),
+  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,73 @@ import { USER_TYPE } from './User.const';
 
 export const userTypeSchema = z.enum(USER_TYPE);
 
-export const userSchema = z.object({
-  id: z.string(),
+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(),
+
   name: z.string(),
-  username: z.string(),
-  email: z.email(),
-  phone: z.string().optional(),
+  lastName: z.string(),
+
+  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({
+    name: true,
+    lastName: true,
+    email: true,
+    phoneNumber: true,
+  })
+  .extend({
+    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`),
 });

package/br-common-lib.code-workspace

@@ -1,19 +0,0 @@
-{
-	"folders": [
-		{
-			"path": "."
-		},
-		{
-			"path": "../game-manager-backend"
-		},
-		{
-			"path": "../game-manager-webapp"
-		},
-		{
-			"path": "../game-track-manager"
-		},
-		{
-			"path": "../kart-manager"
-		}
-	]
-}