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

package/src/domains/socket/SocketHardwareOnDataEventsParams.ts

@@ -0,0 +1,29 @@
+import type {
+  BallSensorDiskThrowerModuleStatus,
+  DiskSensorBallShooterModuleStatus,
+  EmergencyModuleStatus,
+  FlagModuleStatus,
+  RGBModuleStatus,
+  ScreenModuleStatus,
+  SpeedModuleStatus,
+  StarLaserModuleStatus,
+  SteeringWheelModuleStatus,
+} from '../hardware';
+
+/** Data that are triggered from Hardware Modules of Kart */
+export type SocketHardwareOnDataEventsParams = {
+  'hardware:disk-sensor-ball-shooter:onModuleStatus': DiskSensorBallShooterModuleStatus;
+  'hardware:ball-sensor-disk-thrower:onModuleStatus': BallSensorDiskThrowerModuleStatus;
+  'hardware:rgb:onModuleStatus': RGBModuleStatus;
+  'hardware:flag:onModuleStatus': FlagModuleStatus;
+  'hardware:speed:onModuleStatus': SpeedModuleStatus;
+  'hardware:left-star-back-laser:onModuleStatus': StarLaserModuleStatus;
+  'hardware:right-star-front-laser:onModuleStatus': StarLaserModuleStatus;
+  'hardware:steering-wheel:onModuleStatus': SteeringWheelModuleStatus;
+  'hardware:screen:onModuleStatus': ScreenModuleStatus;
+};
+
+/** Data that are triggered from Hardware Modules of Game Track */
+export type SocketGameTrackHardwareOnDataEventsParams = {
+  'hardware:emergency:onModuleStatus': EmergencyModuleStatus;
+};

package/src/domains/socket/SocketPowerUpEventsParams.ts

@@ -0,0 +1,13 @@
+import type { DamageEffectName } from '../damage';
+import type { PowerUp } from '../powerUp';
+
+export type SocketPowerUpEventsParams = {
+  /** Assign the Powerup, shouldOverride will force the assignation */
+  'powerUp:assign': { powerUpId: PowerUp['id']; shouldOverride?: boolean };
+  /** Affect the Kart by a Damage */
+  'powerUp:damage': { damageName: DamageEffectName };
+  /** Trigger the Powerup */
+  'powerUp:execute': { powerUpId?: PowerUp['id'] };
+  /** Sync PowerUps */
+  'powerUps:sync': { powerUps: PowerUp[] };
+};

package/src/domains/socket/clientToServer/SocketGameTrackClientToServerEventsParams.ts

@@ -0,0 +1,7 @@
+export interface SocketGameTrackClientToServerEventsParams {
+  'game-track:init': { macAddress: string };
+  /** Emergency Button Pressed phisicaly */
+  'game-track:emergency:buttonPressed': { macAddress: string };
+  /** Emergency Button released phisicaly */
+  'game-track:emergency:buttonReleased': { macAddress: string };
+}

package/src/domains/socket/clientToServer/SocketKartClientToServerEventsParams.ts

@@ -0,0 +1,16 @@
+import type { DamageEffectName } from '../../damage';
+import type { Kart } from '../../kart';
+import type { SocketInitRaspberryInput, SocketRegisterKartCheckpointInput } from '../inputs';
+
+export interface SocketKartClientToServerEventsParams {
+  'kart:init': SocketInitRaspberryInput;
+  'kart:checkpoint': SocketRegisterKartCheckpointInput;
+  /** Activate the damage of a powerUp  */
+  'kart:damage:sent': { macAddress: string; damageName: DamageEffectName };
+  /** The Kart received damage  */
+  'kart:damage:received': { macAddress: string; damageName: DamageEffectName };
+  'kart:data:changed': {
+    macAddress: string;
+    kart: Kart;
+  };
+}

package/src/domains/socket/clientToServer/SocketWebAppClientToServerEventsParams.ts

@@ -0,0 +1,11 @@
+import type { Game, GameType } from '../../game';
+
+export interface SocketWebAppClientToServerEventsParams {
+  'karts:authenticate': { authToken: string };
+  'karts:list': undefined;
+  'karts:tracking:subscribe': { kartGuid: string };
+  'karts:tracking:unsubscribe': { kartGuid: string };
+  'game-changed:subscribe': { gameId: Game['id']; gameType: GameType };
+  'game-changed:unsubscribe': { gameId: Game['id']; gameType: GameType };
+  'game-tracks:list': undefined;
+}

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

@@ -0,0 +1,3 @@
+export * from './SocketGameTrackClientToServerEventsParams';
+export * from './SocketKartClientToServerEventsParams';
+export * from './SocketWebAppClientToServerEventsParams';

package/src/domains/socket/index.ts

@@ -0,0 +1,7 @@
+export * from './clientToServer';
+export * from './inputs';
+export * from './serverToClient';
+export * from './SocketHardwareModulesEventsParams';
+export * from './SocketHardwareOnDataEventsParams';
+export * from './SocketPowerUpEventsParams';
+export * from './utils';

package/src/domains/socket/inputs/MacAddressGameTrackConnection.ts

@@ -0,0 +1,8 @@
+import type { GameTrack } from '../../gameTrack';
+
+export interface MacAddressGameTrackConnections {
+  connectedRaspberries: {
+    macAddress: string;
+  }[];
+  gameTracks: GameTrack[];
+}

package/src/domains/socket/inputs/SocketInitRaspberryInput.ts

@@ -0,0 +1,4 @@
+export type SocketInitRaspberryInput = {
+  macAddress: string;
+  hostname: string;
+};

package/src/domains/socket/inputs/SocketRegisterKartCheckpointInput.ts

@@ -0,0 +1,12 @@
+import type { Checkpoint } from '../../checkpoint';
+
+export type SocketRegisterKartCheckpointInput = {
+  /** The macAddress is necessary to avoid extra process in the backend to find the macAddress */
+  macAddress: string;
+  checkpointAddress: Checkpoint['address'];
+  checkpointType: Checkpoint['type'];
+  /** Just Request the power-up when there is no a power-up already assigned */
+  shouldRequestPowerUp: boolean;
+  /** The real time when the event was generated on RPI */
+  originTimestampISO: string;
+};

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

@@ -0,0 +1,3 @@
+export * from './SocketInitRaspberryInput';
+export * from './MacAddressGameTrackConnection';
+export * from './SocketRegisterKartCheckpointInput';

package/src/domains/socket/serverToClient/SocketGameTrackServerToClientEventParams.ts

@@ -0,0 +1,20 @@
+import type { GameTrack } from '../../gameTrack';
+import type { PlaySoundOptions, ShowLightsColorParams, ShowLightsEffectParams } from '../../hardware';
+import type { Response } from '../../response';
+
+export interface SocketGameTrackEventsParams {
+  // Response from server (game-track:init)
+  'game-track:init:response': Response<GameTrack>;
+}
+
+export interface SocketGameTrackEventParams {
+  'game-track:emergency:activate': undefined;
+  'game-track:emergency:deactivate': undefined;
+
+  'game-track:lights:showEffect': ShowLightsEffectParams;
+  'game-track:lights:showColor': ShowLightsColorParams;
+
+  'game-track:sound:play': PlaySoundOptions;
+}
+
+export type SocketGameTrackServerToClientEventsParams = SocketGameTrackEventsParams & SocketGameTrackEventParams;

package/src/domains/socket/serverToClient/SocketKartServerToClientEventsParams.ts

@@ -0,0 +1,48 @@
+import type { Game, GameType } from '../../game';
+import type { GameTrack, GameTrackKartConfig, GameTrackKartsConfig } from '../../gameTrack';
+import type { Kart, KartStatus } from '../../kart';
+import type { Response } from '../../response';
+import type { SocketPowerUpEventsParams } from '../SocketPowerUpEventsParams';
+
+interface BaseGameEventParams {
+  gameId: Game['id'];
+  gameType: GameType;
+}
+
+// Add the kart: prefix to the SocketPowerUpEventsParams
+export type SocketKartPowerUpEventsParams = {
+  [Key in keyof SocketPowerUpEventsParams as `kart:${Key}`]: SocketPowerUpEventsParams[Key];
+};
+
+export interface SocketKartEventsParams {
+  // Response from server
+  'kart:init:response': Response<{ kart: Kart; gameTrack: GameTrack }>;
+  /** Whenever the Game Track config changed, the config might change as well*/
+  'kart:gameTrack:updated': { gameTrack: GameTrack; config: GameTrackKartConfig };
+  /** When the physical button of the game track is pressed */
+  'kart:gameTrack:emergency:started': undefined;
+  /** When the physical button of the game track is released */
+  'kart:gameTrack:emergency:stopped': undefined;
+  /** Force kart to change status */
+  'kart:status:change': { status: KartStatus };
+}
+
+export interface SocketGameEventParams {
+  /** Kart is selected for a game */
+  'kart:game:selected': BaseGameEventParams;
+  /** Kart Is eliminated from a game (game is in progress) */
+  'kart:game:eliminated': BaseGameEventParams;
+  'kart:game:yellow-flag:started': BaseGameEventParams;
+  'kart:game:yellow-flag:stopped': BaseGameEventParams;
+  'kart:game:red-flag:started': BaseGameEventParams;
+  'kart:game:red-flag:stopped': BaseGameEventParams;
+
+  // Critical Game Events that require the whole game state to be sent
+  'kart:game:started': { game: Game };
+  'kart:game:finished': { game: Game; isWinner: boolean };
+  'kart:game:sync': { game: Game };
+}
+
+export type SocketKartServerToClientEventsParams = SocketKartEventsParams &
+  SocketGameEventParams &
+  SocketKartPowerUpEventsParams;

package/src/domains/socket/serverToClient/SocketWebAppServerToClientEventsParams.ts

@@ -0,0 +1,25 @@
+import type { Game } from '../../game';
+import type { GameTrack } from '../../gameTrack';
+import type { Kart } from '../../kart';
+import type { CheckpointEvent } from '../../kartTracking';
+import type { Response } from '../../response';
+import type { MacAddressGameTrackConnections } from '../inputs';
+import type { SocketHardwareOnDataEventsParams } from '../SocketHardwareOnDataEventsParams';
+
+export interface SocketWebAppServerToClientEventsParams {
+  'karts:authenticate:response': Response<void>;
+  'karts:list:response': Response<Kart[]>;
+  'karts:onKartsUpdated': Kart[];
+  'karts:onHardwareData': {
+    kartGuid: string;
+    socketEvent: keyof SocketHardwareOnDataEventsParams;
+    payload: SocketHardwareOnDataEventsParams[keyof SocketHardwareOnDataEventsParams];
+  };
+  'karts:tracking:checkpointEvent': {
+    checkpointEvent: CheckpointEvent;
+  };
+  'game:changed': { game: Game };
+  'gameTracks:onGameTrackUpdated': GameTrack[];
+  'gameTracks:connectedRasperries': { macAddress: string }[];
+  'gameTracks:list:response': Response<MacAddressGameTrackConnections>;
+}

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

@@ -0,0 +1,3 @@
+export * from './SocketGameTrackServerToClientEventParams';
+export * from './SocketKartServerToClientEventsParams';
+export * from './SocketWebAppServerToClientEventsParams';

package/src/domains/socket/utils/SocketParamsToEvents.ts

@@ -0,0 +1,16 @@
+/** Map the Events Params Types to Event to be used on Socket.io  */
+export type EmptyEventParams = () => void;
+export type EventParams<EventParams> = (payload: EventParams) => void;
+//With Extra
+export type EmptyEventParamsWithExtra<Extra> = (params: Extra) => void;
+export type EventParamsWithExtra<EventParams, Extra> = (params: Extra & { payload: EventParams }) => void;
+
+export type SocketParamsToEvents<Event, Extra = undefined> = {
+  [EventKey in keyof Event]: Event[EventKey] extends undefined
+    ? Extra extends undefined
+      ? EmptyEventParams
+      : EmptyEventParamsWithExtra<Extra>
+    : Extra extends undefined
+      ? EventParams<Event[EventKey]>
+      : EventParamsWithExtra<Event[EventKey], Extra>;
+};

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

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

package/src/domains/sounds/Sounds.const.ts

@@ -0,0 +1,25 @@
+export const SOUND_NAME = {
+  BATTLE_GOD_ACTIVATION: 'battle_god_activation.mp3',
+  BATTLE_LASER_ACTIVATION: 'battle_laser_activation.mp3',
+  BATTLE_LASER_DAMAGE: 'battle_laser_damage.mp3',
+  BATTLE_PULSE_ACTIVATION: 'battle_pulse_activation.mp3',
+  BATTLE_PULSE_DAMAGE: 'battle_pulse_damage.mp3',
+  BATTLE_SHIELD_ACTIVATION: 'battle_shield_activation.mp3',
+  BATTLE_SHOT_ACTIVATION: 'battle_shot_activation.mp3',
+  BATTLE_SHOT_DAMAGE: 'battle_shot_damage.mp3',
+  BATTLE_STAR_DAMAGE: 'battle_star_damage.mp3',
+  BATTLE_TRAP_ACTIVATION: 'battle_trap_activation.mp3',
+  BATTLE_TRAP_DAMAGE: 'battle_trap_damage.mp3',
+  BATTLE_TURBO_ACTIVATION: 'battle_turbo_activation.mp3',
+  COUNTDOWN_3_2_1: 'countdown_3_2_1.mp3',
+  EMERGENCY_ALERT: 'emergency_alert.mp3',
+  ENGINE_START: 'engine_start.mp3',
+  FINAL_LAP_MARIO_KART: 'final_lap_mario_kart.mp3',
+  KART_SKIDING: 'kart_skiding.mp3',
+  PICK_COIN_X2: 'pick_coin_x2.mp3',
+  POWER_UP_SELECTION: 'power_up_selection.mp3',
+  SAD_TRUMPET_LOSER: 'sad_trumpet_loser.mp3',
+  SYSTEM_STARTED: 'system_started.mp3',
+  WARNING_ALERT_THIS_IS_NOT_A_TEST: 'warning_alert_this_is_not_a_test.mp3',
+  WINNER_LAUGH: 'winner_laugh.mp3',
+} as const;

package/src/domains/sounds/Sounds.schema.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { SOUND_NAME } from './Sounds.const';
+
+export const soundNameSchema = z.enum(SOUND_NAME);

package/src/domains/sounds/Sounds.types.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { soundNameSchema } from './Sounds.schema';
+
+export type SoundName = z.infer<typeof soundNameSchema>;

package/src/domains/sounds/index.ts

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

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

@@ -0,0 +1,12 @@
+export const PAYMENT_PROVIDERS = {
+  STRIPE: 'stripe',
+  PAYPAL: 'paypal',
+} as const;
+
+export const PAYMENT_STATUSES = {
+  PENDING: 'pending',
+  COMPLETED: 'completed',
+  FAILED: 'failed',
+  REFUNDED: 'refunded',
+  CANCELLED: 'cancelled',
+} as const;

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { PAYMENT_PROVIDERS, PAYMENT_STATUSES } from './Payment.const';
+
+export const paymentProviderNameSchema = z.enum(PAYMENT_PROVIDERS);
+
+export const paymentStatusSchema = z.enum(PAYMENT_STATUSES);
+
+export const paymentProviderDataSchema = z.object({
+  provider: paymentProviderNameSchema,
+  paymentIntentId: z.string().optional(),
+  transactionId: z.string(),
+  amountPaid: z.number(),
+  currency: z.string(),
+  paymentStatus: paymentStatusSchema,
+  paymentMethod: z.string().optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+});

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

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { paymentProviderDataSchema, paymentProviderNameSchema, paymentStatusSchema } from './Payment.schema';
+
+export type PaymentProviderName = z.infer<typeof paymentProviderNameSchema>;
+export type PaymentStatus = z.infer<typeof paymentStatusSchema>;
+export type PaymentProviderData = z.infer<typeof paymentProviderDataSchema>;
+
+/**
+ * @deprecated
+ * TODO: REMOVE THIS INTERFACE, move it to the backend
+ * Strategy interface for payment providers
+ */
+export interface PaymentProvider {
+  /**
+   * Confirm and validate a purchase from webhook payload
+   */
+  confirmPurchase(payload: any, signature?: string): Promise<PaymentProviderData>;
+
+  /**
+   * Validate webhook signature if provided
+   */
+  validateWebhookSignature?(payload: any, signature: string): boolean;
+
+  /**
+   * Get provider name
+   */
+  getProviderName(): string;
+}

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

@@ -0,0 +1,44 @@
+export const GAME_TICKET_STATUS = {
+  CREATED: 'created',
+  ASSIGNED: 'assigned',
+  ACTIVE: 'active',
+  COMPLETED: 'completed',
+} as const;
+
+export const TICKET_USER_TYPE = {
+  LEADER: 'leader',
+  SUB_USER: 'sub-user',
+  EXISTING: 'existing',
+  GUEST: 'guest',
+} as const;
+
+export const TICKET_TYPE = {
+  RACE: 'race',
+  BATTLE: 'battle',
+  SOCCER: 'soccer',
+} as const;
+
+export const GAME_TURN_STATUS = {
+  CREATED: 'created',
+  IN_QUEUE: 'in_queue',
+  READY: 'ready',
+  PLAYING: 'playing',
+  COMPLETED: 'completed',
+} as const;
+
+export const GAME_TURN_CHECK = {
+  TUTORIAL: 'tutorial',
+  AGE_VERIFICATION: 'age_verification',
+  TERMS_ACCEPTANCE: 'terms_acceptance',
+} as const;
+
+export const GAME_TURN_TASK_TYPE = {
+  QR_SCAN: 'qr_scan',
+  MANUAL_CHECK: 'manual_check',
+  LINK_ACCEPT: 'link_accept',
+} as const;
+
+export const GAME_TURN_TASK_STATUS = {
+  PENDING: 'pending',
+  COMPLETED: 'completed',
+} as const;

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

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+import {
+  GAME_TICKET_STATUS,
+  GAME_TURN_CHECK,
+  GAME_TURN_STATUS,
+  GAME_TURN_TASK_STATUS,
+  GAME_TURN_TASK_TYPE,
+  TICKET_TYPE,
+  TICKET_USER_TYPE,
+} from './Ticketing.const';
+
+export const gameTicketStatusSchema = z.enum(GAME_TICKET_STATUS);
+export const ticketUserTypeSchema = z.enum(TICKET_USER_TYPE);
+export const ticketTypeSchema = z.enum(TICKET_TYPE);
+export const ticketSummarySchema = z.record(ticketTypeSchema, z.number());
+
+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),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  completedAt: z.date().optional(),
+});
+
+export const purchaseSchema = z.object({
+  id: z.string(),
+  purchaseNumber: z.number(),
+  buyerUserId: z.string(),
+  totalTickets: z.number(),
+  purchaseDate: z.date(),
+  ticketType: ticketTypeSchema.default(TICKET_TYPE.RACE),
+  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 gameTurnStatusSchema = z.enum(GAME_TURN_STATUS);
+
+export const gameTurnCheckSchema = z.enum(GAME_TURN_CHECK);
+
+export const gameTurnTaskTypeSchema = z.enum(GAME_TURN_TASK_TYPE);
+
+export const gameTurnTaskStatusSchema = z.enum(GAME_TURN_TASK_STATUS);
+
+export const gameTurnTaskSchema = z.object({
+  id: z.string(),
+  type: gameTurnTaskTypeSchema,
+  status: gameTurnTaskStatusSchema,
+  label: z.string(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  completedAt: z.date().optional(),
+});
+
+export const gameTurnSchema = z.object({
+  id: z.string(),
+  purchaseId: z.string(),
+  leaderUsername: z.string(),
+  gameTickets: z.array(z.string()),
+  usernames: z.array(z.string()),
+  status: gameTurnStatusSchema,
+  tasks: z.array(gameTurnTaskSchema),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  startedAt: z.date().optional(),
+  completedAt: z.date().optional(),
+});
+
+export const gameTurnQueueItemSchema = gameTurnSchema.extend({
+  position: z.number(),
+});

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

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import {
+  createPurchaseInternalSchema,
+  createPurchasePublicSchema,
+  gameTicketSchema,
+  gameTicketStatusSchema,
+  gameTurnCheckSchema,
+  gameTurnQueueItemSchema,
+  gameTurnSchema,
+  gameTurnStatusSchema,
+  gameTurnTaskSchema,
+  gameTurnTaskStatusSchema,
+  gameTurnTaskTypeSchema,
+  purchaseSchema,
+  ticketSummarySchema,
+  ticketTypeSchema,
+  ticketUserTypeSchema,
+} from './Ticketing.schema';
+
+export type TicketType = z.infer<typeof ticketTypeSchema>;
+export type GameTicketStatus = z.infer<typeof gameTicketStatusSchema>;
+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 GameTicket = z.infer<typeof gameTicketSchema>;
+
+export type GameTurnStatus = z.infer<typeof gameTurnStatusSchema>;
+export type GameTurnCheck = z.infer<typeof gameTurnCheckSchema>;
+export type GameTurnTaskType = z.infer<typeof gameTurnTaskTypeSchema>;
+export type GameTurnTaskStatus = z.infer<typeof gameTurnTaskStatusSchema>;
+export type GameTurnTask = z.infer<typeof gameTurnTaskSchema>;
+export type GameTurn = z.infer<typeof gameTurnSchema>;
+export type GameTurnQueueItem = z.infer<typeof gameTurnQueueItemSchema>;

package/src/domains/ticketing/index.ts

@@ -0,0 +1,6 @@
+export * from './Payment.const';
+export * from './Payment.schema';
+export * from './Payment.types';
+export * from './Ticketing.const';
+export * from './Ticketing.schema';
+export * from './Ticketing.types';

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

@@ -0,0 +1,4 @@
+export const USER_TYPE = {
+  STAFF: 'STAFF',
+  PLAYER: 'PLAYER',
+} as const;

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { userRoleSchema } from '../role';
+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(),
+  role: userRoleSchema,
+  type: userTypeSchema,
+});
+
+export const userWithPasswordSchema = userSchema.extend({
+  password: z.string(),
+});

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

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { userSchema, userTypeSchema, 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>;

package/src/domains/user/index.ts

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

package/src/domains/utils/Utils.schema.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+
+export const arithmeticOperatorSchema = z.enum(['+', '-', '*', '/']);
+
+// Regex for SimpleArithmeticString: check for operator followed by numbers
+export const simpleArithmeticStringSchema = z.string().regex(/^[\+\-\*\/]-?\d+(\.\d+)?$/);
+
+// Regex for ContextArithmeticString: $variable operator number
+export const kartContextVariableSchema = z.enum(['$kart.configuredSpeed', '$kart.powerUpTime']);
+
+export const contextArithmeticStringSchema = z.string().regex(/^\$[a-zA-Z0-9\.]+\s[\+\-\*\/]\s-?\d+(\.\d+)?$/);
+
+export const arithmeticExpressionSchema = z.union([
+  z.number(),
+  simpleArithmeticStringSchema,
+  contextArithmeticStringSchema,
+]);

package/src/domains/utils/Utils.types.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import {
+  arithmeticExpressionSchema,
+  arithmeticOperatorSchema,
+  kartContextVariableSchema,
+  simpleArithmeticStringSchema,
+  contextArithmeticStringSchema,
+} from './Utils.schema';
+
+export type ArithmeticOperator = z.infer<typeof arithmeticOperatorSchema>;
+
+/**
+ * The Value is determined by an arithmetic operator followed by a number.
+ */
+export type SimpleArithmeticString = z.infer<typeof simpleArithmeticStringSchema>;
+
+export type KartContextVariable = z.infer<typeof kartContextVariableSchema>;
+
+export type ContextVariable = KartContextVariable;
+
+export type ContextArithmeticString = z.infer<typeof contextArithmeticStringSchema>;
+
+// Union of all possible expression formats
+export type ArithmeticExpression = z.infer<typeof arithmeticExpressionSchema>;
+
+// Create a type from the object values
+export type ObjectValues<T> = T[keyof T];

package/src/domains/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './Utils.schema';
+export * from './Utils.types';

package/src/index.ts

@@ -1,4 +1,3 @@
-export * from './constants';
 export * from './data';
-export * from './types';
+export * from './domains';
 export * from './utils';

package/src/utils/roles.utils.ts

@@ -1,6 +1,5 @@
-import { USER_ROLE } from '../constants';
 import { ROLE_DEFINITIONS } from '../data';
-import { Permission, UserRole } from '../types';
+import { Permission, USER_ROLE, UserRole } from '../domains';
 
 export function hasPermission(userRole: UserRole, requiredPermission: Permission): boolean {
   if (userRole === USER_ROLE.SUPER_ADMIN) {

package/README.md

@@ -1,3 +0,0 @@
-# Battle Racing Common Library
-
-This is the common library with shared utilities and types to share to all Battle Racing Repositories