@spfn/core 0.1.0-alpha.62 → 0.1.0-alpha.63

package/dist/codegen/generators/index.js

@@ -250,9 +250,13 @@ async function generateClient(mappings, options) {
   const startTime = Date.now();
   const grouped = groupByResource(mappings);
   const resourceNames = Object.keys(grouped);
-  const code = generateClientCode(mappings, grouped);
-  await mkdir(dirname(options.outputPath), { recursive: true });
-  await writeFile(options.outputPath, code, "utf-8");
+  if (options.splitByResource === false) {
+    const code = generateClientCode(mappings, grouped, options);
+    await mkdir(dirname(options.outputPath), { recursive: true });
+    await writeFile(options.outputPath, code, "utf-8");
+  } else {
+    await generateSplitClient(mappings, grouped, options);
+  }
   return {
     routesScanned: mappings.length,
     contractsFound: mappings.length,
@@ -269,7 +273,7 @@ function generateClientCode(mappings, grouped, options) {
   {
     code += generateTypes(mappings);
   }
-  code += generateApiObject(grouped);
+  code += generateApiObject(grouped, options);
   code += generateFooter();
   return code;
 }
@@ -382,7 +386,7 @@ export const api = {
 `;
     for (let j = 0; j < routes.length; j++) {
       const route = routes[j];
-      code += generateMethodCode(route);
+      code += generateMethodCode(route, options);
     }
     code += `    }`;
     if (i < resourceNames.length - 1) {
@@ -398,12 +402,11 @@ export const api = {
 }
 function generateMethodCode(mapping, options) {
   const methodName = generateMethodName(mapping);
-  const contractType = `typeof ${mapping.contractName}`;
   const hasParams = mapping.hasParams || mapping.path.includes(":");
   const hasQuery = mapping.hasQuery || false;
   const hasBody = mapping.hasBody || false;
   let code = "";
-  {
+  if (options.includeJsDoc !== false) {
     code += `        /**
 `;
     code += `         * ${mapping.method} ${mapping.path}
@@ -413,14 +416,15 @@ function generateMethodCode(mapping, options) {
   }
   code += `        ${methodName}: (`;
   const params = [];
+  const typeName = generateTypeName(mapping);
   if (hasParams) {
-    params.push(`params: InferContract<${contractType}>['params']`);
+    params.push(`params: ${typeName}Params`);
   }
   if (hasQuery) {
-    params.push(`query?: InferContract<${contractType}>['query']`);
+    params.push(`query?: ${typeName}Query`);
   }
   if (hasBody) {
-    params.push(`body: InferContract<${contractType}>['body']`);
+    params.push(`body: ${typeName}Body`);
   }
   if (params.length > 0) {
     code += `options: { ${params.join(", ")} }`;
@@ -487,6 +491,130 @@ function countUniqueContractFiles(mappings) {
   }
   return files.size;
 }
+async function generateSplitClient(_mappings, grouped, options) {
+  const outputPath = options.outputPath;
+  const outputDir = outputPath.endsWith(".ts") || outputPath.endsWith(".js") ? outputPath.replace(/\.[jt]s$/, "") : outputPath;
+  await mkdir(outputDir, { recursive: true });
+  const resourceNames = Object.keys(grouped);
+  for (let i = 0; i < resourceNames.length; i++) {
+    const resourceName = resourceNames[i];
+    const routes = grouped[resourceName];
+    const code = generateResourceFile(resourceName, routes, options);
+    const filePath = `${outputDir}/${resourceName}.ts`;
+    await writeFile(filePath, code, "utf-8");
+  }
+  const indexCode = generateIndexFile(resourceNames);
+  const indexPath = `${outputDir}/index.ts`;
+  await writeFile(indexPath, indexCode, "utf-8");
+}
+function generateResourceFile(resourceName, routes, options) {
+  let code = "";
+  code += generateHeader();
+  code += `import { client } from '@spfn/core/client';
+`;
+  {
+    code += `import type { InferContract } from '@spfn/core';
+`;
+  }
+  code += `
+`;
+  const importGroups = groupContractsByImportPath(routes);
+  const importPaths = Object.keys(importGroups);
+  for (let i = 0; i < importPaths.length; i++) {
+    const importPath = importPaths[i];
+    const contracts = importGroups[importPath];
+    code += `import { ${contracts.join(", ")} } from '${importPath}';
+`;
+  }
+  code += `
+`;
+  {
+    code += `// ============================================
+`;
+    code += `// Types
+`;
+    code += `// ============================================
+
+`;
+    for (let i = 0; i < routes.length; i++) {
+      const route = routes[i];
+      const typeName = generateTypeName(route);
+      const contractType = `typeof ${route.contractName}`;
+      code += `export type ${typeName}Response = InferContract<${contractType}>['response'];
+`;
+      if (route.hasQuery) {
+        code += `export type ${typeName}Query = InferContract<${contractType}>['query'];
+`;
+      }
+      if (route.hasParams || route.path.includes(":")) {
+        code += `export type ${typeName}Params = InferContract<${contractType}>['params'];
+`;
+      }
+      if (route.hasBody) {
+        code += `export type ${typeName}Body = InferContract<${contractType}>['body'];
+`;
+      }
+      code += `
+`;
+    }
+  }
+  code += `/**
+`;
+  code += ` * ${resourceName} API
+`;
+  code += ` */
+`;
+  code += `export const ${resourceName} = {
+`;
+  for (let i = 0; i < routes.length; i++) {
+    const route = routes[i];
+    code += generateMethodCode(route, options);
+  }
+  code += `} as const;
+`;
+  return code;
+}
+function generateIndexFile(resourceNames, _options) {
+  let code = "";
+  code += generateHeader();
+  code += `export { client } from '@spfn/core/client';
+
+`;
+  for (let i = 0; i < resourceNames.length; i++) {
+    const resourceName = resourceNames[i];
+    code += `export * from './${resourceName}.js';
+`;
+  }
+  code += `
+`;
+  for (let i = 0; i < resourceNames.length; i++) {
+    const resourceName = resourceNames[i];
+    code += `import { ${resourceName} } from './${resourceName}.js';
+`;
+  }
+  code += `
+`;
+  code += `/**
+`;
+  code += ` * Type-safe API client
+`;
+  code += ` */
+`;
+  code += `export const api = {
+`;
+  for (let i = 0; i < resourceNames.length; i++) {
+    const resourceName = resourceNames[i];
+    code += `    ${resourceName}`;
+    if (i < resourceNames.length - 1) {
+      code += `,`;
+    }
+    code += `
+`;
+  }
+  code += `} as const;
+`;
+  return code;
+}
 var PinoAdapter = class _PinoAdapter {
   logger;
   constructor(config) {
@@ -1281,7 +1409,9 @@ function createContractGenerator(config = {}) {
         }
         const stats = await generateClient(allContracts, {
           // For backwards compatibility
-          outputPath});
+          outputPath,
+          includeJsDoc: true
+        });
         if (options.debug) {
           contractLogger.info("Client generated", {
             endpoints: stats.methodsGenerated,