schemock 0.0.4-alpha.13 → 0.0.4-alpha.14

package/dist/cli/index.mjs

@@ -1228,8 +1228,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 = 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));
 }
@@ -1241,16 +1374,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,
@@ -1264,6 +1413,8 @@ function analyzeEndpoint(endpoint, endpointFiles) {
     mockResolverSource,
     mockResolverName,
     mockResolverImportPath,
+    sourceFile,
+    resolverDependencies,
     description: endpoint.description
   };
 }
@@ -3039,9 +3190,35 @@ 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();
+  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.line("db: Database;");
+    code.line("headers: Record<string, string>;");
+  });
+  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}`;
@@ -3052,7 +3229,37 @@ 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
+          });
+        }
+      }
+    }
   }
+  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");
@@ -3064,27 +3271,29 @@ function generateEndpointResolvers(endpoints, outputDir) {
       importsByPath.get(importPath).push(name);
     }
     for (const [importPath, names] of importsByPath) {
-      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;
-      }
+      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 importsByPath = /* @__PURE__ */ new Map();
+    for (const { name, importPath } of inlineDependencies.values()) {
+      if (!importsByPath.has(importPath)) {
+        importsByPath.set(importPath, []);
+      }
+      const names = importsByPath.get(importPath);
+      if (!names.includes(name)) {
+        names.push(name);
+      }
+    }
+    for (const [importPath, names] of importsByPath) {
+      code.line(`import { ${names.join(", ")} } from '${importPath}';`);
+    }
+  }
   code.line();
-  code.line("type ResolverFn = (ctx: MockResolverContext) => unknown | Promise<unknown>;");
+  code.line("type ResolverFn = (ctx: ResolverContext) => unknown | Promise<unknown>;");
   code.line();
   code.block("export const endpointResolvers: Record<string, ResolverFn> = {", () => {
     for (const endpoint of endpoints) {