@battle-racing/br-common-lib 4.6.1 → 4.6.2

package/.gemini/settings.json

@@ -0,0 +1,10 @@
+{
+  "mcpServers": {
+    "br-common-lib": {
+      "command": "node",
+      "args": [
+        "/Users/jdmaldonado/Documents/dev.nosync/battle-racing/br-common-lib/dist/mcp-server/index.js"
+      ]
+    }
+  }
+}

package/dist/domains/ticketing/Ticketing.schema.d.ts

@@ -85,6 +85,57 @@ export declare const purchaseSchema: z.ZodObject<{
     createdAt: z.ZodDate;
     updatedAt: z.ZodDate;
 }, z.core.$strip>;
+export declare const filterPurchaseSchema: z.ZodObject<{
+    purchaseNumber: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    buyerUserId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        readonly PENDING: "pending";
+        readonly PAID: "paid";
+        readonly CANCELLED: "cancelled";
+    }>>;
+    guestName: z.ZodOptional<z.ZodString>;
+    guestContact: z.ZodOptional<z.ZodString>;
+    page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const paginatedPurchaseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        purchaseNumber: z.ZodNumber;
+        buyerUserId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        guestName: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        guestContact: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        items: z.ZodArray<z.ZodObject<{
+            ticketType: z.ZodEnum<{
+                readonly Race: "Race";
+                readonly Battle: "Battle";
+            }>;
+            quantity: z.ZodNumber;
+            priceCents: z.ZodNumber;
+        }, z.core.$strip>>;
+        totalAmountCents: z.ZodNumber;
+        status: z.ZodDefault<z.ZodEnum<{
+            readonly PENDING: "pending";
+            readonly PAID: "paid";
+            readonly CANCELLED: "cancelled";
+        }>>;
+        totalTickets: z.ZodOptional<z.ZodNumber>;
+        ticketType: z.ZodOptional<z.ZodEnum<{
+            readonly RACE: "race";
+            readonly BATTLE: "battle";
+            readonly SOCCER: "soccer";
+        }>>;
+        paymentData: z.ZodOptional<z.ZodAny>;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+    }, z.core.$strip>>;
+    meta: z.ZodObject<{
+        nextCursor: z.ZodOptional<z.ZodString>;
+        hasMore: z.ZodOptional<z.ZodBoolean>;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export declare const createPurchaseInputSchema: z.ZodObject<{
     buyerUserId: z.ZodOptional<z.ZodString>;
     guestName: z.ZodOptional<z.ZodString>;

package/dist/domains/ticketing/Ticketing.schema.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.gameTurnQueueItemSchema = exports.gameTurnSchema = exports.gameTurnTaskSchema = exports.gameTurnTaskStatusSchema = exports.gameTurnTaskTypeSchema = exports.gameTurnCheckSchema = exports.gameTurnStatusSchema = exports.createPurchaseInputSchema = exports.purchaseSchema = exports.purchaseItemSchema = exports.purchaseStatusSchema = exports.gameTicketSchema = exports.ticketSummarySchema = exports.ticketTypeSchema = exports.ticketUserTypeSchema = exports.gameTicketStatusSchema = void 0;
+exports.gameTurnQueueItemSchema = exports.gameTurnSchema = exports.gameTurnTaskSchema = exports.gameTurnTaskStatusSchema = exports.gameTurnTaskTypeSchema = exports.gameTurnCheckSchema = exports.gameTurnStatusSchema = exports.createPurchaseInputSchema = exports.paginatedPurchaseSchema = exports.filterPurchaseSchema = exports.purchaseSchema = exports.purchaseItemSchema = exports.purchaseStatusSchema = exports.gameTicketSchema = exports.ticketSummarySchema = exports.ticketTypeSchema = exports.ticketUserTypeSchema = exports.gameTicketStatusSchema = void 0;
 const zod_1 = require("zod");
+const pagination_1 = require("../pagination");
 const Ticketing_const_1 = require("./Ticketing.const");
 const game_1 = require("../game");
 exports.gameTicketStatusSchema = zod_1.z.enum(Ticketing_const_1.GAME_TICKET_STATUS);
@@ -43,6 +44,17 @@ exports.purchaseSchema = zod_1.z.object({
     createdAt: zod_1.z.date(),
     updatedAt: zod_1.z.date(),
 });
+exports.filterPurchaseSchema = zod_1.z.object({
+    purchaseNumber: zod_1.z.coerce.number().optional(),
+    buyerUserId: zod_1.z.string().optional(),
+    status: exports.purchaseStatusSchema.optional(),
+    guestName: zod_1.z.string().optional(),
+    guestContact: zod_1.z.string().optional(),
+    page: zod_1.z.coerce.number().min(1).default(1),
+    limit: zod_1.z.coerce.number().min(1).max(100).default(10),
+    cursor: zod_1.z.string().optional(),
+});
+exports.paginatedPurchaseSchema = (0, pagination_1.paginatedResponseSchema)(exports.purchaseSchema);
 exports.createPurchaseInputSchema = zod_1.z.object({
     buyerUserId: zod_1.z.string().optional(),
     guestName: zod_1.z.string().optional(),

package/dist/domains/ticketing/Ticketing.types.d.ts

@@ -1,11 +1,13 @@
 import { z } from 'zod';
-import { createPurchaseInputSchema, gameTicketSchema, gameTicketStatusSchema, gameTurnCheckSchema, gameTurnQueueItemSchema, gameTurnSchema, gameTurnStatusSchema, gameTurnTaskSchema, gameTurnTaskStatusSchema, gameTurnTaskTypeSchema, purchaseSchema, ticketSummarySchema, ticketTypeSchema, ticketUserTypeSchema } from './Ticketing.schema';
+import { createPurchaseInputSchema, filterPurchaseSchema, gameTicketSchema, gameTicketStatusSchema, gameTurnCheckSchema, gameTurnQueueItemSchema, gameTurnSchema, gameTurnStatusSchema, gameTurnTaskSchema, gameTurnTaskStatusSchema, gameTurnTaskTypeSchema, paginatedPurchaseSchema, 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 FilterPurchase = z.infer<typeof filterPurchaseSchema>;
+export type PaginatedPurchase = z.infer<typeof paginatedPurchaseSchema>;
 export type GameTicket = z.infer<typeof gameTicketSchema>;
 export type GameTurnStatus = z.infer<typeof gameTurnStatusSchema>;
 export type GameTurnCheck = z.infer<typeof gameTurnCheckSchema>;

package/dist/mcp-server/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mcp-server/index.js

@@ -0,0 +1,174 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const zod_1 = require("zod");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * MCP Server for Battle Racing Common Library
+ * This server allows other AI agents to query types, schemas and constants
+ * from the br-common-lib repository locally.
+ */
+const DOMAINS_DIR = path.resolve(__dirname, "../../src/domains");
+const server = new mcp_js_1.McpServer({
+    name: "br-common-lib-mcp",
+    version: "1.1.1",
+});
+/**
+ * List all available domains in src/domains
+ */
+async function listDomains() {
+    if (!fs.existsSync(DOMAINS_DIR)) {
+        throw new Error(`Domains directory not found at ${DOMAINS_DIR}`);
+    }
+    const entries = fs.readdirSync(DOMAINS_DIR, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name);
+}
+/**
+ * Get details for a specific domain (recursive)
+ */
+async function getDomainDetails(domain) {
+    const domainPath = path.join(DOMAINS_DIR, domain);
+    if (!fs.existsSync(domainPath)) {
+        throw new Error(`Domain "${domain}" not found at ${domainPath}`);
+    }
+    let output = `## Domain: ${domain}\n\n`;
+    function readDirRecursive(dir) {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                readDirRecursive(fullPath);
+            }
+            else if (entry.name.endsWith(".types.ts") ||
+                entry.name.endsWith(".schema.ts") ||
+                entry.name.endsWith(".const.ts") ||
+                entry.name === "index.ts") {
+                const relativePath = path.relative(domainPath, fullPath);
+                const content = fs.readFileSync(fullPath, "utf-8");
+                output += `### File: ${relativePath}\n\`\`\`typescript\n${content}\n\`\`\`\n\n`;
+            }
+        }
+    }
+    readDirRecursive(domainPath);
+    return output;
+}
+/**
+ * Search for a symbol (type, constant, etc) across all domains
+ */
+async function searchSymbol(query) {
+    const domains = await listDomains();
+    let results = [];
+    for (const domain of domains) {
+        const domainPath = path.join(DOMAINS_DIR, domain);
+        function searchInDir(dir) {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    searchInDir(fullPath);
+                }
+                else if (entry.isFile() && (entry.name.endsWith(".ts"))) {
+                    const content = fs.readFileSync(fullPath, "utf-8");
+                    if (content.includes(query)) {
+                        const lines = content.split("\n");
+                        const matchLine = lines.find(l => l.includes(query)) || "";
+                        results.push({
+                            domain,
+                            file: path.relative(DOMAINS_DIR, fullPath),
+                            match: matchLine.trim()
+                        });
+                    }
+                }
+            }
+        }
+        searchInDir(domainPath);
+    }
+    if (results.length === 0)
+        return `No results found for "${query}"`;
+    return results
+        .map(r => `- [${r.domain}] ${r.file}: \`${r.match}\``)
+        .join("\n");
+}
+// Register tools using the high-level McpServer API (registerTool)
+server.registerTool("list_domains", {
+    description: "List all available domains in br-common-lib (e.g., kart, game, powerUp)",
+}, async () => {
+    const domains = await listDomains();
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Available domains: ${domains.join(", ")}`,
+            },
+        ],
+    };
+});
+server.registerTool("get_domain_details", {
+    description: "Get all types, schemas, and constants for a specific domain (recursive)",
+    inputSchema: zod_1.z.object({
+        domain: zod_1.z.string().describe("The name of the domain (e.g., 'kart')"),
+    }),
+}, async ({ domain }) => {
+    const details = await getDomainDetails(domain);
+    return {
+        content: [{ type: "text", text: details }],
+    };
+});
+server.registerTool("search_symbol", {
+    description: "Search for a specific type, constant or property across all domains",
+    inputSchema: zod_1.z.object({
+        query: zod_1.z.string().describe("The symbol or string to search for (e.g., 'hardwareState')"),
+    }),
+}, async ({ query }) => {
+    const results = await searchSymbol(query);
+    return {
+        content: [{ type: "text", text: results }],
+    };
+});
+// Start the server
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error("Battle Racing Common Lib MCP Server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@battle-racing/br-common-lib",
-  "version": "4.6.1",
+  "version": "4.6.2",
   "description": "Common library for all Battle Racing Repositorios",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -30,10 +30,15 @@
   "license": "MIT",
   "private": false,
   "devDependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@types/node": "^25.6.0",
     "typescript": "^5.8.3",
     "zod": "^4.2.1"
   },
   "peerDependencies": {
     "zod": "^4.2.1"
+  },
+  "dependencies": {
+    "@battle-racing/br-common-lib": "^4.6.1"
   }
 }

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

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { paginatedResponseSchema } from '../pagination';
 import {
   GAME_TICKET_STATUS,
   GAME_TURN_CHECK,
@@ -59,6 +60,19 @@ export const purchaseSchema = z.object({
   updatedAt: z.date(),
 });
 
+export const filterPurchaseSchema = z.object({
+  purchaseNumber: z.coerce.number().optional(),
+  buyerUserId: z.string().optional(),
+  status: purchaseStatusSchema.optional(),
+  guestName: z.string().optional(),
+  guestContact: z.string().optional(),
+  page: z.coerce.number().min(1).default(1),
+  limit: z.coerce.number().min(1).max(100).default(10),
+  cursor: z.string().optional(),
+});
+
+export const paginatedPurchaseSchema = paginatedResponseSchema(purchaseSchema);
+
 export const createPurchaseInputSchema = z.object({
   buyerUserId: z.string().optional(),
   guestName: z.string().optional(),

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import {
   createPurchaseInputSchema,
+  filterPurchaseSchema,
   gameTicketSchema,
   gameTicketStatusSchema,
   gameTurnCheckSchema,
@@ -10,6 +11,7 @@ import {
   gameTurnTaskSchema,
   gameTurnTaskStatusSchema,
   gameTurnTaskTypeSchema,
+  paginatedPurchaseSchema,
   purchaseSchema,
   ticketSummarySchema,
   ticketTypeSchema,
@@ -23,6 +25,8 @@ export type TicketSummary = z.infer<typeof ticketSummarySchema>;
 
 export type Purchase = z.infer<typeof purchaseSchema>;
 export type CreatePurchaseInput = z.infer<typeof createPurchaseInputSchema>;
+export type FilterPurchase = z.infer<typeof filterPurchaseSchema>;
+export type PaginatedPurchase = z.infer<typeof paginatedPurchaseSchema>;
 
 export type GameTicket = z.infer<typeof gameTicketSchema>;
 

package/src/mcp-server/index.ts

@@ -0,0 +1,171 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import * as fs from "fs";
+import * as path from "path";
+
+/**
+ * MCP Server for Battle Racing Common Library
+ * This server allows other AI agents to query types, schemas and constants
+ * from the br-common-lib repository locally.
+ */
+
+const DOMAINS_DIR = path.resolve(__dirname, "../../src/domains");
+
+const server = new McpServer({
+  name: "br-common-lib-mcp",
+  version: "1.1.1",
+});
+
+/**
+ * List all available domains in src/domains
+ */
+async function listDomains() {
+  if (!fs.existsSync(DOMAINS_DIR)) {
+    throw new Error(`Domains directory not found at ${DOMAINS_DIR}`);
+  }
+
+  const entries = fs.readdirSync(DOMAINS_DIR, { withFileTypes: true });
+  return entries
+    .filter((entry: fs.Dirent) => entry.isDirectory())
+    .map((entry: fs.Dirent) => entry.name);
+}
+
+/**
+ * Get details for a specific domain (recursive)
+ */
+async function getDomainDetails(domain: string) {
+  const domainPath = path.join(DOMAINS_DIR, domain);
+
+  if (!fs.existsSync(domainPath)) {
+    throw new Error(`Domain "${domain}" not found at ${domainPath}`);
+  }
+
+  let output = `## Domain: ${domain}\n\n`;
+
+  function readDirRecursive(dir: string) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        readDirRecursive(fullPath);
+      } else if (
+        entry.name.endsWith(".types.ts") ||
+        entry.name.endsWith(".schema.ts") ||
+        entry.name.endsWith(".const.ts") ||
+        entry.name === "index.ts"
+      ) {
+        const relativePath = path.relative(domainPath, fullPath);
+        const content = fs.readFileSync(fullPath, "utf-8");
+        output += `### File: ${relativePath}\n\`\`\`typescript\n${content}\n\`\`\`\n\n`;
+      }
+    }
+  }
+
+  readDirRecursive(domainPath);
+  return output;
+}
+
+/**
+ * Search for a symbol (type, constant, etc) across all domains
+ */
+async function searchSymbol(query: string) {
+  const domains = await listDomains();
+  let results: { domain: string; file: string; match: string }[] = [];
+
+  for (const domain of domains) {
+    const domainPath = path.join(DOMAINS_DIR, domain);
+    
+    function searchInDir(dir: string) {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          searchInDir(fullPath);
+        } else if (entry.isFile() && (entry.name.endsWith(".ts"))) {
+          const content = fs.readFileSync(fullPath, "utf-8");
+          if (content.includes(query)) {
+            const lines = content.split("\n");
+            const matchLine = lines.find(l => l.includes(query)) || "";
+            results.push({
+              domain,
+              file: path.relative(DOMAINS_DIR, fullPath),
+              match: matchLine.trim()
+            });
+          }
+        }
+      }
+    }
+    searchInDir(domainPath);
+  }
+
+  if (results.length === 0) return `No results found for "${query}"`;
+
+  return results
+    .map(r => `- [${r.domain}] ${r.file}: \`${r.match}\``)
+    .join("\n");
+}
+
+// Register tools using the high-level McpServer API (registerTool)
+server.registerTool(
+  "list_domains",
+  {
+    description: "List all available domains in br-common-lib (e.g., kart, game, powerUp)",
+  },
+  async () => {
+    const domains = await listDomains();
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Available domains: ${domains.join(", ")}`,
+        },
+      ],
+    };
+  }
+);
+
+server.registerTool(
+  "get_domain_details",
+  {
+    description: "Get all types, schemas, and constants for a specific domain (recursive)",
+    inputSchema: z.object({
+      domain: z.string().describe("The name of the domain (e.g., 'kart')"),
+    }),
+  },
+  async ({ domain }) => {
+    const details = await getDomainDetails(domain);
+    return {
+      content: [{ type: "text", text: details }],
+    };
+  }
+);
+
+server.registerTool(
+  "search_symbol",
+  {
+    description: "Search for a specific type, constant or property across all domains",
+    inputSchema: z.object({
+      query: z.string().describe("The symbol or string to search for (e.g., 'hardwareState')"),
+    }),
+  },
+  async ({ query }) => {
+    const results = await searchSymbol(query);
+    return {
+      content: [{ type: "text", text: results }],
+    };
+  }
+);
+
+// Start the server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Battle Racing Common Lib MCP Server running on stdio");
+}
+
+main().catch((error) => {
+  console.error("Fatal error in main():", error);
+  process.exit(1);
+});