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

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

@@ -0,0 +1,98 @@
+import { z } from 'zod';
+import {
+  GAME_TICKET_STATUS,
+  GAME_TURN_CHECK,
+  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);
+export const ticketTypeSchema = z.enum(TICKET_TYPE);
+export const ticketSummarySchema = z.record(ticketTypeSchema, z.number());
+
+export const gameTicketSchema = z.object({
+  id: z.uuidv4(),
+  purchaseId: z.string(),
+  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(),
+  updatedAt: z.date(),
+  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.uuidv4(),
+  purchaseNumber: z.number(),
+
+  // Buyer can be null for Guest/On-Site purchases
+  buyerUserId: 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 createPurchaseInputSchema = z.object({
+  buyerUserId: z.string().optional(),
+  items: z.array(purchaseItemSchema).min(1),
+});
+
+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(),
+  leaderPlayerId: z.string(),
+  gameTickets: z.array(z.string()),
+  playerIds: 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,35 @@
+import { z } from 'zod';
+import {
+  createPurchaseInputSchema,
+  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 CreatePurchaseInput = z.infer<typeof createPurchaseInputSchema>;
+
+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,72 @@
+import { z } from 'zod';
+import { userRoleSchema } from '../role';
+import { USER_TYPE } from './User.const';
+
+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;
+
+const baseUserObj = z.object({
+  id: z.uuidv4(),
+
+  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.and(
+  z.object({
+    password: z.string().min(MIN_PASSWORD_LENGTH),
+  }),
+);
+
+export const userRegistrationInputSchema = baseUserObj
+  .pick({
+    email: true,
+    phoneNumber: true,
+  })
+  .extend({
+    name: z.string().optional(),
+    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/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/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"
-		}
-	]
-}

package/dist/schemas/team.schema.d.ts

@@ -1,7 +0,0 @@
-import { z } from 'zod';
-export declare const TeamSchema: z.ZodObject<{
-    name: z.ZodString;
-    imageUrl: z.ZodOptional<z.ZodURL>;
-    fanatismo: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type Team = z.infer<typeof TeamSchema>;

package/dist/schemas/team.schema.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TeamSchema = void 0;
-const zod_1 = require("zod");
-exports.TeamSchema = zod_1.z.object({
-    name: zod_1.z.string().min(3).max(50),
-    imageUrl: zod_1.z.url().optional(),
-    fanatismo: zod_1.z.number().int().min(0).max(100).optional(),
-});

package/dist/types/ticketing/GameTicket.d.ts

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

package/dist/types/ticketing/PlayerTurn.d.ts

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

package/dist/types/ticketing/Purchase.d.ts

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

package/src/constants/index.ts

@@ -1,8 +0,0 @@
-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';

package/src/schemas/team.schema.ts

@@ -1,9 +0,0 @@
-import { z } from 'zod';
-
-export const TeamSchema = z.object({
-  name: z.string().min(3).max(50),
-  imageUrl: z.url().optional(),
-  fanatismo: z.number().int().min(0).max(100).optional(),
-});
-
-export type Team = z.infer<typeof TeamSchema>;

package/src/types/hardware/rgb/RGBStatus.ts

@@ -1,4 +0,0 @@
-import { RGB_STATUS } from '../../../constants/hardware/rgb-status';
-import type { ObjectValues } from '../../utils';
-
-export type RGBStatus = ObjectValues<typeof RGB_STATUS >;

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

@@ -1,29 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,29 +0,0 @@
-// 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/ticketing/GameTicket.ts

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

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

@@ -1,49 +0,0 @@
-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/Purchase.ts

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

package/src/types/ticketing/index.ts

@@ -1,9 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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(),
-});