schemock 0.0.4-alpha.14 → 0.0.4-alpha.16

package/dist/cli/index.js

@@ -3118,6 +3118,7 @@ function generateEndpointHandlers(endpoints) {
 function generateHandler(code, endpoint) {
   const { name, method, path, params, body, pathParams } = endpoint;
   const httpMethod = method.toLowerCase();
+  const hasBody = body.length > 0;
   code.comment(`${method} ${path}`);
   code.block(`http.${httpMethod}('${path}', async ({ request, params: pathParams }) => {`, () => {
     if (method === "GET" && params.length > 0) {
@@ -3139,20 +3140,21 @@ function generateHandler(code, endpoint) {
         }
       }, "};");
       code.line();
+    } else {
+      code.line("const params = {};");
+      code.line();
     }
-    if (body.length > 0) {
+    if (hasBody) {
       code.line("const body = await request.json();");
-      code.line();
+    } else {
+      code.line("const body = {};");
     }
-    const ctxParts = ["db"];
-    if (params.length > 0 || pathParams.length > 0) ctxParts.push("params");
-    if (body.length > 0) ctxParts.push("body");
+    code.line();
     code.line("const headers: Record<string, string> = {};");
     code.line("request.headers.forEach((value, key) => { headers[key] = value; });");
-    ctxParts.push("headers");
     code.line();
     code.block("try {", () => {
-      code.line(`const result = await endpointResolvers.${name}({ ${ctxParts.join(", ")} });`);
+      code.line(`const result = await endpointResolvers.${name}({ db, params, body, headers });`);
       code.line("return HttpResponse.json(result);");
     }, "} catch (error) {");
     code.indent();
@@ -3197,15 +3199,24 @@ function generateEndpointResolvers(endpoints, outputDir) {
   code.comment("consider using named exported functions instead - they will be automatically imported.");
   code.line();
   code.line("import type { Database } from './db';");
+  code.line("import type * as Types from './types';");
   code.line();
-  code.comment("Resolver context with typed database access");
-  code.block("export interface ResolverContext {", () => {
-    code.line("params: Record<string, unknown>;");
-    code.line("body: Record<string, unknown>;");
+  code.comment("Base resolver context with typed database access");
+  code.block("export interface ResolverContext<TParams = Record<string, unknown>, TBody = Record<string, unknown>> {", () => {
+    code.line("params: TParams;");
+    code.line("body: TBody;");
     code.line("db: Database;");
     code.line("headers: Record<string, string>;");
   });
   code.line();
+  code.comment("Per-endpoint typed resolver contexts");
+  for (const endpoint of endpoints) {
+    const { pascalName, params, body } = endpoint;
+    const paramsType = params.length > 0 ? `Types.${pascalName}Params` : "Record<string, never>";
+    const bodyType = body.length > 0 ? `Types.${pascalName}Body` : "Record<string, never>";
+    code.line(`export type ${pascalName}ResolverContext = ResolverContext<${paramsType}, ${bodyType}>;`);
+  }
+  code.line();
   code.comment("Error class for HTTP errors in resolvers");
   code.block("export class HttpError extends Error {", () => {
     code.line("readonly status: number;");
@@ -3237,7 +3248,8 @@ function generateEndpointResolvers(endpoints, outputDir) {
         if (!inlineDependencies.has(key)) {
           inlineDependencies.set(key, {
             name: dep.name,
-            importPath: dep.from
+            importPath: dep.from,
+            sourceFile: endpoint.sourceFile
           });
         }
       }
@@ -3280,33 +3292,63 @@ function generateEndpointResolvers(endpoints, outputDir) {
   if (inlineDependencies.size > 0) {
     code.line();
     code.comment("Dependencies used by inline resolvers");
-    const importsByPath = /* @__PURE__ */ new Map();
-    for (const { name, importPath } of inlineDependencies.values()) {
-      if (!importsByPath.has(importPath)) {
-        importsByPath.set(importPath, []);
+    const importsByResolvedPath = /* @__PURE__ */ new Map();
+    for (const { name, importPath, sourceFile } of inlineDependencies.values()) {
+      let resolvedPath = importPath;
+      if (importPath.startsWith(".") && sourceFile && outputDir) {
+        const toPosix = (p) => p.replace(/\\/g, "/");
+        const sourceDir = toPosix(sourceFile).replace(/\/[^/]+$/, "");
+        const parts = sourceDir.split("/").filter(Boolean);
+        const importParts = importPath.split("/");
+        for (const part of importParts) {
+          if (part === "..") {
+            parts.pop();
+          } else if (part !== ".") {
+            parts.push(part);
+          }
+        }
+        const absolutePath = "/" + parts.join("/");
+        resolvedPath = calculateRelativePath(absolutePath);
+      }
+      if (!importsByResolvedPath.has(resolvedPath)) {
+        importsByResolvedPath.set(resolvedPath, []);
       }
-      const names = importsByPath.get(importPath);
+      const names = importsByResolvedPath.get(resolvedPath);
       if (!names.includes(name)) {
         names.push(name);
       }
     }
-    for (const [importPath, names] of importsByPath) {
-      code.line(`import { ${names.join(", ")} } from '${importPath}';`);
+    for (const [resolvedPath, names] of importsByResolvedPath) {
+      code.line(`import { ${names.join(", ")} } from '${resolvedPath}';`);
     }
   }
   code.line();
-  code.line("type ResolverFn = (ctx: ResolverContext) => unknown | Promise<unknown>;");
+  code.comment("Typed resolver function types");
+  for (const endpoint of endpoints) {
+    const { pascalName } = endpoint;
+    code.line(
+      `type ${pascalName}ResolverFn = (ctx: ${pascalName}ResolverContext) => Types.${pascalName}Response | Promise<Types.${pascalName}Response>;`
+    );
+  }
+  code.line();
+  code.comment("Typed endpoint resolvers interface");
+  code.block("export interface EndpointResolvers {", () => {
+    for (const endpoint of endpoints) {
+      const { name, pascalName } = endpoint;
+      code.line(`${name}: ${pascalName}ResolverFn;`);
+    }
+  });
   code.line();
-  code.block("export const endpointResolvers: Record<string, ResolverFn> = {", () => {
+  code.block("export const endpointResolvers: EndpointResolvers = {", () => {
     for (const endpoint of endpoints) {
       code.comment(`${endpoint.method} ${endpoint.path}`);
       if (endpoint.description) {
         code.comment(endpoint.description);
       }
       if (endpoint.mockResolverName) {
-        code.line(`${endpoint.name}: ${endpoint.mockResolverName},`);
+        code.line(`${endpoint.name}: ${endpoint.mockResolverName} as ${endpoint.pascalName}ResolverFn,`);
       } else {
-        code.line(`${endpoint.name}: ${endpoint.mockResolverSource},`);
+        code.line(`${endpoint.name}: (${endpoint.mockResolverSource}) as ${endpoint.pascalName}ResolverFn,`);
       }
       code.line();
     }