@sync.so/mcp-server 0.1.0

package/dist/openapi/parser.js

@@ -0,0 +1,101 @@
+const HTTP_METHODS = ['get', 'post', 'put', 'patch', 'delete'];
+export function parseSpec(spec) {
+    const operations = [];
+    for (const [path, pathItem] of Object.entries(spec.paths)) {
+        for (const method of HTTP_METHODS) {
+            const operation = pathItem[method];
+            if (!operation)
+                continue;
+            const tags = operation.tags ?? [];
+            if (tags.includes('internal'))
+                continue;
+            const operationId = operation.operationId;
+            if (!operationId)
+                continue;
+            const parameters = parseParameters(operation.parameters ?? [], spec);
+            const requestBody = parseRequestBody(operation.requestBody, spec);
+            const isMultipart = requestBody?.contentType === 'multipart/form-data';
+            operations.push({
+                operationId,
+                method,
+                path,
+                summary: operation.summary ?? operationId,
+                description: operation.description,
+                tags,
+                parameters,
+                requestBody,
+                isMultipart,
+            });
+        }
+    }
+    return operations;
+}
+function parseParameters(params, spec) {
+    return params.map((param) => {
+        const resolved = param.$ref ? resolveRef(spec, param.$ref) : param;
+        return {
+            name: resolved.name,
+            in: resolved.in,
+            required: resolved.required ?? false,
+            schema: resolveSchemaRefs(resolved.schema ?? { type: 'string' }, spec),
+            description: resolved.description,
+        };
+    });
+}
+function parseRequestBody(requestBody, spec) {
+    if (!requestBody?.content)
+        return undefined;
+    const contentType = 'application/json' in requestBody.content
+        ? 'application/json'
+        : 'multipart/form-data' in requestBody.content
+            ? 'multipart/form-data'
+            : Object.keys(requestBody.content)[0];
+    if (!contentType)
+        return undefined;
+    const mediaType = requestBody.content[contentType];
+    if (!mediaType?.schema)
+        return undefined;
+    return {
+        schema: resolveSchemaRefs(mediaType.schema, spec),
+        contentType,
+    };
+}
+export function resolveRef(spec, ref) {
+    const parts = ref.replace('#/', '').split('/');
+    let current = spec;
+    for (const part of parts) {
+        if (current == null || typeof current !== 'object') {
+            throw new Error(`Cannot resolve $ref: ${ref}`);
+        }
+        current = current[part];
+    }
+    return current;
+}
+export function resolveSchemaRefs(schema, spec) {
+    if (schema.$ref) {
+        const resolved = resolveRef(spec, schema.$ref);
+        return resolveSchemaRefs(resolved, spec);
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === 'properties' && typeof value === 'object' && value !== null) {
+            const props = {};
+            for (const [propName, propSchema] of Object.entries(value)) {
+                props[propName] = resolveSchemaRefs(propSchema, spec);
+            }
+            result[key] = props;
+        }
+        else if ((key === 'items' || key === 'additionalProperties') &&
+            typeof value === 'object' &&
+            value !== null) {
+            result[key] = resolveSchemaRefs(value, spec);
+        }
+        else if (key === 'allOf' || key === 'oneOf' || key === 'anyOf') {
+            result[key] = value.map((s) => resolveSchemaRefs(s, spec));
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}

package/dist/openapi/parser.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parser.test.d.ts.map

package/dist/openapi/parser.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.test.d.ts","sourceRoot":"","sources":["../../src/openapi/parser.test.ts"],"names":[],"mappings":""}

package/dist/openapi/parser.test.js

@@ -0,0 +1,188 @@
+import { describe, expect, it } from 'vitest';
+import { parseSpec, resolveRef, resolveSchemaRefs } from './parser.js';
+const MINIMAL_SPEC = {
+    openapi: '3.1.0',
+    paths: {
+        '/v2/generate': {
+            post: {
+                operationId: 'GenerateController_createGeneration',
+                summary: 'Create a generation',
+                tags: ['Generate'],
+                parameters: [],
+                requestBody: {
+                    content: {
+                        'application/json': {
+                            schema: {
+                                type: 'object',
+                                properties: {
+                                    model: { type: 'string' },
+                                    input: { type: 'array', items: { type: 'object' } },
+                                },
+                                required: ['model', 'input'],
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        '/v2/generate/{id}': {
+            get: {
+                operationId: 'GenerateController_getGeneration',
+                summary: 'Get a generation by ID',
+                tags: ['Generate'],
+                parameters: [
+                    {
+                        name: 'id',
+                        in: 'path',
+                        required: true,
+                        schema: { type: 'string' },
+                    },
+                ],
+            },
+        },
+        '/v2/internal/something': {
+            get: {
+                operationId: 'InternalController_doSomething',
+                summary: 'Internal endpoint',
+                tags: ['internal'],
+                parameters: [],
+            },
+        },
+    },
+};
+describe('parseSpec', () => {
+    it('parses operations from OpenAPI spec', () => {
+        const operations = parseSpec(MINIMAL_SPEC);
+        expect(operations).toHaveLength(2);
+    });
+    it('extracts operation details correctly', () => {
+        const operations = parseSpec(MINIMAL_SPEC);
+        const createOp = operations.find((op) => op.operationId === 'GenerateController_createGeneration');
+        expect(createOp).toBeDefined();
+        expect(createOp?.method).toBe('post');
+        expect(createOp?.path).toBe('/v2/generate');
+        expect(createOp?.summary).toBe('Create a generation');
+        expect(createOp?.requestBody).toBeDefined();
+    });
+    it('parses path parameters', () => {
+        const operations = parseSpec(MINIMAL_SPEC);
+        const getOp = operations.find((op) => op.operationId === 'GenerateController_getGeneration');
+        expect(getOp).toBeDefined();
+        expect(getOp?.parameters).toHaveLength(1);
+        expect(getOp?.parameters[0]?.name).toBe('id');
+        expect(getOp?.parameters[0]?.in).toBe('path');
+        expect(getOp?.parameters[0]?.required).toBe(true);
+    });
+    it('filters out internal-tagged endpoints', () => {
+        const operations = parseSpec(MINIMAL_SPEC);
+        const internalOp = operations.find((op) => op.operationId === 'InternalController_doSomething');
+        expect(internalOp).toBeUndefined();
+    });
+    it('skips operations without operationId', () => {
+        const spec = {
+            openapi: '3.1.0',
+            paths: {
+                '/v2/test': {
+                    get: {
+                        summary: 'No operation ID',
+                        tags: ['Test'],
+                    },
+                },
+            },
+        };
+        const operations = parseSpec(spec);
+        expect(operations).toHaveLength(0);
+    });
+    it('detects multipart endpoints', () => {
+        const spec = {
+            openapi: '3.1.0',
+            paths: {
+                '/v2/upload': {
+                    post: {
+                        operationId: 'UploadController_upload',
+                        summary: 'Upload a file',
+                        tags: ['Upload'],
+                        parameters: [],
+                        requestBody: {
+                            content: {
+                                'multipart/form-data': {
+                                    schema: { type: 'object' },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        const operations = parseSpec(spec);
+        expect(operations[0]?.isMultipart).toBe(true);
+    });
+});
+describe('resolveRef', () => {
+    it('resolves $ref to component schemas', () => {
+        const spec = {
+            openapi: '3.1.0',
+            paths: {},
+            components: {
+                schemas: {
+                    MyModel: { type: 'object', properties: { name: { type: 'string' } } },
+                },
+            },
+        };
+        const resolved = resolveRef(spec, '#/components/schemas/MyModel');
+        expect(resolved).toEqual({
+            type: 'object',
+            properties: { name: { type: 'string' } },
+        });
+    });
+});
+describe('resolveSchemaRefs', () => {
+    const spec = {
+        openapi: '3.1.0',
+        paths: {},
+        components: {
+            schemas: {
+                Status: { type: 'string', enum: ['pending', 'completed'] },
+            },
+        },
+    };
+    it('resolves $ref in schema', () => {
+        const schema = { $ref: '#/components/schemas/Status' };
+        const resolved = resolveSchemaRefs(schema, spec);
+        expect(resolved).toEqual({
+            type: 'string',
+            enum: ['pending', 'completed'],
+        });
+    });
+    it('passes through schemas without $ref', () => {
+        const schema = { type: 'string' };
+        const resolved = resolveSchemaRefs(schema, spec);
+        expect(resolved).toEqual({ type: 'string' });
+    });
+    it('resolves nested $ref in properties', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                status: { $ref: '#/components/schemas/Status' },
+            },
+        };
+        const resolved = resolveSchemaRefs(schema, spec);
+        expect(resolved).toEqual({
+            type: 'object',
+            properties: {
+                status: { type: 'string', enum: ['pending', 'completed'] },
+            },
+        });
+    });
+    it('resolves $ref in additionalProperties', () => {
+        const schema = {
+            type: 'object',
+            additionalProperties: { $ref: '#/components/schemas/Status' },
+        };
+        const resolved = resolveSchemaRefs(schema, spec);
+        expect(resolved).toEqual({
+            type: 'object',
+            additionalProperties: { type: 'string', enum: ['pending', 'completed'] },
+        });
+    });
+});

package/dist/openapi/types.d.ts

@@ -0,0 +1,55 @@
+export type ParsedParameter = {
+    name: string;
+    in: 'path' | 'query' | 'header';
+    required: boolean;
+    schema: JsonSchema;
+    description?: string;
+};
+export type ParsedOperation = {
+    operationId: string;
+    method: 'get' | 'post' | 'put' | 'patch' | 'delete';
+    path: string;
+    summary: string;
+    description?: string;
+    tags: string[];
+    parameters: ParsedParameter[];
+    requestBody?: {
+        schema: JsonSchema;
+        contentType: string;
+    };
+    isMultipart: boolean;
+};
+export type JsonSchema = Record<string, unknown>;
+export type OpenApiSpec = {
+    openapi: string;
+    paths: Record<string, Record<string, OpenApiOperation>>;
+    components?: {
+        schemas?: Record<string, JsonSchema>;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+};
+type OpenApiOperation = {
+    operationId?: string;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    parameters?: OpenApiParameter[];
+    requestBody?: {
+        content: Record<string, {
+            schema: JsonSchema;
+        }>;
+        required?: boolean;
+    };
+    [key: string]: unknown;
+};
+type OpenApiParameter = {
+    name: string;
+    in: 'path' | 'query' | 'header';
+    required?: boolean;
+    schema: JsonSchema;
+    description?: string;
+    $ref?: string;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/openapi/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/openapi/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;IAChC,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,WAAW,CAAC,EAAE;QAAE,MAAM,EAAE,UAAU,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1D,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEjD,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC;IACxD,UAAU,CAAC,EAAE;QACX,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QACrC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,CAAC;IACF,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,gBAAgB,GAAG;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAChC,WAAW,CAAC,EAAE;QACZ,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,MAAM,EAAE,UAAU,CAAA;SAAE,CAAC,CAAC;QAChD,QAAQ,CAAC,EAAE,OAAO,CAAC;KACpB,CAAC;IACF,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;IAChC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,UAAU,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC"}

package/dist/openapi/types.js

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

package/dist/server.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SyncMcpConfig } from './config.js';
+export declare function createSyncMcpServer(config: SyncMcpConfig): Promise<McpServer>;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAIpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAMjD,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,SAAS,CAAC,CA6CnF"}

package/dist/server.js

@@ -0,0 +1,65 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { createApiKeyAuth } from './auth/api-key.js';
+import { performDeviceAuth } from './auth/device-auth.js';
+import { loadToken } from './auth/token-store.js';
+import { createHttpClient } from './http-client.js';
+import { fetchSpec } from './openapi/fetcher.js';
+import { parseSpec } from './openapi/parser.js';
+import { generateTools } from './tools/generator.js';
+export async function createSyncMcpServer(config) {
+    const log = (message) => {
+        process.stderr.write(message);
+    };
+    const authHeaders = await resolveAuth(config, log);
+    const httpClient = createHttpClient(config.baseUrl, authHeaders);
+    log(`Fetching OpenAPI spec from ${config.baseUrl}...\n`);
+    const spec = await fetchSpec(config.baseUrl);
+    const operations = parseSpec(spec);
+    log(`Discovered ${operations.length} API operations\n`);
+    const tools = generateTools(operations, httpClient);
+    const server = new McpServer({
+        name: 'sync',
+        version: '0.1.0',
+    });
+    for (const tool of tools) {
+        server.tool(tool.name, tool.description, tool.inputSchema, async (args) => {
+            try {
+                const result = await tool.handler((args ?? {}));
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [{ type: 'text', text: `Error: ${message}` }],
+                    isError: true,
+                };
+            }
+        });
+    }
+    log(`Registered ${tools.length} MCP tools\n`);
+    return server;
+}
+async function resolveAuth(config, log) {
+    if (config.apiKey) {
+        log('Using API key authentication\n');
+        return createApiKeyAuth(config.apiKey).headers;
+    }
+    const cachedToken = await loadToken();
+    if (cachedToken) {
+        log('Using cached device auth token\n');
+        return {
+            Authorization: `Bearer ${cachedToken}`,
+            'x-sync-source': 'mcp',
+        };
+    }
+    log('No API key or cached token found. Starting device auth...\n');
+    const auth = await performDeviceAuth(config.baseUrl, log);
+    return auth.headers;
+}

package/dist/tools/generator.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import type { HttpClient } from '../http-client.js';
+import type { ParsedOperation } from '../openapi/types.js';
+export type McpToolDefinition = {
+    name: string;
+    description: string;
+    inputSchema: Record<string, z.ZodType>;
+    handler: (args: Record<string, unknown>) => Promise<unknown>;
+};
+export declare function generateTools(operations: ParsedOperation[], httpClient: HttpClient): McpToolDefinition[];
+export declare function operationIdToToolName(operationId: string): string;
+//# sourceMappingURL=generator.d.ts.map

package/dist/tools/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../src/tools/generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAc,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGvE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC;IACvC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC9D,CAAC;AAEF,wBAAgB,aAAa,CAC3B,UAAU,EAAE,eAAe,EAAE,EAC7B,UAAU,EAAE,UAAU,GACrB,iBAAiB,EAAE,CAErB;AAuBD,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAQjE"}

package/dist/tools/generator.js

@@ -0,0 +1,154 @@
+import { z } from 'zod';
+import { getOverride } from './overrides.js';
+export function generateTools(operations, httpClient) {
+    return operations.map((op) => generateTool(op, httpClient));
+}
+function generateTool(operation, httpClient) {
+    const name = operationIdToToolName(operation.operationId);
+    const override = getOverride(name);
+    const description = override?.description ?? truncate(operation.summary, 200);
+    const inputSchema = buildInputSchema(operation);
+    return {
+        name,
+        description,
+        inputSchema,
+        handler: async (args) => {
+            const path = buildPath(operation.path, args);
+            const query = buildQuery(operation.parameters, args);
+            const body = buildBody(operation, args);
+            return httpClient.request(operation.method, path, { query, body });
+        },
+    };
+}
+export function operationIdToToolName(operationId) {
+    // "GenerateController_createGeneration" → "generate_create-generation"
+    const parts = operationId.split('_');
+    if (parts.length < 2)
+        return toKebab(operationId);
+    const controller = toKebab(parts[0].replace(/Controller$/, ''));
+    const method = toKebab(parts.slice(1).join('_'));
+    return `${controller}_${method}`;
+}
+function toKebab(str) {
+    return str
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/_/g, '-')
+        .toLowerCase();
+}
+function truncate(str, maxLen) {
+    if (str.length <= maxLen)
+        return str;
+    return `${str.slice(0, maxLen - 3)}...`;
+}
+function buildInputSchema(operation) {
+    const shape = {};
+    for (const param of operation.parameters) {
+        if (param.in === 'header')
+            continue;
+        const zodType = jsonSchemaToZod(param.schema, param.description);
+        shape[param.name] = param.required ? zodType : zodType.optional();
+    }
+    if (operation.requestBody?.schema) {
+        const bodySchema = operation.requestBody.schema;
+        const flatSchemas = flattenComposedSchema(bodySchema);
+        for (const sub of flatSchemas) {
+            if (!sub.properties)
+                continue;
+            const properties = sub.properties;
+            const required = sub.required ?? [];
+            for (const [propName, propSchema] of Object.entries(properties)) {
+                const zodType = jsonSchemaToZod(propSchema, propSchema.description);
+                shape[propName] = required.includes(propName) ? zodType : zodType.optional();
+            }
+        }
+    }
+    return shape;
+}
+function flattenComposedSchema(schema) {
+    const results = [];
+    if (schema.properties)
+        results.push(schema);
+    for (const key of ['allOf', 'oneOf', 'anyOf']) {
+        const composed = schema[key];
+        if (composed)
+            results.push(...composed.flatMap(flattenComposedSchema));
+    }
+    return results.length > 0 ? results : [schema];
+}
+function jsonSchemaToZod(schema, description) {
+    let zodType;
+    const type = schema.type;
+    const enumValues = schema.enum;
+    if (enumValues) {
+        zodType = z.enum(enumValues);
+    }
+    else if (type === 'string') {
+        zodType = z.string();
+    }
+    else if (type === 'number' || type === 'integer') {
+        zodType = z.number();
+    }
+    else if (type === 'boolean') {
+        zodType = z.boolean();
+    }
+    else if (type === 'array') {
+        const items = schema.items;
+        zodType = z.array(items ? jsonSchemaToZod(items) : z.unknown());
+    }
+    else if (type === 'object') {
+        const properties = schema.properties;
+        if (properties) {
+            const required = schema.required ?? [];
+            const shape = {};
+            for (const [propName, propSchema] of Object.entries(properties)) {
+                const innerType = jsonSchemaToZod(propSchema);
+                shape[propName] = required.includes(propName) ? innerType : innerType.optional();
+            }
+            zodType = z.object(shape);
+        }
+        else {
+            zodType = z.record(z.string(), z.unknown());
+        }
+    }
+    else {
+        zodType = z.unknown();
+    }
+    if (description) {
+        zodType = zodType.describe(description);
+    }
+    return zodType;
+}
+function buildPath(pathTemplate, args) {
+    return pathTemplate.replace(/\{(\w+)\}/g, (_match, paramName) => {
+        const value = args[paramName];
+        if (value === undefined) {
+            throw new Error(`Missing required path parameter: ${paramName}`);
+        }
+        return encodeURIComponent(String(value));
+    });
+}
+function buildQuery(parameters, args) {
+    const queryParams = parameters.filter((p) => p.in === 'query');
+    if (queryParams.length === 0)
+        return undefined;
+    const query = {};
+    for (const param of queryParams) {
+        const value = args[param.name];
+        if (value !== undefined && value !== null) {
+            query[param.name] = String(value);
+        }
+    }
+    return Object.keys(query).length > 0 ? query : undefined;
+}
+function buildBody(operation, args) {
+    if (!operation.requestBody)
+        return undefined;
+    const pathAndQueryNames = new Set(operation.parameters.filter((p) => p.in !== 'header').map((p) => p.name));
+    const body = {};
+    for (const [key, value] of Object.entries(args)) {
+        if (!pathAndQueryNames.has(key) && value !== undefined) {
+            body[key] = value;
+        }
+    }
+    return Object.keys(body).length > 0 ? body : undefined;
+}

package/dist/tools/generator.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generator.test.d.ts.map

package/dist/tools/generator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.test.d.ts","sourceRoot":"","sources":["../../src/tools/generator.test.ts"],"names":[],"mappings":""}