openapi-remote-codegen 0.1.0

package/src/generators/remote-functions.ts

@@ -0,0 +1,521 @@
+import type { GeneratorConfig } from '../config.js';
+import type { OperationInfo, ParameterInfo, ParsedSpec } from '../types.js';
+import {
+  operationIdToFunctionName,
+  tagToFileName,
+  resolveInvalidation,
+} from '../utils/naming.js';
+import { getClientPropertyName } from '../utils/client-mapping.js';
+
+export function generateRemoteFunctions(parsed: ParsedSpec, config: GeneratorConfig): Map<string, string> {
+  const fileContents = new Map<string, string>();
+
+  // Group operations by tag
+  const byTag = new Map<string, OperationInfo[]>();
+  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: string, operations: OperationInfo[], config: GeneratorConfig): string {
+  const schemaImports = new Set<string>();
+  const typeImports = new Set<string>();
+  const enumImports = new Set<string>();
+
+  // 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: OperationInfo, tag: string, allOpsInTag: OperationInfo[], config: GeneratorConfig): string {
+  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: GeneratorConfig, clientProperty: string, methodName: string, functionName: string): string {
+  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: GeneratorConfig): string {
+  return `  const apiClient = ${config.clientAccess};`;
+}
+
+function generateQueryFunction(
+  op: OperationInfo,
+  functionName: string,
+  clientProperty: string,
+  methodName: string,
+  config: GeneratorConfig
+): string {
+  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: OperationInfo,
+  functionName: string,
+  clientProperty: string,
+  methodName: string,
+  config: GeneratorConfig
+): string {
+  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: OperationInfo,
+  functionName: string,
+  clientProperty: string,
+  methodName: string,
+  tag: string,
+  allOpsInTag: OperationInfo[],
+  wrapperName: 'command' | 'form',
+  config: GeneratorConfig
+): string {
+  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 is string => 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: OperationInfo): {
+  schemaArg: string;
+  paramList: string;
+  apiCallArgs: string;
+} {
+  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: string): string {
+  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: ParameterInfo): string {
+  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: string, tag: string): string {
+  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: Map<string, OperationInfo[]>): string {
+  // Build map of function name -> list of tags that export it
+  const nameToTags = new Map<string, string[]>();
+  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<string>();
+  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<string>();
+  for (const [name, tags] of nameToTags) {
+    if (tags.length > 1) {
+      for (const tag of tags) tagsWithCollisions.add(tag);
+    }
+  }
+
+  const lines: string[] = [];
+  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/src/index.ts

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, unlinkSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { pathToFileURL } from 'url';
+import { resolveConfig, type UserConfig } 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(): Promise<UserConfig> {
+  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);
+});