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

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import {
+  createRacingTeamSchema,
+  paginatedRacingTeamSchema,
+  paginatedRacingTeamSummarySchema,
+  racingTeamSchema,
+  racingTeamSummarySchema,
+  updateRacingTeamSchema,
+} from './RacingTeam.schema';
+
+export type RacingTeam = z.infer<typeof racingTeamSchema>;
+export type CreateRacingTeamInput = z.infer<typeof createRacingTeamSchema>;
+export type UpdateRacingTeamInput = z.infer<typeof updateRacingTeamSchema>;
+export type PaginatedRacingTeam = z.infer<typeof paginatedRacingTeamSchema>;
+export type RacingTeamSummary = z.infer<typeof racingTeamSummarySchema>;
+export type PaginatedRacingTeamSummary = z.infer<typeof paginatedRacingTeamSummarySchema>;

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

@@ -0,0 +1,30 @@
+// libs/common/src/schemas/racing-team-membership.ts
+
+import { z } from 'zod';
+import { RACING_TEAM_ROLE } from '../../../constants';
+
+export const joinRequestSchema = z.object({
+  id: z.string(),
+  racingTeamId: z.string(),
+  userId: z.string(),
+  status: z.enum(['PENDING', 'ACCEPTED', 'REJECTED'] as const),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+
+export const teamMemberSchema = z.object({
+  racingTeamId: z.string(),
+  userId: z.string(),
+  role: z.enum(RACING_TEAM_ROLE),
+  joinedAt: z.date(),
+});
+
+export const createJoinRequestSchema = z.object({
+  racingTeamId: z.string(),
+});
+
+export const answerJoinRequestSchema = z.object({
+  racingTeamId: z.string(),
+  targetUserId: z.string(),
+  accepted: z.boolean(),
+});

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

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import {
+  joinRequestSchema,
+  teamMemberSchema,
+  createJoinRequestSchema,
+  answerJoinRequestSchema,
+} from './RacingTeamMembership.schema';
+
+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>;

package/src/__deprecated__/types/racingTeam/index.ts

@@ -0,0 +1,4 @@
+export * from './RacingTeam';
+export * from './RacingTeam.schema';
+export * from './RacingTeamMembership';
+export * from './RacingTeamMembership.schema';

package/src/__deprecated__/types/response/index.ts

@@ -0,0 +1,3 @@
+export type { ErrorResponse } from './ErrorResponse';
+export type { SuccessResponse } from './SuccessResponse';
+export type { Response } from './Response';

package/src/{types → __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/{types → __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/role/index.ts

@@ -0,0 +1,3 @@
+export * from './Permission';
+export * from './RoleDefinition';
+export * from './UserRole';

package/src/__deprecated__/types/socket/clientToServer/index.ts

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

package/src/__deprecated__/types/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/__deprecated__/types/socket/inputs/index.ts

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

package/src/{types → __deprecated__/types}/socket/serverToClient/SocketKartServerToClientEventsParams.ts

@@ -1,5 +1,5 @@
 import type { Game, GameType } from '../../game';
-import type { GameTrack } from '../../gameTrack';
+import type { GameTrack, GameTrackKartConfig, GameTrackKartsConfig } from '../../gameTrack';
 import type { Kart, KartStatus } from '../../kart';
 import type { Response } from '../../response';
 import type { SocketPowerUpEventsParams } from '../SocketPowerUpEventsParams';
@@ -15,11 +15,10 @@ export type SocketKartPowerUpEventsParams = {
 };
 
 export interface SocketKartEventsParams {
-  'kart:updated': { kart: Kart };
   // Response from server
   'kart:init:response': Response<{ kart: Kart; gameTrack: GameTrack }>;
-  /** Whenever the Game Track config changed */
-  'kart:gameTrack:updated': { 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 */

package/src/__deprecated__/types/socket/serverToClient/index.ts

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

package/src/__deprecated__/types/socket/utils/index.ts

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

package/src/__deprecated__/types/sounds/index.ts

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

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

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { GameTurnTaskSchema } from './GameTurnTask.schema';
+
+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 GameTurnStatusSchema = z.enum([
+  GAME_TURN_STATUS.CREATED,
+  GAME_TURN_STATUS.IN_QUEUE,
+  GAME_TURN_STATUS.READY,
+  GAME_TURN_STATUS.PLAYING,
+  GAME_TURN_STATUS.COMPLETED,
+]);
+
+export const GameTurnCheckSchema = z.enum([
+  GAME_TURN_CHECK.TUTORIAL,
+  GAME_TURN_CHECK.AGE_VERIFICATION,
+  GAME_TURN_CHECK.TERMS_ACCEPTANCE,
+]);
+
+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(),
+});
+
+// The Game turn queue item requires a position to sort it.
+export const GameTurnQueueItemSchema = GameTurnSchema.extend({
+  position: z.number(),
+});

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

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { GameTurnQueueItemSchema, GameTurnSchema } from './GameTurn.schema';
+
+export type GameTurn = z.infer<typeof GameTurnSchema>;
+
+export type GameTurnQueueItem = z.infer<typeof GameTurnQueueItemSchema>;

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

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+
+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;
+
+export const GameTurnTaskTypeSchema = z.enum([
+  GAME_TURN_TASK_TYPE.QR_SCAN,
+  GAME_TURN_TASK_TYPE.MANUAL_CHECK,
+  GAME_TURN_TASK_TYPE.LINK_ACCEPT,
+] as const);
+
+export const GameTurnTaskStatusSchema = z.enum([
+  GAME_TURN_TASK_STATUS.PENDING,
+  GAME_TURN_TASK_STATUS.COMPLETED,
+] as const);
+
+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(),
+});

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

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

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

@@ -0,0 +1,40 @@
+import { PAYMENT_PROVIDERS, PAYMENT_STATUSES } from '../../../constants';
+
+export type PaymentProviderName = (typeof PAYMENT_PROVIDERS)[keyof typeof PAYMENT_PROVIDERS];
+
+export type PaymentStatus = (typeof PAYMENT_STATUSES)[keyof typeof PAYMENT_STATUSES];
+
+/**
+ * Generic payment provider data that can be reused across different providers
+ * This allows easy switching between Stripe, PayPal, etc.
+ */
+export interface PaymentProviderData {
+  provider: PaymentProviderName;
+  paymentIntentId?: string;
+  transactionId: string;
+  amountPaid: number;
+  currency: string;
+  paymentStatus: PaymentStatus;
+  paymentMethod?: string;
+  metadata?: Record<string, any>;
+}
+
+/**
+ * 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/__deprecated__/types/ticketing/Ticketing.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import {
+  PurchaseSchema,
+  GameTicketSchema,
+  TicketUserTypeSchema,
+  TicketTypeSchema,
+  GameTicketStatusSchema,
+  CreatePurchasePublicSchema,
+  CreatePurchaseInternalSchema,
+  TicketSummarySchema,
+} from './ticketing.schemas';
+
+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>;

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

@@ -0,0 +1,7 @@
+export * from './GameTurn';
+export * from './GameTurn.schema';
+export * from './GameTurnTask';
+export * from './GameTurnTask.schema';
+export * from './PaymentProvider';
+export * from './ticketing.schemas';
+export * from './Ticketing';

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

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+
+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 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(),
+});
+
+/**
+ * Probably temporary as the purchase will be a webhook called by the provider (Stripe, PayPal, etc)
+ */
+export const CreatePurchasePublicSchema = PurchaseSchema.pick({
+  ticketType: true,
+}).extend({
+  ticketCount: z.number(),
+});
+
+/**
+ * The public input doesn't receive a userId, as it's resolved on the backend
+ */
+export const CreatePurchaseInternalSchema = PurchaseSchema.pick({
+  ticketType: true,
+  buyerUserId: true,
+}).extend({
+  ticketCount: z.number(),
+});

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

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import { UserSchema, UserWithPasswordSchema } from './user.schema';
+
+export type User = z.infer<typeof UserSchema>;
+export type UserWithPassword = z.infer<typeof UserWithPasswordSchema>;

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

@@ -0,0 +1,5 @@
+export * from './User';
+export * from './user-type.schema';
+export * from './user.schema';
+export { USER_TYPE } from './user-type.schema';
+

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

@@ -0,0 +1,8 @@
+import z from 'zod';
+
+export const USER_TYPE = {
+  STAFF: 'STAFF',
+  PLAYER: 'PLAYER',
+} as const;
+
+export const UserTypeSchema = z.enum(USER_TYPE);

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+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);
+
+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/__deprecated__/types/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './ObjectValues';
+export * from './ArithmeticString';

package/src/constants/index.ts

@@ -2,6 +2,8 @@ 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/constants/payment-provider.ts

@@ -0,0 +1,5 @@
+export const PAYMENT_PROVIDERS = {
+  STRIPE: 'stripe',
+  PAYPAL: 'paypal',
+  OTHER: 'other',
+} as const;

package/src/constants/payment-status.ts

@@ -0,0 +1,7 @@
+export const PAYMENT_STATUSES = {
+  PENDING: 'pending',
+  COMPLETED: 'completed',
+  FAILED: 'failed',
+  REFUNDED: 'refunded',
+  CANCELLED: 'cancelled',
+} as const;

package/src/constants/racing-team-role.ts

@@ -0,0 +1,5 @@
+export const RACING_TEAM_ROLE = {
+  PILOT: 'PILOT',
+  TECHNICIAN: 'TECHNICIAN',
+  COACH: 'COACH',
+} as const;

package/src/constants/user-role.ts

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

package/src/data/all-damages.ts

@@ -1,5 +1,4 @@
-import { FLAG_MEDIA_NAME } from '../constants';
-import type { Damage } from '../types';
+import { Damage, FLAG_MEDIA_NAME } from '../domains';
 
 export const allDamages: Damage[] = [
   {

package/src/data/all-power-ups.ts

@@ -1,5 +1,4 @@
-import { FLAG_MEDIA_NAME } from '../constants';
-import type { PowerUp } from '../types';
+import { FLAG_MEDIA_NAME, PowerUp } from '../domains';
 
 export const allPowerUps: PowerUp[] = [
   {

package/src/data/role-definitions.ts

@@ -1,5 +1,4 @@
-import { PERMISSION, USER_ROLE } from '../constants';
-import type { RoleDefinition } from '../types/role/RoleDefinition';
+import { PERMISSION, RoleDefinition, USER_ROLE } from '../domains';
 
 export const ROLE_DEFINITIONS: RoleDefinition[] = [
   {

package/src/domains/checkpoint/Checkpoint.const.ts

@@ -0,0 +1,6 @@
+export const CHECKPOINT_TYPE = {
+  TRACK: 'Track',
+  POWER_UP: 'PowerUp',
+  SHORTCUT: 'Shortcut',
+  UNKNOWN: 'Unknown',
+} as const;

package/src/domains/checkpoint/Checkpoint.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { CHECKPOINT_TYPE } from './Checkpoint.const';
+
+export const checkpointTypeSchema = z.enum(CHECKPOINT_TYPE);
+
+export const checkpointSchema = z.object({
+  id: z.string(),
+  address: z.number(),
+  name: z.string().optional(),
+  type: checkpointTypeSchema,
+  progress: z.number(),
+});

package/src/domains/checkpoint/Checkpoint.types.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import { checkpointSchema, checkpointTypeSchema } from './Checkpoint.schema';
+
+export type CheckpointType = z.infer<typeof checkpointTypeSchema>;
+export type Checkpoint = z.infer<typeof checkpointSchema>;

package/src/domains/checkpoint/index.ts

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

package/src/domains/color/Color.const.ts

@@ -0,0 +1,14 @@
+export const COLOR_NAME = {
+  Black: 'Black',
+  Red: 'Red',
+  Blue: 'Blue',
+  Green: 'Green',
+  Yellow: 'Yellow',
+  Violet: 'Violet',
+  Cyan: 'Cyan',
+  Magenta: 'Magenta',
+  Orange: 'Orange',
+  White: 'White',
+  GreenYellow: 'GreenYellow',
+  SaddleBrown: 'SaddleBrown',
+} as const;

package/src/domains/color/Color.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { COLOR_NAME } from './Color.const';
+
+export const colorNameSchema = z.enum(COLOR_NAME);
+
+export const colorInfoSchema = z.object({
+  fastLedId: z.number(),
+  hex: z.string(),
+});

package/src/domains/color/Color.types.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import { colorInfoSchema, colorNameSchema } from './Color.schema';
+
+export type ColorName = z.infer<typeof colorNameSchema>;
+export type ColorInfo = z.infer<typeof colorInfoSchema>;

package/src/domains/color/index.ts

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