@spfn/core 0.1.0-alpha.68 → 0.1.0-alpha.72

package/dist/codegen/index.d.ts

@@ -1,10 +1,11 @@
 import { G as Generator, a as GeneratorTrigger } from '../index-DHiAqhKv.js';
 export { C as ContractGeneratorConfig, b as GeneratorOptions, c as createContractGenerator } from '../index-DHiAqhKv.js';
 import '../auto-loader-JFaZ9gON.js';
-import { H as HttpMethod } from '../types-CAON3Mmg.js';
+import { H as HttpMethod } from '../types-Dzggq1Yb.js';
 import 'hono';
 import 'hono/utils/http-status';
 import '@sinclair/typebox';
+import '../error-handler-wjLL3v-a.js';
 
 /**
  * Codegen Orchestrator

package/dist/codegen/index.js

@@ -1222,21 +1222,28 @@ function generateTypeName(mapping) {
   }
   return name;
 }
-function generateMethodCode(mapping, options) {
-  const methodName = generateMethodName(mapping);
+function generateFunctionName(mapping) {
+  let name = mapping.contractName;
+  if (name.endsWith("Contract")) {
+    name = name.slice(0, -8);
+  }
+  return name;
+}
+function generateFunctionCode(mapping, options) {
+  const functionName = generateFunctionName(mapping);
   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 += `/**
 `;
-    code += `         * ${mapping.method} ${mapping.path}
+    code += ` * ${mapping.method} ${mapping.path}
 `;
-    code += `         */
+    code += ` */
 `;
   }
-  code += `        ${methodName}: (`;
+  code += `export const ${functionName} = (`;
   const params = [];
   const typeName = generateTypeName(mapping);
   if (hasParams) {
@@ -1256,33 +1263,11 @@ function generateMethodCode(mapping, options) {
   if (params.length > 0) {
     code += `, options`;
   }
-  code += `),
+  code += `);
+
 `;
   return code;
 }
-function generateMethodName(mapping) {
-  const method = mapping.method.toLowerCase();
-  if (mapping.path === "/" || mapping.path.match(/^\/[\w-]+$/)) {
-    if (method === "get") {
-      return "list";
-    }
-    if (method === "post") {
-      return "create";
-    }
-  }
-  if (mapping.path.includes(":")) {
-    if (method === "get") {
-      return "getById";
-    }
-    if (method === "put" || method === "patch") {
-      return "update";
-    }
-    if (method === "delete") {
-      return "delete";
-    }
-  }
-  return method;
-}
 function countUniqueContractFiles(mappings) {
   const files = /* @__PURE__ */ new Set();
   for (let i = 0; i < mappings.length; i++) {
@@ -1311,11 +1296,11 @@ async function generateSplitClient(_mappings, grouped, options) {
     const filePath = `${outputDir}/${kebabName}.ts`;
     await writeFile(filePath, code, "utf-8");
   }
-  const indexCode = generateIndexFile(resourceNames, options);
+  const indexCode = generateIndexFile(grouped, options);
   const indexPath = `${outputDir}/index.ts`;
   await writeFile(indexPath, indexCode, "utf-8");
 }
-function generateResourceFile(resourceName, routes, options) {
+function generateResourceFile(_resourceName, routes, options) {
   let code = "";
   code += generateHeader();
   code += `import { client } from '@spfn/core/client';
@@ -1366,52 +1351,63 @@ function generateResourceFile(resourceName, routes, options) {
 `;
     }
   }
-  code += `/**
+  code += `// ============================================
 `;
-  code += ` * ${resourceName} API
+  code += `// API Functions
 `;
-  code += ` */
-`;
-  code += `export const ${resourceName} = {
+  code += `// ============================================
+
 `;
   for (let i = 0; i < routes.length; i++) {
     const route = routes[i];
-    code += generateMethodCode(route, options);
+    code += generateFunctionCode(route, options);
   }
-  code += `} as const;
-`;
   return code;
 }
-function toCamelCase2(str) {
-  if (str.length === 0) {
-    return str;
-  }
-  return str.charAt(0).toLowerCase() + str.slice(1);
-}
-function generateIndexFile(resourceNames, options) {
+function generateIndexFile(grouped, options) {
   let code = "";
   const apiName = options.apiName || "api";
+  const resourceNames = Object.keys(grouped);
   code += generateHeader();
   code += `export { client } from '@spfn/core/client';
 
 `;
   for (let i = 0; i < resourceNames.length; i++) {
     const resourceName = resourceNames[i];
+    const routes = grouped[resourceName];
     const kebabName = toKebabCase(resourceName);
-    code += `export * from './${kebabName}.js';
+    const typeNames = [];
+    for (let j = 0; j < routes.length; j++) {
+      const route = routes[j];
+      const typeName = generateTypeName(route);
+      typeNames.push(`${typeName}Response`);
+      if (route.hasQuery) {
+        typeNames.push(`${typeName}Query`);
+      }
+      if (route.hasParams || route.path.includes(":")) {
+        typeNames.push(`${typeName}Params`);
+      }
+      if (route.hasBody) {
+        typeNames.push(`${typeName}Body`);
+      }
+    }
+    if (typeNames.length > 0) {
+      code += `export type { ${typeNames.join(", ")} } from './${kebabName}.js';
 `;
+    }
   }
   code += `
 `;
   for (let i = 0; i < resourceNames.length; i++) {
     const resourceName = resourceNames[i];
+    const routes = grouped[resourceName];
     const kebabName = toKebabCase(resourceName);
-    code += `import { ${resourceName} } from './${kebabName}.js';
+    const functionNames = routes.map((route) => generateFunctionName(route));
+    code += `import { ${functionNames.join(", ")} } from './${kebabName}.js';
 `;
   }
   code += `
 `;
-  const resourceKeys = resourceNames.map((name) => toCamelCase2(name));
   code += `/**
 `;
   code += ` * Type-safe API client
@@ -1420,17 +1416,23 @@ function generateIndexFile(resourceNames, options) {
 `;
   code += `export const ${apiName} = {
 `;
+  let isFirst = true;
   for (let i = 0; i < resourceNames.length; i++) {
     const resourceName = resourceNames[i];
-    const resourceKey = resourceKeys[i];
-    code += `    ${resourceKey}: ${resourceName}`;
-    if (i < resourceNames.length - 1) {
-      code += `,`;
-    }
-    code += `
+    const routes = grouped[resourceName];
+    for (let j = 0; j < routes.length; j++) {
+      const route = routes[j];
+      const functionName = generateFunctionName(route);
+      if (!isFirst) {
+        code += `,
 `;
+      }
+      code += `    ${functionName}`;
+      isFirst = false;
+    }
   }
-  code += `} as const;
+  code += `
+} as const;
 `;
   return code;
 }