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

package/src/domains/hardware/index.ts

@@ -8,7 +8,8 @@ export * from './lights';
 export * from './ModuleName.const';
 export * from './ModuleStatus.schema';
 export * from './ModuleStatus.types';
-export * from './KartHardwareState.schema'; // Added
+export * from './KartHardwareState.schema';
+export * from './KartHardwareState.types';
 export * from './rgb';
 export * from './screen';
 export * from './sound';

package/src/domains/hardware/lights/Lights.const.ts

@@ -9,3 +9,8 @@ export const LIGHTS_EFFECT = {
   RED_FLAG: 'RED_FLAG',
   PULSE: 'PULSE',
 } as const;
+
+export const LIGHTS_ACTION_COMMAND = {
+  SHOW_COLOR: 'ShowColor',
+  SHOW_EFFECT: 'ShowEffect',
+} as const;

package/src/domains/hardware/lights/Lights.schema.ts

@@ -1,5 +1,7 @@
 import { z } from 'zod';
-import { LIGHTS_EFFECT } from './Lights.const';
+import { LIGHTS_EFFECT, LIGHTS_ACTION_COMMAND } from './Lights.const';
+
+export const lightsActionCommandSchema = z.enum(LIGHTS_ACTION_COMMAND);
 
 export const lightsEffectSchema = z.enum(LIGHTS_EFFECT);
 
@@ -14,3 +16,7 @@ export const showLightsEffectParamsSchema = z.object({
   effect: lightsEffectSchema,
   timeDuration: z.number().min(1).max(25),
 });
+
+export const lightsModuleStatusSchema = z.object({
+  currentEffect: lightsEffectSchema.nullable(),
+});

package/src/domains/hardware/lights/Lights.types.ts

@@ -1,6 +1,14 @@
 import { z } from 'zod';
-import { lightsEffectSchema, showLightsColorParamsSchema, showLightsEffectParamsSchema } from './Lights.schema';
+import {
+  lightsActionCommandSchema,
+  lightsEffectSchema,
+  lightsModuleStatusSchema,
+  showLightsColorParamsSchema,
+  showLightsEffectParamsSchema,
+} from './Lights.schema';
 
+export type LightsActionCommand = z.infer<typeof lightsActionCommandSchema>;
 export type LightsEffect = z.infer<typeof lightsEffectSchema>;
+export type LightsModuleStatus = z.infer<typeof lightsModuleStatusSchema>;
 export type ShowLightsColorParams = z.infer<typeof showLightsColorParamsSchema>;
 export type ShowLightsEffectParams = z.infer<typeof showLightsEffectParamsSchema>;

package/src/domains/hardware/rgb/RGB.const.ts

@@ -6,3 +6,8 @@ export const RGB_STATUS = {
   UNKNOWN: 'Unknown',
   ERROR: 'Error',
 } as const;
+
+export const RGB_ACTION_COMMANDS = {
+  EXEC: 'Exec',
+  CONFIGURE: 'Configure',
+} as const;

package/src/domains/hardware/rgb/RGB.schema.ts

@@ -1,10 +1,12 @@
 import { z } from 'zod';
 import { colorNameSchema } from '../../color';
 import { kartEffectSchema } from '../../hardware/kart-effect';
-import { RGB_STATUS } from './RGB.const';
+import { RGB_STATUS, RGB_ACTION_COMMANDS } from './RGB.const';
 
 export const rgbStatusSchema = z.enum(RGB_STATUS);
 
+export const rgbActionCommandSchema = z.enum(RGB_ACTION_COMMANDS);
+
 export const rgbModuleStatusSchema = z.object({
   rgbStatus: rgbStatusSchema,
   kartColor: colorNameSchema,

package/src/domains/hardware/rgb/RGB.types.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import {
+  rgbActionCommandSchema,
   rgbConfigurationOptionsSchema,
   rgbModuleStatusSchema,
   rgbShowEffectOptionsSchema,
@@ -10,3 +11,4 @@ export type RGBStatus = z.infer<typeof rgbStatusSchema>;
 export type RGBModuleStatus = z.infer<typeof rgbModuleStatusSchema>;
 export type RGBConfigurationOptions = z.infer<typeof rgbConfigurationOptionsSchema>;
 export type RGBShowEffectOptions = z.infer<typeof rgbShowEffectOptionsSchema>;
+export type RGBActionCommand = z.infer<typeof rgbActionCommandSchema>;

package/src/domains/hardware/sound/Sound.const.ts

@@ -1,3 +1,7 @@
 export const PLAY_SOUND_DURATION = {
   INFINITE: 'infinite',
 } as const;
+
+export const SOUND_ACTION_COMMAND = {
+  PLAY: 'Play',
+} as const;

package/src/domains/hardware/sound/Sound.schema.ts

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import { soundNameSchema } from '../../sounds'; // Import from domains/sounds
-import { PLAY_SOUND_DURATION } from './Sound.const';
+import { PLAY_SOUND_DURATION, SOUND_ACTION_COMMAND } from './Sound.const';
+
+export const soundActionCommandSchema = z.enum(SOUND_ACTION_COMMAND);
 
 export const playSoundOptionsSchema = z.object({
   soundName: soundNameSchema,

package/src/domains/hardware/sound/Sound.types.ts

@@ -1,4 +1,6 @@
 import { z } from 'zod';
-import { playSoundOptionsSchema } from './Sound.schema';
+import { soundActionCommandSchema, playSoundOptionsSchema } from './Sound.schema';
+
+export type SoundActionCommand = z.infer<typeof soundActionCommandSchema>;
 
 export type PlaySoundOptions = z.infer<typeof playSoundOptionsSchema>;

package/src/domains/hardware/steering-wheel/SteeringWheel.const.ts

@@ -0,0 +1,4 @@
+export const STEERING_WHEEL_ACTION_COMMAND = {
+  TURN_LED_ON: 'TurnLedOn',
+  TURN_LED_OFF: 'TurnLedOff',
+} as const;

package/src/domains/hardware/steering-wheel/SteeringWheel.schema.ts

@@ -1,4 +1,7 @@
 import { z } from 'zod';
+import { STEERING_WHEEL_ACTION_COMMAND } from './SteeringWheel.const';
+
+export const steeringWheelActionCommandSchema = z.enum(STEERING_WHEEL_ACTION_COMMAND);
 
 export const steeringWheelModuleStatusSchema = z.object({
   isLeftButtonPressed: z.boolean(),

package/src/domains/hardware/steering-wheel/SteeringWheel.types.ts

@@ -1,4 +1,6 @@
 import { z } from 'zod';
-import { steeringWheelModuleStatusSchema } from './SteeringWheel.schema';
+import { steeringWheelActionCommandSchema, steeringWheelModuleStatusSchema } from './SteeringWheel.schema';
+
+export type SteeringWheelActionCommand = z.infer<typeof steeringWheelActionCommandSchema>;
 
 export type SteeringWheelModuleStatus = z.infer<typeof steeringWheelModuleStatusSchema>;

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

@@ -37,6 +37,8 @@ export const playerSchema = z.object({
 export const createPlayerSchema = playerSchema
   .pick({
     nickname: true,
+    ownerUserId: true,
+    isGuest: true,
   })
   .extend({
     birthDate: z.coerce.date(),
@@ -46,9 +48,3 @@ 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/racingTeam/RacingTeam.schema.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { paginatedResponseSchema } from '../pagination';
 import { JOIN_REQUEST_STATUS, RACING_TEAM_ROLE } from './RacingTeam.const';
+import { playerSchema } from '../player/Player.schema';
 
 // --- Team Schemas ---
 
@@ -44,25 +45,41 @@ export const paginatedRacingTeamSummarySchema = paginatedResponseSchema(racingTe
 export const joinRequestSchema = z.object({
   id: z.string(),
   racingTeamId: z.string(),
-  userId: z.string(),
+  playerId: z.string(),
   status: z.enum(JOIN_REQUEST_STATUS),
   createdAt: z.date(),
   updatedAt: z.date(),
 });
 
 export const teamMemberSchema = z.object({
+  id: z.string(),
   racingTeamId: z.string(),
-  userId: z.string(),
+  playerId: z.string(),
+  role: z.enum(RACING_TEAM_ROLE),
+  joinedAt: z.date(),
+});
+
+export const teamMemberWithPlayerSchema = playerSchema.extend({
   role: z.enum(RACING_TEAM_ROLE),
   joinedAt: z.date(),
 });
 
+export const racingTeamWithMembersSchema = racingTeamSchema.extend({
+  members: z.array(teamMemberWithPlayerSchema),
+});
+
 export const createJoinRequestSchema = z.object({
   racingTeamId: z.string(),
+  playerId: z.string(),
 });
 
 export const answerJoinRequestSchema = z.object({
   racingTeamId: z.string(),
-  targetUserId: z.string(),
+  targetPlayerId: z.string(),
   accepted: z.boolean(),
 });
+
+export const addTeamMemberSchema = z.object({
+  nickname: z.string().min(2).max(20),
+  birthDate: z.coerce.date(),
+});

package/src/domains/racingTeam/RacingTeam.types.ts

@@ -6,10 +6,13 @@ import {
   joinRequestSchema,
   paginatedRacingTeamSchema,
   paginatedRacingTeamSummarySchema,
+  racingTeamWithMembersSchema,
   racingTeamSchema,
   racingTeamSummarySchema,
+  teamMemberWithPlayerSchema,
   teamMemberSchema,
   updateRacingTeamSchema,
+  addTeamMemberSchema,
 } from './RacingTeam.schema';
 
 export type RacingTeam = z.infer<typeof racingTeamSchema>;
@@ -23,3 +26,7 @@ export type JoinRequest = z.infer<typeof joinRequestSchema>;
 export type TeamMember = z.infer<typeof teamMemberSchema>;
 export type CreateJoinRequest = z.infer<typeof createJoinRequestSchema>;
 export type AnswerJoinRequest = z.infer<typeof answerJoinRequestSchema>;
+
+export type TeamMemberWithPlayer = z.infer<typeof teamMemberWithPlayerSchema>;
+export type RacingTeamWithMembers = z.infer<typeof racingTeamWithMembersSchema>;
+export type AddTeamMember = z.infer<typeof addTeamMemberSchema>;

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

@@ -43,6 +43,10 @@ export const joinSessionSchema = z.object({
   birthDate: z.coerce.date(),
 });
 
+export const addExistingPlayersSchema = z.object({
+  playerIds: z.array(z.uuidv4()).min(1),
+});
+
 export const updateSessionStatusSchema = z.object({
   status: sessionStatusSchema,
 });

package/src/domains/socket/index.ts

@@ -5,3 +5,4 @@ export * from './SocketHardwareModulesEventsParams';
 export * from './SocketHardwareOnDataEventsParams';
 export * from './SocketPowerUpEventsParams';
 export * from './utils';
+export * from './screen';

package/src/domains/socket/screen/SocketScreenServerToClientEventsParams.ts

@@ -0,0 +1,19 @@
+import type {
+  ScreenCountdownParams,
+  ScreenDebugViewInput,
+  ScreenFinishViewInput,
+  ScreenHomeViewInput,
+  ScreenUpdateGameViewInput,
+} from '../../hardware';
+
+/**
+ * Socket events from Raspberry Pi to Screen
+ */
+export interface SocketScreenServerToClientEventsParams {
+  'view:home': ScreenHomeViewInput;
+  'view:countdown': ScreenCountdownParams;
+  'game:sync_state': ScreenUpdateGameViewInput;
+  'view:summary': ScreenFinishViewInput & { state: 'Victory' | 'Defeat' };
+  'view:debug': ScreenDebugViewInput;
+  'view:instruction_video': Record<string, never>;
+}

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

@@ -0,0 +1 @@
+export * from './SocketScreenServerToClientEventsParams';

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

@@ -85,6 +85,8 @@ export const gameTurnTaskSchema = z.object({
 
 export const gameTurnSchema = z.object({
   id: z.string(),
+  turnNumber: z.number().int().positive(),
+  groupName: z.string().optional(),
   purchaseId: z.string(),
   sessionId: z.string().optional(),
   leaderPlayerId: z.string(),

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

@@ -7,15 +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(),
 
   name: z.string(),
   lastName: z.string(),
 
-  email: z.email().toLowerCase().optional(),
+  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,
@@ -37,12 +49,57 @@ export const userSchema = baseUserObj.refine((data) => data.email || data.phoneN
   path: ['email', 'phoneNumber'],
 });
 
+/**
+ * When a user registers, we don't have all the information, so we use this schema
+ */
+export const initialUserSchema = baseUserObj.pick({
+  id: true,
+  email: true,
+  phoneNumber: true,
+  isEmailVerified: true,
+  isPhoneVerified: true,
+  type: true,
+  createdAt: true,
+});
+
+/**
+ * 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,
@@ -61,16 +118,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,22 @@
 import { z } from 'zod';
-import { userSchema, userTypeSchema, userWithPasswordSchema } from './User.schema';
+import {
+  authUserSchema,
+  initialUserSchema,
+  userCompleteProfileSchema,
+  userInitialRegistrationSchema,
+  userLoginInputSchema,
+  userSchema,
+  userTypeSchema,
+  userVerifySchema,
+  userWithPasswordSchema,
+} 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 InitialUser = z.infer<typeof initialUserSchema>;
+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>;