openapi-remote-codegen 0.1.0

package/dist/generators/remote-functions.js

@@ -0,0 +1,439 @@
+import { operationIdToFunctionName, tagToFileName, resolveInvalidation, } from '../utils/naming.js';
+import { getClientPropertyName } from '../utils/client-mapping.js';
+export function generateRemoteFunctions(parsed, config) {
+    const fileContents = new Map();
+    // Group operations by tag
+    const byTag = new Map();
+    for (const op of parsed.operations) {
+        const existing = byTag.get(op.tag) ?? [];
+        existing.push(op);
+        byTag.set(op.tag, existing);
+    }
+    // Generate file for each tag
+    for (const [tag, operations] of byTag) {
+        const fileName = `${tagToFileName(tag)}.generated.remote.ts`;
+        const content = generateTagFile(tag, operations, config);
+        fileContents.set(fileName, content);
+    }
+    // Generate barrel export (pass operations to detect name collisions)
+    const indexContent = generateIndexFile(byTag);
+    fileContents.set('index.ts', indexContent);
+    return fileContents;
+}
+function generateTagFile(tag, operations, config) {
+    const schemaImports = new Set();
+    const typeImports = new Set();
+    const enumImports = new Set();
+    // Collect imports
+    for (const op of operations) {
+        if (op.requestBodySchema) {
+            schemaImports.add(op.requestBodySchema);
+            const typeName = op.requestBodySchema.replace(/Schema$/, '');
+            typeImports.add(typeName);
+        }
+        for (const param of op.parameters) {
+            if (param.enumName) {
+                enumImports.add(param.enumName);
+            }
+        }
+    }
+    const schemaImportLine = schemaImports.size > 0
+        ? `import { ${Array.from(schemaImports).join(', ')} } from '${config.imports.schemas}';\n`
+        : '';
+    // Build apiTypes import line with both value imports (enums) and type imports (DTOs)
+    let apiImportLine = '';
+    const valueImports = Array.from(enumImports);
+    const typeOnlyImports = Array.from(typeImports);
+    if (valueImports.length > 0 || typeOnlyImports.length > 0) {
+        const parts = [
+            ...valueImports,
+            ...typeOnlyImports.map(t => `type ${t}`),
+        ];
+        apiImportLine = `import { ${parts.join(', ')} } from '${config.imports.apiTypes}';\n`;
+    }
+    const functions = operations.map(op => generateFunction(op, tag, operations, config)).join('\n\n');
+    // Only import query/command/form if actually used
+    const hasQuery = operations.some(op => op.remoteType === 'query');
+    const hasCommand = operations.some(op => op.remoteType === 'command');
+    const hasForm = operations.some(op => op.remoteType === 'form');
+    const serverImports = ['getRequestEvent', ...(hasQuery ? ['query'] : []), ...(hasCommand ? ['command'] : []), ...(hasForm ? ['form'] : [])];
+    // Only import z from zod if any function actually uses Zod schema constructors
+    const usesZod = operations.some(op => {
+        const hasPathParams = op.parameters.some(p => p.in === 'path');
+        const hasQueryParams = op.parameters.some(p => p.in === 'query');
+        const hasInlineBody = op.inlineRequestBody !== undefined;
+        return hasPathParams || hasQueryParams || op.isArrayBody || hasInlineBody;
+    });
+    const zodImportLine = usesZod ? `import { z } from '${config.imports.zod}';\n` : '';
+    const kitImports = ['error', 'redirect', ...(hasForm ? ['invalid'] : [])];
+    return `// AUTO-GENERATED - DO NOT EDIT
+// Generated by openapi-remote-codegen
+// Source: openapi.json
+
+import { ${serverImports.join(', ')} } from '${config.imports.server}';
+import { ${kitImports.join(', ')} } from '${config.imports.kit}';
+${zodImportLine}${schemaImportLine}${apiImportLine}
+${functions}
+`;
+}
+function generateFunction(op, tag, allOpsInTag, config) {
+    const functionName = operationIdToFunctionName(op.operationId);
+    const clientProperty = op.clientPropertyName ?? getClientPropertyName(tag);
+    const methodName = getMethodName(op.operationId, tag);
+    if (op.remoteType === 'query') {
+        if (op.isBatch) {
+            return generateBatchQueryFunction(op, functionName, clientProperty, methodName, config);
+        }
+        return generateQueryFunction(op, functionName, clientProperty, methodName, config);
+    }
+    else if (op.remoteType === 'form') {
+        return generateMutationFunction(op, functionName, clientProperty, methodName, tag, allOpsInTag, 'form', config);
+    }
+    else {
+        return generateMutationFunction(op, functionName, clientProperty, methodName, tag, allOpsInTag, 'command', config);
+    }
+}
+function generateCatchBlock(config, clientProperty, methodName, functionName) {
+    const humanName = functionName.replace(/([A-Z])/g, ' $1').toLowerCase().trim();
+    return `  } catch (err) {
+    const status = (err as any)?.status;
+    if (status === 401) { ${config.errorHandling.on401}; }
+    if (status === 403) ${config.errorHandling.on403};
+    console.error('Error in ${clientProperty}.${methodName}:', err);
+    ${config.errorHandling.on500(humanName)};
+  }`;
+}
+function generateClientAccess(config) {
+    return `  const apiClient = ${config.clientAccess};`;
+}
+function generateQueryFunction(op, functionName, clientProperty, methodName, config) {
+    const { schemaArg, paramList, apiCallArgs } = buildParameterMapping(op);
+    const comment = op.summary ? `/** ${op.summary} */\n` : '';
+    const catchBlock = generateCatchBlock(config, clientProperty, methodName, functionName);
+    const clientAccess = generateClientAccess(config);
+    if (schemaArg) {
+        return `${comment}export const ${functionName} = query(${schemaArg}, async (${paramList}) => {
+${clientAccess}
+  try {
+    return await apiClient.${clientProperty}.${methodName}(${apiCallArgs});
+${catchBlock}
+});`;
+    }
+    return `${comment}export const ${functionName} = query(async () => {
+${clientAccess}
+  try {
+    return await apiClient.${clientProperty}.${methodName}();
+${catchBlock}
+});`;
+}
+function generateBatchQueryFunction(op, functionName, clientProperty, methodName, config) {
+    const { schemaArg, paramList, apiCallArgs } = buildParameterMapping(op);
+    const comment = op.summary ? `/** ${op.summary} */\n` : '';
+    const catchBlock = generateCatchBlock(config, clientProperty, methodName, functionName);
+    const clientAccess = generateClientAccess(config);
+    if (schemaArg) {
+        return `${comment}export const ${functionName} = query.batch(${schemaArg}, async (args) => {
+${clientAccess}
+  try {
+    const results = await Promise.all(args.map((${paramList}) => apiClient.${clientProperty}.${methodName}(${apiCallArgs})));
+    return (${paramList}, i) => results[i];
+${catchBlock}
+});`;
+    }
+    // No-arg batch doesn't make sense - fall back to regular query
+    return `${comment}export const ${functionName} = query(async () => {
+${clientAccess}
+  try {
+    return await apiClient.${clientProperty}.${methodName}();
+${catchBlock}
+});`;
+}
+function generateMutationFunction(op, functionName, clientProperty, methodName, tag, allOpsInTag, wrapperName, config) {
+    const { schemaArg, paramList, apiCallArgs } = buildParameterMapping(op);
+    // Build invalidation calls
+    const invalidations = op.invalidates.map(inv => {
+        const resolved = resolveInvalidation(inv, tag);
+        return resolved.functionName;
+    });
+    // Filter to only include functions that exist in the same file (same tag)
+    const localFunctionNames = new Set(allOpsInTag.map(o => operationIdToFunctionName(o.operationId)));
+    const localInvalidations = invalidations.filter(fn => localFunctionNames.has(fn));
+    // Build refresh calls
+    const commandPathParams = op.parameters.filter(p => p.in === 'path');
+    const commandPathParamNames = new Set(commandPathParams.map(p => p.name));
+    const refreshCallsArr = localInvalidations.map(fn => {
+        // Check if the target function actually takes a path parameter
+        const targetOp = allOpsInTag.find(o => operationIdToFunctionName(o.operationId) === fn);
+        const targetPathParams = targetOp?.parameters.filter(p => p.in === 'path') ?? [];
+        if (targetPathParams.length > 0) {
+            // Find matching path param names between the command and the target query
+            const matchingParams = targetPathParams.filter(p => commandPathParamNames.has(p.name));
+            if (matchingParams.length > 0) {
+                if (targetPathParams.length === 1) {
+                    return `${fn}(${matchingParams[0].name}).refresh()`;
+                }
+                return `${fn}(${matchingParams[0].name}).refresh()`;
+            }
+            // Target requires path params the command can't provide - skip
+            return null;
+        }
+        return `${fn}(undefined).refresh()`;
+    }).filter((call) => call !== null);
+    const refreshCalls = refreshCallsArr.length > 0
+        ? `\n    await Promise.all([
+      ${refreshCallsArr.join(',\n      ')}
+    ]);`
+        : '';
+    const comment = op.summary ? `/** ${op.summary} */\n` : '';
+    const catchBlock = generateCatchBlock(config, clientProperty, methodName, functionName);
+    const clientAccess = generateClientAccess(config);
+    // Handle void responses (204 No Content)
+    const apiCall = op.isVoidResponse
+        ? `    await apiClient.${clientProperty}.${methodName}(${apiCallArgs});${refreshCalls}
+    return { success: true };`
+        : `    const result = await apiClient.${clientProperty}.${methodName}(${apiCallArgs});${refreshCalls}
+    return result;`;
+    if (schemaArg) {
+        // form() requires StandardSchemaV1<RemoteFormInput, Record<string, any>> but z.fromJSONSchema()
+        // returns ZodType<unknown> - cast to any to bypass the constraint while keeping runtime validation
+        const schemaArgStr = wrapperName === 'form' ? `${schemaArg} as any` : schemaArg;
+        return `${comment}export const ${functionName} = ${wrapperName}(${schemaArgStr}, async (${paramList}) => {
+${clientAccess}
+  try {
+${apiCall}
+${catchBlock}
+});`;
+    }
+    return `${comment}export const ${functionName} = ${wrapperName}(async () => {
+${clientAccess}
+  try {
+${apiCall}
+${catchBlock}
+});`;
+}
+function buildParameterMapping(op) {
+    const pathParams = op.parameters.filter(p => p.in === 'path');
+    const queryParams = op.parameters.filter(p => p.in === 'query');
+    const hasNamedBody = !!op.requestBodySchema;
+    const hasInlineBody = !!op.inlineRequestBody;
+    const hasBody = hasNamedBody || hasInlineBody;
+    // Single path param only (e.g., GET /trackers/{id})
+    if (pathParams.length === 1 && queryParams.length === 0 && !hasBody) {
+        const param = pathParams[0];
+        const zodType = param.enumName ? `z.enum(${param.enumName})` : 'z.string()';
+        return {
+            schemaArg: zodType,
+            paramList: param.name,
+            apiCallArgs: param.name,
+        };
+    }
+    // Multiple path params, no request body
+    if (pathParams.length > 1 && queryParams.length === 0 && !hasBody) {
+        const fields = pathParams.map(p => {
+            const zodType = p.enumName ? `z.enum(${p.enumName})` : 'z.string()';
+            return `${p.name}: ${zodType}`;
+        });
+        const paramNames = pathParams.map(p => p.name);
+        return {
+            schemaArg: `z.object({ ${fields.join(', ')} })`,
+            paramList: `{ ${paramNames.join(', ')} }`,
+            apiCallArgs: paramNames.join(', '),
+        };
+    }
+    // Request body only (named schema)
+    if (pathParams.length === 0 && queryParams.length === 0 && hasNamedBody) {
+        const typeName = op.requestBodySchema.replace(/Schema$/, '');
+        const bodyOptional = !op.requestBodyRequired;
+        if (op.isArrayBody) {
+            return {
+                schemaArg: `z.array(${op.requestBodySchema})`,
+                paramList: 'request',
+                apiCallArgs: `request as ${typeName}[]`,
+            };
+        }
+        if (bodyOptional) {
+            return {
+                schemaArg: `${op.requestBodySchema}.optional()`,
+                paramList: 'request',
+                apiCallArgs: `(request ?? {}) as ${typeName}`,
+            };
+        }
+        return {
+            schemaArg: op.requestBodySchema,
+            paramList: 'request',
+            apiCallArgs: `request as ${typeName}`,
+        };
+    }
+    // Inline request body only
+    if (pathParams.length === 0 && queryParams.length === 0 && hasInlineBody) {
+        const inline = op.inlineRequestBody;
+        const bodyOptional = !op.requestBodyRequired;
+        const schemaArg = bodyOptional ? `${inline.zodSchema}.optional()` : inline.zodSchema;
+        const requestArg = bodyOptional
+            ? `(request ?? {}) as ${inline.tsType}`
+            : `request as ${inline.tsType}`;
+        return {
+            schemaArg,
+            paramList: 'request',
+            apiCallArgs: requestArg,
+        };
+    }
+    // Path param(s) + named request body
+    if (pathParams.length >= 1 && hasNamedBody) {
+        const typeName = op.requestBodySchema.replace(/Schema$/, '');
+        const bodyOptional = !op.requestBodyRequired;
+        const pathFields = pathParams.map(p => {
+            const zodType = p.enumName ? `z.enum(${p.enumName})` : 'z.string()';
+            return `${p.name}: ${zodType}`;
+        });
+        const requestField = bodyOptional
+            ? `request: ${op.requestBodySchema}.optional()`
+            : `request: ${op.requestBodySchema}`;
+        const requestArg = bodyOptional
+            ? `(request ?? {}) as ${typeName}`
+            : `request as ${typeName}`;
+        const paramNames = pathParams.map(p => p.name);
+        return {
+            schemaArg: `z.object({ ${pathFields.join(', ')}, ${requestField} })`,
+            paramList: `{ ${paramNames.join(', ')}, request }`,
+            apiCallArgs: `${paramNames.join(', ')}, ${requestArg}`,
+        };
+    }
+    // Path param(s) + inline request body
+    if (pathParams.length >= 1 && hasInlineBody) {
+        const inline = op.inlineRequestBody;
+        const bodyOptional = !op.requestBodyRequired;
+        const pathFields = pathParams.map(p => {
+            const zodType = p.enumName ? `z.enum(${p.enumName})` : 'z.string()';
+            return `${p.name}: ${zodType}`;
+        });
+        const requestField = bodyOptional
+            ? `request: ${inline.zodSchema}.optional()`
+            : `request: ${inline.zodSchema}`;
+        const requestArg = bodyOptional
+            ? `(request ?? {}) as ${inline.tsType}`
+            : `request as ${inline.tsType}`;
+        const paramNames = pathParams.map(p => p.name);
+        return {
+            schemaArg: `z.object({ ${pathFields.join(', ')}, ${requestField} })`,
+            paramList: `{ ${paramNames.join(', ')}, request }`,
+            apiCallArgs: `${paramNames.join(', ')}, ${requestArg}`,
+        };
+    }
+    // Path param(s) + query param(s), no body
+    if (pathParams.length >= 1 && queryParams.length > 0 && !hasBody) {
+        const pathFields = pathParams.map(p => {
+            const zodType = p.enumName ? `z.enum(${p.enumName})` : 'z.string()';
+            return `${p.name}: ${zodType}`;
+        });
+        const queryFields = queryParams.map(p => {
+            const zodType = p.enumName ? `z.enum(${p.enumName})` : getZodTypeForParam(p);
+            return `${p.name}: ${zodType}${p.required ? '' : '.optional()'}`;
+        });
+        const allFields = [...pathFields, ...queryFields];
+        const pathParamNames = pathParams.map(p => p.name);
+        const queryParamAccess = queryParams.map(p => `params.${p.name}`);
+        return {
+            schemaArg: `z.object({ ${allFields.join(', ')} })`,
+            paramList: 'params',
+            apiCallArgs: [...pathParamNames.map(n => `params.${n}`), ...queryParamAccess].join(', '),
+        };
+    }
+    // Query params only
+    if (queryParams.length > 0 && !hasBody) {
+        const fields = queryParams.map(p => {
+            const zodType = p.enumName ? `z.enum(${p.enumName})` : getZodTypeForParam(p);
+            return `${p.name}: ${zodType}${p.required ? '' : '.optional()'}`;
+        });
+        const schemaArg = `z.object({ ${fields.join(', ')} }).optional()`;
+        const paramList = 'params';
+        const apiCallArgs = queryParams.map(p => `params?.${p.name}`).join(', ');
+        return { schemaArg, paramList, apiCallArgs };
+    }
+    // No params
+    return {
+        schemaArg: '',
+        paramList: '',
+        apiCallArgs: '',
+    };
+}
+function getZodType(type) {
+    switch (type) {
+        case 'boolean': return 'z.boolean()';
+        case 'number': return 'z.number()';
+        case 'integer': return 'z.number().int()';
+        case 'Date': return 'z.coerce.date()';
+        default: return 'z.string()';
+    }
+}
+/**
+ * Get Zod type for a parameter, handling array types by wrapping the item type.
+ */
+function getZodTypeForParam(param) {
+    if (param.type === 'array') {
+        const itemZod = getZodType(param.itemType ?? 'string');
+        return `z.array(${itemZod})`;
+    }
+    return getZodType(param.type);
+}
+/**
+ * Get the method name from operationId.
+ * NSwag generates method names by removing the tag prefix.
+ * "Trackers_GetDefinitions" -> "getDefinitions"
+ */
+function getMethodName(operationId, tag) {
+    const parts = operationId.split('_');
+    const name = parts.length > 1 ? parts.slice(1).join('_') : parts[0];
+    return name.charAt(0).toLowerCase() + name.slice(1);
+}
+function generateIndexFile(byTag) {
+    // Build map of function name -> list of tags that export it
+    const nameToTags = new Map();
+    for (const [tag, operations] of byTag) {
+        for (const op of operations) {
+            const fnName = operationIdToFunctionName(op.operationId);
+            const existing = nameToTags.get(fnName) ?? [];
+            existing.push(tag);
+            nameToTags.set(fnName, existing);
+        }
+    }
+    // Find names that appear in multiple tags (collisions)
+    const collidingNames = new Set();
+    for (const [name, tags] of nameToTags) {
+        if (tags.length > 1)
+            collidingNames.add(name);
+    }
+    // Find tags that have at least one colliding export
+    const tagsWithCollisions = new Set();
+    for (const [name, tags] of nameToTags) {
+        if (tags.length > 1) {
+            for (const tag of tags)
+                tagsWithCollisions.add(tag);
+        }
+    }
+    const lines = [];
+    for (const [tag, operations] of byTag) {
+        const fileName = tagToFileName(tag);
+        if (!tagsWithCollisions.has(tag)) {
+            // No collisions - safe to export *
+            lines.push(`export * from './${fileName}.generated.remote';`);
+        }
+        else {
+            // Has collisions - use explicit named exports, skipping colliding names
+            const safeNames = operations
+                .map(op => operationIdToFunctionName(op.operationId))
+                .filter(name => !collidingNames.has(name));
+            if (safeNames.length > 0) {
+                lines.push(`export { ${safeNames.join(', ')} } from './${fileName}.generated.remote';`);
+            }
+            else {
+                lines.push(`// './${fileName}.generated.remote' - all exports collide, import directly`);
+            }
+        }
+    }
+    return `// AUTO-GENERATED - DO NOT EDIT
+// Generated by openapi-remote-codegen
+
+${lines.join('\n')}
+`;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, unlinkSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { pathToFileURL } from 'url';
+import { resolveConfig } from './config.js';
+import { parseOpenApiSpec } from './parser.js';
+import { generateRemoteFunctions } from './generators/remote-functions.js';
+import { generateApiClient } from './generators/api-client.js';
+async function loadConfig() {
+    const configNames = [
+        'remote-codegen.config.ts',
+        'remote-codegen.config.js',
+        'remote-codegen.config.mjs',
+    ];
+    // Check for --config flag
+    const configFlagIndex = process.argv.indexOf('--config');
+    if (configFlagIndex !== -1 && process.argv[configFlagIndex + 1]) {
+        const configPath = resolve(process.cwd(), process.argv[configFlagIndex + 1]);
+        if (!existsSync(configPath)) {
+            console.error(`Config file not found: ${configPath}`);
+            process.exit(1);
+        }
+        const mod = await import(pathToFileURL(configPath).href);
+        return mod.default ?? mod;
+    }
+    // Auto-discover
+    for (const name of configNames) {
+        const configPath = resolve(process.cwd(), name);
+        if (existsSync(configPath)) {
+            console.log(`Using config: ${name}`);
+            const mod = await import(pathToFileURL(configPath).href);
+            return mod.default ?? mod;
+        }
+    }
+    return {};
+}
+async function main() {
+    const userConfig = await loadConfig();
+    const config = resolveConfig(userConfig);
+    console.log('OpenAPI Remote Function Generator');
+    console.log('=================================\n');
+    const specPath = resolve(process.cwd(), config.openApiPath);
+    if (!existsSync(specPath)) {
+        console.error(`OpenAPI spec not found: ${specPath}`);
+        process.exit(1);
+    }
+    const spec = JSON.parse(readFileSync(specPath, 'utf-8'));
+    console.log(`Loaded OpenAPI spec: ${spec.info?.title ?? 'unknown'} v${spec.info?.version ?? 'unknown'}`);
+    const parsed = parseOpenApiSpec(spec);
+    console.log(`Found ${parsed.operations.length} annotated operations across ${parsed.tags.length} tags.\n`);
+    if (parsed.operations.length === 0) {
+        console.log('No operations with x-remote-* extensions found.');
+        console.log('Add x-remote-type to your OpenAPI operations, or use the companion attributes package.');
+        process.exit(0);
+    }
+    // Generate remote functions
+    console.log('Generating remote functions...');
+    const remoteFunctions = generateRemoteFunctions(parsed, config);
+    const remoteFunctionsDir = resolve(config.outputDir, config.remoteFunctionsOutput);
+    mkdirSync(remoteFunctionsDir, { recursive: true });
+    // Clean up stale generated files
+    const generatedFileNames = new Set(remoteFunctions.keys());
+    if (existsSync(remoteFunctionsDir)) {
+        for (const existing of readdirSync(remoteFunctionsDir)) {
+            if (existing.endsWith('.generated.remote.ts') && !generatedFileNames.has(existing)) {
+                unlinkSync(resolve(remoteFunctionsDir, existing));
+                console.log(`  Removed stale: ${config.remoteFunctionsOutput}/${existing}`);
+            }
+        }
+    }
+    for (const [fileName, content] of remoteFunctions) {
+        const filePath = resolve(remoteFunctionsDir, fileName);
+        writeFileSync(filePath, content, 'utf-8');
+        console.log(`  Generated: ${config.remoteFunctionsOutput}/${fileName}`);
+    }
+    // Generate ApiClient
+    console.log('\nGenerating ApiClient...');
+    const apiClientContent = generateApiClient(spec, config);
+    const apiClientPath = resolve(config.outputDir, config.apiClientOutput);
+    mkdirSync(dirname(apiClientPath), { recursive: true });
+    writeFileSync(apiClientPath, apiClientContent, 'utf-8');
+    console.log(`  Generated: ${config.apiClientOutput}`);
+    console.log('\nDone!');
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/parser.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParsedSpec } from './types.js';
+export declare function parseOpenApiSpec(spec: OpenAPIV3.Document): ParsedSpec;