schemock 0.0.4-alpha.16 → 0.0.4-alpha.17

package/README.md

@@ -609,6 +609,71 @@ export const HealthEndpoint = defineEndpoint('/api/health', {
 - Easier debugging with meaningful stack traces
 - Cleaner generated code
 
+### Inline Resolver Limitations
+
+When using inline `mockResolver` functions with local helper functions, be aware of these limitations:
+
+#### 1. Only Directly-Used Functions Are Copied
+
+Local functions are only copied if they are **directly called** in a resolver. Transitive dependencies (functions called by other functions) are not automatically detected.
+
+```typescript
+// ❌ Problem: innerHelper won't be copied
+function innerHelper(x: string) { return x.toUpperCase(); }
+function outerHelper(x: string) { return innerHelper(x); }
+
+export const MyEndpoint = defineEndpoint('/api/test', {
+  mockResolver: async ({ body }) => ({
+    result: outerHelper(body.input)  // Only outerHelper is detected
+  })
+});
+
+// ✅ Solution: Use named exported function
+export async function myResolver({ body, db }) {
+  return { result: outerHelper(body.input) };
+}
+
+export const MyEndpoint = defineEndpoint('/api/test', {
+  mockResolver: myResolver  // Function is imported, not serialized
+});
+```
+
+#### 2. Arrow Functions Need Parentheses
+
+Arrow functions without parentheses around parameters are not detected:
+
+```typescript
+// ❌ Not detected
+const double = x => x * 2;
+
+// ✅ Detected
+const double = (x) => x * 2;
+```
+
+#### 3. Recommended: Use Named Functions for Complex Logic
+
+For resolvers with helper functions, use named exported functions instead of inline resolvers:
+
+```typescript
+// Recommended approach
+export async function loginResolver({ body, db }) {
+  const user = db.user.findFirst({ where: { email: { equals: body.email } } });
+  if (!verifyPassword(body.password, user.hash)) {
+    throw new Error('Invalid credentials');
+  }
+  return { token: generateToken(user.id), user };
+}
+
+export const LoginEndpoint = defineEndpoint('/api/auth/login', {
+  mockResolver: loginResolver  // ✅ Imported directly, full IDE support
+});
+```
+
+Benefits of named functions:
+- All dependencies are available (no serialization)
+- Full IDE support (go-to-definition, refactoring)
+- Better stack traces for debugging
+
 ### Row-Level Security (RLS)
 
 **Scope-based RLS (simple - recommended):**

package/dist/cli/index.d.mts

@@ -423,6 +423,15 @@ interface ResolverDependency {
     /** Whether it's a default import */
     isDefault?: boolean;
 }
+/**
+ * Local function definition used by inline resolver
+ */
+interface LocalFunction {
+    /** Function name */
+    name: string;
+    /** Full function source code */
+    source: string;
+}
 /**
  * Fully analyzed endpoint with all computed properties
  */
@@ -455,6 +464,8 @@ interface AnalyzedEndpoint {
     sourceFile?: string;
     /** Dependencies detected in inline resolver (functions used but not defined locally) */
     resolverDependencies?: ResolverDependency[];
+    /** Local functions used by inline resolver */
+    localFunctions?: LocalFunction[];
     /** Description */
     description?: string;
 }
@@ -1068,4 +1079,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 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 };
+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 LocalFunction, 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

@@ -423,6 +423,15 @@ interface ResolverDependency {
     /** Whether it's a default import */
     isDefault?: boolean;
 }
+/**
+ * Local function definition used by inline resolver
+ */
+interface LocalFunction {
+    /** Function name */
+    name: string;
+    /** Full function source code */
+    source: string;
+}
 /**
  * Fully analyzed endpoint with all computed properties
  */
@@ -455,6 +464,8 @@ interface AnalyzedEndpoint {
     sourceFile?: string;
     /** Dependencies detected in inline resolver (functions used but not defined locally) */
     resolverDependencies?: ResolverDependency[];
+    /** Local functions used by inline resolver */
+    localFunctions?: LocalFunction[];
     /** Description */
     description?: string;
 }
@@ -1068,4 +1079,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 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 };
+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 LocalFunction, 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

@@ -1263,6 +1263,83 @@ function parseImportsFromFile(filePath) {
   importCache.set(filePath, imports);
   return imports;
 }
+var localFunctionCache = /* @__PURE__ */ new Map();
+function parseLocalFunctions(filePath) {
+  if (localFunctionCache.has(filePath)) {
+    return localFunctionCache.get(filePath);
+  }
+  const functions = /* @__PURE__ */ new Map();
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const funcDeclRegex = /^(export\s+)?function\s+(\w+)\s*\([^)]*\)[^{]*\{/gm;
+    let match;
+    while ((match = funcDeclRegex.exec(content)) !== null) {
+      const name = match[2];
+      const source = extractFunctionBody2(content, match.index);
+      if (source) functions.set(name, source);
+    }
+    const arrowRegex = /^(export\s+)?(const|let)\s+(\w+)\s*=\s*(async\s*)?\([^)]*\)[^=]*=>/gm;
+    while ((match = arrowRegex.exec(content)) !== null) {
+      const name = match[3];
+      const source = extractArrowFunction(content, match.index);
+      if (source) functions.set(name, source);
+    }
+  } catch {
+    console.warn(`Warning: Could not parse local functions from ${filePath}`);
+  }
+  localFunctionCache.set(filePath, functions);
+  return functions;
+}
+function extractFunctionBody2(content, startIndex) {
+  let braceCount = 0;
+  let started = false;
+  for (let i = startIndex; i < content.length; i++) {
+    if (content[i] === "{") {
+      braceCount++;
+      started = true;
+    } else if (content[i] === "}") {
+      braceCount--;
+      if (started && braceCount === 0) {
+        return content.slice(startIndex, i + 1).trim();
+      }
+    }
+  }
+  return null;
+}
+function extractArrowFunction(content, startIndex) {
+  const arrowIndex = content.indexOf("=>", startIndex);
+  if (arrowIndex === -1) return null;
+  let i = arrowIndex + 2;
+  while (i < content.length && /\s/.test(content[i])) i++;
+  if (content[i] === "{") {
+    let braceCount = 0;
+    let started = false;
+    for (let j = i; j < content.length; j++) {
+      if (content[j] === "{") {
+        braceCount++;
+        started = true;
+      } else if (content[j] === "}") {
+        braceCount--;
+        if (started && braceCount === 0) {
+          return content.slice(startIndex, j + 1).trim();
+        }
+      }
+    }
+    return null;
+  } else {
+    let end = i;
+    let parenCount = 0;
+    while (end < content.length) {
+      if (content[end] === "(") parenCount++;
+      else if (content[end] === ")") parenCount--;
+      else if ((content[end] === ";" || content[end] === "\n") && parenCount === 0) {
+        break;
+      }
+      end++;
+    }
+    return content.slice(startIndex, end).trim() + ";";
+  }
+}
 function detectUsedIdentifiers(functionSource) {
   const withoutStrings = functionSource.replace(/'[^']*'/g, "").replace(/"[^"]*"/g, "").replace(/`[^`]*`/g, "");
   const identifiers = /* @__PURE__ */ new Set();
@@ -1382,6 +1459,7 @@ function analyzeEndpoint(endpoint, endpointFiles) {
   let mockResolverName;
   let mockResolverImportPath;
   let resolverDependencies;
+  let localFunctions;
   if (isNamedFunction) {
     mockResolverName = resolverName;
     if (sourceFile) {
@@ -1391,16 +1469,26 @@ function analyzeEndpoint(endpoint, endpointFiles) {
     const usedIdentifiers = detectUsedIdentifiers(mockResolverSource);
     if (usedIdentifiers.length > 0) {
       const fileImports = parseImportsFromFile(sourceFile);
+      const localFuncs = parseLocalFunctions(sourceFile);
       const deps = [];
+      const locals = [];
       for (const identifier of usedIdentifiers) {
         const importPath = fileImports.get(identifier);
         if (importPath) {
           deps.push({ name: identifier, from: importPath });
+        } else {
+          const localSource = localFuncs.get(identifier);
+          if (localSource) {
+            locals.push({ name: identifier, source: localSource });
+          }
         }
       }
       if (deps.length > 0) {
         resolverDependencies = deps;
       }
+      if (locals.length > 0) {
+        localFunctions = locals;
+      }
     }
   }
   return {
@@ -1417,6 +1505,7 @@ function analyzeEndpoint(endpoint, endpointFiles) {
     mockResolverImportPath,
     sourceFile,
     resolverDependencies,
+    localFunctions,
     description: endpoint.description
   };
 }
@@ -2952,6 +3041,18 @@ function generateRouteHelpers(code, schemas) {
 }
 
 // src/cli/generators/mock/endpoints.ts
+function injectResolverTypeAnnotation(source, contextType) {
+  const match = source.match(/^(async\s*)?\(([^)]*)\)\s*=>/);
+  if (match) {
+    const [fullMatch, asyncPart = "", params] = match;
+    if (params.includes(":")) {
+      return source;
+    }
+    const replacement = `${asyncPart}(${params}: ${contextType}) =>`;
+    return source.replace(fullMatch, replacement);
+  }
+  return source;
+}
 function generateEndpointTypes(endpoints) {
   const code = new CodeBuilder();
   code.line();
@@ -3322,6 +3423,24 @@ function generateEndpointResolvers(endpoints, outputDir) {
       code.line(`import { ${names.join(", ")} } from '${resolvedPath}';`);
     }
   }
+  const allLocalFunctions = /* @__PURE__ */ new Map();
+  for (const endpoint of endpoints) {
+    if (endpoint.localFunctions) {
+      for (const fn of endpoint.localFunctions) {
+        if (!allLocalFunctions.has(fn.name)) {
+          allLocalFunctions.set(fn.name, fn.source);
+        }
+      }
+    }
+  }
+  if (allLocalFunctions.size > 0) {
+    code.line();
+    code.comment("Local helper functions (copied from source files)");
+    for (const [, source] of allLocalFunctions) {
+      code.line(source);
+      code.line();
+    }
+  }
   code.line();
   code.comment("Typed resolver function types");
   for (const endpoint of endpoints) {
@@ -3348,7 +3467,11 @@ function generateEndpointResolvers(endpoints, outputDir) {
       if (endpoint.mockResolverName) {
         code.line(`${endpoint.name}: ${endpoint.mockResolverName} as ${endpoint.pascalName}ResolverFn,`);
       } else {
-        code.line(`${endpoint.name}: (${endpoint.mockResolverSource}) as ${endpoint.pascalName}ResolverFn,`);
+        const typedSource = injectResolverTypeAnnotation(
+          endpoint.mockResolverSource,
+          `${endpoint.pascalName}ResolverContext`
+        );
+        code.line(`${endpoint.name}: ${typedSource},`);
       }
       code.line();
     }