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

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

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { paginatedResponseSchema } from '../pagination';
+
+export const racingTeamSchema = z.object({
+  id: z.string(),
+  name: z.string().min(3).max(50),
+  imageUrl: z.string().url().optional(),
+  adminUserId: z.string(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+
+export const createRacingTeamSchema = racingTeamSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true,
+});
+
+export const updateRacingTeamSchema = racingTeamSchema.partial();
+
+export const filterRacingTeamSchema = z.object({
+  name: z.string().optional(),
+  adminUserId: z.string().optional(),
+  page: z.number().min(1).default(1),
+  limit: z.number().min(1).max(100).default(10),
+  cursor: z.string().optional(),
+});
+
+export const paginatedRacingTeamSchema = paginatedResponseSchema(racingTeamSchema);

package/src/types/racingTeam/RacingTeam.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import {
+  createRacingTeamSchema,
+  paginatedRacingTeamSchema,
+  racingTeamSchema,
+  updateRacingTeamSchema,
+} from './RacingTeam.schema';
+
+export type RacingTeam = z.infer<typeof racingTeamSchema>;
+export type CreateRacingTeamDto = z.infer<typeof createRacingTeamSchema>;
+export type UpdateRacingTeamDto = z.infer<typeof updateRacingTeamSchema>;
+export type PaginatedRacingTeam = z.infer<typeof paginatedRacingTeamSchema>;

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

@@ -0,0 +1,29 @@
+// libs/common/src/schemas/racing-team-membership.ts
+
+import { z } from 'zod';
+
+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(['PILOT', 'TECHNICIAN', 'COACH'] as const),
+  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/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/types/racingTeam/index.ts

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

package/src/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/types/ticketing/GameTicket.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { GameTicketSchema } from './ticketing.schemas';
+
+export type GameTicket = z.infer<typeof GameTicketSchema>;

package/src/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/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/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/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/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/types/ticketing/Purchase.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { PurchaseSchema } from './ticketing.schemas';
+
+export type Purchase = z.infer<typeof PurchaseSchema>;

package/src/types/ticketing/index.ts

@@ -0,0 +1,9 @@
+export * from './GameTicket';
+export * from './PaymentProvider';
+export * from './GameTurn';
+export * from './Purchase';
+export * from './ticketing.schemas';
+export * from './ticketing.schemas';
+export * from './GameTurnTask';
+export * from './GameTurnTask.schema';
+export * from './GameTurn.schema';

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

@@ -0,0 +1,43 @@
+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 GameTicketStatusSchema = z.enum(GAME_TICKET_STATUS);
+export const TicketUserTypeSchema = z.enum(TICKET_USER_TYPE);
+
+export const GameTicketSchema = z.object({
+  id: z.string(),
+  purchaseId: z.string(),
+  gameTurnId: z.string(),
+  ownerUsername: z.string(),
+  userType: TicketUserTypeSchema,
+  status: GameTicketStatusSchema,
+  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(),
+  availableTickets: z.number(),
+  usedTickets: z.number(),
+  purchaseDate: z.date(),
+  paymentData: z.any().optional(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});

package/src/types/user/User.ts

@@ -1,10 +1,5 @@
-import type { UserRole } from '../role/UserRole';
-import type { UserOrigin } from './UserOrigin';
+import { z } from 'zod';
+import { UserSchema, UserWithPasswordSchema } from './user.schema';
 
-export interface User {
-  id: string;
-  username: string;
-  name: string;
-  origin: UserOrigin;
-  role: UserRole;
-}
+export type User = z.infer<typeof UserSchema>;
+export type UserWithPassword = z.infer<typeof UserWithPasswordSchema>;

package/src/types/user/index.ts

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

package/src/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/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/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

package/dist/data/RoleDefinitions.d.ts

@@ -1,2 +0,0 @@
-import type { RoleDefinition } from '../types/role/RoleDefinition';
-export declare const ROLE_DEFINITIONS: RoleDefinition[];

package/dist/data/RoleDefinitions.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ROLE_DEFINITIONS = void 0;
-const constants_1 = require("../constants");
-exports.ROLE_DEFINITIONS = [
-    {
-        role: constants_1.USER_ROLE.SUPER_ADMIN,
-        description: 'Complete access to all features and settings',
-        permissions: [
-            constants_1.PERMISSION.FULL_ACCESS,
-            constants_1.PERMISSION.KARTS_MANAGE_HARDWARE,
-            constants_1.PERMISSION.KARTS_MANAGE_POWER_UPS,
-            constants_1.PERMISSION.GAME_TRACK_MANAGE_GAMES,
-            constants_1.PERMISSION.GAME_TRACK_MANAGE_BASIC_INFO,
-            constants_1.PERMISSION.GAME_TRACK_MANAGE_HARDWARE,
-            constants_1.PERMISSION.GAME_TRACK_MANAGE_KARTS_CONFIG,
-            constants_1.PERMISSION.GAME_TRACK_MANAGE_CHECKPOINTS,
-            constants_1.PERMISSION.GAME_TRACK_MANAGE_KARTS,
-            constants_1.PERMISSION.KARTS_TRACKING,
-        ],
-    },
-    {
-        role: constants_1.USER_ROLE.OPERATOR,
-        description: 'Game Track Operator',
-        permissions: [constants_1.PERMISSION.GAME_TRACK_MANAGE_GAMES],
-    },
-];

package/dist/types/hardware/screen/ScreenKartPosition.d.ts

@@ -1,4 +0,0 @@
-export type ScreenKartPosition = {
-    currentPosition: number | null;
-    totalKarts: number | null;
-};

package/dist/types/hardware/screen/ScreenRaceLaps.d.ts

@@ -1,4 +0,0 @@
-export type ScreenRaceLaps = {
-    currentLap: number | null;
-    totalLaps: number | null;
-};

package/dist/types/response/SuccesResponse.d.ts

@@ -1,5 +0,0 @@
-export interface SuccessResponse<T> {
-    status: 'success';
-    code: 200;
-    data?: T;
-}

package/dist/types/user/UserOrigin.d.ts

@@ -1 +0,0 @@
-export type UserOrigin = 'webapp' | 'hardware';

package/src/types/user/UserOrigin.ts

@@ -1 +0,0 @@
-export type UserOrigin = 'webapp' | 'hardware';