mcp-prqx-pricer 1.0.1 → 1.0.2

package/build/index.js

@@ -8,9 +8,12 @@ const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const axios_1 = __importDefault(require("axios"));
+const getProductions_1 = require("./tools/getProductions");
+const getProductionInventory_1 = require("./tools/getProductionInventory");
 class PrqxMcpServer {
     server;
     axiosInstance;
+    tools = [];
     constructor() {
         console.error('[Setup] Initializing MCP server...');
         this.server = new index_js_1.Server({
@@ -28,6 +31,8 @@ class PrqxMcpServer {
                 'Authorization': 'Bearer ' + process.env.TOKEN
             },
         });
+        this.tools.push(new getProductions_1.GetProductionsTool());
+        this.tools.push(new getProductionInventory_1.GetProductionInventoryTool());
         this.setupToolHandlers();
         this.server.onerror = (error) => {
             console.error('[Error] MCP server error:', error);
@@ -40,55 +45,14 @@ class PrqxMcpServer {
     }
     setupToolHandlers() {
         this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-            tools: [
-                {
-                    name: 'Get Productions',
-                    description: 'Get productions by production name, venue, performer, city. Within a range of dates (StartDate, EndDate). Only retrieves a maximum of 10 items',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            filter: {
-                                type: 'string',
-                                description: 'Filter to be applied to the production search (Name, Venue, Performer or City) separated by spaces'
-                            },
-                            startDate: {
-                                type: 'string',
-                                description: 'Start date of the production search (YYYY-MM-DD)'
-                            },
-                            endDate: {
-                                type: 'string',
-                                description: 'End date of the production search (YYYY-MM-DD)'
-                            }
-                        }
-                    }
-                }
-            ]
+            tools: this.tools
         }));
         this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
-            try {
-                if (!['Get Productions'].includes(request.params.name)) {
-                    throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Tool name ${request.params.name} is not supported`);
-                }
-                const args = request.params.arguments;
-                args.pageSize = 10;
-                args.pageNumber = 1;
-                console.error('[API] Get Productions with arguments:', args);
-                const response = await this.axiosInstance.get('/v2/client/production', { params: args });
-                if (response.status !== 200) {
-                    throw new Error(`API error: ${response.statusText}`);
-                }
-                if (response.data.totalFilteredRecords === 0) {
-                    return { content: [{ type: "text", text: "No results found" }] };
-                }
-                return { content: [{ type: "text", text: JSON.stringify(response.data) }] };
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    console.error('Error in Get Productions:', error);
-                    throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to fetch data: ${error.message}`);
-                }
-                throw error;
+            const tool = this.tools.find(tool => tool.name === request.params.name);
+            if (!tool) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Tool name ${request.params.name} is not supported`);
             }
+            return await tool.toolHandler(request, this.axiosInstance);
         });
     }
     async run() {

package/build/tools/getProductionInventory.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetProductionInventoryTool = void 0;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+class GetProductionInventoryTool {
+    name = 'Get Production Inventory';
+    description = 'Get all the organization inventory (ticket groups) for a single production';
+    inputSchema = {
+        type: 'object',
+        properties: {
+            productionId: {
+                type: 'number',
+                description: 'ID of the production'
+            }
+        }
+    };
+    toolHandler = async (request, httpClient) => {
+        try {
+            const args = request.params.arguments;
+            console.error('[API] Get Production Inventory with arguments:', args);
+            const response = await httpClient.get(`/v2/client/production/${args.productionId}/inventory`);
+            if (response.status !== 200) {
+                throw new Error(`API error: ${response.statusText}`);
+            }
+            return { content: [{ type: 'text', text: JSON.stringify(response.data) }] };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error('Error in Get Production Inventory:', error);
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to fetch data: ${error.message}`);
+            }
+            throw error;
+        }
+    };
+}
+exports.GetProductionInventoryTool = GetProductionInventoryTool;

package/build/tools/getProductions.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetProductionsTool = void 0;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+class GetProductionsTool {
+    name = 'Get Productions';
+    description = 'Get productions by production name, venue, performer, city. Within a range of dates (StartDate, EndDate). Only retrieves a maximum of 10 items';
+    inputSchema = {
+        type: 'object',
+        properties: {
+            filter: {
+                type: 'string',
+                description: 'Filter to be applied to the production search (Name, Venue, Performer or City) separated by spaces'
+            },
+            startDate: {
+                type: 'string',
+                description: 'Start date of the production search (YYYY-MM-DD)'
+            },
+            endDate: {
+                type: 'string',
+                description: 'End date of the production search (YYYY-MM-DD)'
+            },
+            productionStatus: {
+                type: 'string',
+                description: 'Status of the production ("Active","Inactive","Cancelled","Postponed", "All") - Include only Active if not specified'
+            }
+        }
+    };
+    toolHandler = async (request, httpClient) => {
+        try {
+            const args = request.params.arguments;
+            args.pageSize = 10;
+            args.pageNumber = 1;
+            args.productionStatus = args.productionStatus === "All" ? undefined : args.productionStatus || 'Active';
+            console.error('[API] Get Productions with arguments:', args);
+            const response = await httpClient.get('/v2/client/production', { params: args });
+            if (response.status !== 200) {
+                throw new Error(`API error: ${response.statusText}`);
+            }
+            if (response.data.totalFilteredRecords === 0) {
+                return { content: [{ type: "text", text: "No results found" }] };
+            }
+            return { content: [{ type: "text", text: JSON.stringify(response.data) }] };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error('Error in Get Productions:', error);
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to fetch data: ${error.message}`);
+            }
+            throw error;
+        }
+    };
+}
+exports.GetProductionsTool = GetProductionsTool;

package/build/types/productionInventory.js

@@ -0,0 +1,4 @@
+"use strict";
+// Auto-generated interfaces for /v2/client/production/{ProductionId}/inventory
+// Based on OpenAPI pricer.json
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/types/tool.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-prqx-pricer",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "",
   "main": "index.js",
   "bin": {

package/src/index.ts

@@ -2,17 +2,21 @@
 import {Server} from "@modelcontextprotocol/sdk/server/index.js";
 import {StdioServerTransport} from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
+    CallToolRequest,
     CallToolRequestSchema,
     ErrorCode,
     ListToolsRequestSchema,
     McpError,
   } from '@modelcontextprotocol/sdk/types.js';
   import axios from 'axios';
-import { PagedProductionResponseDto } from "./types/production";
+import { McpTool } from "./types/tool";
+import { GetProductionsTool } from "./tools/getProductions";
+import { GetProductionInventoryTool } from "./tools/getProductionInventory";
 
   class PrqxMcpServer{
     private server: Server;
     private axiosInstance;
+    private tools: McpTool[] = [];
 
     constructor() {
       console.error('[Setup] Initializing MCP server...');
@@ -34,6 +38,8 @@ import { PagedProductionResponseDto } from "./types/production";
         },
       });
 
+      this.tools.push(new GetProductionsTool());
+      this.tools.push(new GetProductionInventoryTool());
       this.setupToolHandlers();
 
       this.server.onerror = (error) => {
@@ -49,66 +55,16 @@ import { PagedProductionResponseDto } from "./types/production";
     
     private setupToolHandlers() {
         this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-            tools: [
-                {
-                    name: 'Get Productions',
-                    description: 'Get productions by production name, venue, performer, city. Within a range of dates (StartDate, EndDate). Only retrieves a maximum of 10 items',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            filter: {
-                                type: 'string',
-                                description: 'Filter to be applied to the production search (Name, Venue, Performer or City) separated by spaces'    
-                            },
-                            startDate: {
-                                type: 'string',
-                                description: 'Start date of the production search (YYYY-MM-DD)'    
-                            },
-                            endDate: {
-                                type: 'string',
-                                description: 'End date of the production search (YYYY-MM-DD)'    
-                            }
-                        }
-                    }
-                }
-            ]
+            tools: this.tools
         }));
 
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            try{
-                if(!['Get Productions'].includes(request.params.name)){
-                    throw new McpError(ErrorCode.MethodNotFound, `Tool name ${request.params.name} is not supported`);
-                }
-                const args = request.params.arguments as {
-                    filter?: string;
-                    startDate?: string;
-                    endDate?: string;
-                    pageSize?: number;
-                    pageNumber?: number;
-                };
-
-                args.pageSize = 10;
-                args.pageNumber = 1;
-
-                console.error('[API] Get Productions with arguments:', args);
-                const response = await this.axiosInstance.get<PagedProductionResponseDto>('/v2/client/production', {params: args});
-
-                if (response.status !== 200) {
-                    throw new Error(`API error: ${response.statusText}`);
-                }
-
-                if(response.data.totalFilteredRecords === 0) {
-                    return {content: [{type: "text", text: "No results found"}]};
-                }
-                
-                return {content: [{type: "text", text: JSON.stringify(response.data)}]};
-            } catch (error) {
-                if(error instanceof Error) {
-                    console.error('Error in Get Productions:', error);
-                    throw new McpError(ErrorCode.InternalError, `Failed to fetch data: ${error.message}`);
-                }
-                throw error;
+        this.server.setRequestHandler(CallToolRequestSchema, async (request: CallToolRequest) => {
+            const tool = this.tools.find(tool => tool.name === request.params.name);
+            if(!tool) {
+                throw new McpError(ErrorCode.MethodNotFound, `Tool name ${request.params.name} is not supported`);
             }
+
+            return await tool.toolHandler(request, this.axiosInstance);
         });
     }
 

package/src/tools/getProductionInventory.ts

@@ -0,0 +1,35 @@
+import { CallToolRequest, ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
+import { AxiosInstance } from "axios";
+import { McpTool } from "../types/tool";
+import { GetProductionInventoryResponse } from "../types/productionInventory";
+
+export class GetProductionInventoryTool implements McpTool {
+    name = 'Get Production Inventory';
+    description = 'Get all the organization inventory (ticket groups) for a single production';
+    inputSchema = {
+        type: 'object',
+        properties: {
+            productionId: {
+                type: 'number',
+                description: 'ID of the production'
+            }
+        }
+    };
+    toolHandler = async (request: CallToolRequest, httpClient: AxiosInstance) => {
+        try {
+            const args = request.params.arguments as { productionId: number };
+            console.error('[API] Get Production Inventory with arguments:', args);
+            const response = await httpClient.get<GetProductionInventoryResponse>(`/v2/client/production/${args.productionId}/inventory`);
+            if (response.status !== 200) {
+                throw new Error(`API error: ${response.statusText}`);
+            }
+            return { content: [{ type: 'text', text: JSON.stringify(response.data) }] };
+        } catch (error) {
+            if (error instanceof Error) {
+                console.error('Error in Get Production Inventory:', error);
+                throw new McpError(ErrorCode.InternalError, `Failed to fetch data: ${error.message}`);
+            }
+            throw error;
+        }
+    };
+}

package/src/tools/getProductions.ts

@@ -0,0 +1,67 @@
+import { CallToolRequest, ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
+import { McpTool } from "../types/tool";
+import { PagedProductionResponseDto } from "../types/production";
+import axios from "axios";
+
+export class GetProductionsTool implements McpTool {
+    name = 'Get Productions';
+    description = 'Get productions by production name, venue, performer, city. Within a range of dates (StartDate, EndDate). Only retrieves a maximum of 10 items';
+    inputSchema = {
+        type: 'object',
+        properties: {   
+            filter: {
+                type: 'string',
+                description: 'Filter to be applied to the production search (Name, Venue, Performer or City) separated by spaces'    
+            },
+            startDate: {
+                type: 'string',
+                description: 'Start date of the production search (YYYY-MM-DD)'    
+            },
+            endDate: {
+                type: 'string',
+                description: 'End date of the production search (YYYY-MM-DD)'    
+            },
+            productionStatus:{
+                type: 'string',
+                description: 'Status of the production ("Active","Inactive","Cancelled","Postponed", "All") - Include only Active if not specified'
+            }
+        }
+    };
+
+    toolHandler = async (request: CallToolRequest, httpClient: axios.AxiosInstance) => {
+        try{
+            const args = request.params.arguments as {
+                filter?: string;
+                startDate?: string;
+                endDate?: string;
+                pageSize?: number;
+                pageNumber?: number;
+                productionStatus?: string;
+            };
+
+            args.pageSize = 10;
+            args.pageNumber = 1;
+            args.productionStatus = args.productionStatus === "All" ? undefined : args.productionStatus || 'Active';
+
+            console.error('[API] Get Productions with arguments:', args);
+            const response = await httpClient.get<PagedProductionResponseDto>('/v2/client/production', {params: args});
+
+            if (response.status !== 200) {
+                throw new Error(`API error: ${response.statusText}`);
+            }
+
+            if(response.data.totalFilteredRecords === 0) {
+                return {content: [{type: "text", text: "No results found"}]};
+            }
+            
+            return {content: [{type: "text", text: JSON.stringify(response.data)}]};
+        } catch (error) {
+            if(error instanceof Error) {
+                console.error('Error in Get Productions:', error);
+                throw new McpError(ErrorCode.InternalError, `Failed to fetch data: ${error.message}`);
+            }
+            throw error;
+        }
+    };
+}
+    

package/src/types/productionInventory.ts

@@ -0,0 +1,56 @@
+// Auto-generated interfaces for /v2/client/production/{ProductionId}/inventory
+// Based on OpenAPI pricer.json
+
+export interface GetProductionInventoryRequest {
+  ProductionId: number; // path param (int64)
+  showParking?: boolean; // query param
+  showSpeculation?: boolean; // query param
+}
+
+export type StockType = 'Pdf' | 'MobileTransfer' | 'Physical';
+export type SeatType = 'Consecutive' | 'OddEven' | 'Piggyback' | 'GeneralAdmission';
+export type SplitRule = 'Default' | 'NoSplit' | 'NeverLeaveOne' | 'AnySplit' | 'Custom';
+export type InventoryStatus = 'Available' | 'Sold' | 'Held' | 'Deleted';
+
+export interface InventoryResponseDtoV2 {
+  productionId: number;
+  section?: string | null;
+  row?: string | null;
+  quantity?: number | null;
+  validSplits?: number[] | null;
+  startSeat?: number | null;
+  endSeat?: number | null;
+  stockType: StockType;
+  attributes?: string[] | null;
+  inHandDate?: string | null; // YYYY-MM-DD
+  isParking?: boolean | null;
+  isInHand?: boolean | null;
+  isSpeculation?: boolean | null;
+  costPrice?: number | null;
+  listPrice?: number | null;
+  listPriceChange?: number | null;
+  suggestedPrice?: number | null;
+  retailPrice?: number | null;
+  retailPriceChange?: number | null;
+  suggestedRetailPrice?: number | null;
+  rank?: number | null;
+  pricingGroupId?: number | null;
+  pricingGroupName?: string | null;
+  isAutoPricingEnabled?: boolean | null;
+  seatType: SeatType;
+  splitRule: SplitRule;
+  internalNotes?: string | null;
+  externalNotes?: string | null;
+  isCeilingHit: boolean;
+  isFloorHit: boolean;
+  isNoActiveCompHit: boolean;
+  ticketGroupId: number;
+  isShared?: boolean | null;
+  inventoryStatus: InventoryStatus;
+  posOrganizationId?: number | null;
+  isPendingChange?: boolean | null;
+  inventoryTags?: string[] | null;
+  sourceKey?: string | null;
+}
+
+export type GetProductionInventoryResponse = InventoryResponseDtoV2[];

package/src/types/tool.ts

@@ -0,0 +1,12 @@
+import { CallToolRequest } from "@modelcontextprotocol/sdk/types.js";
+import axios from "axios";
+
+export interface McpTool {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: object;
+    };
+    toolHandler: (request: CallToolRequest, httpClient: axios.AxiosInstance) => Promise<{content: {type: string; text: string}[]}>
+}