schemock 0.0.4-alpha.13 → 0.0.4-alpha.15

package/dist/adapters/index.d.mts

@@ -1,7 +1,7 @@
-import { A as Adapter, a as AdapterContext, b as AdapterResponse, d as MswjsDataFactory, F as FetchAdapterOptions } from '../types-vPJ91BuY.mjs';
-export { c as AdapterResponseMeta, D as Database, M as MockAdapterOptions, S as SchemaRegistry } from '../types-vPJ91BuY.mjs';
-import { o as EntitySchema, b as FieldDefinition } from '../types-CWZQ6vqt.mjs';
-import { M as Middleware } from '../types-D-u5uw1E.mjs';
+import { A as Adapter, a as AdapterContext, b as AdapterResponse, d as MswjsDataFactory, F as FetchAdapterOptions } from '../types-BBeKlEd1.mjs';
+export { c as AdapterResponseMeta, D as Database, M as MockAdapterOptions, S as SchemaRegistry } from '../types-BBeKlEd1.mjs';
+import { o as EntitySchema, b as FieldDefinition } from '../types-BCLdZDSF.mjs';
+import { M as Middleware } from '../types-DKrOkBcu.mjs';
 
 /**
  * Storage Driver Types - Abstract storage interface for different backends

package/dist/adapters/index.d.ts

@@ -1,7 +1,7 @@
-import { A as Adapter, a as AdapterContext, b as AdapterResponse, d as MswjsDataFactory, F as FetchAdapterOptions } from '../types-4EDTne0h.js';
-export { c as AdapterResponseMeta, D as Database, M as MockAdapterOptions, S as SchemaRegistry } from '../types-4EDTne0h.js';
-import { o as EntitySchema, b as FieldDefinition } from '../types-CWZQ6vqt.js';
-import { M as Middleware } from '../types-Ku_ykMzx.js';
+import { A as Adapter, a as AdapterContext, b as AdapterResponse, d as MswjsDataFactory, F as FetchAdapterOptions } from '../types-CVeLQjhD.js';
+export { c as AdapterResponseMeta, D as Database, M as MockAdapterOptions, S as SchemaRegistry } from '../types-CVeLQjhD.js';
+import { o as EntitySchema, b as FieldDefinition } from '../types-BCLdZDSF.js';
+import { M as Middleware } from '../types-CZdze7Tl.js';
 
 /**
  * Storage Driver Types - Abstract storage interface for different backends

package/dist/cli/index.d.mts

@@ -1,5 +1,5 @@
-import { l as RLSScopeMapping, m as RLSBypass, n as RLSConfig, o as EntitySchema, v as EndpointSchema, b as FieldDefinition } from '../types-CWZQ6vqt.mjs';
-export { I as IndexConfig, j as RLSContext, k as RLSFilter, f as RPCArgument, g as RPCConfig } from '../types-CWZQ6vqt.mjs';
+import { l as RLSScopeMapping, m as RLSBypass, n as RLSConfig, o as EntitySchema, v as EndpointSchema, b as FieldDefinition } from '../types-BCLdZDSF.mjs';
+export { I as IndexConfig, j as RLSContext, k as RLSFilter, f as RPCArgument, g as RPCConfig } from '../types-BCLdZDSF.mjs';
 
 /**
  * CLI type definitions for Schemock code generation
@@ -412,6 +412,17 @@ interface AnalyzedEndpointField {
     /** Enum values if enum type */
     enumValues?: string[];
 }
+/**
+ * Dependency import for inline resolvers
+ */
+interface ResolverDependency {
+    /** Identifier name used in the resolver */
+    name: string;
+    /** Module path to import from */
+    from: string;
+    /** Whether it's a default import */
+    isDefault?: boolean;
+}
 /**
  * Fully analyzed endpoint with all computed properties
  */
@@ -440,6 +451,10 @@ interface AnalyzedEndpoint {
     mockResolverImportPath?: string;
     /** Export name in the source file */
     mockResolverExportName?: string;
+    /** Source file path where this endpoint is defined */
+    sourceFile?: string;
+    /** Dependencies detected in inline resolver (functions used but not defined locally) */
+    resolverDependencies?: ResolverDependency[];
     /** Description */
     description?: string;
 }
@@ -1053,4 +1068,4 @@ declare function generateFetchClient(schemas: AnalyzedSchema[], config: FetchAda
  */
 declare function generateFormSchemas(schemas: AnalyzedSchema[]): string;
 
-export { type AnalyzedComputed, type AnalyzedEndpoint, type AnalyzedEndpointField, type AnalyzedField, type AnalyzedIndex, type AnalyzedRLS, type AnalyzedRPC, type AnalyzedRelation, type AnalyzedSchema, type AuthProviderConfig, CodeBuilder, type FakerMapping, type FetchAdapterConfig, type FirebaseAdapterConfig, type FrameworkType, type GenerateOptions, type GenerateSQLOptions, type GenerationTarget, type GraphQLAdapterConfig, type MockAdapterConfig, type PGliteAdapterConfig, type PluralizeConfig, RLSBypass, RLSConfig, RLSScopeMapping, type SQLGeneratorResult, type SchemockConfig, type SupabaseAdapterConfig, type TargetMiddlewareConfig, type TargetType, analyzeSchemas, defineConfig, discoverSchemas, fieldToFakerCall, fieldToTsType, generate, generateClaudeMd, generateCursorRules, generateFetchClient, generateFirebaseClient, generateFormSchemas, generateHooks, generateMockClient, generateMockDb, generateMockHandlers, generateSchemockSection, generateSeed, generateSupabaseClient, generateTypes, getDefaultConfig, getRelativePath, loadConfig, mergeClaudeMdContent, pluralize, primitiveToTs, setupAI, toCamelCase, toPascalCase };
+export { type AnalyzedComputed, type AnalyzedEndpoint, type AnalyzedEndpointField, type AnalyzedField, type AnalyzedIndex, type AnalyzedRLS, type AnalyzedRPC, type AnalyzedRelation, type AnalyzedSchema, type AuthProviderConfig, CodeBuilder, type FakerMapping, type FetchAdapterConfig, type FirebaseAdapterConfig, type FrameworkType, type GenerateOptions, type GenerateSQLOptions, type GenerationTarget, type GraphQLAdapterConfig, type MockAdapterConfig, type PGliteAdapterConfig, type PluralizeConfig, RLSBypass, RLSConfig, RLSScopeMapping, type ResolverDependency, type SQLGeneratorResult, type SchemockConfig, type SupabaseAdapterConfig, type TargetMiddlewareConfig, type TargetType, analyzeSchemas, defineConfig, discoverSchemas, fieldToFakerCall, fieldToTsType, generate, generateClaudeMd, generateCursorRules, generateFetchClient, generateFirebaseClient, generateFormSchemas, generateHooks, generateMockClient, generateMockDb, generateMockHandlers, generateSchemockSection, generateSeed, generateSupabaseClient, generateTypes, getDefaultConfig, getRelativePath, loadConfig, mergeClaudeMdContent, pluralize, primitiveToTs, setupAI, toCamelCase, toPascalCase };

package/dist/cli/index.d.ts

@@ -1,5 +1,5 @@
-import { l as RLSScopeMapping, m as RLSBypass, n as RLSConfig, o as EntitySchema, v as EndpointSchema, b as FieldDefinition } from '../types-CWZQ6vqt.js';
-export { I as IndexConfig, j as RLSContext, k as RLSFilter, f as RPCArgument, g as RPCConfig } from '../types-CWZQ6vqt.js';
+import { l as RLSScopeMapping, m as RLSBypass, n as RLSConfig, o as EntitySchema, v as EndpointSchema, b as FieldDefinition } from '../types-BCLdZDSF.js';
+export { I as IndexConfig, j as RLSContext, k as RLSFilter, f as RPCArgument, g as RPCConfig } from '../types-BCLdZDSF.js';
 
 /**
  * CLI type definitions for Schemock code generation
@@ -412,6 +412,17 @@ interface AnalyzedEndpointField {
     /** Enum values if enum type */
     enumValues?: string[];
 }
+/**
+ * Dependency import for inline resolvers
+ */
+interface ResolverDependency {
+    /** Identifier name used in the resolver */
+    name: string;
+    /** Module path to import from */
+    from: string;
+    /** Whether it's a default import */
+    isDefault?: boolean;
+}
 /**
  * Fully analyzed endpoint with all computed properties
  */
@@ -440,6 +451,10 @@ interface AnalyzedEndpoint {
     mockResolverImportPath?: string;
     /** Export name in the source file */
     mockResolverExportName?: string;
+    /** Source file path where this endpoint is defined */
+    sourceFile?: string;
+    /** Dependencies detected in inline resolver (functions used but not defined locally) */
+    resolverDependencies?: ResolverDependency[];
     /** Description */
     description?: string;
 }
@@ -1053,4 +1068,4 @@ declare function generateFetchClient(schemas: AnalyzedSchema[], config: FetchAda
  */
 declare function generateFormSchemas(schemas: AnalyzedSchema[]): string;
 
-export { type AnalyzedComputed, type AnalyzedEndpoint, type AnalyzedEndpointField, type AnalyzedField, type AnalyzedIndex, type AnalyzedRLS, type AnalyzedRPC, type AnalyzedRelation, type AnalyzedSchema, type AuthProviderConfig, CodeBuilder, type FakerMapping, type FetchAdapterConfig, type FirebaseAdapterConfig, type FrameworkType, type GenerateOptions, type GenerateSQLOptions, type GenerationTarget, type GraphQLAdapterConfig, type MockAdapterConfig, type PGliteAdapterConfig, type PluralizeConfig, RLSBypass, RLSConfig, RLSScopeMapping, type SQLGeneratorResult, type SchemockConfig, type SupabaseAdapterConfig, type TargetMiddlewareConfig, type TargetType, analyzeSchemas, defineConfig, discoverSchemas, fieldToFakerCall, fieldToTsType, generate, generateClaudeMd, generateCursorRules, generateFetchClient, generateFirebaseClient, generateFormSchemas, generateHooks, generateMockClient, generateMockDb, generateMockHandlers, generateSchemockSection, generateSeed, generateSupabaseClient, generateTypes, getDefaultConfig, getRelativePath, loadConfig, mergeClaudeMdContent, pluralize, primitiveToTs, setupAI, toCamelCase, toPascalCase };
+export { type AnalyzedComputed, type AnalyzedEndpoint, type AnalyzedEndpointField, type AnalyzedField, type AnalyzedIndex, type AnalyzedRLS, type AnalyzedRPC, type AnalyzedRelation, type AnalyzedSchema, type AuthProviderConfig, CodeBuilder, type FakerMapping, type FetchAdapterConfig, type FirebaseAdapterConfig, type FrameworkType, type GenerateOptions, type GenerateSQLOptions, type GenerationTarget, type GraphQLAdapterConfig, type MockAdapterConfig, type PGliteAdapterConfig, type PluralizeConfig, RLSBypass, RLSConfig, RLSScopeMapping, type ResolverDependency, type SQLGeneratorResult, type SchemockConfig, type SupabaseAdapterConfig, type TargetMiddlewareConfig, type TargetType, analyzeSchemas, defineConfig, discoverSchemas, fieldToFakerCall, fieldToTsType, generate, generateClaudeMd, generateCursorRules, generateFetchClient, generateFirebaseClient, generateFormSchemas, generateHooks, generateMockClient, generateMockDb, generateMockHandlers, generateSchemockSection, generateSeed, generateSupabaseClient, generateTypes, getDefaultConfig, getRelativePath, loadConfig, mergeClaudeMdContent, pluralize, primitiveToTs, setupAI, toCamelCase, toPascalCase };

package/dist/cli/index.js

@@ -1230,8 +1230,141 @@ function topologicalSort(schemas) {
   }
   return sorted;
 }
-
-// src/cli/analyze-endpoints.ts
+var importCache = /* @__PURE__ */ new Map();
+function parseImportsFromFile(filePath) {
+  if (importCache.has(filePath)) {
+    return importCache.get(filePath);
+  }
+  const imports = /* @__PURE__ */ new Map();
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const importRegex = /import\s+(?:(?:(\w+)(?:\s*,\s*)?)?(?:\{([^}]+)\})?\s+from\s+)?['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      const [, defaultImport, namedImports, modulePath] = match;
+      if (defaultImport) {
+        imports.set(defaultImport, modulePath);
+      }
+      if (namedImports) {
+        const names = namedImports.split(",").map((s) => s.trim());
+        for (const name of names) {
+          const asMatch = name.match(/(\w+)\s+as\s+(\w+)/);
+          if (asMatch) {
+            imports.set(asMatch[2], modulePath);
+          } else if (name && /^\w+$/.test(name)) {
+            imports.set(name, modulePath);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    console.warn(`Warning: Could not parse imports from ${filePath}`);
+  }
+  importCache.set(filePath, imports);
+  return imports;
+}
+function detectUsedIdentifiers(functionSource) {
+  const withoutStrings = functionSource.replace(/'[^']*'/g, "").replace(/"[^"]*"/g, "").replace(/`[^`]*`/g, "");
+  const identifiers = /* @__PURE__ */ new Set();
+  const callRegex = /\b([A-Z][a-zA-Z0-9]*|[a-z][a-zA-Z0-9]*)\s*\(/g;
+  let match;
+  while ((match = callRegex.exec(withoutStrings)) !== null) {
+    const name = match[1];
+    if (!isBuiltIn(name) && !isContextProperty(name)) {
+      identifiers.add(name);
+    }
+  }
+  const newRegex = /\bnew\s+([A-Z][a-zA-Z0-9]*)/g;
+  while ((match = newRegex.exec(withoutStrings)) !== null) {
+    const name = match[1];
+    if (!isBuiltIn(name)) {
+      identifiers.add(name);
+    }
+  }
+  const throwRegex = /\bthrow\s+new\s+([A-Z][a-zA-Z0-9]*)/g;
+  while ((match = throwRegex.exec(withoutStrings)) !== null) {
+    identifiers.add(match[1]);
+  }
+  return Array.from(identifiers);
+}
+function isBuiltIn(name) {
+  const builtIns = /* @__PURE__ */ new Set([
+    // Functions
+    "console",
+    "JSON",
+    "Object",
+    "Array",
+    "String",
+    "Number",
+    "Boolean",
+    "Date",
+    "Math",
+    "Promise",
+    "Map",
+    "Set",
+    "WeakMap",
+    "WeakSet",
+    "parseInt",
+    "parseFloat",
+    "isNaN",
+    "isFinite",
+    "fetch",
+    "setTimeout",
+    "setInterval",
+    "clearTimeout",
+    "clearInterval",
+    // Errors
+    "Error",
+    "TypeError",
+    "ReferenceError",
+    "SyntaxError",
+    "RangeError",
+    // Common methods that look like function calls
+    "toString",
+    "valueOf",
+    "hasOwnProperty",
+    "length",
+    "push",
+    "pop",
+    "map",
+    "filter",
+    "reduce",
+    "find",
+    "findIndex",
+    "some",
+    "every",
+    "includes",
+    "indexOf",
+    "slice",
+    "splice",
+    "concat",
+    "join",
+    "split"
+  ]);
+  return builtIns.has(name);
+}
+function isContextProperty(name) {
+  const contextProps = /* @__PURE__ */ new Set([
+    "params",
+    "body",
+    "db",
+    "headers",
+    "ctx",
+    // Common db methods
+    "findMany",
+    "findFirst",
+    "findUnique",
+    "create",
+    "update",
+    "delete",
+    "count",
+    "getAll",
+    "deleteMany",
+    "updateMany",
+    "upsert"
+  ]);
+  return contextProps.has(name);
+}
 function analyzeEndpoints(endpoints, endpointFiles) {
   return endpoints.map((endpoint) => analyzeEndpoint(endpoint, endpointFiles));
 }
@@ -1243,16 +1376,32 @@ function analyzeEndpoint(endpoint, endpointFiles) {
   const body = analyzeFields(endpoint.body);
   const response = analyzeFields(endpoint.response);
   const mockResolverSource = serializeMockResolver(endpoint.mockResolver);
+  const sourceFile = endpointFiles?.get(endpoint.path);
   const resolverName = endpoint.mockResolver.name;
   const isNamedFunction = resolverName && !resolverName.startsWith("bound ") && resolverName !== "mockResolver";
   let mockResolverName;
   let mockResolverImportPath;
+  let resolverDependencies;
   if (isNamedFunction) {
     mockResolverName = resolverName;
-    const sourceFile = endpointFiles?.get(endpoint.path);
     if (sourceFile) {
       mockResolverImportPath = sourceFile;
     }
+  } else if (sourceFile) {
+    const usedIdentifiers = detectUsedIdentifiers(mockResolverSource);
+    if (usedIdentifiers.length > 0) {
+      const fileImports = parseImportsFromFile(sourceFile);
+      const deps = [];
+      for (const identifier of usedIdentifiers) {
+        const importPath = fileImports.get(identifier);
+        if (importPath) {
+          deps.push({ name: identifier, from: importPath });
+        }
+      }
+      if (deps.length > 0) {
+        resolverDependencies = deps;
+      }
+    }
   }
   return {
     path: endpoint.path,
@@ -1266,6 +1415,8 @@ function analyzeEndpoint(endpoint, endpointFiles) {
     mockResolverSource,
     mockResolverName,
     mockResolverImportPath,
+    sourceFile,
+    resolverDependencies,
     description: endpoint.description
   };
 }
@@ -2967,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) {
@@ -2988,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();
@@ -3041,9 +3194,44 @@ function generateEndpointResolvers(endpoints, outputDir) {
   code.comment("");
   code.comment("These resolvers are copied from your defineEndpoint() calls.");
   code.comment("They receive { params, body, db, headers } and return the response.");
+  code.comment("");
+  code.comment("NOTE: If your inline resolvers use external functions (e.g., hashPassword, generateToken),");
+  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("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;");
+    code.line("readonly code?: string;");
+    code.line();
+    code.block("constructor(message: string, status: number, code?: string) {", () => {
+      code.line("super(message);");
+      code.line('this.name = "HttpError";');
+      code.line("this.status = status;");
+      code.line("this.code = code;");
+    });
+  });
   code.line();
-  code.line("import type { MockResolverContext } from 'schemock/schema';");
   const externalResolvers = /* @__PURE__ */ new Map();
+  const inlineDependencies = /* @__PURE__ */ new Map();
   for (const endpoint of endpoints) {
     if (endpoint.mockResolverName && endpoint.mockResolverImportPath) {
       const key = `${endpoint.mockResolverImportPath}:${endpoint.mockResolverName}`;
@@ -3054,7 +3242,38 @@ function generateEndpointResolvers(endpoints, outputDir) {
         });
       }
     }
+    if (endpoint.resolverDependencies) {
+      for (const dep of endpoint.resolverDependencies) {
+        const key = `${dep.from}:${dep.name}`;
+        if (!inlineDependencies.has(key)) {
+          inlineDependencies.set(key, {
+            name: dep.name,
+            importPath: dep.from,
+            sourceFile: endpoint.sourceFile
+          });
+        }
+      }
+    }
   }
+  const calculateRelativePath = (importPath) => {
+    let relativePath = importPath;
+    if (outputDir) {
+      const toPosix = (p) => p.replace(/\\/g, "/");
+      const from = toPosix(outputDir);
+      const to = toPosix(importPath);
+      const fromParts = from.split("/").filter(Boolean);
+      const toParts = to.split("/").filter(Boolean);
+      while (fromParts.length && toParts.length && fromParts[0] === toParts[0]) {
+        fromParts.shift();
+        toParts.shift();
+      }
+      let rel = "../".repeat(fromParts.length) + toParts.join("/");
+      if (!rel.startsWith(".") && rel !== "") rel = "./" + rel;
+      rel = rel.replace(/\.(ts|js)$/, "");
+      relativePath = rel;
+    }
+    return relativePath;
+  };
   if (externalResolvers.size > 0) {
     code.line();
     code.comment("External resolver imports");
@@ -3066,38 +3285,70 @@ function generateEndpointResolvers(endpoints, outputDir) {
       importsByPath.get(importPath).push(name);
     }
     for (const [importPath, names] of importsByPath) {
-      let relativePath = importPath;
-      if (outputDir) {
+      const relativePath = calculateRelativePath(importPath);
+      code.line(`import { ${names.join(", ")} } from '${relativePath}';`);
+    }
+  }
+  if (inlineDependencies.size > 0) {
+    code.line();
+    code.comment("Dependencies used by inline resolvers");
+    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 from = toPosix(outputDir);
-        const to = toPosix(importPath);
-        const fromParts = from.split("/").filter(Boolean);
-        const toParts = to.split("/").filter(Boolean);
-        while (fromParts.length && toParts.length && fromParts[0] === toParts[0]) {
-          fromParts.shift();
-          toParts.shift();
+        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);
+          }
         }
-        let rel = "../".repeat(fromParts.length) + toParts.join("/");
-        if (!rel.startsWith(".") && rel !== "") rel = "./" + rel;
-        rel = rel.replace(/\.(ts|js)$/, "");
-        relativePath = rel;
+        const absolutePath = "/" + parts.join("/");
+        resolvedPath = calculateRelativePath(absolutePath);
       }
-      code.line(`import { ${names.join(", ")} } from '${relativePath}';`);
+      if (!importsByResolvedPath.has(resolvedPath)) {
+        importsByResolvedPath.set(resolvedPath, []);
+      }
+      const names = importsByResolvedPath.get(resolvedPath);
+      if (!names.includes(name)) {
+        names.push(name);
+      }
+    }
+    for (const [resolvedPath, names] of importsByResolvedPath) {
+      code.line(`import { ${names.join(", ")} } from '${resolvedPath}';`);
     }
   }
   code.line();
-  code.line("type ResolverFn = (ctx: MockResolverContext) => 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();
     }