sfcc-dev-mcp 1.0.15 → 1.0.19

package/dist/core/tool-schemas/shared-schemas.js

@@ -0,0 +1,153 @@
+/**
+ * Shared MCP Tool Schema Components
+ *
+ * Reusable schema definitions for MCP tool definitions.
+ * DRY: These are used across multiple tool categories.
+ */
+/**
+ * Common query schema for OCAPI search operations
+ */
+export const QUERY_SCHEMA = {
+    type: 'object',
+    description: 'Query to filter results',
+    properties: {
+        text_query: {
+            type: 'object',
+            description: 'Search for text in specific fields',
+            properties: {
+                fields: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Fields to search in (e.g., ["id", "display_name", "description"])',
+                },
+                search_phrase: {
+                    type: 'string',
+                    description: 'Text to search for',
+                },
+            },
+            required: ['fields', 'search_phrase'],
+        },
+        term_query: {
+            type: 'object',
+            description: 'Search for exact term matches',
+            properties: {
+                fields: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Fields to search in',
+                },
+                operator: {
+                    type: 'string',
+                    description: 'Query operator (e.g., "is", "one_of")',
+                },
+                values: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Values to match',
+                },
+            },
+            required: ['fields', 'operator', 'values'],
+        },
+        bool_query: {
+            type: 'object',
+            description: 'Combine multiple queries with boolean logic',
+            properties: {
+                must: {
+                    type: 'array',
+                    items: { type: 'object' },
+                    description: 'Queries that must match (AND)',
+                },
+                must_not: {
+                    type: 'array',
+                    items: { type: 'object' },
+                    description: 'Queries that must not match',
+                },
+                should: {
+                    type: 'array',
+                    items: { type: 'object' },
+                    description: 'Queries that should match (OR)',
+                },
+            },
+        },
+        match_all_query: {
+            type: 'object',
+            description: 'Match all documents - useful when you want all results or to filter with sorts/pagination only.',
+            properties: {},
+        },
+    },
+};
+/**
+ * Common sorts schema for OCAPI search operations
+ */
+export const SORTS_SCHEMA = {
+    type: 'array',
+    description: 'Sort criteria',
+    items: {
+        type: 'object',
+        properties: {
+            field: {
+                type: 'string',
+                description: 'Field to sort by',
+            },
+            sort_order: {
+                type: 'string',
+                enum: ['asc', 'desc'],
+                description: 'Sort order (default: asc)',
+            },
+        },
+        required: ['field'],
+    },
+};
+/**
+ * Common pagination schema for OCAPI search operations
+ */
+export const PAGINATION_SCHEMA = {
+    start: {
+        type: 'number',
+        description: 'Start index for pagination (default: 0)',
+        default: 0,
+    },
+    count: {
+        type: 'number',
+        description: 'Number of results to return (default: 200)',
+        default: 200,
+    },
+    select: {
+        type: 'string',
+        description: "Property selector (e.g., '(**)' for all properties)",
+    },
+};
+/**
+ * Factory to create search request schema with optional description override
+ */
+export function createSearchRequestSchema(queryDescription) {
+    return {
+        type: 'object',
+        description: 'The search request with query, sorting, and pagination options',
+        properties: {
+            query: queryDescription
+                ? { ...QUERY_SCHEMA, description: queryDescription }
+                : QUERY_SCHEMA,
+            sorts: SORTS_SCHEMA,
+            ...PAGINATION_SCHEMA,
+        },
+    };
+}
+/**
+ * Common date parameter schema
+ */
+export const DATE_PARAM_SCHEMA = {
+    type: 'string',
+    description: 'Date in YYYYMMDD format (default: today)',
+};
+/**
+ * Common limit parameter schema
+ */
+export function createLimitSchema(defaultValue, description) {
+    return {
+        type: 'number',
+        description: description ?? `Number of entries to return (default: ${defaultValue})`,
+        default: defaultValue,
+    };
+}
+//# sourceMappingURL=shared-schemas.js.map

package/dist/core/tool-schemas/shared-schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-schemas.js","sourceRoot":"","sources":["../../../src/core/tool-schemas/shared-schemas.ts"],"names":[],"mappings":"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"}

package/dist/core/tool-schemas/system-object-tools.d.ts

@@ -0,0 +1,511 @@
+/**
+ * System Object Tool Schemas
+ */
+export declare const SYSTEM_OBJECT_TOOLS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            start: {
+                type: string;
+                description: string;
+                default: number;
+            };
+            count: {
+                type: string;
+                description: string;
+                default: number;
+            };
+            select: {
+                type: string;
+                description: string;
+                default: string;
+            };
+            objectType?: undefined;
+            searchRequest?: undefined;
+            groupId?: undefined;
+            instanceType?: undefined;
+            options?: undefined;
+        };
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            objectType: {
+                type: string;
+                description: string;
+            };
+            start?: undefined;
+            count?: undefined;
+            select?: undefined;
+            searchRequest?: undefined;
+            groupId?: undefined;
+            instanceType?: undefined;
+            options?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            objectType: {
+                type: string;
+                description: string;
+            };
+            searchRequest: {
+                type: string;
+                description: string;
+                properties: {
+                    start: {
+                        readonly type: "number";
+                        readonly description: "Start index for pagination (default: 0)";
+                        readonly default: 0;
+                    };
+                    count: {
+                        readonly type: "number";
+                        readonly description: "Number of results to return (default: 200)";
+                        readonly default: 200;
+                    };
+                    select: {
+                        readonly type: "string";
+                        readonly description: "Property selector (e.g., '(**)' for all properties)";
+                    };
+                    query: {
+                        readonly type: "object";
+                        readonly description: "Query to filter results";
+                        readonly properties: {
+                            readonly text_query: {
+                                readonly type: "object";
+                                readonly description: "Search for text in specific fields";
+                                readonly properties: {
+                                    readonly fields: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                        };
+                                        readonly description: "Fields to search in (e.g., [\"id\", \"display_name\", \"description\"])";
+                                    };
+                                    readonly search_phrase: {
+                                        readonly type: "string";
+                                        readonly description: "Text to search for";
+                                    };
+                                };
+                                readonly required: readonly ["fields", "search_phrase"];
+                            };
+                            readonly term_query: {
+                                readonly type: "object";
+                                readonly description: "Search for exact term matches";
+                                readonly properties: {
+                                    readonly fields: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                        };
+                                        readonly description: "Fields to search in";
+                                    };
+                                    readonly operator: {
+                                        readonly type: "string";
+                                        readonly description: "Query operator (e.g., \"is\", \"one_of\")";
+                                    };
+                                    readonly values: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                        };
+                                        readonly description: "Values to match";
+                                    };
+                                };
+                                readonly required: readonly ["fields", "operator", "values"];
+                            };
+                            readonly bool_query: {
+                                readonly type: "object";
+                                readonly description: "Combine multiple queries with boolean logic";
+                                readonly properties: {
+                                    readonly must: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "object";
+                                        };
+                                        readonly description: "Queries that must match (AND)";
+                                    };
+                                    readonly must_not: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "object";
+                                        };
+                                        readonly description: "Queries that must not match";
+                                    };
+                                    readonly should: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "object";
+                                        };
+                                        readonly description: "Queries that should match (OR)";
+                                    };
+                                };
+                            };
+                            readonly match_all_query: {
+                                readonly type: "object";
+                                readonly description: "Match all documents - useful when you want all results or to filter with sorts/pagination only.";
+                                readonly properties: {};
+                            };
+                        };
+                    } | {
+                        description: string;
+                        type: "object";
+                        properties: {
+                            readonly text_query: {
+                                readonly type: "object";
+                                readonly description: "Search for text in specific fields";
+                                readonly properties: {
+                                    readonly fields: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                        };
+                                        readonly description: "Fields to search in (e.g., [\"id\", \"display_name\", \"description\"])";
+                                    };
+                                    readonly search_phrase: {
+                                        readonly type: "string";
+                                        readonly description: "Text to search for";
+                                    };
+                                };
+                                readonly required: readonly ["fields", "search_phrase"];
+                            };
+                            readonly term_query: {
+                                readonly type: "object";
+                                readonly description: "Search for exact term matches";
+                                readonly properties: {
+                                    readonly fields: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                        };
+                                        readonly description: "Fields to search in";
+                                    };
+                                    readonly operator: {
+                                        readonly type: "string";
+                                        readonly description: "Query operator (e.g., \"is\", \"one_of\")";
+                                    };
+                                    readonly values: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                        };
+                                        readonly description: "Values to match";
+                                    };
+                                };
+                                readonly required: readonly ["fields", "operator", "values"];
+                            };
+                            readonly bool_query: {
+                                readonly type: "object";
+                                readonly description: "Combine multiple queries with boolean logic";
+                                readonly properties: {
+                                    readonly must: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "object";
+                                        };
+                                        readonly description: "Queries that must match (AND)";
+                                    };
+                                    readonly must_not: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "object";
+                                        };
+                                        readonly description: "Queries that must not match";
+                                    };
+                                    readonly should: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "object";
+                                        };
+                                        readonly description: "Queries that should match (OR)";
+                                    };
+                                };
+                            };
+                            readonly match_all_query: {
+                                readonly type: "object";
+                                readonly description: "Match all documents - useful when you want all results or to filter with sorts/pagination only.";
+                                readonly properties: {};
+                            };
+                        };
+                    };
+                    sorts: {
+                        readonly type: "array";
+                        readonly description: "Sort criteria";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly field: {
+                                    readonly type: "string";
+                                    readonly description: "Field to sort by";
+                                };
+                                readonly sort_order: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["asc", "desc"];
+                                    readonly description: "Sort order (default: asc)";
+                                };
+                            };
+                            readonly required: readonly ["field"];
+                        };
+                    };
+                };
+            };
+            start?: undefined;
+            count?: undefined;
+            select?: undefined;
+            groupId?: undefined;
+            instanceType?: undefined;
+            options?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            groupId: {
+                type: string;
+                description: string;
+            };
+            instanceType: {
+                type: string;
+                enum: string[];
+                description: string;
+                default: string;
+            };
+            searchRequest: {
+                type: string;
+                description: string;
+                properties: {
+                    start: {
+                        readonly type: "number";
+                        readonly description: "Start index for pagination (default: 0)";
+                        readonly default: 0;
+                    };
+                    count: {
+                        readonly type: "number";
+                        readonly description: "Number of results to return (default: 200)";
+                        readonly default: 200;
+                    };
+                    select: {
+                        readonly type: "string";
+                        readonly description: "Property selector (e.g., '(**)' for all properties)";
+                    };
+                    query: {
+                        readonly type: "object";
+                        readonly description: "Query to filter results";
+                        readonly properties: {
+                            readonly text_query: {
+                                readonly type: "object";
+                                readonly description: "Search for text in specific fields";
+                                readonly properties: {
+                                    readonly fields: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                        };
+                                        readonly description: "Fields to search in (e.g., [\"id\", \"display_name\", \"description\"])";
+                                    };
+                                    readonly search_phrase: {
+                                        readonly type: "string";
+                                        readonly description: "Text to search for";
+                                    };
+                                };
+                                readonly required: readonly ["fields", "search_phrase"];
+                            };
+                            readonly term_query: {
+                                readonly type: "object";
+                                readonly description: "Search for exact term matches";
+                                readonly properties: {
+                                    readonly fields: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                        };
+                                        readonly description: "Fields to search in";
+                                    };
+                                    readonly operator: {
+                                        readonly type: "string";
+                                        readonly description: "Query operator (e.g., \"is\", \"one_of\")";
+                                    };
+                                    readonly values: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                        };
+                                        readonly description: "Values to match";
+                                    };
+                                };
+                                readonly required: readonly ["fields", "operator", "values"];
+                            };
+                            readonly bool_query: {
+                                readonly type: "object";
+                                readonly description: "Combine multiple queries with boolean logic";
+                                readonly properties: {
+                                    readonly must: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "object";
+                                        };
+                                        readonly description: "Queries that must match (AND)";
+                                    };
+                                    readonly must_not: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "object";
+                                        };
+                                        readonly description: "Queries that must not match";
+                                    };
+                                    readonly should: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "object";
+                                        };
+                                        readonly description: "Queries that should match (OR)";
+                                    };
+                                };
+                            };
+                            readonly match_all_query: {
+                                readonly type: "object";
+                                readonly description: "Match all documents - useful when you want all results or to filter with sorts/pagination only.";
+                                readonly properties: {};
+                            };
+                        };
+                    } | {
+                        description: string;
+                        type: "object";
+                        properties: {
+                            readonly text_query: {
+                                readonly type: "object";
+                                readonly description: "Search for text in specific fields";
+                                readonly properties: {
+                                    readonly fields: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                        };
+                                        readonly description: "Fields to search in (e.g., [\"id\", \"display_name\", \"description\"])";
+                                    };
+                                    readonly search_phrase: {
+                                        readonly type: "string";
+                                        readonly description: "Text to search for";
+                                    };
+                                };
+                                readonly required: readonly ["fields", "search_phrase"];
+                            };
+                            readonly term_query: {
+                                readonly type: "object";
+                                readonly description: "Search for exact term matches";
+                                readonly properties: {
+                                    readonly fields: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                        };
+                                        readonly description: "Fields to search in";
+                                    };
+                                    readonly operator: {
+                                        readonly type: "string";
+                                        readonly description: "Query operator (e.g., \"is\", \"one_of\")";
+                                    };
+                                    readonly values: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                        };
+                                        readonly description: "Values to match";
+                                    };
+                                };
+                                readonly required: readonly ["fields", "operator", "values"];
+                            };
+                            readonly bool_query: {
+                                readonly type: "object";
+                                readonly description: "Combine multiple queries with boolean logic";
+                                readonly properties: {
+                                    readonly must: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "object";
+                                        };
+                                        readonly description: "Queries that must match (AND)";
+                                    };
+                                    readonly must_not: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "object";
+                                        };
+                                        readonly description: "Queries that must not match";
+                                    };
+                                    readonly should: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "object";
+                                        };
+                                        readonly description: "Queries that should match (OR)";
+                                    };
+                                };
+                            };
+                            readonly match_all_query: {
+                                readonly type: "object";
+                                readonly description: "Match all documents - useful when you want all results or to filter with sorts/pagination only.";
+                                readonly properties: {};
+                            };
+                        };
+                    };
+                    sorts: {
+                        readonly type: "array";
+                        readonly description: "Sort criteria";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly field: {
+                                    readonly type: "string";
+                                    readonly description: "Field to sort by";
+                                };
+                                readonly sort_order: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["asc", "desc"];
+                                    readonly description: "Sort order (default: asc)";
+                                };
+                            };
+                            readonly required: readonly ["field"];
+                        };
+                    };
+                };
+            };
+            options: {
+                type: string;
+                description: string;
+                properties: {
+                    maskPasswords: {
+                        type: string;
+                        description: string;
+                        default: boolean;
+                    };
+                    expand: {
+                        type: string;
+                        description: string;
+                    };
+                };
+            };
+            start?: undefined;
+            count?: undefined;
+            select?: undefined;
+            objectType?: undefined;
+        };
+        required: string[];
+    };
+})[];
+//# sourceMappingURL=system-object-tools.d.ts.map

package/dist/core/tool-schemas/system-object-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-object-tools.d.ts","sourceRoot":"","sources":["../../../src/core/tool-schemas/system-object-tools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAwH/B,CAAC"}