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

package/dist/cli.js

@@ -1510,6 +1510,140 @@ var init_analyze = __esm({
 });
 
 // src/cli/analyze-endpoints.ts
+function parseImportsFromFile(filePath) {
+  if (importCache.has(filePath)) {
+    return importCache.get(filePath);
+  }
+  const imports = /* @__PURE__ */ new Map();
+  try {
+    const content = (0, import_node_fs2.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));
 }
@@ -1521,16 +1655,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,
@@ -1544,6 +1694,8 @@ function analyzeEndpoint(endpoint, endpointFiles) {
     mockResolverSource,
     mockResolverName,
     mockResolverImportPath,
+    sourceFile,
+    resolverDependencies,
     description: endpoint.description
   };
 }
@@ -1661,9 +1813,12 @@ function serializeMockResolver(resolver) {
   }
   return source;
 }
+var import_node_fs2, importCache;
 var init_analyze_endpoints = __esm({
   "src/cli/analyze-endpoints.ts"() {
     "use strict";
+    import_node_fs2 = require("fs");
+    importCache = /* @__PURE__ */ new Map();
   }
 });
 
@@ -3379,9 +3534,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}`;
@@ -3392,7 +3573,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");
@@ -3404,27 +3615,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) {
@@ -9535,9 +9748,9 @@ async function setupAI(options = {}) {
   const outputDir = options.output || process.cwd();
   const claudeMdPath = (0, import_node_path8.resolve)(outputDir, "CLAUDE.md");
   let existingContent = "";
-  if ((0, import_node_fs2.existsSync)(claudeMdPath)) {
+  if ((0, import_node_fs3.existsSync)(claudeMdPath)) {
     console.log("\u{1F4C4} Found existing CLAUDE.md");
-    existingContent = (0, import_node_fs2.readFileSync)(claudeMdPath, "utf-8");
+    existingContent = (0, import_node_fs3.readFileSync)(claudeMdPath, "utf-8");
   } else {
     console.log("\u{1F4C4} No existing CLAUDE.md found - will create new file");
   }
@@ -9559,7 +9772,7 @@ async function setupAI(options = {}) {
     }
     console.log("\u2500".repeat(60));
   } else if (claudeMdResult.modified || claudeMdResult.created) {
-    (0, import_node_fs2.writeFileSync)(claudeMdPath, claudeMdResult.content, "utf-8");
+    (0, import_node_fs3.writeFileSync)(claudeMdPath, claudeMdResult.content, "utf-8");
     if (claudeMdResult.created) {
       console.log(`   \u2713 Created ${claudeMdPath}`);
     } else {
@@ -9571,7 +9784,7 @@ async function setupAI(options = {}) {
   let cursorResult;
   if (options.cursor) {
     const cursorPath = (0, import_node_path8.resolve)(outputDir, ".cursorrules");
-    const cursorExists = (0, import_node_fs2.existsSync)(cursorPath);
+    const cursorExists = (0, import_node_fs3.existsSync)(cursorPath);
     console.log("\n\u{1F4C4} Generating .cursorrules for Cursor IDE...");
     const cursorContent = generateCursorRules(config);
     if (options.dryRun) {
@@ -9583,7 +9796,7 @@ async function setupAI(options = {}) {
     } else {
       let shouldWrite = true;
       if (cursorExists && !options.force) {
-        const existingCursor = (0, import_node_fs2.readFileSync)(cursorPath, "utf-8");
+        const existingCursor = (0, import_node_fs3.readFileSync)(cursorPath, "utf-8");
         if (!existingCursor.includes("Schemock Rules for Cursor")) {
           console.log("   \u26A0\uFE0F  Existing .cursorrules was not created by Schemock");
           console.log("   Use --force to overwrite, or manually add Schemock rules");
@@ -9594,7 +9807,7 @@ async function setupAI(options = {}) {
         }
       }
       if (shouldWrite) {
-        (0, import_node_fs2.writeFileSync)(cursorPath, cursorContent, "utf-8");
+        (0, import_node_fs3.writeFileSync)(cursorPath, cursorContent, "utf-8");
         console.log(`   \u2713 ${cursorExists ? "Updated" : "Created"} ${cursorPath}`);
       }
       cursorResult = { created: !cursorExists, modified: shouldWrite, path: cursorPath };
@@ -9617,11 +9830,11 @@ async function setupAI(options = {}) {
     cursorRules: cursorResult
   };
 }
-var import_node_fs2, import_node_path8;
+var import_node_fs3, import_node_path8;
 var init_setup_ai = __esm({
   "src/cli/commands/setup-ai.ts"() {
     "use strict";
-    import_node_fs2 = require("fs");
+    import_node_fs3 = require("fs");
     import_node_path8 = require("path");
     init_config();
     init_claude_md();
@@ -9629,7 +9842,7 @@ var init_setup_ai = __esm({
 });
 
 // src/cli.ts
-var import_node_fs3 = require("fs");
+var import_node_fs4 = require("fs");
 var import_node_path9 = require("path");
 function parseArgs(args) {
   const options = {};
@@ -9762,8 +9975,8 @@ Entity Filtering (in config):
 function showVersion() {
   try {
     const pkgPath = (0, import_node_path9.resolve)(__dirname, "../package.json");
-    if ((0, import_node_fs3.existsSync)(pkgPath)) {
-      const pkg = JSON.parse((0, import_node_fs3.readFileSync)(pkgPath, "utf-8"));
+    if ((0, import_node_fs4.existsSync)(pkgPath)) {
+      const pkg = JSON.parse((0, import_node_fs4.readFileSync)(pkgPath, "utf-8"));
       console.log(`schemock v${pkg.version}`);
       return;
     }
@@ -9778,13 +9991,13 @@ Initializing Schemock project with template: ${template}
 `);
   const dirs = ["src/schemas"];
   for (const dir of dirs) {
-    if (!(0, import_node_fs3.existsSync)(dir)) {
-      (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
+    if (!(0, import_node_fs4.existsSync)(dir)) {
+      (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
       console.log(`  Created ${dir}/`);
     }
   }
   const schemaPath = "src/schemas/user.ts";
-  if (!(0, import_node_fs3.existsSync)(schemaPath)) {
+  if (!(0, import_node_fs4.existsSync)(schemaPath)) {
     const schemaContent = `import { defineData, field, hasMany, belongsTo } from 'schemock/schema';
 
 /**
@@ -9828,7 +10041,7 @@ export const commentSchema = defineData('comment', {
   },
 });
 `;
-    (0, import_node_fs3.writeFileSync)(schemaPath, schemaContent);
+    (0, import_node_fs4.writeFileSync)(schemaPath, schemaContent);
     console.log(`  Created ${schemaPath}`);
   }
   const configPath = "schemock.config.ts";
@@ -9838,7 +10051,7 @@ export const commentSchema = defineData('comment', {
     adapter: "mock",
     apiPrefix: "/api"
   };
-  if (!(0, import_node_fs3.existsSync)(configPath)) {
+  if (!(0, import_node_fs4.existsSync)(configPath)) {
     const configContent = `import { defineConfig } from 'schemock/cli';
 
 export default defineConfig({
@@ -9875,19 +10088,19 @@ export default defineConfig({
   },
 });
 `;
-    (0, import_node_fs3.writeFileSync)(configPath, configContent);
+    (0, import_node_fs4.writeFileSync)(configPath, configContent);
     console.log(`  Created ${configPath}`);
   }
   console.log("\n\u{1F916} Setting up AI configuration...");
   const { generateClaudeMd: generateClaudeMd2 } = await Promise.resolve().then(() => (init_claude_md(), claude_md_exports));
   const claudeMdPath = (0, import_node_path9.resolve)("CLAUDE.md");
   let existingClaudeMd = "";
-  if ((0, import_node_fs3.existsSync)(claudeMdPath)) {
-    existingClaudeMd = (0, import_node_fs3.readFileSync)(claudeMdPath, "utf-8");
+  if ((0, import_node_fs4.existsSync)(claudeMdPath)) {
+    existingClaudeMd = (0, import_node_fs4.readFileSync)(claudeMdPath, "utf-8");
   }
   const claudeResult = generateClaudeMd2(defaultConfig, existingClaudeMd);
   if (claudeResult.modified || claudeResult.created) {
-    (0, import_node_fs3.writeFileSync)(claudeMdPath, claudeResult.content, "utf-8");
+    (0, import_node_fs4.writeFileSync)(claudeMdPath, claudeResult.content, "utf-8");
     if (claudeResult.created) {
       console.log("  Created CLAUDE.md");
     } else {
@@ -9962,8 +10175,8 @@ async function generateOpenAPICommand(options) {
     description: "Generated by Schemock"
   });
   const output = format === "yaml" ? toYAML(spec) : JSON.stringify(spec, null, 2);
-  (0, import_node_fs3.mkdirSync)((0, import_node_path9.dirname)(outputPath), { recursive: true });
-  (0, import_node_fs3.writeFileSync)(outputPath, output);
+  (0, import_node_fs4.mkdirSync)((0, import_node_path9.dirname)(outputPath), { recursive: true });
+  (0, import_node_fs4.writeFileSync)(outputPath, output);
   console.log(`  Generated: ${outputPath}`);
   console.log("\n\u2713 OpenAPI specification generated successfully!\n");
 }
@@ -10002,8 +10215,8 @@ async function generatePostmanCommand(options) {
     baseUrl: "http://localhost:3000",
     description: "Generated by Schemock"
   });
-  (0, import_node_fs3.mkdirSync)((0, import_node_path9.dirname)(outputPath), { recursive: true });
-  (0, import_node_fs3.writeFileSync)(outputPath, JSON.stringify(collection, null, 2));
+  (0, import_node_fs4.mkdirSync)((0, import_node_path9.dirname)(outputPath), { recursive: true });
+  (0, import_node_fs4.writeFileSync)(outputPath, JSON.stringify(collection, null, 2));
   console.log(`  Generated: ${outputPath}`);
   console.log("\n\u2713 Postman collection generated successfully!\n");
 }

package/dist/index.d.mts

@@ -1,8 +1,8 @@
-export { A as ArrayFieldBuilder, C as ComputedFieldDefinition, D as DateFieldBuilder, p as EmbedConfig, u as EndpointConfig, t as EndpointMethod, v as EndpointSchema, e as EntityApiConfig, h as EntityOptions, o as EntitySchema, E as EnumFieldBuilder, F as FieldBuilder, a as FieldConstraints, b as FieldDefinition, I as IndexConfig, z as InferCreate, y as InferEntity, x as InferFieldType, B as InferUpdate, M as MockResolverContext, N as NumberFieldBuilder, O as ObjectFieldBuilder, m as RLSBypass, n as RLSConfig, j as RLSContext, k as RLSFilter, l as RLSScopeMapping, f as RPCArgument, g as RPCConfig, R as RefFieldBuilder, c as RelationDefinition, S as StringFieldBuilder, V as ViewFieldValue, q as ViewFields, r as ViewOptions, s as ViewSchema, i as isComputedField, w as isEndpointSchema, d as isRelation } from './types-CWZQ6vqt.mjs';
+export { A as ArrayFieldBuilder, C as ComputedFieldDefinition, D as DateFieldBuilder, p as EmbedConfig, u as EndpointConfig, t as EndpointMethod, v as EndpointSchema, e as EntityApiConfig, h as EntityOptions, o as EntitySchema, E as EnumFieldBuilder, F as FieldBuilder, a as FieldConstraints, b as FieldDefinition, I as IndexConfig, z as InferCreate, y as InferEntity, x as InferFieldType, B as InferUpdate, M as MockResolverContext, N as NumberFieldBuilder, O as ObjectFieldBuilder, m as RLSBypass, n as RLSConfig, j as RLSContext, k as RLSFilter, l as RLSScopeMapping, f as RPCArgument, g as RPCConfig, R as RefFieldBuilder, c as RelationDefinition, S as StringFieldBuilder, V as ViewFieldValue, q as ViewFields, r as ViewOptions, s as ViewSchema, i as isComputedField, w as isEndpointSchema, d as isRelation } from './types-BCLdZDSF.mjs';
 export { BelongsToOptions, EmbedMarker, FieldDefinitions, HasManyOptions, HasOneOptions, ViewFieldDefinitions, belongsTo, defineData, defineEndpoint, defineView, embed, field, hasMany, hasOne, isEmbedMarker, omit, pick } from './schema/index.mjs';
 export { DataGenerator, FetchAdapter, FirebaseAdapter, GraphQLAdapter, LocalStorageDriver, LocalStorageDriverConfig, MemoryStorageDriver, MockAdapter, MockAdapterConfig, MswStorageDriver, QueryMeta, QueryOptions, StorageDriver, StorageDriverConfig, SupabaseAdapter, createFetchAdapter, createFirebaseAdapter, createGraphQLAdapter, createMockAdapter, createSupabaseAdapter, dataGenerator, generateFactories, generateFactory } from './adapters/index.mjs';
-export { A as Adapter, a as AdapterContext, b as AdapterResponse, c as AdapterResponseMeta, F as FetchAdapterOptions, M as MockAdapterOptions, d as MswjsDataFactory } from './types-vPJ91BuY.mjs';
-export { M as Middleware, b as MiddlewareContext, a as MiddlewareFunction, c as MiddlewareResult } from './types-D-u5uw1E.mjs';
+export { A as Adapter, a as AdapterContext, b as AdapterResponse, c as AdapterResponseMeta, F as FetchAdapterOptions, M as MockAdapterOptions, d as MswjsDataFactory } from './types-BBeKlEd1.mjs';
+export { M as Middleware, b as MiddlewareContext, a as MiddlewareFunction, c as MiddlewareResult } from './types-DKrOkBcu.mjs';
 export { AuthMiddlewareConfig, CacheEntry, CacheMiddlewareConfig, CacheStorage, ContextMiddlewareConfig, DEFAULT_MIDDLEWARE_ORDER, LogLevel, LoggerMiddlewareConfig, MOCK_MIDDLEWARE_PRESET, MemoryCacheStorage, MiddlewareChain, PRODUCTION_MIDDLEWARE_PRESET, RLSError, RLSFilters, RLSMiddlewareConfig, RetryMiddlewareConfig, TEST_MIDDLEWARE_PRESET, createAuthMiddleware, createBypassCheck, createCacheInvalidator, createCacheMiddleware, createContextMiddleware, createLoggerMiddleware, createMiddlewareChain, createMockJwt, createRLSMiddleware, createRetryMiddleware, createSilentLogger, createVerboseLogger, filterMiddleware, orderMiddleware } from './middleware/index.mjs';
 export { CountOptions, CreateInput, EntityQueryOptions, HandlerOptions, ListQueryOptions, ResolveRelationOptions, Resolver, ResolverContext, SetupOptions, UpdateInput, ViewResolveOptions, ViewResolver, clearComputeCache, createHandlers, createResolver, createViewResolver, eagerLoadRelations, getAdapter, isInitialized, reset, resolveComputedField, resolveComputedFields, resolveComputedFieldsSync, resolveRelation, resolveRelations, seed, seedWithRelations, setAdapter, setup, teardown, topologicalSort } from './runtime/index.mjs';
 import 'msw';

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export { A as ArrayFieldBuilder, C as ComputedFieldDefinition, D as DateFieldBuilder, p as EmbedConfig, u as EndpointConfig, t as EndpointMethod, v as EndpointSchema, e as EntityApiConfig, h as EntityOptions, o as EntitySchema, E as EnumFieldBuilder, F as FieldBuilder, a as FieldConstraints, b as FieldDefinition, I as IndexConfig, z as InferCreate, y as InferEntity, x as InferFieldType, B as InferUpdate, M as MockResolverContext, N as NumberFieldBuilder, O as ObjectFieldBuilder, m as RLSBypass, n as RLSConfig, j as RLSContext, k as RLSFilter, l as RLSScopeMapping, f as RPCArgument, g as RPCConfig, R as RefFieldBuilder, c as RelationDefinition, S as StringFieldBuilder, V as ViewFieldValue, q as ViewFields, r as ViewOptions, s as ViewSchema, i as isComputedField, w as isEndpointSchema, d as isRelation } from './types-CWZQ6vqt.js';
+export { A as ArrayFieldBuilder, C as ComputedFieldDefinition, D as DateFieldBuilder, p as EmbedConfig, u as EndpointConfig, t as EndpointMethod, v as EndpointSchema, e as EntityApiConfig, h as EntityOptions, o as EntitySchema, E as EnumFieldBuilder, F as FieldBuilder, a as FieldConstraints, b as FieldDefinition, I as IndexConfig, z as InferCreate, y as InferEntity, x as InferFieldType, B as InferUpdate, M as MockResolverContext, N as NumberFieldBuilder, O as ObjectFieldBuilder, m as RLSBypass, n as RLSConfig, j as RLSContext, k as RLSFilter, l as RLSScopeMapping, f as RPCArgument, g as RPCConfig, R as RefFieldBuilder, c as RelationDefinition, S as StringFieldBuilder, V as ViewFieldValue, q as ViewFields, r as ViewOptions, s as ViewSchema, i as isComputedField, w as isEndpointSchema, d as isRelation } from './types-BCLdZDSF.js';
 export { BelongsToOptions, EmbedMarker, FieldDefinitions, HasManyOptions, HasOneOptions, ViewFieldDefinitions, belongsTo, defineData, defineEndpoint, defineView, embed, field, hasMany, hasOne, isEmbedMarker, omit, pick } from './schema/index.js';
 export { DataGenerator, FetchAdapter, FirebaseAdapter, GraphQLAdapter, LocalStorageDriver, LocalStorageDriverConfig, MemoryStorageDriver, MockAdapter, MockAdapterConfig, MswStorageDriver, QueryMeta, QueryOptions, StorageDriver, StorageDriverConfig, SupabaseAdapter, createFetchAdapter, createFirebaseAdapter, createGraphQLAdapter, createMockAdapter, createSupabaseAdapter, dataGenerator, generateFactories, generateFactory } from './adapters/index.js';
-export { A as Adapter, a as AdapterContext, b as AdapterResponse, c as AdapterResponseMeta, F as FetchAdapterOptions, M as MockAdapterOptions, d as MswjsDataFactory } from './types-4EDTne0h.js';
-export { M as Middleware, b as MiddlewareContext, a as MiddlewareFunction, c as MiddlewareResult } from './types-Ku_ykMzx.js';
+export { A as Adapter, a as AdapterContext, b as AdapterResponse, c as AdapterResponseMeta, F as FetchAdapterOptions, M as MockAdapterOptions, d as MswjsDataFactory } from './types-CVeLQjhD.js';
+export { M as Middleware, b as MiddlewareContext, a as MiddlewareFunction, c as MiddlewareResult } from './types-CZdze7Tl.js';
 export { AuthMiddlewareConfig, CacheEntry, CacheMiddlewareConfig, CacheStorage, ContextMiddlewareConfig, DEFAULT_MIDDLEWARE_ORDER, LogLevel, LoggerMiddlewareConfig, MOCK_MIDDLEWARE_PRESET, MemoryCacheStorage, MiddlewareChain, PRODUCTION_MIDDLEWARE_PRESET, RLSError, RLSFilters, RLSMiddlewareConfig, RetryMiddlewareConfig, TEST_MIDDLEWARE_PRESET, createAuthMiddleware, createBypassCheck, createCacheInvalidator, createCacheMiddleware, createContextMiddleware, createLoggerMiddleware, createMiddlewareChain, createMockJwt, createRLSMiddleware, createRetryMiddleware, createSilentLogger, createVerboseLogger, filterMiddleware, orderMiddleware } from './middleware/index.js';
 export { CountOptions, CreateInput, EntityQueryOptions, HandlerOptions, ListQueryOptions, ResolveRelationOptions, Resolver, ResolverContext, SetupOptions, UpdateInput, ViewResolveOptions, ViewResolver, clearComputeCache, createHandlers, createResolver, createViewResolver, eagerLoadRelations, getAdapter, isInitialized, reset, resolveComputedField, resolveComputedFields, resolveComputedFieldsSync, resolveRelation, resolveRelations, seed, seedWithRelations, setAdapter, setup, teardown, topologicalSort } from './runtime/index.js';
 import 'msw';