schemock 0.0.1

package/dist/cli/index.mjs

@@ -0,0 +1,4401 @@
+import { existsSync } from 'fs';
+import { resolve, relative, join } from 'path';
+import { spawnSync } from 'child_process';
+import { z } from 'zod';
+import { stat, mkdir, writeFile, readdir } from 'fs/promises';
+
+// src/cli/types.ts
+function defineConfig(config) {
+  return {
+    schemas: "./src/schemas/**/*.ts",
+    output: "./src/generated",
+    adapter: "mock",
+    apiPrefix: "/api",
+    ...config
+  };
+}
+var FakerMappingSchema = z.object({
+  hint: z.string().optional(),
+  type: z.string().optional(),
+  fieldName: z.instanceof(RegExp).optional(),
+  call: z.string()
+});
+var MockAdapterConfigSchema = z.object({
+  seed: z.record(z.string(), z.number()).optional(),
+  delay: z.number().min(0).optional(),
+  fakerSeed: z.number().optional(),
+  persist: z.boolean().optional(),
+  storageKey: z.string().optional()
+}).strict();
+var SupabaseAdapterConfigSchema = z.object({
+  tableMap: z.record(z.string(), z.string()).optional(),
+  envPrefix: z.string().optional()
+}).strict();
+var FirebaseAdapterConfigSchema = z.object({
+  collectionMap: z.record(z.string(), z.string()).optional()
+}).strict();
+var FetchAdapterConfigSchema = z.object({
+  baseUrl: z.string().url().optional(),
+  endpointPattern: z.string().optional()
+}).strict();
+var GraphQLAdapterConfigSchema = z.object({
+  operations: z.object({
+    findOne: z.string().optional(),
+    findMany: z.string().optional(),
+    create: z.string().optional(),
+    update: z.string().optional(),
+    delete: z.string().optional()
+  }).optional()
+}).strict();
+var PGliteAdapterConfigSchema = z.object({
+  persistence: z.enum(["memory", "indexeddb", "opfs"]).optional(),
+  dataDir: z.string().optional(),
+  fakerSeed: z.number().optional(),
+  seed: z.record(z.string(), z.number()).optional()
+}).strict();
+var PluralizeConfigSchema = z.object({
+  custom: z.record(z.string(), z.string()).optional()
+}).strict();
+var SchemockConfigSchema = z.object({
+  schemas: z.string().min(1, "schemas path is required"),
+  output: z.string().min(1, "output path is required"),
+  adapter: z.enum(["mock", "supabase", "firebase", "fetch", "graphql", "pglite"]),
+  apiPrefix: z.string(),
+  pluralization: PluralizeConfigSchema.optional(),
+  fakerMappings: z.array(FakerMappingSchema).optional(),
+  adapters: z.object({
+    mock: MockAdapterConfigSchema.optional(),
+    supabase: SupabaseAdapterConfigSchema.optional(),
+    firebase: FirebaseAdapterConfigSchema.optional(),
+    fetch: FetchAdapterConfigSchema.optional(),
+    graphql: GraphQLAdapterConfigSchema.optional(),
+    pglite: PGliteAdapterConfigSchema.optional()
+  }).optional()
+}).strict();
+function validateConfig(config, filePath) {
+  const result = SchemockConfigSchema.safeParse(config);
+  if (!result.success) {
+    const errors = result.error.errors.map((err) => {
+      const path = err.path.join(".");
+      return `  - ${path ? `${path}: ` : ""}${err.message}`;
+    }).join("\n");
+    throw new Error(
+      `Invalid configuration in ${filePath}:
+${errors}
+
+Common issues:
+  - Typos in config keys (e.g., 'scemas' instead of 'schemas')
+  - Unknown adapter types
+  - Invalid adapter-specific options`
+    );
+  }
+  return result.data;
+}
+var CONFIG_FILES = ["schemock.config.ts", "schemock.config.js", "schemock.config.mjs"];
+var DEFAULT_CONFIG = {
+  schemas: "./src/schemas/**/*.ts",
+  output: "./src/generated",
+  adapter: "mock",
+  apiPrefix: "/api"
+};
+async function loadConfig(configPath) {
+  if (configPath) {
+    const fullPath = resolve(configPath);
+    if (!existsSync(fullPath)) {
+      throw new Error(`Config file not found: ${configPath}`);
+    }
+    return await loadConfigFile(fullPath);
+  }
+  for (const filename of CONFIG_FILES) {
+    const fullPath = resolve(filename);
+    if (existsSync(fullPath)) {
+      return await loadConfigFile(fullPath);
+    }
+  }
+  return { ...DEFAULT_CONFIG };
+}
+async function loadConfigFile(fullPath) {
+  let rawConfig;
+  try {
+    const module = await import(fullPath);
+    rawConfig = module.default || module;
+  } catch (error) {
+    try {
+      rawConfig = loadConfigViaTsx(fullPath);
+    } catch (tsxError) {
+      throw new Error(
+        `Failed to load config file: ${fullPath}
+Original error: ${error}
+tsx fallback error: ${tsxError}
+
+Suggestions:
+  1. Ensure the config file has valid syntax
+  2. Install tsx globally: npm install -g tsx
+  3. Or compile TypeScript config to JavaScript first`
+      );
+    }
+  }
+  const mergedConfig = {
+    ...DEFAULT_CONFIG,
+    ...rawConfig
+  };
+  return validateConfig(mergedConfig, fullPath);
+}
+function loadConfigViaTsx(fullPath) {
+  const inlineScript = `
+    const path = process.argv[2];
+    const c = require(path);
+    console.log(JSON.stringify(c.default || c));
+  `;
+  const result = spawnSync("npx", ["tsx", "-e", inlineScript, fullPath], {
+    encoding: "utf-8",
+    // Don't use shell - pass args directly to avoid injection
+    shell: false,
+    // Set reasonable timeout to prevent hanging
+    timeout: 3e4
+  });
+  if (result.error) {
+    throw new Error(`Failed to execute tsx: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    const stderr = result.stderr?.trim() || "Unknown error";
+    throw new Error(`tsx exited with code ${result.status}: ${stderr}`);
+  }
+  const output = result.stdout?.trim();
+  if (!output) {
+    throw new Error("tsx produced no output");
+  }
+  try {
+    return JSON.parse(output);
+  } catch (parseError) {
+    throw new Error(`Failed to parse config output as JSON: ${output}`);
+  }
+}
+function getDefaultConfig() {
+  return { ...DEFAULT_CONFIG };
+}
+
+// src/schema/types.ts
+function isEndpointSchema(value) {
+  return typeof value === "object" && value !== null && "_endpoint" in value && value._endpoint === true;
+}
+
+// src/cli/discover.ts
+function parseGlobPattern(pattern) {
+  const parts = pattern.split("/");
+  const baseParts = [];
+  const patternParts = [];
+  let foundGlob = false;
+  for (const part of parts) {
+    if (foundGlob || part.includes("*") || part.includes("?") || part.includes("[")) {
+      foundGlob = true;
+      patternParts.push(part);
+    } else {
+      baseParts.push(part);
+    }
+  }
+  return {
+    baseDir: baseParts.join("/") || ".",
+    patterns: patternParts
+  };
+}
+function matchesPattern(filePath, patterns) {
+  const parts = filePath.split("/");
+  if (patterns.length === 0) return true;
+  const patternStr = patterns.join("/");
+  if (patternStr.includes("**")) {
+    let regexStr = patternStr.replace(/\*\*\//g, "<<<GLOBSTAR_SLASH>>>").replace(/\*\*/g, "<<<GLOBSTAR>>>").replace(/\?/g, "<<<QUESTION>>>").replace(/\*/g, "<<<STAR>>>").replace(/\./g, "\\.").replace(/<<<GLOBSTAR_SLASH>>>/g, "(?:.*/)?").replace(/<<<GLOBSTAR>>>/g, ".*").replace(/<<<STAR>>>/g, "[^/]*").replace(/<<<QUESTION>>>/g, ".");
+    const regex = new RegExp(`^${regexStr}$`);
+    return regex.test(filePath);
+  }
+  if (parts.length !== patterns.length) return false;
+  for (let i = 0; i < patterns.length; i++) {
+    const pattern = patterns[i];
+    const part = parts[i];
+    if (pattern === "*") continue;
+    if (pattern.includes("*")) {
+      const regexStr = pattern.replace(/\*/g, ".*").replace(/\?/g, ".");
+      const regex = new RegExp(`^${regexStr}$`);
+      if (!regex.test(part)) return false;
+    } else if (pattern !== part) {
+      return false;
+    }
+  }
+  return true;
+}
+async function findFiles(baseDir, patterns, currentPath = "") {
+  const fullPath = resolve(baseDir, currentPath);
+  const files = [];
+  try {
+    const entries = await readdir(fullPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryPath = currentPath ? `${currentPath}/${entry.name}` : entry.name;
+      if (entry.name === "node_modules" || entry.name.startsWith(".")) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        const subFiles = await findFiles(baseDir, patterns, entryPath);
+        files.push(...subFiles);
+      } else if (entry.isFile()) {
+        if (matchesPattern(entryPath, patterns)) {
+          if (!entry.name.endsWith(".d.ts") && !entry.name.endsWith(".test.ts") && !entry.name.endsWith(".spec.ts")) {
+            files.push(resolve(baseDir, entryPath));
+          }
+        }
+      }
+    }
+  } catch (error) {
+    console.warn(`Warning: Could not read directory ${fullPath}`);
+  }
+  return files;
+}
+function isEntitySchema(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const obj = value;
+  return typeof obj.name === "string" && typeof obj.fields === "object" && obj.fields !== null;
+}
+async function discoverSchemas(pattern) {
+  let files;
+  const isGlobPattern = pattern.includes("*") || pattern.includes("?") || pattern.includes("[");
+  if (!isGlobPattern) {
+    const resolvedPath = resolve(pattern);
+    try {
+      const fileStat = await stat(resolvedPath);
+      if (fileStat.isFile()) {
+        files = [resolvedPath];
+      } else {
+        throw new Error(`Path is not a file: ${pattern}`);
+      }
+    } catch (error) {
+      throw new Error(`Schema file not found: ${pattern}`);
+    }
+  } else {
+    const { baseDir, patterns } = parseGlobPattern(pattern);
+    const resolvedBaseDir = resolve(baseDir);
+    files = await findFiles(resolvedBaseDir, patterns);
+    if (files.length === 0) {
+      throw new Error(`No schema files found matching: ${pattern}`);
+    }
+  }
+  const schemas = [];
+  const endpoints = [];
+  const loadedFiles = [];
+  for (const file of files) {
+    try {
+      const module = await import(file);
+      let foundSchema = false;
+      for (const [_exportName, value] of Object.entries(module)) {
+        if (isEntitySchema(value)) {
+          schemas.push(value);
+          foundSchema = true;
+        } else if (isEndpointSchema(value)) {
+          endpoints.push(value);
+          foundSchema = true;
+        }
+      }
+      if (foundSchema) {
+        loadedFiles.push(file);
+      }
+    } catch (error) {
+      console.warn(`Warning: Could not import ${file}: ${error}`);
+    }
+  }
+  if (schemas.length === 0 && endpoints.length === 0) {
+    throw new Error("No schemas found. Make sure your schema files export defineData() or defineEndpoint() results.");
+  }
+  return { schemas, endpoints, files: loadedFiles };
+}
+function getRelativePath(absolutePath) {
+  return relative(process.cwd(), absolutePath);
+}
+
+// src/cli/utils/pluralize.ts
+var irregulars = {
+  person: "people",
+  child: "children",
+  man: "men",
+  woman: "women",
+  tooth: "teeth",
+  foot: "feet",
+  mouse: "mice",
+  goose: "geese",
+  ox: "oxen",
+  leaf: "leaves",
+  life: "lives",
+  knife: "knives",
+  wife: "wives",
+  self: "selves",
+  elf: "elves",
+  loaf: "loaves",
+  potato: "potatoes",
+  tomato: "tomatoes",
+  cactus: "cacti",
+  focus: "foci",
+  fungus: "fungi",
+  nucleus: "nuclei",
+  syllabus: "syllabi",
+  analysis: "analyses",
+  diagnosis: "diagnoses",
+  thesis: "theses",
+  crisis: "crises",
+  phenomenon: "phenomena",
+  criterion: "criteria",
+  datum: "data"
+};
+var irregularsReverse = Object.fromEntries(
+  Object.entries(irregulars).map(([k, v]) => [v, k])
+);
+var uncountables = /* @__PURE__ */ new Set([
+  "sheep",
+  "fish",
+  "deer",
+  "species",
+  "series",
+  "news",
+  "money",
+  "rice",
+  "information",
+  "equipment"
+]);
+function isVowel(char) {
+  return "aeiou".includes(char?.toLowerCase() ?? "");
+}
+function singularize(word) {
+  const lower = word.toLowerCase();
+  if (irregularsReverse[lower]) {
+    return irregularsReverse[lower];
+  }
+  if (uncountables.has(lower)) {
+    return lower;
+  }
+  if (irregulars[lower]) {
+    return lower;
+  }
+  if (lower.endsWith("ies") && lower.length > 3) {
+    const base = lower.slice(0, -3);
+    if (base.length > 0 && !isVowel(base[base.length - 1])) {
+      return base + "y";
+    }
+  }
+  if (lower.endsWith("ves") && lower.length > 3) {
+    const base = lower.slice(0, -3);
+    const feWords = ["kni", "wi", "li"];
+    if (feWords.some((w) => base.endsWith(w))) {
+      return base + "fe";
+    }
+    return base + "f";
+  }
+  if (lower.endsWith("oes") && lower.length > 3) {
+    const base = lower.slice(0, -2);
+    if (base.length > 2) {
+      return base;
+    }
+  }
+  if ((lower.endsWith("ses") || lower.endsWith("xes") || lower.endsWith("zes") || lower.endsWith("ches") || lower.endsWith("shes")) && lower.length > 3) {
+    return lower.slice(0, -2);
+  }
+  if (lower.endsWith("s") && !lower.endsWith("ss") && lower.length > 1) {
+    return lower.slice(0, -1);
+  }
+  return lower;
+}
+function pluralize(word, config) {
+  const lower = word.toLowerCase();
+  if (config?.custom?.[lower]) {
+    return config.custom[lower];
+  }
+  const singular = singularize(lower);
+  if (irregulars[singular]) {
+    return irregulars[singular];
+  }
+  if (uncountables.has(singular)) {
+    return singular;
+  }
+  if (singular.endsWith("y") && !isVowel(singular[singular.length - 2])) {
+    return singular.slice(0, -1) + "ies";
+  }
+  if (singular.endsWith("s") || singular.endsWith("x") || singular.endsWith("z") || singular.endsWith("ch") || singular.endsWith("sh")) {
+    return singular + "es";
+  }
+  if (singular.endsWith("f")) {
+    return singular.slice(0, -1) + "ves";
+  }
+  if (singular.endsWith("fe")) {
+    return singular.slice(0, -2) + "ves";
+  }
+  return singular + "s";
+}
+function toPascalCase(str) {
+  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function toCamelCase(str) {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function toSnakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "").replace(/[-\s]+/g, "_");
+}
+
+// src/cli/utils/faker-mapping.ts
+function escapeJsString(value) {
+  return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+var defaultMappings = [
+  // By hint - Person
+  { hint: "person.fullName", call: "faker.person.fullName()" },
+  { hint: "person.firstName", call: "faker.person.firstName()" },
+  { hint: "person.lastName", call: "faker.person.lastName()" },
+  { hint: "person.bio", call: "faker.lorem.paragraph()" },
+  { hint: "person.jobTitle", call: "faker.person.jobTitle()" },
+  // By hint - Internet
+  { hint: "internet.email", call: "faker.internet.email()" },
+  { hint: "internet.url", call: "faker.internet.url()" },
+  { hint: "internet.avatar", call: "faker.image.avatar()" },
+  { hint: "internet.username", call: "faker.internet.username()" },
+  { hint: "internet.password", call: "faker.internet.password()" },
+  // By hint - Lorem
+  { hint: "lorem.word", call: "faker.lorem.word()" },
+  { hint: "lorem.sentence", call: "faker.lorem.sentence()" },
+  { hint: "lorem.paragraph", call: "faker.lorem.paragraph()" },
+  { hint: "lorem.paragraphs", call: "faker.lorem.paragraphs(3)" },
+  { hint: "lorem.text", call: "faker.lorem.text()" },
+  // By hint - Image
+  { hint: "image.avatar", call: "faker.image.avatar()" },
+  { hint: "image.url", call: "faker.image.url()" },
+  // By hint - Location
+  { hint: "location.city", call: "faker.location.city()" },
+  { hint: "location.country", call: "faker.location.country()" },
+  { hint: "location.streetAddress", call: "faker.location.streetAddress()" },
+  { hint: "location.zipCode", call: "faker.location.zipCode()" },
+  { hint: "location.latitude", call: "faker.location.latitude()" },
+  { hint: "location.longitude", call: "faker.location.longitude()" },
+  // By hint - Commerce
+  { hint: "commerce.price", call: "parseFloat(faker.commerce.price())" },
+  { hint: "commerce.productName", call: "faker.commerce.productName()" },
+  { hint: "commerce.department", call: "faker.commerce.department()" },
+  // By hint - Company
+  { hint: "company.name", call: "faker.company.name()" },
+  { hint: "company.catchPhrase", call: "faker.company.catchPhrase()" },
+  // By hint - Color
+  { hint: "color.rgb", call: "faker.color.rgb()" },
+  { hint: "color.human", call: "faker.color.human()" },
+  // By hint - Date
+  { hint: "date.past", call: "faker.date.past()" },
+  { hint: "date.future", call: "faker.date.future()" },
+  { hint: "date.recent", call: "faker.date.recent()" },
+  { hint: "date.birthdate", call: "faker.date.birthdate()" },
+  // By field name patterns
+  { fieldName: /^email$/i, call: "faker.internet.email()" },
+  { fieldName: /^name$/i, call: "faker.person.fullName()" },
+  { fieldName: /firstName/i, call: "faker.person.firstName()" },
+  { fieldName: /lastName/i, call: "faker.person.lastName()" },
+  { fieldName: /phone/i, call: "faker.phone.number()" },
+  { fieldName: /avatar/i, call: "faker.image.avatar()" },
+  { fieldName: /image|photo|picture/i, call: "faker.image.url()" },
+  { fieldName: /url|link|website/i, call: "faker.internet.url()" },
+  { fieldName: /address/i, call: "faker.location.streetAddress()" },
+  { fieldName: /city/i, call: "faker.location.city()" },
+  { fieldName: /country/i, call: "faker.location.country()" },
+  { fieldName: /zip|postal/i, call: "faker.location.zipCode()" },
+  { fieldName: /price|cost|amount/i, call: "parseFloat(faker.commerce.price())" },
+  { fieldName: /title/i, call: "faker.lorem.sentence({ min: 3, max: 8 })" },
+  { fieldName: /description|content|body|text/i, call: "faker.lorem.paragraphs(2)" },
+  { fieldName: /bio|about/i, call: "faker.lorem.paragraph()" },
+  { fieldName: /color/i, call: "faker.color.rgb()" },
+  { fieldName: /slug/i, call: "faker.helpers.slugify(faker.lorem.words(3))" },
+  { fieldName: /token|key|secret/i, call: "faker.string.alphanumeric(32)" },
+  // By type (fallback)
+  { type: "uuid", call: "faker.string.uuid()" },
+  { type: "email", call: "faker.internet.email()" },
+  { type: "url", call: "faker.internet.url()" },
+  { type: "string", call: "faker.lorem.word()" },
+  { type: "text", call: "faker.lorem.paragraphs(2)" },
+  { type: "number", call: "faker.number.int({ min: 1, max: 1000 })" },
+  { type: "int", call: "faker.number.int({ min: 1, max: 1000 })" },
+  { type: "float", call: "faker.number.float({ min: 0, max: 1000, fractionDigits: 2 })" },
+  { type: "boolean", call: "faker.datatype.boolean()" },
+  { type: "date", call: "faker.date.recent()" },
+  { type: "json", call: "{}" },
+  { type: "ref", call: "faker.string.uuid()" }
+];
+function fieldToFakerCall(fieldName, field, config) {
+  const mappings = [...config.fakerMappings || [], ...defaultMappings];
+  if (field.type === "enum" || field.values && field.values.length > 0) {
+    const values = field.values.map((v) => `'${escapeJsString(v)}'`).join(", ");
+    return `faker.helpers.arrayElement([${values}])`;
+  }
+  if (field.type === "array") {
+    const itemCall = field.items ? fieldToFakerCall("item", field.items, config) : "faker.lorem.word()";
+    const min = field.constraints?.min ?? 1;
+    const max = field.constraints?.max ?? 5;
+    return `Array.from({ length: faker.number.int({ min: ${min}, max: ${max} }) }, () => ${itemCall})`;
+  }
+  if (field.type === "object" && field.shape) {
+    const props = Object.entries(field.shape).map(([k, v]) => `${k}: ${fieldToFakerCall(k, v, config)}`).join(", ");
+    return `({ ${props} })`;
+  }
+  if (field.hint) {
+    const match = mappings.find((m) => m.hint === field.hint);
+    if (match) return match.call;
+  }
+  for (const mapping of mappings) {
+    if (mapping.fieldName && mapping.fieldName.test(fieldName)) {
+      return mapping.call;
+    }
+  }
+  if (field.type === "number" || field.type === "int") {
+    const min = field.constraints?.min ?? 1;
+    const max = field.constraints?.max ?? 1e3;
+    return `faker.number.int({ min: ${min}, max: ${max} })`;
+  }
+  if (field.type === "float") {
+    const min = field.constraints?.min ?? 0;
+    const max = field.constraints?.max ?? 1e3;
+    return `faker.number.float({ min: ${min}, max: ${max}, fractionDigits: 2 })`;
+  }
+  if (field.type === "string" && (field.constraints?.min || field.constraints?.max)) {
+    const min = field.constraints?.min ?? 1;
+    const max = field.constraints?.max ?? 100;
+    return `faker.string.alphanumeric({ length: { min: ${min}, max: ${max} } })`;
+  }
+  const typeMatch = mappings.find((m) => m.type === field.type);
+  if (typeMatch) return typeMatch.call;
+  return "faker.lorem.word()";
+}
+
+// src/cli/utils/type-mapping.ts
+function fieldToTsType(field) {
+  switch (field.type) {
+    case "uuid":
+    case "string":
+    case "email":
+    case "url":
+    case "text":
+      return "string";
+    case "number":
+    case "int":
+    case "integer":
+    case "float":
+    case "double":
+      return "number";
+    // BigInt support - use native bigint type
+    case "bigint":
+    case "bigserial":
+      return "bigint";
+    // Decimal/Money - use string for precision (avoids floating point issues)
+    case "decimal":
+    case "numeric":
+    case "money":
+      return "string";
+    // Binary data - use Uint8Array or Buffer
+    case "bytea":
+    case "binary":
+    case "blob":
+      return "Uint8Array";
+    case "boolean":
+      return "boolean";
+    // Date/time types
+    case "date":
+    case "datetime":
+    case "timestamp":
+    case "timestamptz":
+      return "Date";
+    // Time without date
+    case "time":
+    case "timetz":
+      return "string";
+    // HH:MM:SS format
+    // Interval (duration)
+    case "interval":
+      return "string";
+    // ISO 8601 duration or PostgreSQL interval format
+    case "enum":
+      if (field.values && field.values.length > 0) {
+        return field.values.map((v) => `'${v}'`).join(" | ");
+      }
+      return "string";
+    case "array":
+      if (field.items) {
+        return `${fieldToTsType(field.items)}[]`;
+      }
+      return "unknown[]";
+    case "object":
+      if (field.shape) {
+        const props = Object.entries(field.shape).map(([k, v]) => `${escapePropertyKey(k)}: ${fieldToTsType(v)}`).join("; ");
+        return `{ ${props} }`;
+      }
+      return "Record<string, unknown>";
+    case "json":
+    case "jsonb":
+      return "unknown";
+    case "ref":
+      return "string";
+    // FK is always string UUID
+    // PostGIS geometry types
+    case "point":
+      return "{ x: number; y: number }";
+    case "geometry":
+    case "geography":
+      return "unknown";
+    // GeoJSON or WKT - depends on use case
+    default:
+      return "unknown";
+  }
+}
+function escapePropertyKey(key) {
+  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) {
+    return key;
+  }
+  return `'${key.replace(/'/g, "\\'")}'`;
+}
+function primitiveToTs(type) {
+  switch (type) {
+    case "string":
+    case "text":
+    case "uuid":
+    case "email":
+    case "url":
+      return "string";
+    case "number":
+    case "int":
+    case "integer":
+    case "float":
+    case "double":
+      return "number";
+    case "bigint":
+    case "bigserial":
+      return "bigint";
+    case "decimal":
+    case "numeric":
+    case "money":
+      return "string";
+    case "bytea":
+    case "binary":
+    case "blob":
+      return "Uint8Array";
+    case "boolean":
+      return "boolean";
+    case "date":
+    case "datetime":
+    case "timestamp":
+    case "timestamptz":
+      return "Date";
+    case "time":
+    case "timetz":
+    case "interval":
+      return "string";
+    default:
+      return "unknown";
+  }
+}
+
+// src/cli/analyze.ts
+function inferComputedType(name) {
+  const lowerName = name.toLowerCase();
+  if (lowerName.endsWith("at") || lowerName.endsWith("date") || lowerName.endsWith("time") || lowerName.endsWith("timestamp") || lowerName.endsWith("datetime") || lowerName.endsWith("since") || lowerName.endsWith("until") || lowerName.endsWith("deadline") || lowerName.startsWith("date") || lowerName.startsWith("time")) {
+    return "Date";
+  }
+  if (lowerName.endsWith("count") || lowerName.endsWith("total") || lowerName.endsWith("sum") || lowerName.endsWith("avg") || lowerName.endsWith("average") || lowerName.endsWith("min") || lowerName.endsWith("max") || lowerName.endsWith("length") || lowerName.endsWith("size") || lowerName.endsWith("index")) {
+    return "number";
+  }
+  if (lowerName.includes("amount") || lowerName.includes("price") || lowerName.includes("cost") || lowerName.includes("fee") || lowerName.includes("balance") || lowerName.includes("score") || lowerName.includes("rating") || lowerName.includes("rank") || lowerName.includes("level") || lowerName.includes("age") || lowerName.includes("weight") || lowerName.includes("height") || lowerName.includes("width") || lowerName.includes("depth") || lowerName.includes("quantity") || lowerName.includes("percent") || lowerName.includes("ratio") || lowerName.includes("progress") || lowerName.includes("position") || lowerName.includes("order") || lowerName.includes("duration") || lowerName.includes("offset") || lowerName.includes("limit")) {
+    return "number";
+  }
+  if (lowerName.startsWith("is") || lowerName.startsWith("has") || lowerName.startsWith("can") || lowerName.startsWith("should") || lowerName.startsWith("will") || lowerName.startsWith("was") || lowerName.startsWith("did") || lowerName.startsWith("does") || lowerName.startsWith("allow") || lowerName.startsWith("enable") || lowerName.startsWith("disable")) {
+    return "boolean";
+  }
+  if (lowerName.endsWith("enabled") || lowerName.endsWith("disabled") || lowerName.endsWith("active") || lowerName.endsWith("visible") || lowerName.endsWith("hidden") || lowerName.endsWith("valid") || lowerName.endsWith("invalid") || lowerName.endsWith("complete") || lowerName.endsWith("empty") || lowerName.endsWith("loading") || lowerName.endsWith("loaded") || lowerName.endsWith("ready") || lowerName.endsWith("available") || lowerName.endsWith("exists") || lowerName.endsWith("selected") || lowerName.endsWith("checked") || lowerName.endsWith("required") || lowerName.endsWith("optional")) {
+    return "boolean";
+  }
+  if (lowerName.endsWith("name") || lowerName.endsWith("title") || lowerName.endsWith("label") || lowerName.endsWith("description") || lowerName.endsWith("text") || lowerName.endsWith("content") || lowerName.endsWith("message") || lowerName.endsWith("str") || lowerName.endsWith("string") || lowerName.endsWith("slug") || lowerName.endsWith("path") || lowerName.endsWith("url") || lowerName.endsWith("uri") || lowerName.endsWith("email") || lowerName.endsWith("phone") || lowerName.endsWith("address") || lowerName.endsWith("display") || lowerName.endsWith("format") || lowerName.endsWith("html") || lowerName.endsWith("json") || lowerName.endsWith("type") || lowerName.endsWith("status") || lowerName.endsWith("key") || lowerName.endsWith("id") || lowerName.endsWith("code") || lowerName.endsWith("token") || lowerName.endsWith("hash") || lowerName.endsWith("signature")) {
+    return "string";
+  }
+  if (lowerName.startsWith("get") && (lowerName.includes("name") || lowerName.includes("title") || lowerName.includes("label") || lowerName.includes("display") || lowerName.includes("format") || lowerName.includes("string"))) {
+    return "string";
+  }
+  if (lowerName.endsWith("list") || lowerName.endsWith("array") || lowerName.endsWith("items") || lowerName.endsWith("collection") || lowerName.endsWith("all") || lowerName.endsWith("entries") || lowerName.endsWith("values") || lowerName.endsWith("keys") || lowerName.endsWith("ids") || lowerName.endsWith("names") || lowerName.startsWith("all") || lowerName.startsWith("list")) {
+    return "unknown[]";
+  }
+  if ((lowerName.startsWith("get") || lowerName.startsWith("fetch") || lowerName.startsWith("load") || lowerName.startsWith("find")) && (lowerName.endsWith("s") && !lowerName.endsWith("ss"))) {
+    return "unknown[]";
+  }
+  if (lowerName.endsWith("config") || lowerName.endsWith("options") || lowerName.endsWith("settings") || lowerName.endsWith("props") || lowerName.endsWith("properties") || lowerName.endsWith("data") || lowerName.endsWith("info") || lowerName.endsWith("meta") || lowerName.endsWith("metadata") || lowerName.endsWith("attrs") || lowerName.endsWith("attributes") || lowerName.endsWith("context") || lowerName.endsWith("state") || lowerName.endsWith("result") || lowerName.endsWith("response") || lowerName.endsWith("payload")) {
+    return "Record<string, unknown>";
+  }
+  if (lowerName.startsWith("get") || lowerName.startsWith("compute") || lowerName.startsWith("calculate") || lowerName.startsWith("derive")) {
+    const withoutPrefix = lowerName.replace(/^(get|compute|calculate|derive)/, "");
+    if (withoutPrefix) {
+      return inferComputedType(withoutPrefix);
+    }
+  }
+  return "unknown";
+}
+function findSchemaByName(schemaMap, name) {
+  const exact = schemaMap.get(name);
+  if (exact) return exact;
+  const singular = singularize(name);
+  const singularMatch = schemaMap.get(singular);
+  if (singularMatch) return singularMatch;
+  const plural = pluralize(name);
+  const pluralMatch = schemaMap.get(plural);
+  if (pluralMatch) return pluralMatch;
+  const lowerName = name.toLowerCase();
+  for (const [schemaName, schema] of schemaMap) {
+    if (schemaName.toLowerCase() === lowerName) return schema;
+    if (singularize(schemaName).toLowerCase() === lowerName) return schema;
+    if (pluralize(schemaName).toLowerCase() === lowerName) return schema;
+  }
+  return void 0;
+}
+function analyzeSchemas(schemas, config) {
+  const schemaMap = new Map(schemas.map((s) => [s.name, s]));
+  const analyzed = [];
+  for (const schema of schemas) {
+    analyzed.push(analyzeSchema(schema, schemaMap, config));
+  }
+  return topologicalSort(analyzed);
+}
+function analyzeSchema(schema, schemaMap, config) {
+  const singular = singularize(schema.name);
+  const plural = pluralize(schema.name, config.pluralization);
+  const adapterConfig = config.adapters?.[config.adapter];
+  let tableName = plural;
+  if (config.adapter === "supabase" && adapterConfig && "tableMap" in adapterConfig) {
+    tableName = adapterConfig.tableMap?.[schema.name] ?? plural;
+  } else if (config.adapter === "firebase" && adapterConfig && "collectionMap" in adapterConfig) {
+    tableName = adapterConfig.collectionMap?.[schema.name] ?? plural;
+  }
+  const result = {
+    name: schema.name,
+    singularName: singular,
+    pluralName: plural,
+    pascalName: toPascalCase(singular),
+    // Use singular for PascalCase (User, not Users)
+    pascalSingularName: toPascalCase(singular),
+    pascalPluralName: toPascalCase(plural),
+    tableName,
+    endpoint: `${config.apiPrefix}/${plural}`,
+    fields: [],
+    relations: [],
+    computed: [],
+    dependsOn: [],
+    hasTimestamps: schema.timestamps ?? true,
+    isJunctionTable: false,
+    rls: analyzeRLS(schema.rls),
+    indexes: [],
+    // Will be populated after fields analysis
+    rpc: [],
+    // Will be populated after RPC analysis
+    original: schema
+  };
+  let refCount = 0;
+  let nonRefNonIdCount = 0;
+  for (const [fieldName, field] of Object.entries(schema.fields)) {
+    const analyzedField = analyzeField(fieldName, field, config);
+    result.fields.push(analyzedField);
+    if (analyzedField.isRef) {
+      refCount++;
+      if (analyzedField.refTarget) {
+        result.dependsOn.push(analyzedField.refTarget);
+      }
+    } else if (fieldName !== "id") {
+      nonRefNonIdCount++;
+    }
+  }
+  result.isJunctionTable = refCount >= 2 && nonRefNonIdCount <= 1;
+  if (schema.relations) {
+    for (const [relName, rel] of Object.entries(schema.relations)) {
+      const analyzedRel = analyzeRelation(relName, rel, singular, schema.fields, schemaMap, schema.name);
+      result.relations.push(analyzedRel);
+      if (analyzedRel.type === "belongsTo" && !result.dependsOn.includes(analyzedRel.target)) {
+        result.dependsOn.push(analyzedRel.target);
+      }
+    }
+  }
+  if (schema.computed) {
+    for (const [compName, comp] of Object.entries(schema.computed)) {
+      const inferredType = inferComputedType(compName);
+      result.computed.push({
+        name: compName,
+        type: inferredType,
+        tsType: primitiveToTs(inferredType)
+      });
+    }
+  }
+  result.indexes = analyzeIndexes(schema, result.fields, tableName);
+  result.rpc = analyzeRPC(schema, tableName, schemaMap);
+  return result;
+}
+function analyzeField(name, field, config) {
+  const result = {
+    name,
+    type: field.type,
+    tsType: fieldToTsType(field),
+    fakerCall: fieldToFakerCall(name, field, config),
+    nullable: field.nullable ?? false,
+    unique: field.unique ?? false,
+    readOnly: field.readOnly ?? false,
+    hasDefault: field.default !== void 0,
+    defaultValue: field.default,
+    isRef: field.type === "ref",
+    refTarget: field.type === "ref" ? field.target : void 0,
+    isEnum: field.type === "enum" || (field.values?.length ?? 0) > 0,
+    enumValues: field.values,
+    isArray: field.type === "array",
+    isObject: field.type === "object",
+    min: field.constraints?.min,
+    max: field.constraints?.max,
+    pattern: field.constraints?.pattern?.source
+  };
+  if (field.type === "array" && field.items) {
+    result.itemType = analyzeField("item", field.items, config);
+  }
+  if (field.type === "object" && field.shape) {
+    result.shape = {};
+    for (const [k, v] of Object.entries(field.shape)) {
+      result.shape[k] = analyzeField(k, v, config);
+    }
+  }
+  return result;
+}
+function findForeignKeyField(fields, entityName) {
+  const lowerEntity = entityName.toLowerCase();
+  const singularEntity = singularize(entityName).toLowerCase();
+  const pluralEntity = pluralize(entityName).toLowerCase();
+  for (const [fieldName, field] of Object.entries(fields)) {
+    if (field.type === "ref" && field.target) {
+      const targetLower = field.target.toLowerCase();
+      const targetSingular = singularize(field.target).toLowerCase();
+      const targetPlural = pluralize(field.target).toLowerCase();
+      if (targetLower === lowerEntity || targetLower === singularEntity || targetLower === pluralEntity || targetSingular === singularEntity || targetPlural === pluralEntity) {
+        return fieldName;
+      }
+    }
+  }
+  const fieldNames = Object.keys(fields);
+  const patterns = [
+    `${singularEntity}Id`,
+    // projectId
+    `${singularEntity}_id`,
+    // project_id
+    `${singularEntity}ID`,
+    // projectID
+    `${pluralEntity}Id`,
+    // projectsId (less common but possible)
+    `${pluralEntity}_id`
+    // projects_id
+  ];
+  for (const pattern of patterns) {
+    const match = fieldNames.find((f) => f.toLowerCase() === pattern.toLowerCase());
+    if (match) {
+      return match;
+    }
+  }
+  return void 0;
+}
+function analyzeRelation(name, rel, sourceEntitySingular, localFields, schemaMap, sourceEntityName) {
+  const singularTarget = singularize(rel.target);
+  let foreignKey;
+  let fkInferred = false;
+  let fkDefaultFallback = false;
+  if (rel.foreignKey) {
+    foreignKey = rel.foreignKey;
+  } else if (rel.type === "belongsTo") {
+    const foundField = findForeignKeyField(localFields, singularTarget);
+    if (foundField) {
+      foreignKey = foundField;
+      fkInferred = true;
+    } else {
+      foreignKey = `${singularTarget}Id`;
+      fkDefaultFallback = true;
+    }
+  } else {
+    const targetSchema = findSchemaByName(schemaMap, rel.target);
+    const targetFields = targetSchema?.fields ?? {};
+    const targetRelations = targetSchema?.relations ?? {};
+    let foundField;
+    for (const [, targetRel] of Object.entries(targetRelations)) {
+      if (targetRel.type === "belongsTo") {
+        const belongsToTarget = targetRel.target.toLowerCase();
+        const sourceVariants = [
+          sourceEntitySingular.toLowerCase(),
+          singularize(sourceEntitySingular).toLowerCase(),
+          pluralize(sourceEntitySingular).toLowerCase()
+        ];
+        const targetMatches = sourceVariants.includes(belongsToTarget) || sourceVariants.includes(singularize(belongsToTarget).toLowerCase()) || sourceVariants.includes(pluralize(belongsToTarget).toLowerCase());
+        if (targetMatches) {
+          if (targetRel.foreignKey) {
+            foundField = targetRel.foreignKey;
+          } else {
+            const belongsToSingular = singularize(targetRel.target);
+            foundField = findForeignKeyField(targetFields, belongsToSingular);
+          }
+          if (foundField) break;
+        }
+      }
+    }
+    if (!foundField) {
+      foundField = findForeignKeyField(targetFields, sourceEntitySingular);
+    }
+    if (foundField) {
+      foreignKey = foundField;
+      fkInferred = true;
+    } else {
+      foreignKey = `${sourceEntitySingular}Id`;
+      fkDefaultFallback = true;
+    }
+  }
+  if (fkDefaultFallback) {
+    const entityContext = sourceEntityName ? ` in '${sourceEntityName}'` : "";
+    const targetInfo = rel.type === "belongsTo" ? `Could not find a field matching '${singularTarget}' (tried: ${singularTarget}Id, ${singularTarget}_id, ref fields targeting ${rel.target})` : `Could not find a field in '${rel.target}' pointing back to '${sourceEntitySingular}'`;
+    console.warn(
+      `\x1B[33m\u26A0 FK Inference Warning:\x1B[0m Relation '${name}'${entityContext} (${rel.type} \u2192 ${rel.target})
+  ${targetInfo}
+  Using default: '${foreignKey}'
+  \x1B[2mTo fix: Add 'foreignKey' option to the relation, e.g.: ${rel.type}('${rel.target}', { foreignKey: 'yourFieldName' })\x1B[0m`
+    );
+  }
+  const result = {
+    name,
+    type: rel.type,
+    target: rel.target,
+    targetPascal: toPascalCase(singularize(rel.target)),
+    foreignKey,
+    eager: rel.eager ?? false,
+    inferred: fkInferred
+    // Track whether FK was inferred vs explicit
+  };
+  if (rel.type === "belongsTo") {
+    result.localField = foreignKey;
+  }
+  if (rel.type === "hasMany" && rel.through) {
+    result.type = "manyToMany";
+    result.through = rel.through;
+    result.otherKey = rel.otherKey;
+  }
+  return result;
+}
+function analyzeIndexes(schema, fields, tableName) {
+  const indexes = [];
+  const existingIndexFields = /* @__PURE__ */ new Set();
+  if (schema.indexes) {
+    for (const indexConfig of schema.indexes) {
+      const indexName = indexConfig.name ?? `idx_${tableName}_${indexConfig.fields.join("_")}`;
+      indexes.push({
+        name: indexName,
+        tableName,
+        fields: indexConfig.fields,
+        type: indexConfig.type ?? "btree",
+        unique: indexConfig.unique ?? false,
+        using: indexConfig.using,
+        where: indexConfig.where,
+        concurrently: indexConfig.concurrently ?? false,
+        autoGenerated: false
+      });
+      indexConfig.fields.forEach((f) => existingIndexFields.add(f));
+    }
+  }
+  for (const field of fields) {
+    if (field.isRef && !existingIndexFields.has(field.name)) {
+      indexes.push({
+        name: `idx_${tableName}_${toSnakeCase(field.name)}`,
+        tableName,
+        fields: [field.name],
+        type: "btree",
+        unique: false,
+        concurrently: false,
+        autoGenerated: true
+      });
+      existingIndexFields.add(field.name);
+    }
+  }
+  for (const field of fields) {
+    if (field.unique && field.name !== "id" && !existingIndexFields.has(field.name)) {
+      indexes.push({
+        name: `idx_${tableName}_${toSnakeCase(field.name)}_unique`,
+        tableName,
+        fields: [field.name],
+        type: "btree",
+        unique: true,
+        concurrently: false,
+        autoGenerated: true
+      });
+      existingIndexFields.add(field.name);
+    }
+  }
+  return indexes;
+}
+function schemaToPgType(type) {
+  const typeMap = {
+    uuid: "UUID",
+    string: "TEXT",
+    text: "TEXT",
+    email: "TEXT",
+    url: "TEXT",
+    int: "INTEGER",
+    integer: "INTEGER",
+    number: "DOUBLE PRECISION",
+    float: "DOUBLE PRECISION",
+    boolean: "BOOLEAN",
+    date: "TIMESTAMPTZ",
+    datetime: "TIMESTAMPTZ",
+    json: "JSONB",
+    jsonb: "JSONB",
+    array: "JSONB",
+    object: "JSONB"
+  };
+  return typeMap[type.toLowerCase()] ?? "TEXT";
+}
+function analyzeRPC(schema, tableName, schemaMap) {
+  const rpcFunctions = [];
+  if (!schema.rpc) {
+    return rpcFunctions;
+  }
+  for (const [name, config] of Object.entries(schema.rpc)) {
+    const returnsArray = config.returns.endsWith("[]");
+    const baseReturnType = returnsArray ? config.returns.slice(0, -2) : config.returns;
+    const isEntityReturn = schemaMap.has(baseReturnType) || baseReturnType === schema.name;
+    let pgReturns;
+    if (config.returns === "void") {
+      pgReturns = "VOID";
+    } else if (isEntityReturn) {
+      const targetTable = baseReturnType === schema.name ? tableName : schemaMap.get(baseReturnType)?.name ?? baseReturnType;
+      pgReturns = returnsArray ? `SETOF ${targetTable}` : targetTable;
+    } else {
+      pgReturns = returnsArray ? `${schemaToPgType(baseReturnType)}[]` : schemaToPgType(baseReturnType);
+    }
+    const args = (config.args ?? []).map((arg) => ({
+      name: arg.name,
+      type: arg.type,
+      pgType: schemaToPgType(arg.type),
+      default: arg.default
+    }));
+    rpcFunctions.push({
+      name,
+      entityName: schema.name,
+      tableName,
+      args,
+      returns: config.returns,
+      pgReturns,
+      returnsArray,
+      sql: config.sql,
+      language: config.language ?? "sql",
+      volatility: config.volatility ?? "volatile",
+      security: config.security ?? "invoker",
+      description: config.description
+    });
+  }
+  return rpcFunctions;
+}
+function extractFunctionBody(fnSource) {
+  const trimmed = fnSource.trim();
+  const arrowMatch = trimmed.match(/^\([^)]*\)\s*=>\s*(.+)$/s);
+  if (!arrowMatch) {
+    return trimmed;
+  }
+  const body = arrowMatch[1].trim();
+  if (body.startsWith("{") && body.endsWith("}")) {
+    return body.slice(1, -1).trim();
+  }
+  return `return ${body};`;
+}
+function serializeRLSFunction(fn) {
+  if (typeof fn !== "function") return void 0;
+  const source = fn.toString();
+  return extractFunctionBody(source);
+}
+function analyzeRLS(rls) {
+  if (!rls) {
+    return {
+      enabled: false,
+      hasSelect: false,
+      hasInsert: false,
+      hasUpdate: false,
+      hasDelete: false,
+      scope: [],
+      bypass: []
+    };
+  }
+  const hasScope = (rls.scope?.length ?? 0) > 0;
+  const hasSelect = !!(rls.select || hasScope || rls.sql?.select);
+  const hasInsert = !!(rls.insert || hasScope || rls.sql?.insert);
+  const hasUpdate = !!(rls.update || hasScope || rls.sql?.update);
+  const hasDelete = !!(rls.delete || hasScope || rls.sql?.delete);
+  const enabled = hasSelect || hasInsert || hasUpdate || hasDelete;
+  const selectSource = serializeRLSFunction(rls.select);
+  const insertSource = serializeRLSFunction(rls.insert);
+  const updateSource = serializeRLSFunction(rls.update);
+  const deleteSource = serializeRLSFunction(rls.delete);
+  return {
+    enabled,
+    hasSelect,
+    hasInsert,
+    hasUpdate,
+    hasDelete,
+    scope: rls.scope ?? [],
+    bypass: rls.bypass ?? [],
+    selectSource,
+    insertSource,
+    updateSource,
+    deleteSource,
+    sql: rls.sql,
+    original: rls
+  };
+}
+function topologicalSort(schemas) {
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const schemaMap = new Map(schemas.map((s) => [s.name, s]));
+  function visit(schema) {
+    if (visited.has(schema.name)) return;
+    if (visiting.has(schema.name)) {
+      console.warn(`Warning: Circular dependency involving ${schema.name}`);
+      return;
+    }
+    visiting.add(schema.name);
+    for (const dep of schema.dependsOn) {
+      const depSchema = schemaMap.get(dep);
+      if (depSchema) {
+        visit(depSchema);
+      }
+    }
+    visiting.delete(schema.name);
+    visited.add(schema.name);
+    sorted.push(schema);
+  }
+  for (const schema of schemas) {
+    visit(schema);
+  }
+  return sorted;
+}
+
+// src/cli/analyze-endpoints.ts
+function analyzeEndpoints(endpoints) {
+  return endpoints.map(analyzeEndpoint);
+}
+function analyzeEndpoint(endpoint) {
+  const name = deriveEndpointName(endpoint.path);
+  const pascalName = toPascalCase2(name);
+  const pathParams = extractPathParams(endpoint.path);
+  const params = analyzeFields(endpoint.params);
+  const body = analyzeFields(endpoint.body);
+  const response = analyzeFields(endpoint.response);
+  const mockResolverSource = serializeMockResolver(endpoint.mockResolver);
+  return {
+    path: endpoint.path,
+    method: endpoint.method,
+    name,
+    pascalName,
+    pathParams,
+    params,
+    body,
+    response,
+    mockResolverSource,
+    description: endpoint.description
+  };
+}
+function deriveEndpointName(path) {
+  let cleaned = path.replace(/^\/api\//, "");
+  cleaned = cleaned.replace(/^\//, "");
+  const parts = cleaned.split("/");
+  const nameParts = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part.startsWith(":")) {
+      const paramName = part.slice(1);
+      nameParts.push("By" + capitalize(paramName));
+    } else if (part) {
+      if (i === 0) {
+        nameParts.push(part);
+      } else {
+        nameParts.push(capitalize(part));
+      }
+    }
+  }
+  return nameParts.join("");
+}
+function extractPathParams(path) {
+  const matches = path.match(/:(\w+)/g) || [];
+  return matches.map((m) => m.slice(1));
+}
+function toPascalCase2(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function analyzeFields(fields) {
+  return Object.entries(fields).map(([name, field]) => analyzeField2(name, field));
+}
+function analyzeField2(name, field) {
+  const tsType = fieldToTsType2(field);
+  const hasDefault = field.default !== void 0;
+  const analyzed = {
+    name,
+    type: field.type,
+    tsType,
+    required: !hasDefault && !field.nullable,
+    hasDefault,
+    default: field.default,
+    isArray: field.type === "array",
+    isObject: field.type === "object"
+  };
+  if (field.values && field.values.length > 0) {
+    analyzed.enumValues = field.values;
+  }
+  if (field.type === "array" && field.items) {
+    analyzed.itemType = analyzeField2("item", field.items);
+  }
+  if (field.type === "object" && field.shape) {
+    analyzed.shape = Object.entries(field.shape).map(([n, f]) => analyzeField2(n, f));
+  }
+  return analyzed;
+}
+function fieldToTsType2(field) {
+  if (field.values && field.values.length > 0) {
+    return field.values.map((v) => `'${v}'`).join(" | ");
+  }
+  if (field.type === "array") {
+    if (field.items) {
+      const itemType = fieldToTsType2(field.items);
+      return `Array<${itemType}>`;
+    }
+    return "unknown[]";
+  }
+  if (field.type === "object") {
+    if (field.shape) {
+      const props = Object.entries(field.shape).map(([name, f]) => {
+        const optional = f.default !== void 0 ? "?" : "";
+        return `${name}${optional}: ${fieldToTsType2(f)}`;
+      }).join("; ");
+      return `{ ${props} }`;
+    }
+    return "Record<string, unknown>";
+  }
+  const typeMap = {
+    string: "string",
+    uuid: "string",
+    email: "string",
+    url: "string",
+    number: "number",
+    int: "number",
+    float: "number",
+    boolean: "boolean",
+    date: "Date",
+    ref: "string"
+  };
+  const baseType = typeMap[field.type] || "unknown";
+  if (field.nullable) {
+    return `${baseType} | null`;
+  }
+  return baseType;
+}
+function serializeMockResolver(resolver) {
+  const source = resolver.toString();
+  if (source.startsWith("async (") || source.startsWith("(") || source.startsWith("async(")) {
+    return source;
+  }
+  if (source.startsWith("async function") || source.startsWith("function")) {
+    const match = source.match(/^(async\s+)?function\s*\w*\s*\(([^)]*)\)\s*\{([\s\S]*)\}$/);
+    if (match) {
+      const [, asyncPrefix, params, body] = match;
+      return `${asyncPrefix || ""}(${params}) => {${body}}`;
+    }
+  }
+  return source;
+}
+
+// src/cli/utils/code-builder.ts
+var CodeBuilder = class {
+  _lines = [];
+  indentLevel = 0;
+  indentStr = "  ";
+  // 2 spaces
+  /**
+   * Increase indentation level
+   */
+  indent() {
+    this.indentLevel++;
+    return this;
+  }
+  /**
+   * Decrease indentation level
+   */
+  dedent() {
+    this.indentLevel = Math.max(0, this.indentLevel - 1);
+    return this;
+  }
+  /**
+   * Add a line of code
+   */
+  line(content = "") {
+    if (content === "") {
+      this._lines.push("");
+    } else {
+      this._lines.push(this.indentStr.repeat(this.indentLevel) + content);
+    }
+    return this;
+  }
+  /**
+   * Add multiple lines of code
+   */
+  addLines(content) {
+    for (const line of content) {
+      this.line(line);
+    }
+    return this;
+  }
+  /**
+   * Add a single-line comment
+   */
+  comment(text) {
+    return this.line(`// ${text}`);
+  }
+  /**
+   * Add a JSDoc comment
+   */
+  docComment(text) {
+    return this.line(`/** ${text} */`);
+  }
+  /**
+   * Add a multi-line JSDoc comment
+   */
+  multiDocComment(lines) {
+    this.line("/**");
+    for (const line of lines) {
+      this.line(` * ${line}`);
+    }
+    this.line(" */");
+    return this;
+  }
+  /**
+   * Add a code block with automatic indentation
+   */
+  block(opener, fn, closer = "}") {
+    this.line(opener);
+    this.indent();
+    fn();
+    this.dedent();
+    this.line(closer);
+    return this;
+  }
+  /**
+   * Add raw content without indentation
+   */
+  raw(content) {
+    this._lines.push(content);
+    return this;
+  }
+  /**
+   * Get the generated code as a string
+   */
+  toString() {
+    return this._lines.join("\n");
+  }
+  /**
+   * Clear all content
+   */
+  clear() {
+    this._lines = [];
+    this.indentLevel = 0;
+    return this;
+  }
+  /**
+   * Get current indentation level
+   */
+  getIndentLevel() {
+    return this.indentLevel;
+  }
+};
+
+// src/cli/generators/types.ts
+function generateTypes(schemas) {
+  const code = new CodeBuilder();
+  code.comment("GENERATED BY SCHEMOCK - DO NOT EDIT");
+  code.comment("Regenerate with: npx schemock generate");
+  code.line();
+  for (const schema of schemas) {
+    if (schema.isJunctionTable) continue;
+    generateEntityTypes(code, schema);
+  }
+  generateCommonTypes(code);
+  return code.toString();
+}
+function generateEntityTypes(code, schema, allSchemas) {
+  const { pascalName, fields, relations, computed, hasTimestamps } = schema;
+  code.docComment(`${pascalName} entity`);
+  code.block(`export interface ${pascalName} {`, () => {
+    code.line("[key: string]: unknown;");
+    for (const field of fields) {
+      const opt = field.nullable ? "?" : "";
+      code.line(`${field.name}${opt}: ${field.tsType};`);
+    }
+    for (const comp of computed) {
+      code.line(`${comp.name}: ${comp.tsType};`);
+    }
+    for (const rel of relations) {
+      const relType = rel.type === "hasMany" || rel.type === "manyToMany" ? `${rel.targetPascal}[]` : rel.targetPascal;
+      code.line(`${rel.name}?: ${relType};`);
+    }
+  });
+  code.line();
+  for (const rel of relations) {
+    const relType = rel.type === "hasMany" || rel.type === "manyToMany" ? `${rel.targetPascal}[]` : rel.targetPascal;
+    const typeName = `${pascalName}With${toPascalCase(rel.name)}`;
+    code.docComment(`${pascalName} with ${rel.name} loaded`);
+    code.block(`export interface ${typeName} extends Omit<${pascalName}, '${rel.name}'> {`, () => {
+      code.line(`${rel.name}: ${relType};`);
+    });
+    code.line();
+  }
+  code.docComment(`Data for creating a ${pascalName}`);
+  code.block(`export interface ${pascalName}Create {`, () => {
+    for (const field of fields) {
+      if (field.name === "id" || field.readOnly) continue;
+      const opt = field.nullable || field.hasDefault ? "?" : "";
+      code.line(`${field.name}${opt}: ${field.tsType};`);
+    }
+    for (const rel of relations) {
+      if (rel.type === "hasMany") {
+        code.line(`${rel.name}?: ${rel.targetPascal}Create[];`);
+      } else if (rel.type === "hasOne") {
+        code.line(`${rel.name}?: ${rel.targetPascal}Create;`);
+      }
+    }
+  });
+  code.line();
+  code.docComment(`Data for updating a ${pascalName}`);
+  code.block(`export interface ${pascalName}Update {`, () => {
+    for (const field of fields) {
+      if (field.name === "id" || field.readOnly) continue;
+      code.line(`${field.name}?: ${field.tsType};`);
+    }
+  });
+  code.line();
+  code.docComment(`Filter options for querying ${pascalName}`);
+  code.block(`export interface ${pascalName}Filter {`, () => {
+    code.line("[key: string]: unknown;");
+    for (const field of fields) {
+      code.line(`${field.name}?: ${field.tsType} | FieldFilter<${field.tsType}>;`);
+    }
+  });
+  code.line();
+  if (relations.length > 0) {
+    const relNames = relations.map((r) => `'${r.name}'`).join(" | ");
+    code.docComment(`Relations that can be included when fetching ${pascalName}`);
+    code.line(`export type ${pascalName}Include = ${relNames};`);
+    code.line();
+  }
+}
+function generateCommonTypes(code) {
+  code.docComment("Generic field filter for complex queries");
+  code.block("export interface FieldFilter<T> {", () => {
+    code.line("equals?: T;");
+    code.line("not?: T;");
+    code.line("in?: T[];");
+    code.line("notIn?: T[];");
+    code.line("lt?: T;");
+    code.line("lte?: T;");
+    code.line("gt?: T;");
+    code.line("gte?: T;");
+    code.line("contains?: string;");
+    code.line("startsWith?: string;");
+    code.line("endsWith?: string;");
+    code.line("isNull?: boolean;");
+  });
+  code.line();
+  code.docComment("Common query options");
+  code.block("export interface QueryOptions<TFilter, TInclude extends string = never> {", () => {
+    code.line("where?: TFilter;");
+    code.line("include?: TInclude[];");
+    code.line('orderBy?: Record<string, "asc" | "desc">;');
+    code.line("limit?: number;");
+    code.line("offset?: number;");
+    code.line("cursor?: string;");
+  });
+  code.line();
+  code.docComment("Paginated list response");
+  code.block("export interface ListResponse<T> {", () => {
+    code.line("data: T[];");
+    code.block("meta: {", () => {
+      code.line("total: number;");
+      code.line("limit: number;");
+      code.line("offset: number;");
+      code.line("hasMore: boolean;");
+      code.line("nextCursor?: string;");
+    });
+  });
+  code.line();
+  code.docComment("Single item response");
+  code.block("export interface ItemResponse<T> {", () => {
+    code.line("data: T;");
+  });
+  code.line();
+}
+
+// src/cli/generators/mock/db.ts
+function generateMockDb(schemas, config) {
+  const code = new CodeBuilder();
+  const entityNames = schemas.map((s) => s.name);
+  const persist = config.persist !== false;
+  code.comment("GENERATED BY SCHEMOCK - DO NOT EDIT");
+  code.line("import { factory, primaryKey, nullable } from '@mswjs/data';");
+  code.line("import { faker } from '@faker-js/faker';");
+  code.line();
+  if (config.fakerSeed !== void 0) {
+    code.line(`faker.seed(${config.fakerSeed});`);
+  } else {
+    code.line("faker.seed(Date.now());");
+  }
+  code.line();
+  code.block("export const db = factory({", () => {
+    for (const schema of schemas) {
+      generateEntityFactory(code, schema);
+    }
+  }, "});");
+  code.line();
+  code.line("export type Database = typeof db;");
+  if (persist) {
+    code.line();
+    generatePersistenceLayer(code, entityNames, config.storageKey);
+  }
+  return code.toString();
+}
+function generatePersistenceLayer(code, entityNames, storageKey) {
+  const key = storageKey || "schemock";
+  code.comment("=== localStorage Persistence ===");
+  code.line();
+  code.line(`const STORAGE_KEY = '${key}';`);
+  code.line();
+  code.block("function isLocalStorageAvailable(): boolean {", () => {
+    code.block("try {", () => {
+      code.line("if (typeof window === 'undefined' || !window.localStorage) return false;");
+      code.line("const testKey = '__schemock_test__';");
+      code.line("window.localStorage.setItem(testKey, 'test');");
+      code.line("window.localStorage.removeItem(testKey);");
+      code.line("return true;");
+    }, "} catch {");
+    code.indent();
+    code.line("return false;");
+    code.dedent();
+    code.line("}");
+  });
+  code.line();
+  code.block("function restoreDates(record: Record<string, unknown>): Record<string, unknown> {", () => {
+    code.line("const result = { ...record };");
+    code.block("for (const [key, value] of Object.entries(result)) {", () => {
+      code.block("if (typeof value === 'string' && /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}/.test(value)) {", () => {
+        code.line("const date = new Date(value);");
+        code.line("if (!isNaN(date.getTime())) result[key] = date;");
+      });
+    });
+    code.line("return result;");
+  });
+  code.line();
+  code.block("function loadFromStorage(): void {", () => {
+    code.line("if (!isLocalStorageAvailable()) return;");
+    code.line();
+    code.block("try {", () => {
+      for (const entity of entityNames) {
+        code.line(`const ${entity}Data = window.localStorage.getItem(\`\${STORAGE_KEY}:${entity}\`);`);
+        code.block(`if (${entity}Data) {`, () => {
+          code.line(`const records = JSON.parse(${entity}Data) as Record<string, unknown>[];`);
+          code.block("for (const record of records) {", () => {
+            code.line("const restored = restoreDates(record);");
+            code.line(`db.${entity}.create(restored as Parameters<typeof db.${entity}.create>[0]);`);
+          });
+        });
+      }
+    }, "} catch (error) {");
+    code.indent();
+    code.line("console.warn('[Schemock] Error loading from localStorage:', error);");
+    code.dedent();
+    code.line("}");
+  });
+  code.line();
+  code.block("function saveToStorage(): void {", () => {
+    code.line("if (!isLocalStorageAvailable()) return;");
+    code.line();
+    code.block("try {", () => {
+      for (const entity of entityNames) {
+        code.line(`window.localStorage.setItem(\`\${STORAGE_KEY}:${entity}\`, JSON.stringify(db.${entity}.getAll()));`);
+      }
+    }, "} catch (error) {");
+    code.indent();
+    code.line("console.warn('[Schemock] Error saving to localStorage:', error);");
+    code.dedent();
+    code.line("}");
+  });
+  code.line();
+  code.block("function clearStorage(): void {", () => {
+    code.line("if (!isLocalStorageAvailable()) return;");
+    for (const entity of entityNames) {
+      code.line(`window.localStorage.removeItem(\`\${STORAGE_KEY}:${entity}\`);`);
+    }
+  });
+  code.line();
+  code.line("let saveTimer: ReturnType<typeof setTimeout> | null = null;");
+  code.line();
+  code.block("function scheduleSave(): void {", () => {
+    code.line("if (saveTimer) clearTimeout(saveTimer);");
+    code.line("saveTimer = setTimeout(() => {");
+    code.line("  saveToStorage();");
+    code.line("  saveTimer = null;");
+    code.line("}, 100);");
+  });
+  code.line();
+  code.comment("Wrap database methods to persist on changes");
+  code.block("function wrapDbMethods(): void {", () => {
+    for (const entity of entityNames) {
+      code.line(`const orig${entity}Create = db.${entity}.create.bind(db.${entity});`);
+      code.line(`const orig${entity}Update = db.${entity}.update.bind(db.${entity});`);
+      code.line(`const orig${entity}Delete = db.${entity}.delete.bind(db.${entity});`);
+      code.line();
+      code.line(`db.${entity}.create = (data) => {`);
+      code.line(`  const result = orig${entity}Create(data);`);
+      code.line("  scheduleSave();");
+      code.line("  return result;");
+      code.line("};");
+      code.line();
+      code.line(`db.${entity}.update = (query) => {`);
+      code.line(`  const result = orig${entity}Update(query);`);
+      code.line("  scheduleSave();");
+      code.line("  return result;");
+      code.line("};");
+      code.line();
+      code.line(`db.${entity}.delete = (query) => {`);
+      code.line(`  const result = orig${entity}Delete(query);`);
+      code.line("  scheduleSave();");
+      code.line("  return result;");
+      code.line("};");
+      code.line();
+    }
+  });
+  code.line();
+  code.comment("Persistence utilities");
+  code.block("export const persistence = {", () => {
+    code.line("save: saveToStorage,");
+    code.line("load: loadFromStorage,");
+    code.line("clear: clearStorage,");
+    code.line("/** Force immediate save (bypass debounce) */");
+    code.block("flush: () => {", () => {
+      code.line("if (saveTimer) {");
+      code.line("  clearTimeout(saveTimer);");
+      code.line("  saveTimer = null;");
+      code.line("}");
+      code.line("saveToStorage();");
+    }, "},");
+  }, "};");
+  code.line();
+  code.comment("Initialize: load data and wrap methods");
+  code.line("loadFromStorage();");
+  code.line("wrapDbMethods();");
+}
+function generateEntityFactory(code, schema) {
+  code.block(`${schema.name}: {`, () => {
+    for (const field of schema.fields) {
+      if (field.name === "id") {
+        code.line("id: primaryKey(faker.string.uuid),");
+      } else if (field.isObject) {
+        if (field.nullable) {
+          code.line(`${field.name}: nullable(() => JSON.stringify(${field.fakerCall})),`);
+        } else {
+          code.line(`${field.name}: () => JSON.stringify(${field.fakerCall}),`);
+        }
+      } else if (field.nullable) {
+        code.line(`${field.name}: nullable(() => ${field.fakerCall}),`);
+      } else {
+        code.line(`${field.name}: () => ${field.fakerCall},`);
+      }
+    }
+  }, "},");
+}
+
+// src/cli/generators/shared/rls.ts
+function getRLSImports() {
+  return "";
+}
+function generateRLSContextType(code) {
+  code.comment("Row-Level Security Context (generic key-value)");
+  code.block("export interface RLSContext {", () => {
+    code.line("[key: string]: unknown;");
+  }, "}");
+  code.line();
+  code.comment("=============================================================================");
+  code.comment("Browser-Compatible RLS Context Storage");
+  code.comment("");
+  code.comment("Uses a simple global context that works in both browsers and Node.js.");
+  code.comment("This is appropriate for development/mock scenarios where concurrent");
+  code.comment("request isolation is not required.");
+  code.comment("=============================================================================");
+  code.line();
+  code.comment("Global context storage - works in browsers and Node.js");
+  code.line("let currentContext: RLSContext | null = null;");
+  code.line();
+  code.multiDocComment([
+    "Set RLS context for the current execution.",
+    "",
+    "@param ctx - The RLS context to set, or null to clear",
+    "",
+    "@example",
+    "```typescript",
+    "// Set context for a request",
+    "setContext({ userId: 'user-123', role: 'admin' });",
+    "",
+    "// Clear context",
+    "setContext(null);",
+    "```"
+  ]);
+  code.block("export function setContext(ctx: RLSContext | null): void {", () => {
+    code.line("currentContext = ctx;");
+  });
+  code.line();
+  code.multiDocComment([
+    "Get RLS context for the current execution.",
+    "",
+    "@returns The current RLS context, or null if not set"
+  ]);
+  code.block("export function getContext(): RLSContext | null {", () => {
+    code.line("return currentContext;");
+  });
+  code.line();
+  code.multiDocComment([
+    "Run a function with RLS context.",
+    "Context is set before the function runs and restored after.",
+    "",
+    "@param ctx - The RLS context to use",
+    "@param fn - The function to run with the context",
+    "@returns The result of the function",
+    "",
+    "@example",
+    "```typescript",
+    "// Run with context",
+    "const result = runWithContext({ userId: '123' }, () => {",
+    "  return api.posts.list();",
+    "});",
+    "```"
+  ]);
+  code.block("export function runWithContext<T>(ctx: RLSContext | null, fn: () => T): T {", () => {
+    code.line("const previousContext = currentContext;");
+    code.line("currentContext = ctx;");
+    code.block("try {", () => {
+      code.line("return fn();");
+    }, "} finally {");
+    code.indent();
+    code.line("currentContext = previousContext;");
+    code.dedent();
+    code.line("}");
+  });
+  code.line();
+  code.multiDocComment([
+    "Async version of runWithContext for async functions.",
+    "",
+    "@param ctx - The RLS context to use",
+    "@param fn - The async function to run with the context",
+    "@returns Promise resolving to the result of the function"
+  ]);
+  code.block("export async function runWithContextAsync<T>(ctx: RLSContext | null, fn: () => Promise<T>): Promise<T> {", () => {
+    code.line("const previousContext = currentContext;");
+    code.line("currentContext = ctx;");
+    code.block("try {", () => {
+      code.line("return await fn();");
+    }, "} finally {");
+    code.indent();
+    code.line("currentContext = previousContext;");
+    code.dedent();
+    code.line("}");
+  });
+  code.line();
+}
+function collectBypassConditions(schemas) {
+  const bypassMap = /* @__PURE__ */ new Map();
+  for (const schema of schemas) {
+    for (const bypass of schema.rls.bypass) {
+      if (!bypassMap.has(bypass.contextKey)) {
+        bypassMap.set(bypass.contextKey, /* @__PURE__ */ new Set());
+      }
+      for (const val of bypass.values) {
+        bypassMap.get(bypass.contextKey).add(val);
+      }
+    }
+  }
+  return Array.from(bypassMap.entries()).map(([contextKey, values]) => ({
+    contextKey,
+    values: Array.from(values)
+  }));
+}
+function generateBypassCheck(code, bypassConditions) {
+  if (bypassConditions.length === 0) {
+    code.block("function checkBypass(_ctx: RLSContext | null): boolean {", () => {
+      code.line("return false;");
+    });
+    return;
+  }
+  code.block("function checkBypass(ctx: RLSContext | null): boolean {", () => {
+    code.line("if (!ctx) return false;");
+    for (const bypass of bypassConditions) {
+      const valuesStr = bypass.values.map((v) => `'${v}'`).join(", ");
+      code.line(`if ([${valuesStr}].includes(ctx.${bypass.contextKey} as string)) return true;`);
+    }
+    code.line("return false;");
+  });
+}
+function hasAnyRLS(schemas) {
+  return schemas.some((s) => s.rls.enabled);
+}
+function generateRLSError(code) {
+  code.comment("RLS Error for unauthorized access");
+  code.block("export class RLSError extends Error {", () => {
+    code.line('readonly code = "RLS_DENIED";');
+    code.block("constructor(operation: string, entity: string) {", () => {
+      code.line("super(`Access denied: ${operation} on ${entity}`);");
+      code.line('this.name = "RLSError";');
+    });
+  }, "}");
+  code.line();
+}
+
+// src/cli/generators/mock/handlers.ts
+function generateMockHandlers(schemas, apiPrefix = "/api") {
+  const code = new CodeBuilder();
+  const hasRLS = hasAnyRLS(schemas);
+  code.comment("GENERATED BY SCHEMOCK - DO NOT EDIT");
+  code.line("import { http, HttpResponse } from 'msw';");
+  code.line("import { api } from './client';");
+  code.line("import { routes } from './routes';");
+  code.line("import type * as Types from './types';");
+  code.line();
+  if (hasRLS) {
+    code.comment("RLS error class for access denied responses");
+    code.block("class RLSError extends Error {", () => {
+      code.line('readonly code = "RLS_DENIED";');
+      code.block("constructor(operation: string, entity: string) {", () => {
+        code.line("super(`Access denied: ${operation} on ${entity}`);");
+        code.line('this.name = "RLSError";');
+      });
+    });
+    code.line();
+    code.comment("Handle errors and return appropriate HTTP responses");
+    code.block("function handleError(error: unknown): Response {", () => {
+      code.block("if (error instanceof RLSError) {", () => {
+        code.line("return HttpResponse.json({ error: error.message }, { status: 403 });");
+      });
+      code.block('if (error instanceof Error && error.message.includes("not found")) {', () => {
+        code.line("return HttpResponse.json({ error: error.message }, { status: 404 });");
+      });
+      code.line("console.error(error);");
+      code.line("return HttpResponse.json({ error: 'Internal server error' }, { status: 500 });");
+    });
+    code.line();
+  }
+  code.block("export const handlers = [", () => {
+    for (const schema of schemas) {
+      if (schema.isJunctionTable) continue;
+      generateEntityHandlers(code, schema, hasRLS);
+    }
+  }, "];");
+  return code.toString();
+}
+function generateEntityHandlers(code, schema, hasRLS) {
+  const { name, pascalName } = schema;
+  const pluralName = pluralize(name);
+  code.comment(`${pascalName} handlers`);
+  code.block(`http.get(routes.${pluralName}.list.path, async ({ request }) => {`, () => {
+    code.line("const url = new URL(request.url);");
+    code.line("const limit = parseInt(url.searchParams.get('limit') || '20');");
+    code.line("const offset = parseInt(url.searchParams.get('offset') || '0');");
+    code.line();
+    if (hasRLS) {
+      code.block("try {", () => {
+        code.line(`const response = await api.${name}.list({ limit, offset });`);
+        code.line("return HttpResponse.json(response);");
+      }, "} catch (error) {");
+      code.indent();
+      code.line("return handleError(error);");
+      code.dedent();
+      code.line("}");
+    } else {
+      code.line(`const response = await api.${name}.list({ limit, offset });`);
+      code.line("return HttpResponse.json(response);");
+    }
+  }, "}),");
+  code.line();
+  code.block(`http.get(routes.${pluralName}.get.path, async ({ params }) => {`, () => {
+    if (hasRLS) {
+      code.block("try {", () => {
+        code.line(`const response = await api.${name}.get(params.id as string);`);
+        code.line("if (!response.data) {");
+        code.line(`  return HttpResponse.json({ error: '${pascalName} not found' }, { status: 404 });`);
+        code.line("}");
+        code.line("return HttpResponse.json(response);");
+      }, "} catch (error) {");
+      code.indent();
+      code.line("return handleError(error);");
+      code.dedent();
+      code.line("}");
+    } else {
+      code.line(`const response = await api.${name}.get(params.id as string);`);
+      code.line("if (!response.data) {");
+      code.line(`  return HttpResponse.json({ error: '${pascalName} not found' }, { status: 404 });`);
+      code.line("}");
+      code.line("return HttpResponse.json(response);");
+    }
+  }, "}),");
+  code.line();
+  code.block(`http.post(routes.${pluralName}.create.path, async ({ request }) => {`, () => {
+    code.line(`const body = await request.json() as Types.${pascalName}Create;`);
+    code.line();
+    if (hasRLS) {
+      code.block("try {", () => {
+        code.line(`const response = await api.${name}.create(body);`);
+        code.line("return HttpResponse.json(response, { status: 201 });");
+      }, "} catch (error) {");
+      code.indent();
+      code.line("return handleError(error);");
+      code.dedent();
+      code.line("}");
+    } else {
+      code.line(`const response = await api.${name}.create(body);`);
+      code.line("return HttpResponse.json(response, { status: 201 });");
+    }
+  }, "}),");
+  code.line();
+  code.block(`http.put(routes.${pluralName}.update.path, async ({ params, request }) => {`, () => {
+    code.line(`const body = await request.json() as Types.${pascalName}Update;`);
+    code.line();
+    if (hasRLS) {
+      code.block("try {", () => {
+        code.line(`const response = await api.${name}.update(params.id as string, body);`);
+        code.line("return HttpResponse.json(response);");
+      }, "} catch (error) {");
+      code.indent();
+      code.line("return handleError(error);");
+      code.dedent();
+      code.line("}");
+    } else {
+      code.line(`const response = await api.${name}.update(params.id as string, body);`);
+      code.line("return HttpResponse.json(response);");
+    }
+  }, "}),");
+  code.line();
+  code.block(`http.patch(routes.${pluralName}.patch.path, async ({ params, request }) => {`, () => {
+    code.line(`const body = await request.json() as Types.${pascalName}Update;`);
+    code.line();
+    if (hasRLS) {
+      code.block("try {", () => {
+        code.line(`const response = await api.${name}.update(params.id as string, body);`);
+        code.line("return HttpResponse.json(response);");
+      }, "} catch (error) {");
+      code.indent();
+      code.line("return handleError(error);");
+      code.dedent();
+      code.line("}");
+    } else {
+      code.line(`const response = await api.${name}.update(params.id as string, body);`);
+      code.line("return HttpResponse.json(response);");
+    }
+  }, "}),");
+  code.line();
+  code.block(`http.delete(routes.${pluralName}.delete.path, async ({ params }) => {`, () => {
+    if (hasRLS) {
+      code.block("try {", () => {
+        code.line(`await api.${name}.delete(params.id as string);`);
+        code.line("return new HttpResponse(null, { status: 204 });");
+      }, "} catch (error) {");
+      code.indent();
+      code.line("return handleError(error);");
+      code.dedent();
+      code.line("}");
+    } else {
+      code.line(`await api.${name}.delete(params.id as string);`);
+      code.line("return new HttpResponse(null, { status: 204 });");
+    }
+  }, "}),");
+  code.line();
+}
+function generateAllHandlersExport(hasEndpoints) {
+  const code = new CodeBuilder();
+  code.comment("GENERATED BY SCHEMOCK - DO NOT EDIT");
+  code.comment("Combined handlers for MSW setup");
+  code.line();
+  code.line("import { handlers } from './handlers';");
+  if (hasEndpoints) {
+    code.line("import { endpointHandlers } from './endpoint-handlers';");
+    code.line();
+    code.comment("All handlers: entity CRUD + custom endpoints");
+    code.line("export const allHandlers = [...handlers, ...endpointHandlers];");
+  } else {
+    code.line();
+    code.comment("All handlers (no custom endpoints defined)");
+    code.line("export const allHandlers = handlers;");
+  }
+  code.line();
+  code.comment("Re-export for convenience");
+  code.line("export { handlers };");
+  if (hasEndpoints) {
+    code.line("export { endpointHandlers };");
+  }
+  return code.toString();
+}
+
+// src/cli/generators/mock/client.ts
+function generateMockClient(schemas) {
+  const code = new CodeBuilder();
+  const schemasWithRLS = hasAnyRLS(schemas);
+  const allBypassConditions = collectBypassConditions(schemas);
+  code.comment("GENERATED BY SCHEMOCK - DO NOT EDIT");
+  code.line("import { db } from './db';");
+  code.line("import type * as Types from './types';");
+  if (schemasWithRLS) {
+    code.line(getRLSImports());
+  }
+  code.line();
+  if (schemasWithRLS) {
+    generateRLSContextType(code);
+    generateRLSError(code);
+    generateBypassCheck(code, allBypassConditions);
+    code.line();
+    const hasGlobalBypass = allBypassConditions.length > 0;
+    for (const schema of schemas) {
+      if (schema.isJunctionTable) continue;
+      generateEntityRLSFilters(code, schema, hasGlobalBypass);
+    }
+    code.line();
+  }
+  generateFilterHelper(code);
+  code.line();
+  generateParseRowHelper(code);
+  code.line();
+  code.block("export const api = {", () => {
+    for (const schema of schemas) {
+      if (schema.isJunctionTable) continue;
+      generateEntityApi(code, schema, schemas, schemasWithRLS);
+    }
+  }, "};");
+  return code.toString();
+}
+function generateEntityRLSFilters(code, schema, hasGlobalBypass) {
+  const { pascalName, rls } = schema;
+  if (!rls.enabled) {
+    code.comment(`RLS filters for ${pascalName} (disabled)`);
+    code.line(`const rls${pascalName}Select = (_row: Record<string, unknown>, _ctx: RLSContext | null): boolean => true;`);
+    code.line(`const rls${pascalName}Insert = (_row: Record<string, unknown>, _ctx: RLSContext | null): boolean => true;`);
+    code.line(`const rls${pascalName}Update = (_row: Record<string, unknown>, _ctx: RLSContext | null): boolean => true;`);
+    code.line(`const rls${pascalName}Delete = (_row: Record<string, unknown>, _ctx: RLSContext | null): boolean => true;`);
+    code.line();
+    return;
+  }
+  code.comment(`RLS filters for ${pascalName}`);
+  const sourceFields = {
+    Select: rls.selectSource,
+    Insert: rls.insertSource,
+    Update: rls.updateSource,
+    Delete: rls.deleteSource
+  };
+  for (const op of ["Select", "Insert", "Update", "Delete"]) {
+    const hasPolicy = rls[`has${op}`];
+    const customSource = sourceFields[op];
+    code.block(`const rls${pascalName}${op} = (row: Record<string, unknown>, ctx: RLSContext | null): boolean => {`, () => {
+      if (hasGlobalBypass) {
+        code.line("if (checkBypass(ctx)) return true;");
+      }
+      if (!hasPolicy) {
+        code.line("return true;");
+        return;
+      }
+      if (customSource) {
+        for (const line of customSource.split("\n")) {
+          code.line(line.trim());
+        }
+        return;
+      }
+      if (rls.scope.length > 0) {
+        for (const mapping of rls.scope) {
+          code.line(`// Scope: ${mapping.field} must match context.${mapping.contextKey}`);
+          code.line(`if (!ctx || row.${mapping.field} !== ctx.${mapping.contextKey}) return false;`);
+        }
+      }
+      code.line("return true;");
+    }, "};");
+  }
+  code.line();
+}
+function generateFilterHelper(code) {
+  code.block("function applyFilter<T>(items: T[], filter: Record<string, unknown>): T[] {", () => {
+    code.block("return items.filter(item => {", () => {
+      code.block("for (const [key, value] of Object.entries(filter)) {", () => {
+        code.line("const itemValue = (item as Record<string, unknown>)[key];");
+        code.block('if (typeof value === "object" && value !== null) {', () => {
+          code.line("const f = value as Record<string, unknown>;");
+          code.line("if ('equals' in f && itemValue !== f.equals) return false;");
+          code.line("if ('not' in f && itemValue === f.not) return false;");
+          code.line("if ('in' in f && !(f.in as unknown[]).includes(itemValue)) return false;");
+          code.line("if ('notIn' in f && (f.notIn as unknown[]).includes(itemValue)) return false;");
+          code.line("if ('contains' in f && !String(itemValue).includes(f.contains as string)) return false;");
+          code.line("if ('startsWith' in f && !String(itemValue).startsWith(f.startsWith as string)) return false;");
+          code.line("if ('endsWith' in f && !String(itemValue).endsWith(f.endsWith as string)) return false;");
+          code.line("if ('gt' in f && (itemValue as number) <= (f.gt as number)) return false;");
+          code.line("if ('lt' in f && (itemValue as number) >= (f.lt as number)) return false;");
+          code.line("if ('gte' in f && (itemValue as number) < (f.gte as number)) return false;");
+          code.line("if ('lte' in f && (itemValue as number) > (f.lte as number)) return false;");
+          code.line("if ('isNull' in f && f.isNull && itemValue !== null && itemValue !== undefined) return false;");
+          code.line("if ('isNull' in f && !f.isNull && (itemValue === null || itemValue === undefined)) return false;");
+        }, "} else {");
+        code.indent();
+        code.line("if (itemValue !== value) return false;");
+        code.dedent();
+        code.line("}");
+      });
+      code.line("return true;");
+    }, "});");
+  });
+}
+function generateParseRowHelper(code) {
+  code.comment("Parse JSONB fields stored as strings by @mswjs/data");
+  code.block(
+    "function parseRow<T>(row: Record<string, unknown>, jsonFields: string[]): T {",
+    () => {
+      code.line("const result = { ...row };");
+      code.block("for (const field of jsonFields) {", () => {
+        code.block('if (result[field] && typeof result[field] === "string") {', () => {
+          code.block("try {", () => {
+            code.line("result[field] = JSON.parse(result[field] as string);");
+          }, "} catch { /* keep as string */ }");
+        });
+      });
+      code.line("return result as T;");
+    }
+  );
+}
+function generateEntityApi(code, schema, allSchemas, hasRLS) {
+  const { name, pascalName, relations, fields, rls } = schema;
+  const hasRelations = relations.length > 0;
+  const includeType = hasRelations ? `Types.${pascalName}Include` : "never";
+  const jsonFields = fields.filter((f) => f.isArray || f.isObject).map((f) => f.name);
+  const hasJsonFields = jsonFields.length > 0;
+  const jsonFieldsStr = jsonFields.map((f) => `'${f}'`).join(", ");
+  code.block(`${name}: {`, () => {
+    code.block(
+      `list: async (options?: Types.QueryOptions<Types.${pascalName}Filter, ${includeType}>): Promise<Types.ListResponse<Types.${pascalName}>> => {`,
+      () => {
+        if (hasJsonFields) {
+          code.line(`let rawItems = db.${name}.getAll() as unknown as Record<string, unknown>[];`);
+          code.line(`let items = rawItems.map(row => parseRow<Types.${pascalName}>(row, [${jsonFieldsStr}]));`);
+        } else {
+          code.line(`let items = db.${name}.getAll() as unknown as Types.${pascalName}[];`);
+        }
+        code.line();
+        if (hasRLS) {
+          code.comment("Apply RLS filter");
+          code.line(`const ctx = getContext();`);
+          code.line(`items = items.filter(item => rls${pascalName}Select(item as unknown as Record<string, unknown>, ctx));`);
+          code.line();
+        }
+        code.block("if (options?.where) {", () => {
+          code.line("items = applyFilter(items, options.where);");
+        });
+        code.line();
+        code.line("const total = items.length;");
+        code.line();
+        code.block("if (options?.orderBy) {", () => {
+          code.line("const [field, dir] = Object.entries(options.orderBy)[0];");
+          code.block("items = [...items].sort((a, b) => {", () => {
+            code.line("const aVal = (a as Record<string, unknown>)[field] as string | number | Date;");
+            code.line("const bVal = (b as Record<string, unknown>)[field] as string | number | Date;");
+            code.line("if (aVal < bVal) return dir === 'asc' ? -1 : 1;");
+            code.line("if (aVal > bVal) return dir === 'asc' ? 1 : -1;");
+            code.line("return 0;");
+          }, "});");
+        });
+        code.line();
+        code.line("const limit = options?.limit ?? 20;");
+        code.line("const offset = options?.offset ?? 0;");
+        code.line("items = items.slice(offset, offset + limit);");
+        code.line();
+        if (hasRelations) {
+          code.block("if (options?.include?.length) {", () => {
+            code.block("items = items.map(item => {", () => {
+              code.line("const result = { ...item } as Record<string, unknown>;");
+              for (const rel of relations) {
+                code.block(`if (options.include!.includes('${rel.name}')) {`, () => {
+                  generateRelationLoad(code, schema, rel);
+                });
+              }
+              code.line(`return result as Types.${pascalName};`);
+            }, "});");
+          });
+          code.line();
+        }
+        code.line("return { data: items, meta: { total, limit, offset, hasMore: offset + limit < total } };");
+      },
+      "},"
+    );
+    code.line();
+    code.block(
+      `get: async (id: string, options?: { include?: ${includeType}[] }): Promise<Types.ItemResponse<Types.${pascalName}>> => {`,
+      () => {
+        code.line(`const rawItem = db.${name}.findFirst({ where: { id: { equals: id } } }) as unknown as Record<string, unknown> | null;`);
+        code.line(`if (!rawItem) throw new Error('${pascalName} not found');`);
+        if (hasJsonFields) {
+          code.line(`const item = parseRow<Types.${pascalName}>(rawItem, [${jsonFieldsStr}]);`);
+        } else {
+          code.line(`const item = rawItem as Types.${pascalName};`);
+        }
+        code.line();
+        if (hasRLS) {
+          code.comment("Apply RLS check");
+          code.line(`const ctx = getContext();`);
+          code.block(`if (!rls${pascalName}Select(item as unknown as Record<string, unknown>, ctx)) {`, () => {
+            code.line(`throw new RLSError('select', '${pascalName}');`);
+          });
+          code.line();
+        }
+        if (hasRelations) {
+          code.line("const result = { ...item } as Record<string, unknown>;");
+          code.line();
+          code.block("if (options?.include?.length) {", () => {
+            for (const rel of relations) {
+              code.block(`if (options.include.includes('${rel.name}')) {`, () => {
+                generateRelationLoad(code, schema, rel);
+              });
+            }
+          });
+          code.line();
+          code.line(`return { data: result as Types.${pascalName} };`);
+        } else {
+          code.line("return { data: item };");
+        }
+      },
+      "},"
+    );
+    code.line();
+    generateCreateMethod(code, schema, hasJsonFields, jsonFieldsStr, hasRLS);
+    code.line();
+    code.block(`update: async (id: string, input: Types.${pascalName}Update): Promise<Types.ItemResponse<Types.${pascalName}>> => {`, () => {
+      if (hasRLS) {
+        code.comment("Check RLS before update");
+        code.line(`const existing = db.${name}.findFirst({ where: { id: { equals: id } } }) as unknown as Record<string, unknown> | null;`);
+        code.line(`if (!existing) throw new Error('${pascalName} not found');`);
+        code.line(`const ctx = getContext();`);
+        code.block(`if (!rls${pascalName}Update(existing, ctx)) {`, () => {
+          code.line(`throw new RLSError('update', '${pascalName}');`);
+        });
+        code.line();
+      }
+      code.line(`const rawItem = db.${name}.update({`);
+      code.line("  where: { id: { equals: id } },");
+      code.line(`  // eslint-disable-next-line @typescript-eslint/no-explicit-any`);
+      code.line("  data: { ...input, updatedAt: new Date() } as any,");
+      code.line("}) as unknown as Record<string, unknown> | null;");
+      if (!hasRLS) {
+        code.line(`if (!rawItem) throw new Error('${pascalName} not found');`);
+      }
+      if (hasJsonFields) {
+        code.line(`return { data: parseRow<Types.${pascalName}>(rawItem!, [${jsonFieldsStr}]) };`);
+      } else {
+        code.line(`return { data: rawItem as Types.${pascalName} };`);
+      }
+    }, "},");
+    code.line();
+    code.block("delete: async (id: string): Promise<void> => {", () => {
+      if (hasRLS) {
+        code.comment("Check RLS before delete");
+        code.line(`const existing = db.${name}.findFirst({ where: { id: { equals: id } } }) as unknown as Record<string, unknown> | null;`);
+        code.line(`if (!existing) throw new Error('${pascalName} not found');`);
+        code.line(`const ctx = getContext();`);
+        code.block(`if (!rls${pascalName}Delete(existing, ctx)) {`, () => {
+          code.line(`throw new RLSError('delete', '${pascalName}');`);
+        });
+        code.line();
+      }
+      code.line(`const item = db.${name}.delete({ where: { id: { equals: id } } });`);
+      if (!hasRLS) {
+        code.line(`if (!item) throw new Error('${pascalName} not found');`);
+      }
+    }, "},");
+  }, "},");
+  code.line();
+}
+function generateRelationLoad(code, schema, rel) {
+  if (rel.type === "hasMany") {
+    code.line(`result.${rel.name} = db.${rel.target}.findMany({`);
+    code.line(`  where: { ${rel.foreignKey}: { equals: item.id } }`);
+    code.line("});");
+  } else if (rel.type === "hasOne") {
+    code.line(`result.${rel.name} = db.${rel.target}.findFirst({`);
+    code.line(`  where: { ${rel.foreignKey}: { equals: item.id } }`);
+    code.line("});");
+  } else if (rel.type === "belongsTo") {
+    code.line(`result.${rel.name} = db.${rel.target}.findFirst({`);
+    code.line(`  where: { id: { equals: (item as Record<string, unknown>).${rel.localField} as string } }`);
+    code.line("});");
+  } else if (rel.type === "manyToMany") {
+    code.line(`const junctions = db.${rel.through}.findMany({`);
+    code.line(`  where: { ${rel.foreignKey}: { equals: item.id } }`);
+    code.line("});");
+    code.line(`result.${rel.name} = junctions`);
+    code.line(`  .map(j => db.${rel.target}.findFirst({`);
+    code.line(`    where: { id: { equals: (j as Record<string, unknown>).${rel.otherKey} as string } }`);
+    code.line("  }))");
+    code.line("  .filter(Boolean);");
+  }
+}
+function generateCreateMethod(code, schema, hasJsonFields, jsonFieldsStr, hasRLS) {
+  const { name, pascalName, relations } = schema;
+  const nestedRels = relations.filter((r) => r.type === "hasMany" || r.type === "hasOne");
+  code.block(`create: async (input: Types.${pascalName}Create): Promise<Types.ItemResponse<Types.${pascalName}>> => {`, () => {
+    if (nestedRels.length > 0) {
+      const relNames = nestedRels.map((r) => r.name).join(", ");
+      code.line(`const { ${relNames}, ...data } = input;`);
+      code.line();
+      code.line(`// eslint-disable-next-line @typescript-eslint/no-explicit-any`);
+      code.line(`const rawItem = db.${name}.create(data as any) as unknown as Record<string, unknown>;`);
+      if (hasJsonFields) {
+        code.line(`const item = parseRow<Types.${pascalName}>(rawItem, [${jsonFieldsStr}]);`);
+      } else {
+        code.line(`const item = rawItem as Types.${pascalName};`);
+      }
+      code.line();
+      if (hasRLS) {
+        code.comment("Check RLS on created item");
+        code.line(`const ctx = getContext();`);
+        code.block(`if (!rls${pascalName}Insert(item as unknown as Record<string, unknown>, ctx)) {`, () => {
+          code.comment("Rollback by deleting");
+          code.line(`db.${name}.delete({ where: { id: { equals: item.id } } });`);
+          code.line(`throw new RLSError('insert', '${pascalName}');`);
+        });
+        code.line();
+      }
+      for (const rel of nestedRels) {
+        code.block(`if (${rel.name}) {`, () => {
+          if (rel.type === "hasMany") {
+            code.block(`for (const nested of ${rel.name}) {`, () => {
+              code.line(`// eslint-disable-next-line @typescript-eslint/no-explicit-any`);
+              code.line(`db.${rel.target}.create({ ...nested, ${rel.foreignKey}: item.id } as any);`);
+            });
+          } else {
+            code.line(`// eslint-disable-next-line @typescript-eslint/no-explicit-any`);
+            code.line(`db.${rel.target}.create({ ...${rel.name}, ${rel.foreignKey}: item.id } as any);`);
+          }
+        });
+      }
+      code.line();
+      code.line("return { data: item };");
+    } else {
+      code.line(`// eslint-disable-next-line @typescript-eslint/no-explicit-any`);
+      code.line(`const rawItem = db.${name}.create(input as any) as unknown as Record<string, unknown>;`);
+      if (hasJsonFields) {
+        code.line(`const item = parseRow<Types.${pascalName}>(rawItem, [${jsonFieldsStr}]);`);
+      } else {
+        code.line(`const item = rawItem as Types.${pascalName};`);
+      }
+      if (hasRLS) {
+        code.line();
+        code.comment("Check RLS on created item");
+        code.line(`const ctx = getContext();`);
+        code.block(`if (!rls${pascalName}Insert(item as unknown as Record<string, unknown>, ctx)) {`, () => {
+          code.comment("Rollback by deleting");
+          code.line(`db.${name}.delete({ where: { id: { equals: item.id } } });`);
+          code.line(`throw new RLSError('insert', '${pascalName}');`);
+        });
+      }
+      code.line();
+      code.line("return { data: item };");
+    }
+  }, "},");
+}
+
+// src/cli/generators/mock/seed.ts
+function generateSeed(schemas, config) {
+  const code = new CodeBuilder();
+  code.comment("GENERATED BY SCHEMOCK - DO NOT EDIT");
+  code.line("import { db } from './db';");
+  code.line();
+  code.block("export interface SeedCounts {", () => {
+    for (const schema of schemas) {
+      if (schema.isJunctionTable) continue;
+      code.line(`${schema.name}?: number;`);
+    }
+  });
+  code.line();
+  code.block("const defaultCounts: Required<SeedCounts> = {", () => {
+    for (const schema of schemas) {
+      if (schema.isJunctionTable) continue;
+      const count = config.seed?.[schema.name] ?? 10;
+      code.line(`${schema.name}: ${count},`);
+    }
+  }, "};");
+  code.line();
+  code.block("function pickRandom<T>(arr: T[]): T | undefined {", () => {
+    code.line("if (arr.length === 0) return undefined;");
+    code.line("return arr[Math.floor(Math.random() * arr.length)];");
+  });
+  code.line();
+  code.block("export function seed(counts: SeedCounts = {}): void {", () => {
+    code.line("const merged = { ...defaultCounts, ...counts };");
+    code.line();
+    code.comment("Track created entity IDs for foreign key references");
+    code.line("const ids: Record<string, string[]> = {};");
+    code.line();
+    for (const schema of schemas) {
+      if (schema.isJunctionTable) continue;
+      const belongsToRels = schema.relations.filter((r) => r.type === "belongsTo");
+      const fkFields = belongsToRels.map((r) => ({
+        fieldName: r.localField || r.foreignKey,
+        target: r.target,
+        nullable: schema.fields.find((f) => f.name === (r.localField || r.foreignKey))?.nullable ?? false
+      }));
+      code.line(`ids.${schema.name} = [];`);
+      code.block(`for (let i = 0; i < merged.${schema.name}; i++) {`, () => {
+        if (fkFields.length > 0) {
+          code.line(`const item = db.${schema.name}.create({`);
+          code.indent();
+          for (const fk of fkFields) {
+            if (fk.nullable) {
+              code.line(`${fk.fieldName}: Math.random() > 0.3 ? pickRandom(ids.${fk.target}) : undefined,`);
+            } else {
+              code.line(`${fk.fieldName}: pickRandom(ids.${fk.target}),`);
+            }
+          }
+          code.dedent();
+          code.line(`// eslint-disable-next-line @typescript-eslint/no-explicit-any`);
+          code.line("} as any);");
+        } else {
+          code.line(`const item = db.${schema.name}.create({});`);
+        }
+        code.line(`ids.${schema.name}.push(item.id);`);
+      });
+      code.line();
+    }
+  });
+  code.line();
+  code.block("export function reset(): void {", () => {
+    for (const schema of [...schemas].reverse()) {
+      code.line(`db.${schema.name}.deleteMany({ where: {} });`);
+    }
+  });
+  code.line();
+  code.block("export function getAll(): Record<string, unknown[]> {", () => {
+    code.block("return {", () => {
+      for (const schema of schemas) {
+        code.line(`${schema.name}: db.${schema.name}.getAll(),`);
+      }
+    }, "};");
+  });
+  return code.toString();
+}
+
+// src/cli/generators/mock/routes.ts
+function generateRoutes(schemas) {
+  const code = new CodeBuilder();
+  code.comment("GENERATED BY SCHEMOCK - DO NOT EDIT");
+  code.line();
+  code.comment("Auto-generated REST route definitions");
+  code.comment("");
+  code.comment("These routes are used by:");
+  code.comment("- MSW handlers for intercepting requests");
+  code.comment("- Backend reference for implementing custom servers");
+  code.line();
+  code.comment("Route definition type");
+  code.block("export interface RouteDefinition {", () => {
+    code.line("method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';");
+    code.line("path: string;");
+  }, "}");
+  code.line();
+  code.comment("Entity route definitions");
+  code.block("export const routes = {", () => {
+    for (const schema of schemas) {
+      if (schema.isJunctionTable) continue;
+      generateEntityRoutes(code, schema);
+    }
+  }, "} as const;");
+  code.line();
+  code.line("export type Routes = typeof routes;");
+  code.line();
+  generateRouteHelpers(code, schemas);
+  return code.toString();
+}
+function generateEntityRoutes(code, schema) {
+  const { name } = schema;
+  const pluralName = pluralize(name);
+  const basePath = `/api/${pluralName}`;
+  code.block(`${pluralName}: {`, () => {
+    code.line(`list:   { method: 'GET',    path: '${basePath}' },`);
+    code.line(`get:    { method: 'GET',    path: '${basePath}/:id' },`);
+    code.line(`create: { method: 'POST',   path: '${basePath}' },`);
+    code.line(`update: { method: 'PUT',    path: '${basePath}/:id' },`);
+    code.line(`patch:  { method: 'PATCH',  path: '${basePath}/:id' },`);
+    code.line(`delete: { method: 'DELETE', path: '${basePath}/:id' },`);
+  }, "},");
+}
+function generateRouteHelpers(code, schemas) {
+  code.comment("Route path helpers - generate paths with parameters");
+  code.line();
+  for (const schema of schemas) {
+    if (schema.isJunctionTable) continue;
+    const { name, pascalName } = schema;
+    const pluralName = pluralize(name);
+    const basePath = `/api/${pluralName}`;
+    code.block(`export const ${name}Routes = {`, () => {
+      code.line(`list: () => '${basePath}',`);
+      code.line(`get: (id: string) => \`${basePath}/\${id}\`,`);
+      code.line(`create: () => '${basePath}',`);
+      code.line(`update: (id: string) => \`${basePath}/\${id}\`,`);
+      code.line(`patch: (id: string) => \`${basePath}/\${id}\`,`);
+      code.line(`delete: (id: string) => \`${basePath}/\${id}\`,`);
+    }, "};");
+    code.line();
+  }
+}
+
+// src/cli/generators/mock/endpoints.ts
+function generateEndpointTypes(endpoints) {
+  const code = new CodeBuilder();
+  code.line();
+  code.comment("=============================================================================");
+  code.comment("Custom Endpoint Types");
+  code.comment("=============================================================================");
+  code.line();
+  for (const endpoint of endpoints) {
+    generateEndpointTypeSet(code, endpoint);
+  }
+  return code.toString();
+}
+function generateEndpointTypeSet(code, endpoint) {
+  const { pascalName, params, body, response } = endpoint;
+  if (params.length > 0) {
+    code.comment(`Parameters for ${endpoint.path}`);
+    code.block(`export interface ${pascalName}Params {`, () => {
+      for (const param of params) {
+        const optional = !param.required ? "?" : "";
+        code.line(`${param.name}${optional}: ${param.tsType};`);
+      }
+    });
+    code.line();
+  }
+  if (body.length > 0) {
+    code.comment(`Request body for ${endpoint.path}`);
+    code.block(`export interface ${pascalName}Body {`, () => {
+      for (const field of body) {
+        const optional = !field.required ? "?" : "";
+        code.line(`${field.name}${optional}: ${field.tsType};`);
+      }
+    });
+    code.line();
+  }
+  code.comment(`Response from ${endpoint.path}`);
+  code.block(`export interface ${pascalName}Response {`, () => {
+    for (const field of response) {
+      code.line(`${field.name}: ${field.tsType};`);
+    }
+  });
+  code.line();
+}
+function generateEndpointClient(endpoints) {
+  const code = new CodeBuilder();
+  code.comment("GENERATED BY SCHEMOCK - DO NOT EDIT");
+  code.comment("Client methods for custom endpoints");
+  code.line();
+  code.line("import type * as Types from './types';");
+  code.line();
+  code.comment("API base URL - configure based on environment");
+  code.line("const API_BASE = typeof window !== 'undefined' ? window.location.origin : '';");
+  code.line();
+  code.block("export const endpoints = {", () => {
+    for (const endpoint of endpoints) {
+      generateClientMethod(code, endpoint);
+    }
+  }, "};");
+  return code.toString();
+}
+function generateClientMethod(code, endpoint) {
+  const { name, pascalName, method, path, params, body, pathParams } = endpoint;
+  const args = [];
+  if (params.length > 0) {
+    args.push(`params: Types.${pascalName}Params`);
+  }
+  if (body.length > 0) {
+    args.push(`body: Types.${pascalName}Body`);
+  }
+  const returnType = `Promise<Types.${pascalName}Response>`;
+  code.block(`${name}: async (${args.join(", ")}): ${returnType} => {`, () => {
+    let urlExpr;
+    if (pathParams.length > 0) {
+      let pathTemplate = path;
+      for (const param of pathParams) {
+        pathTemplate = pathTemplate.replace(`:${param}`, `\${params.${param}}`);
+      }
+      urlExpr = `\`\${API_BASE}${pathTemplate}\``;
+    } else {
+      urlExpr = `\`\${API_BASE}${path}\``;
+    }
+    if (method === "GET" && params.length > 0) {
+      code.line(`const url = new URL(${urlExpr});`);
+      const queryParams = params.filter((p) => !pathParams.includes(p.name));
+      for (const param of queryParams) {
+        code.block(`if (params.${param.name} !== undefined) {`, () => {
+          code.line(`url.searchParams.set('${param.name}', String(params.${param.name}));`);
+        });
+      }
+      code.line("const response = await fetch(url.toString());");
+    } else if (body.length > 0) {
+      code.line(`const response = await fetch(${urlExpr}, {`);
+      code.line(`  method: '${method}',`);
+      code.line("  headers: { 'Content-Type': 'application/json' },");
+      code.line("  body: JSON.stringify(body),");
+      code.line("});");
+    } else {
+      code.line(`const response = await fetch(${urlExpr}, { method: '${method}' });`);
+    }
+    code.line();
+    code.block("if (!response.ok) {", () => {
+      code.line("const error = await response.json().catch(() => ({}));");
+      code.line("throw new Error(error.message || `HTTP ${response.status}`);");
+    });
+    code.line();
+    code.line("return response.json();");
+  }, "},");
+  code.line();
+}
+function generateEndpointHandlers(endpoints) {
+  const code = new CodeBuilder();
+  code.comment("GENERATED BY SCHEMOCK - DO NOT EDIT");
+  code.comment("MSW handlers for custom endpoints");
+  code.line();
+  code.line("import { http, HttpResponse } from 'msw';");
+  code.line("import { db } from './db';");
+  code.line("import { endpointResolvers } from './endpoint-resolvers';");
+  code.line();
+  code.block("export const endpointHandlers = [", () => {
+    for (const endpoint of endpoints) {
+      generateHandler(code, endpoint);
+    }
+  }, "];");
+  return code.toString();
+}
+function generateHandler(code, endpoint) {
+  const { name, method, path, params, body, pathParams } = endpoint;
+  const httpMethod = method.toLowerCase();
+  code.comment(`${method} ${path}`);
+  code.block(`http.${httpMethod}('${path}', async ({ request, params: pathParams }) => {`, () => {
+    if (method === "GET" && params.length > 0) {
+      code.line("const url = new URL(request.url);");
+      code.block("const params = {", () => {
+        for (const param of params) {
+          if (pathParams.includes(param.name)) {
+            code.line(`${param.name}: pathParams.${param.name} as string,`);
+          } else {
+            generateParamParsing(code, param);
+          }
+        }
+      }, "};");
+      code.line();
+    } else if (pathParams.length > 0) {
+      code.block("const params = {", () => {
+        for (const paramName of pathParams) {
+          code.line(`${paramName}: pathParams.${paramName} as string,`);
+        }
+      }, "};");
+      code.line();
+    }
+    if (body.length > 0) {
+      code.line("const body = await request.json();");
+      code.line();
+    }
+    const ctxParts = ["db"];
+    if (params.length > 0 || pathParams.length > 0) ctxParts.push("params");
+    if (body.length > 0) ctxParts.push("body");
+    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("return HttpResponse.json(result);");
+    }, "} catch (error) {");
+    code.indent();
+    code.line("console.error(`Error in ${name}:`, error);");
+    code.line('const message = error instanceof Error ? error.message : "Internal server error";');
+    code.line("return HttpResponse.json({ error: message }, { status: 500 });");
+    code.dedent();
+    code.line("}");
+  }, "}),");
+  code.line();
+}
+function generateParamParsing(code, param) {
+  const { name, tsType, hasDefault } = param;
+  const defaultVal = hasDefault ? JSON.stringify(param.default) : "undefined";
+  if (tsType === "number" || tsType.includes("number")) {
+    if (hasDefault) {
+      code.line(`${name}: Number(url.searchParams.get('${name}') ?? ${defaultVal}),`);
+    } else {
+      code.line(`${name}: url.searchParams.has('${name}') ? Number(url.searchParams.get('${name}')) : undefined,`);
+    }
+  } else if (tsType === "boolean" || tsType.includes("boolean")) {
+    if (hasDefault) {
+      code.line(`${name}: url.searchParams.has('${name}') ? url.searchParams.get('${name}') === 'true' : ${defaultVal},`);
+    } else {
+      code.line(`${name}: url.searchParams.has('${name}') ? url.searchParams.get('${name}') === 'true' : undefined,`);
+    }
+  } else {
+    if (hasDefault) {
+      code.line(`${name}: url.searchParams.get('${name}') ?? ${defaultVal},`);
+    } else {
+      code.line(`${name}: url.searchParams.get('${name}') ?? undefined,`);
+    }
+  }
+}
+function generateEndpointResolvers(endpoints) {
+  const code = new CodeBuilder();
+  code.comment("GENERATED BY SCHEMOCK - DO NOT EDIT");
+  code.comment("Mock resolvers for custom endpoints");
+  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.line();
+  code.line("import type { MockResolverContext } from 'schemock/schema';");
+  code.line();
+  code.line("type ResolverFn = (ctx: MockResolverContext) => unknown | Promise<unknown>;");
+  code.line();
+  code.block("export const endpointResolvers: Record<string, ResolverFn> = {", () => {
+    for (const endpoint of endpoints) {
+      code.comment(`${endpoint.method} ${endpoint.path}`);
+      if (endpoint.description) {
+        code.comment(endpoint.description);
+      }
+      code.line(`${endpoint.name}: ${endpoint.mockResolverSource},`);
+      code.line();
+    }
+  }, "};");
+  return code.toString();
+}
+
+// src/cli/generators/supabase/client.ts
+function generateSupabaseClient(schemas, config) {
+  const code = new CodeBuilder();
+  const envPrefix = config.envPrefix ?? "NEXT_PUBLIC_SUPABASE";
+  code.comment("GENERATED BY SCHEMOCK - DO NOT EDIT");
+  code.line("import { createClient } from '@supabase/supabase-js';");
+  code.line("import type * as Types from './types';");
+  code.line();
+  code.line(`const supabaseUrl = process.env.${envPrefix}_URL!;`);
+  code.line(`const supabaseKey = process.env.${envPrefix}_ANON_KEY!;`);
+  code.line();
+  code.line("export const supabase = createClient(supabaseUrl, supabaseKey);");
+  code.line();
+  code.block("function buildSelect(include?: string[]): string {", () => {
+    code.line("if (!include?.length) return '*';");
+    code.line("return `*, ${include.map(rel => `${rel}(*)`).join(', ')}`;");
+  });
+  code.line();
+  const schemaMap = new Map(schemas.map((s) => [s.name, s]));
+  code.block("export const api = {", () => {
+    for (const schema of schemas) {
+      if (schema.isJunctionTable) continue;
+      generateSupabaseEntityApi(code, schema, config, schemaMap);
+    }
+  }, "};");
+  return code.toString();
+}
+function generateSupabaseEntityApi(code, schema, config, schemaMap) {
+  const { name, pascalName, tableName, relations } = schema;
+  const hasRelations = relations.length > 0;
+  const includeType = hasRelations ? `Types.${pascalName}Include` : "never";
+  code.block(`${name}: {`, () => {
+    code.block(
+      `list: async (options?: Types.QueryOptions<Types.${pascalName}Filter, ${includeType}>): Promise<Types.ListResponse<Types.${pascalName}>> => {`,
+      () => {
+        code.line("const select = buildSelect(options?.include);");
+        code.line(`let query = supabase.from('${tableName}').select(select, { count: 'exact' });`);
+        code.line();
+        code.block("if (options?.where) {", () => {
+          code.block("for (const [key, value] of Object.entries(options.where)) {", () => {
+            code.block('if (typeof value === "object" && value !== null) {', () => {
+              code.line("const f = value as Record<string, unknown>;");
+              code.line("if ('equals' in f) query = query.eq(key, f.equals);");
+              code.line("if ('not' in f) query = query.neq(key, f.not);");
+              code.line("if ('in' in f) query = query.in(key, f.in as unknown[]);");
+              code.line("if ('notIn' in f) query = query.not(key, 'in', `(${(f.notIn as unknown[]).join(',')})`);");
+              code.line("if ('contains' in f) query = query.ilike(key, `%${f.contains}%`);");
+              code.line("if ('startsWith' in f) query = query.ilike(key, `${f.startsWith}%`);");
+              code.line("if ('endsWith' in f) query = query.ilike(key, `%${f.endsWith}`);");
+              code.line("if ('gt' in f) query = query.gt(key, f.gt);");
+              code.line("if ('gte' in f) query = query.gte(key, f.gte);");
+              code.line("if ('lt' in f) query = query.lt(key, f.lt);");
+              code.line("if ('lte' in f) query = query.lte(key, f.lte);");
+              code.line("if ('isNull' in f) f.isNull ? query = query.is(key, null) : query = query.not(key, 'is', null);");
+            }, "} else {");
+            code.indent();
+            code.line("query = query.eq(key, value);");
+            code.dedent();
+            code.line("}");
+          });
+        });
+        code.line();
+        code.block("if (options?.orderBy) {", () => {
+          code.block("for (const [field, dir] of Object.entries(options.orderBy)) {", () => {
+            code.line("query = query.order(field, { ascending: dir === 'asc' });");
+          });
+        });
+        code.line();
+        code.line("const limit = options?.limit ?? 20;");
+        code.line("const offset = options?.offset ?? 0;");
+        code.line("query = query.range(offset, offset + limit - 1);");
+        code.line();
+        code.line("const { data, error, count } = await query;");
+        code.line("if (error) throw error;");
+        code.line();
+        code.line("return {");
+        code.line(`  data: (data || []) as Types.${pascalName}[],`);
+        code.line("  meta: { total: count || 0, limit, offset, hasMore: offset + limit < (count || 0) },");
+        code.line("};");
+      },
+      "},"
+    );
+    code.line();
+    code.block(`get: async (id: string, options?: { include?: ${includeType}[] }): Promise<Types.ItemResponse<Types.${pascalName}>> => {`, () => {
+      code.line("const select = buildSelect(options?.include);");
+      code.line(`const { data, error } = await supabase.from('${tableName}').select(select).eq('id', id).single();`);
+      code.line("if (error) throw error;");
+      code.line(`return { data: data as Types.${pascalName} };`);
+    }, "},");
+    code.line();
+    generateSupabaseCreateMethod(code, schema, config, schemaMap);
+    code.line();
+    code.block(`update: async (id: string, input: Types.${pascalName}Update): Promise<Types.ItemResponse<Types.${pascalName}>> => {`, () => {
+      code.line(`const { data, error } = await supabase.from('${tableName}').update(input).eq('id', id).select().single();`);
+      code.line("if (error) throw error;");
+      code.line(`return { data: data as Types.${pascalName} };`);
+    }, "},");
+    code.line();
+    code.block("delete: async (id: string): Promise<void> => {", () => {
+      code.line(`const { error } = await supabase.from('${tableName}').delete().eq('id', id);`);
+      code.line("if (error) throw error;");
+    }, "},");
+  }, "},");
+  code.line();
+}
+function generateSupabaseCreateMethod(code, schema, config, schemaMap) {
+  const { pascalName, tableName, relations } = schema;
+  const nestedRels = relations.filter((r) => r.type === "hasMany" || r.type === "hasOne");
+  code.block(`create: async (input: Types.${pascalName}Create): Promise<Types.ItemResponse<Types.${pascalName}>> => {`, () => {
+    if (nestedRels.length > 0) {
+      const relNames = nestedRels.map((r) => r.name).join(", ");
+      code.line(`const { ${relNames}, ...data } = input;`);
+      code.line();
+      code.line(`const { data: item, error } = await supabase.from('${tableName}').insert(data).select().single();`);
+      code.line("if (error) throw error;");
+      code.line();
+      for (const rel of nestedRels) {
+        const targetSchema = schemaMap.get(rel.target);
+        const targetTable = config.tableMap?.[rel.target] ?? targetSchema?.tableName ?? rel.target + "s";
+        code.block(`if (${rel.name}) {`, () => {
+          if (rel.type === "hasMany") {
+            code.line(`const nestedData = ${rel.name}.map(nested => ({ ...nested, ${rel.foreignKey}: item.id }));`);
+            code.line(`const { error: nestedError } = await supabase.from('${targetTable}').insert(nestedData);`);
+            code.line("if (nestedError) throw nestedError;");
+          } else {
+            code.line(`const { error: nestedError } = await supabase.from('${targetTable}').insert({ ...${rel.name}, ${rel.foreignKey}: item.id });`);
+            code.line("if (nestedError) throw nestedError;");
+          }
+        });
+      }
+      code.line();
+      code.line(`return { data: item as Types.${pascalName} };`);
+    } else {
+      code.line(`const { data, error } = await supabase.from('${tableName}').insert(input).select().single();`);
+      code.line("if (error) throw error;");
+      code.line(`return { data: data as Types.${pascalName} };`);
+    }
+  }, "},");
+}
+
+// src/cli/generators/firebase/client.ts
+function generateFirebaseClient(schemas, config) {
+  const code = new CodeBuilder();
+  code.comment("GENERATED BY SCHEMOCK - DO NOT EDIT");
+  code.line("import {");
+  code.line("  collection,");
+  code.line("  doc,");
+  code.line("  getDoc,");
+  code.line("  getDocs,");
+  code.line("  addDoc,");
+  code.line("  updateDoc,");
+  code.line("  deleteDoc,");
+  code.line("  query,");
+  code.line("  where,");
+  code.line("  orderBy,");
+  code.line("  limit as fbLimit,");
+  code.line("} from 'firebase/firestore';");
+  code.line("import type * as Types from './types';");
+  code.line();
+  code.comment("Import your Firebase instance");
+  code.line("import { db as firestore } from '../lib/firebase';");
+  code.line();
+  code.block("export const api = {", () => {
+    for (const schema of schemas) {
+      if (schema.isJunctionTable) continue;
+      generateFirebaseEntityApi(code, schema, config, schemas);
+    }
+  }, "};");
+  return code.toString();
+}
+function generateFirebaseEntityApi(code, schema, config, allSchemas) {
+  const { name, pascalName, relations } = schema;
+  const collectionName = config.collectionMap?.[name] ?? schema.pluralName;
+  const hasRelations = relations.length > 0;
+  const includeType = hasRelations ? `Types.${pascalName}Include` : "never";
+  new Map(allSchemas.map((s) => [s.name, s]));
+  code.block(`${name}: {`, () => {
+    code.block(
+      `list: async (options?: Types.QueryOptions<Types.${pascalName}Filter, ${includeType}>): Promise<Types.ListResponse<Types.${pascalName}>> => {`,
+      () => {
+        code.line(`let q = query(collection(firestore, '${collectionName}'));`);
+        code.line();
+        code.block("if (options?.where) {", () => {
+          code.block("for (const [key, value] of Object.entries(options.where)) {", () => {
+            code.block('if (typeof value === "object" && value !== null) {', () => {
+              code.line("const f = value as Record<string, unknown>;");
+              code.line("if ('equals' in f) q = query(q, where(key, '==', f.equals));");
+              code.line("if ('not' in f) q = query(q, where(key, '!=', f.not));");
+              code.line("if ('gt' in f) q = query(q, where(key, '>', f.gt));");
+              code.line("if ('gte' in f) q = query(q, where(key, '>=', f.gte));");
+              code.line("if ('lt' in f) q = query(q, where(key, '<', f.lt));");
+              code.line("if ('lte' in f) q = query(q, where(key, '<=', f.lte));");
+              code.line("if ('in' in f) q = query(q, where(key, 'in', f.in));");
+              code.line("if ('notIn' in f) q = query(q, where(key, 'not-in', f.notIn));");
+              code.comment("Note: contains/startsWith/endsWith require compound indexes in Firebase");
+              code.line("if ('contains' in f) q = query(q, where(key, '>=', f.contains), where(key, '<=', f.contains + '\\uf8ff'));");
+              code.line("if ('startsWith' in f) q = query(q, where(key, '>=', f.startsWith), where(key, '<=', f.startsWith + '\\uf8ff'));");
+            }, "} else {");
+            code.indent();
+            code.line("q = query(q, where(key, '==', value));");
+            code.dedent();
+            code.line("}");
+          });
+        });
+        code.line();
+        code.block("if (options?.orderBy) {", () => {
+          code.block("for (const [field, dir] of Object.entries(options.orderBy)) {", () => {
+            code.line("q = query(q, orderBy(field, dir as 'asc' | 'desc'));");
+          });
+        });
+        code.line();
+        code.line("const queryLimit = options?.limit ?? 20;");
+        code.line("const queryOffset = options?.offset ?? 0;");
+        code.comment("Fetch limit + offset to enable client-side offset");
+        code.line("q = query(q, fbLimit(queryLimit + queryOffset));");
+        code.line();
+        code.line("const snapshot = await getDocs(q);");
+        code.line(`let allItems = snapshot.docs.map(d => ({ id: d.id, ...d.data() })) as Types.${pascalName}[];`);
+        code.line("const total = allItems.length;");
+        code.comment("Apply client-side offset");
+        code.line("let items = allItems.slice(queryOffset, queryOffset + queryLimit);");
+        code.line();
+        if (hasRelations) {
+          code.block("if (options?.include?.length) {", () => {
+            code.block("items = await Promise.all(items.map(async (item) => {", () => {
+              code.line("const result = { ...item } as Record<string, unknown>;");
+              for (const rel of relations) {
+                code.block(`if (options.include!.includes('${rel.name}')) {`, () => {
+                  generateFirebaseRelationLoad(code, schema, rel, config);
+                });
+              }
+              code.line(`return result as Types.${pascalName};`);
+            }, "}));");
+          });
+        }
+        code.line();
+        code.line("return {");
+        code.line("  data: items,");
+        code.line("  meta: { total, limit: queryLimit, offset: queryOffset, hasMore: queryOffset + queryLimit < total },");
+        code.line("};");
+      },
+      "},"
+    );
+    code.line();
+    code.block(`get: async (id: string, options?: { include?: ${includeType}[] }): Promise<Types.ItemResponse<Types.${pascalName}>> => {`, () => {
+      code.line(`const docRef = doc(firestore, '${collectionName}', id);`);
+      code.line("const snapshot = await getDoc(docRef);");
+      code.line(`if (!snapshot.exists()) throw new Error('${pascalName} not found');`);
+      code.line(`let item = { id: snapshot.id, ...snapshot.data() } as Types.${pascalName};`);
+      if (hasRelations) {
+        code.line();
+        code.block("if (options?.include?.length) {", () => {
+          code.line("const result = { ...item } as Record<string, unknown>;");
+          for (const rel of relations) {
+            code.block(`if (options.include.includes('${rel.name}')) {`, () => {
+              generateFirebaseRelationLoad(code, schema, rel, config);
+            });
+          }
+          code.line(`item = result as Types.${pascalName};`);
+        });
+      }
+      code.line();
+      code.line("return { data: item };");
+    }, "},");
+    code.line();
+    generateFirebaseCreateMethod(code, schema, collectionName, config, allSchemas);
+    code.line();
+    code.block(`update: async (id: string, input: Types.${pascalName}Update): Promise<Types.ItemResponse<Types.${pascalName}>> => {`, () => {
+      code.line(`const docRef = doc(firestore, '${collectionName}', id);`);
+      code.line("await updateDoc(docRef, { ...input, updatedAt: new Date() });");
+      code.line("const snapshot = await getDoc(docRef);");
+      code.line(`return { data: { id: snapshot.id, ...snapshot.data() } as Types.${pascalName} };`);
+    }, "},");
+    code.line();
+    code.block("delete: async (id: string): Promise<void> => {", () => {
+      code.line(`await deleteDoc(doc(firestore, '${collectionName}', id));`);
+    }, "},");
+  }, "},");
+  code.line();
+}
+function generateFirebaseCreateMethod(code, schema, collectionName, config, allSchemas) {
+  const { pascalName, relations } = schema;
+  const nestedRels = relations.filter((r) => r.type === "hasMany" || r.type === "hasOne");
+  const schemaMap = new Map(allSchemas.map((s) => [s.name, s]));
+  const getTargetCollection = (targetName) => {
+    const targetSchema = schemaMap.get(targetName);
+    return config.collectionMap?.[targetName] ?? targetSchema?.pluralName ?? targetName + "s";
+  };
+  code.block(`create: async (input: Types.${pascalName}Create): Promise<Types.ItemResponse<Types.${pascalName}>> => {`, () => {
+    if (nestedRels.length > 0) {
+      const relNames = nestedRels.map((r) => r.name).join(", ");
+      code.line(`const { ${relNames}, ...data } = input;`);
+      code.line("const withTimestamps = { ...data, createdAt: new Date(), updatedAt: new Date() };");
+      code.line(`const docRef = await addDoc(collection(firestore, '${collectionName}'), withTimestamps);`);
+      code.line(`const item = { id: docRef.id, ...withTimestamps } as Types.${pascalName};`);
+      code.line();
+      for (const rel of nestedRels) {
+        const targetCollection = getTargetCollection(rel.target);
+        code.block(`if (${rel.name}) {`, () => {
+          if (rel.type === "hasMany") {
+            code.block(`for (const nested of ${rel.name}) {`, () => {
+              code.line(`const nestedData = { ...nested, ${rel.foreignKey}: item.id, createdAt: new Date(), updatedAt: new Date() };`);
+              code.line(`await addDoc(collection(firestore, '${targetCollection}'), nestedData);`);
+            });
+          } else {
+            code.line(`const nestedData = { ...${rel.name}, ${rel.foreignKey}: item.id, createdAt: new Date(), updatedAt: new Date() };`);
+            code.line(`await addDoc(collection(firestore, '${targetCollection}'), nestedData);`);
+          }
+        });
+      }
+      code.line();
+      code.line("return { data: item };");
+    } else {
+      code.line("const data = { ...input, createdAt: new Date(), updatedAt: new Date() };");
+      code.line(`const docRef = await addDoc(collection(firestore, '${collectionName}'), data);`);
+      code.line(`return { data: { id: docRef.id, ...data } as Types.${pascalName} };`);
+    }
+  }, "},");
+}
+function generateFirebaseRelationLoad(code, schema, rel, config, allSchemas) {
+  const schemaMap = /* @__PURE__ */ new Map();
+  const getCollection = (targetName) => {
+    const targetSchema = schemaMap.get(targetName);
+    return config.collectionMap?.[targetName] ?? targetSchema?.pluralName ?? targetName + "s";
+  };
+  const targetCollection = getCollection(rel.target);
+  if (rel.type === "hasMany") {
+    code.line(`const ${rel.name}Query = query(`);
+    code.line(`  collection(firestore, '${targetCollection}'),`);
+    code.line(`  where('${rel.foreignKey}', '==', item.id)`);
+    code.line(");");
+    code.line(`const ${rel.name}Snapshot = await getDocs(${rel.name}Query);`);
+    code.line(`result.${rel.name} = ${rel.name}Snapshot.docs.map(d => ({ id: d.id, ...d.data() }));`);
+  } else if (rel.type === "hasOne") {
+    code.line(`const ${rel.name}Query = query(`);
+    code.line(`  collection(firestore, '${targetCollection}'),`);
+    code.line(`  where('${rel.foreignKey}', '==', item.id),`);
+    code.line("  fbLimit(1)");
+    code.line(");");
+    code.line(`const ${rel.name}Snapshot = await getDocs(${rel.name}Query);`);
+    code.line(`result.${rel.name} = ${rel.name}Snapshot.docs[0] ? { id: ${rel.name}Snapshot.docs[0].id, ...${rel.name}Snapshot.docs[0].data() } : null;`);
+  } else if (rel.type === "belongsTo") {
+    code.line(`const ${rel.name}Ref = doc(firestore, '${targetCollection}', (item as Record<string, unknown>).${rel.localField} as string);`);
+    code.line(`const ${rel.name}Snapshot = await getDoc(${rel.name}Ref);`);
+    code.line(`result.${rel.name} = ${rel.name}Snapshot.exists() ? { id: ${rel.name}Snapshot.id, ...${rel.name}Snapshot.data() } : null;`);
+  } else if (rel.type === "manyToMany" && rel.through) {
+    const throughCollection = getCollection(rel.through);
+    code.comment("Load manyToMany via junction collection");
+    code.line(`const junctionQuery = query(`);
+    code.line(`  collection(firestore, '${throughCollection}'),`);
+    code.line(`  where('${rel.foreignKey}', '==', item.id)`);
+    code.line(");");
+    code.line(`const junctionSnapshot = await getDocs(junctionQuery);`);
+    code.line(`const relatedIds = junctionSnapshot.docs.map(d => (d.data() as Record<string, unknown>).${rel.otherKey}) as string[];`);
+    code.line();
+    code.block("if (relatedIds.length > 0) {", () => {
+      code.comment("Firebase in query limited to 10 items, batch if needed");
+      code.line(`const ${rel.name}Results: unknown[] = [];`);
+      code.block("for (let i = 0; i < relatedIds.length; i += 10) {", () => {
+        code.line("const batch = relatedIds.slice(i, i + 10);");
+        code.line(`const batchQuery = query(`);
+        code.line(`  collection(firestore, '${targetCollection}'),`);
+        code.line("  where('__name__', 'in', batch)");
+        code.line(");");
+        code.line("const batchSnapshot = await getDocs(batchQuery);");
+        code.line(`${rel.name}Results.push(...batchSnapshot.docs.map(d => ({ id: d.id, ...d.data() })));`);
+      });
+      code.line(`result.${rel.name} = ${rel.name}Results;`);
+    }, "} else {");
+    code.indent();
+    code.line(`result.${rel.name} = [];`);
+    code.dedent();
+    code.line("}");
+  }
+}
+
+// src/cli/generators/fetch/client.ts
+function generateFetchClient(schemas, config) {
+  const code = new CodeBuilder();
+  const baseUrl = config.baseUrl ?? "";
+  code.comment("GENERATED BY SCHEMOCK - DO NOT EDIT");
+  code.line("import type * as Types from './types';");
+  code.line();
+  code.line(`const BASE_URL = '${baseUrl}';`);
+  code.line();
+  code.block("async function request<T>(path: string, options?: RequestInit): Promise<T> {", () => {
+    code.line("const response = await fetch(`${BASE_URL}${path}`, {");
+    code.line("  headers: { 'Content-Type': 'application/json', ...options?.headers },");
+    code.line("  ...options,");
+    code.line("});");
+    code.line("if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);");
+    code.line("if (response.status === 204) return undefined as T;");
+    code.line("return response.json();");
+  });
+  code.line();
+  code.block("function buildQuery(options?: Record<string, unknown>): string {", () => {
+    code.line("if (!options) return '';");
+    code.line("const params = new URLSearchParams();");
+    code.block("for (const [key, value] of Object.entries(options)) {", () => {
+      code.line("if (value !== undefined) {");
+      code.line("  params.set(key, typeof value === 'object' ? JSON.stringify(value) : String(value));");
+      code.line("}");
+    });
+    code.line("const str = params.toString();");
+    code.line("return str ? `?${str}` : '';");
+  });
+  code.line();
+  code.block("export const api = {", () => {
+    for (const schema of schemas) {
+      if (schema.isJunctionTable) continue;
+      generateFetchEntityApi(code, schema);
+    }
+  }, "};");
+  return code.toString();
+}
+function generateFetchEntityApi(code, schema) {
+  const { name, pascalName, endpoint, relations } = schema;
+  const hasRelations = relations.length > 0;
+  const includeType = hasRelations ? `Types.${pascalName}Include` : "never";
+  code.block(`${name}: {`, () => {
+    code.block(
+      `list: async (options?: Types.QueryOptions<Types.${pascalName}Filter, ${includeType}>): Promise<Types.ListResponse<Types.${pascalName}>> => {`,
+      () => {
+        code.line(`return request('${endpoint}' + buildQuery(options));`);
+      },
+      "},"
+    );
+    code.line();
+    code.block(`get: async (id: string, options?: { include?: ${includeType}[] }): Promise<Types.ItemResponse<Types.${pascalName}>> => {`, () => {
+      code.line(`return request(\`${endpoint}/\${id}\` + buildQuery(options));`);
+    }, "},");
+    code.line();
+    code.block(`create: async (input: Types.${pascalName}Create): Promise<Types.ItemResponse<Types.${pascalName}>> => {`, () => {
+      code.line(`return request('${endpoint}', {`);
+      code.line("  method: 'POST',");
+      code.line("  body: JSON.stringify(input),");
+      code.line("});");
+    }, "},");
+    code.line();
+    code.block(`update: async (id: string, input: Types.${pascalName}Update): Promise<Types.ItemResponse<Types.${pascalName}>> => {`, () => {
+      code.line(`return request(\`${endpoint}/\${id}\`, {`);
+      code.line("  method: 'PUT',");
+      code.line("  body: JSON.stringify(input),");
+      code.line("});");
+    }, "},");
+    code.line();
+    code.block(`patch: async (id: string, input: Types.${pascalName}Update): Promise<Types.ItemResponse<Types.${pascalName}>> => {`, () => {
+      code.line(`return request(\`${endpoint}/\${id}\`, {`);
+      code.line("  method: 'PATCH',");
+      code.line("  body: JSON.stringify(input),");
+      code.line("});");
+    }, "},");
+    code.line();
+    code.block("delete: async (id: string): Promise<void> => {", () => {
+      code.line(`await request(\`${endpoint}/\${id}\`, { method: 'DELETE' });`);
+    }, "},");
+  }, "},");
+  code.line();
+}
+
+// src/cli/generators/pglite/db.ts
+function mapToPostgresType(field) {
+  if (field.name === "id") return "UUID PRIMARY KEY DEFAULT gen_random_uuid()";
+  if (field.isEnum && field.enumValues?.length) {
+    const enumValues = field.enumValues.map((v) => `'${v}'`).join(", ");
+    return `TEXT CHECK (${field.name} IN (${enumValues}))`;
+  }
+  if (field.isArray || field.isObject) {
+    return field.nullable ? "JSONB" : "JSONB NOT NULL";
+  }
+  if (field.isRef) {
+    return field.nullable ? "UUID" : "UUID NOT NULL";
+  }
+  let pgType;
+  switch (field.type) {
+    case "uuid":
+      pgType = "UUID";
+      break;
+    case "string":
+    case "text":
+      pgType = "TEXT";
+      break;
+    case "email":
+      pgType = "TEXT";
+      break;
+    case "url":
+      pgType = "TEXT";
+      break;
+    case "number":
+    case "float":
+      pgType = "DOUBLE PRECISION";
+      break;
+    case "int":
+    case "integer":
+      pgType = "INTEGER";
+      break;
+    case "boolean":
+      pgType = "BOOLEAN";
+      break;
+    case "date":
+    case "datetime":
+      pgType = "TIMESTAMPTZ";
+      break;
+    case "json":
+      pgType = "JSONB";
+      break;
+    default:
+      pgType = "TEXT";
+  }
+  const constraints = [];
+  if (!field.nullable && field.name !== "id") {
+    constraints.push("NOT NULL");
+  }
+  if (field.unique) {
+    constraints.push("UNIQUE");
+  }
+  if (field.hasDefault && field.defaultValue !== void 0) {
+    const defaultVal = formatDefaultValue(field);
+    if (defaultVal) {
+      constraints.push(`DEFAULT ${defaultVal}`);
+    }
+  }
+  return constraints.length > 0 ? `${pgType} ${constraints.join(" ")}` : pgType;
+}
+function formatDefaultValue(field) {
+  const val = field.defaultValue;
+  if (val === null) return "NULL";
+  if (typeof val === "boolean") return val ? "TRUE" : "FALSE";
+  if (typeof val === "number") return String(val);
+  if (typeof val === "string") return `'${val.replace(/'/g, "''")}'`;
+  if (val instanceof Date) return `'${val.toISOString()}'`;
+  if (typeof val === "object") return `'${JSON.stringify(val).replace(/'/g, "''")}'::jsonb`;
+  return null;
+}
+function generateCreateTable(schema) {
+  const lines = [`CREATE TABLE IF NOT EXISTS "${schema.tableName}" (`];
+  const columns = [];
+  for (const field of schema.fields) {
+    const pgType = mapToPostgresType(field);
+    columns.push(`  "${field.name}" ${pgType}`);
+  }
+  lines.push(columns.join(",\n"));
+  lines.push(");");
+  return lines.join("\n");
+}
+function generateForeignKeys(schema, allSchemas) {
+  const fks = [];
+  for (const field of schema.fields) {
+    if (field.isRef && field.refTarget) {
+      const targetSchema = allSchemas.find((s) => s.name === field.refTarget);
+      if (targetSchema) {
+        fks.push(
+          `ALTER TABLE "${schema.tableName}" ADD CONSTRAINT "fk_${schema.tableName}_${field.name}" FOREIGN KEY ("${field.name}") REFERENCES "${targetSchema.tableName}"("id") ON DELETE CASCADE;`
+        );
+      }
+    }
+  }
+  return fks;
+}
+function generateIndexes(schema) {
+  const indexes = [];
+  for (const field of schema.fields) {
+    if (field.isRef) {
+      indexes.push(
+        `CREATE INDEX IF NOT EXISTS "idx_${schema.tableName}_${field.name}" ON "${schema.tableName}"("${field.name}");`
+      );
+    }
+  }
+  return indexes;
+}
+function generateRLSPolicies(schema) {
+  const { tableName, rls } = schema;
+  const policies = [];
+  if (!rls.enabled) {
+    return policies;
+  }
+  policies.push(`ALTER TABLE "${tableName}" ENABLE ROW LEVEL SECURITY;`);
+  policies.push(`ALTER TABLE "${tableName}" FORCE ROW LEVEL SECURITY;`);
+  const operations = ["SELECT", "INSERT", "UPDATE", "DELETE"];
+  const opHas = {
+    SELECT: rls.hasSelect,
+    INSERT: rls.hasInsert,
+    UPDATE: rls.hasUpdate,
+    DELETE: rls.hasDelete
+  };
+  for (const op of operations) {
+    if (!opHas[op]) continue;
+    const opLower = op.toLowerCase();
+    const customSql = rls.sql?.[opLower];
+    if (customSql) {
+      policies.push(
+        `CREATE POLICY "${tableName}_${opLower}_policy" ON "${tableName}" FOR ${op} USING (${customSql});`
+      );
+    } else if (rls.scope.length > 0) {
+      const conditions = [];
+      for (const bypass of rls.bypass) {
+        const valuesStr = bypass.values.map((v) => `'${v}'`).join(", ");
+        conditions.push(`current_setting('app.${bypass.contextKey}', true) IN (${valuesStr})`);
+      }
+      for (const mapping of rls.scope) {
+        conditions.push(`"${mapping.field}" = current_setting('app.${mapping.contextKey}', true)::uuid`);
+      }
+      const condition = conditions.length > 1 ? conditions.map((c, i) => i === 0 && rls.bypass.length > 0 ? c : `(${c})`).join(" OR ") : conditions[0] || "true";
+      policies.push(
+        `CREATE POLICY "${tableName}_${opLower}_policy" ON "${tableName}" FOR ${op} USING (${condition});`
+      );
+    }
+  }
+  return policies;
+}
+function generatePGliteDb(schemas, config) {
+  const code = new CodeBuilder();
+  code.comment("GENERATED BY SCHEMOCK - DO NOT EDIT");
+  code.line("import { PGlite } from '@electric-sql/pglite';");
+  code.line();
+  const storage = config.persistence === "memory" ? void 0 : config.dataDir || "idb://schemock-db";
+  code.comment("Database instance");
+  if (storage) {
+    code.line(`export const db = new PGlite('${storage}');`);
+  } else {
+    code.line("export const db = new PGlite();");
+  }
+  code.line();
+  code.comment("SQL Schema");
+  code.line("const schema = `");
+  code.raw('CREATE EXTENSION IF NOT EXISTS "pgcrypto";');
+  code.raw("");
+  for (const schema of schemas) {
+    code.raw(generateCreateTable(schema));
+    code.raw("");
+  }
+  const allFKs = [];
+  for (const schema of schemas) {
+    allFKs.push(...generateForeignKeys(schema, schemas));
+  }
+  if (allFKs.length > 0) {
+    code.raw("-- Foreign Keys");
+    for (const fk of allFKs) {
+      code.raw(fk);
+    }
+    code.raw("");
+  }
+  const allIndexes = [];
+  for (const schema of schemas) {
+    allIndexes.push(...generateIndexes(schema));
+  }
+  if (allIndexes.length > 0) {
+    code.raw("-- Indexes");
+    for (const idx of allIndexes) {
+      code.raw(idx);
+    }
+    code.raw("");
+  }
+  const allPolicies = [];
+  for (const schema of schemas) {
+    allPolicies.push(...generateRLSPolicies(schema));
+  }
+  if (allPolicies.length > 0) {
+    code.raw("-- Row-Level Security Policies");
+    for (const policy of allPolicies) {
+      code.raw(policy);
+    }
+  }
+  code.line("`;");
+  code.line();
+  code.comment("Initialize database schema");
+  code.line("let initialized = false;");
+  code.line();
+  code.block("export async function initDb(): Promise<void> {", () => {
+    code.line("if (initialized) return;");
+    code.line("await db.exec(schema);");
+    code.line("initialized = true;");
+  });
+  code.line();
+  code.comment("Reset database (drop and recreate all tables)");
+  code.block("export async function resetDb(): Promise<void> {", () => {
+    code.line("const dropSql = [");
+    for (const schema of [...schemas].reverse()) {
+      code.line(`  'DROP TABLE IF EXISTS "${schema.tableName}" CASCADE',`);
+    }
+    code.line('].join(";\\n");');
+    code.line();
+    code.line("await db.exec(dropSql);");
+    code.line("initialized = false;");
+    code.line("await initDb();");
+  });
+  code.line();
+  code.comment("Table name mapping");
+  code.block("export const tables = {", () => {
+    for (const schema of schemas) {
+      code.line(`${schema.name}: '${schema.tableName}',`);
+    }
+  }, "} as const;");
+  code.line();
+  code.line("export type TableName = keyof typeof tables;");
+  code.line();
+  const hasRLS = schemas.some((s) => s.rls.enabled);
+  if (hasRLS) {
+    generateRLSHelpers(code);
+  }
+  return code.toString();
+}
+function generateRLSHelpers(code) {
+  code.comment("Row-Level Security Context (generic key-value)");
+  code.block("export interface RLSContext {", () => {
+    code.line("[key: string]: unknown;");
+  }, "}");
+  code.line();
+  code.comment("Set context for RLS (sets PostgreSQL session variables)");
+  code.block("export async function setContext(ctx: RLSContext | null): Promise<void> {", () => {
+    code.block("if (ctx) {", () => {
+      code.block("for (const [key, value] of Object.entries(ctx)) {", () => {
+        code.line("if (value !== undefined && value !== null) {");
+        code.line("  await db.exec(`SET LOCAL app.${key} = '${value}'`);");
+        code.line("}");
+      });
+    }, "} else {");
+    code.indent();
+    code.comment("Reset all app.* settings would require knowing which keys were set");
+    code.comment("For simplicity, start a new transaction instead");
+    code.dedent();
+    code.line("}");
+  });
+  code.line();
+  code.comment("Execute a function with context (transaction-scoped)");
+  code.block("export async function withContext<T>(ctx: RLSContext, fn: () => Promise<T>): Promise<T> {", () => {
+    code.line("await db.exec('BEGIN');");
+    code.block("try {", () => {
+      code.line("await setContext(ctx);");
+      code.line("const result = await fn();");
+      code.line("await db.exec('COMMIT');");
+      code.line("return result;");
+    }, "} catch (e) {");
+    code.indent();
+    code.line("await db.exec('ROLLBACK');");
+    code.line("throw e;");
+    code.dedent();
+    code.line("}");
+  });
+  code.line();
+  code.comment("RLS Error class");
+  code.block("export class RLSError extends Error {", () => {
+    code.line("readonly code = 'RLS_DENIED';");
+    code.block("constructor(message: string) {", () => {
+      code.line("super(message);");
+      code.line("this.name = 'RLSError';");
+    });
+  }, "}");
+}
+
+// src/cli/generators/pglite/client.ts
+function generatePGliteClient(schemas) {
+  const code = new CodeBuilder();
+  code.comment("GENERATED BY SCHEMOCK - DO NOT EDIT");
+  code.line("import { db, initDb, tables } from './db';");
+  code.line("import type * as Types from './types';");
+  code.line();
+  generateQueryHelpers(code);
+  code.line();
+  code.block("export const api = {", () => {
+    for (const schema of schemas) {
+      if (schema.isJunctionTable) continue;
+      generateEntityApi2(code, schema, schemas);
+    }
+  }, "};");
+  return code.toString();
+}
+function generateQueryHelpers(code) {
+  code.comment("Build WHERE clause from filter object");
+  code.block(
+    "function buildWhere(filter: Record<string, unknown>, params: unknown[], startIndex = 1): { sql: string; nextIndex: number } {",
+    () => {
+      code.line("const conditions: string[] = [];");
+      code.line("let paramIndex = startIndex;");
+      code.line();
+      code.block("for (const [key, value] of Object.entries(filter)) {", () => {
+        code.block('if (typeof value === "object" && value !== null) {', () => {
+          code.line("const f = value as Record<string, unknown>;");
+          code.line();
+          code.block("if ('equals' in f) {", () => {
+            code.line('conditions.push(`"${key}" = $${paramIndex++}`);');
+            code.line("params.push(f.equals);");
+          });
+          code.block("if ('not' in f) {", () => {
+            code.line('conditions.push(`"${key}" != $${paramIndex++}`);');
+            code.line("params.push(f.not);");
+          });
+          code.block("if ('in' in f) {", () => {
+            code.line("const arr = f.in as unknown[];");
+            code.line('const placeholders = arr.map(() => `$${paramIndex++}`).join(", ");');
+            code.line('conditions.push(`"${key}" IN (${placeholders})`);');
+            code.line("params.push(...arr);");
+          });
+          code.block("if ('notIn' in f) {", () => {
+            code.line("const arr = f.notIn as unknown[];");
+            code.line('const placeholders = arr.map(() => `$${paramIndex++}`).join(", ");');
+            code.line('conditions.push(`"${key}" NOT IN (${placeholders})`);');
+            code.line("params.push(...arr);");
+          });
+          code.block("if ('contains' in f) {", () => {
+            code.line('conditions.push(`"${key}" ILIKE $${paramIndex++}`);');
+            code.line("params.push(`%${f.contains}%`);");
+          });
+          code.block("if ('startsWith' in f) {", () => {
+            code.line('conditions.push(`"${key}" ILIKE $${paramIndex++}`);');
+            code.line("params.push(`${f.startsWith}%`);");
+          });
+          code.block("if ('endsWith' in f) {", () => {
+            code.line('conditions.push(`"${key}" ILIKE $${paramIndex++}`);');
+            code.line("params.push(`%${f.endsWith}`);");
+          });
+          code.block("if ('gt' in f) {", () => {
+            code.line('conditions.push(`"${key}" > $${paramIndex++}`);');
+            code.line("params.push(f.gt);");
+          });
+          code.block("if ('lt' in f) {", () => {
+            code.line('conditions.push(`"${key}" < $${paramIndex++}`);');
+            code.line("params.push(f.lt);");
+          });
+          code.block("if ('gte' in f) {", () => {
+            code.line('conditions.push(`"${key}" >= $${paramIndex++}`);');
+            code.line("params.push(f.gte);");
+          });
+          code.block("if ('lte' in f) {", () => {
+            code.line('conditions.push(`"${key}" <= $${paramIndex++}`);');
+            code.line("params.push(f.lte);");
+          });
+          code.block("if ('isNull' in f) {", () => {
+            code.line('conditions.push(f.isNull ? `"${key}" IS NULL` : `"${key}" IS NOT NULL`);');
+          });
+        }, "} else {");
+        code.indent();
+        code.line('conditions.push(`"${key}" = $${paramIndex++}`);');
+        code.line("params.push(value);");
+        code.dedent();
+        code.line("}");
+      });
+      code.line();
+      code.line("return { sql: conditions.length ? conditions.join(' AND ') : '1=1', nextIndex: paramIndex };");
+    }
+  );
+  code.line();
+  code.comment("Build ORDER BY clause");
+  code.block('function buildOrderBy(orderBy?: Record<string, "asc" | "desc">): string {', () => {
+    code.line('if (!orderBy) return "";');
+    code.line('const clauses = Object.entries(orderBy).map(([key, dir]) => `"${key}" ${dir.toUpperCase()}`);');
+    code.line('return clauses.length ? `ORDER BY ${clauses.join(", ")}` : "";');
+  });
+  code.line();
+  code.comment("Parse JSONB fields in result");
+  code.block(
+    "function parseRow<T>(row: Record<string, unknown>, jsonFields: string[]): T {",
+    () => {
+      code.line("const result = { ...row };");
+      code.block("for (const field of jsonFields) {", () => {
+        code.block('if (result[field] && typeof result[field] === "string") {', () => {
+          code.block("try {", () => {
+            code.line("result[field] = JSON.parse(result[field] as string);");
+          }, "} catch { /* keep as string */ }");
+        });
+      });
+      code.line("return result as T;");
+    }
+  );
+}
+function generateEntityApi2(code, schema, allSchemas) {
+  const { name, pascalName, tableName, relations, fields } = schema;
+  const hasRelations = relations.length > 0;
+  const includeType = hasRelations ? `Types.${pascalName}Include` : "never";
+  const jsonFields = fields.filter((f) => f.isArray || f.isObject).map((f) => f.name);
+  code.block(`${name}: {`, () => {
+    code.block(
+      `list: async (options?: Types.QueryOptions<Types.${pascalName}Filter, ${includeType}>): Promise<Types.ListResponse<Types.${pascalName}>> => {`,
+      () => {
+        code.line("await initDb();");
+        code.line("const params: unknown[] = [];");
+        code.line("let paramIndex = 1;");
+        code.line();
+        code.line('let whereClause = "1=1";');
+        code.block("if (options?.where) {", () => {
+          code.line("const { sql, nextIndex } = buildWhere(options.where, params);");
+          code.line("whereClause = sql;");
+          code.line("paramIndex = nextIndex;");
+        });
+        code.line();
+        code.line(`const countResult = await db.query<{ count: string }>(`);
+        code.line(`  \`SELECT COUNT(*) as count FROM "${tableName}" WHERE \${whereClause}\`,`);
+        code.line("  params");
+        code.line(");");
+        code.line("const total = parseInt(countResult.rows[0].count, 10);");
+        code.line();
+        code.line("const orderBy = buildOrderBy(options?.orderBy);");
+        code.line("const limit = options?.limit ?? 20;");
+        code.line("const offset = options?.offset ?? 0;");
+        code.line();
+        code.line(`const result = await db.query<Types.${pascalName}>(`);
+        code.line(`  \`SELECT * FROM "${tableName}" WHERE \${whereClause} \${orderBy} LIMIT \${limit} OFFSET \${offset}\`,`);
+        code.line("  params");
+        code.line(");");
+        code.line();
+        if (jsonFields.length > 0) {
+          const jsonFieldsStr = jsonFields.map((f) => `'${f}'`).join(", ");
+          code.line(`let items = result.rows.map(row => parseRow<Types.${pascalName}>(row as Record<string, unknown>, [${jsonFieldsStr}]));`);
+        } else {
+          code.line("let items = result.rows;");
+        }
+        code.line();
+        if (hasRelations) {
+          code.block("if (options?.include?.length) {", () => {
+            code.block("items = await Promise.all(items.map(async (item) => {", () => {
+              code.line("const result = { ...item } as Record<string, unknown>;");
+              for (const rel of relations) {
+                code.block(`if (options.include!.includes('${rel.name}')) {`, () => {
+                  generateRelationLoad2(code, schema, rel, allSchemas);
+                });
+              }
+              code.line(`return result as Types.${pascalName};`);
+            }, "}));");
+          });
+          code.line();
+        }
+        code.line("return { data: items, meta: { total, limit, offset, hasMore: offset + limit < total } };");
+      },
+      "},"
+    );
+    code.line();
+    code.block(
+      `get: async (id: string, options?: { include?: ${includeType}[] }): Promise<Types.ItemResponse<Types.${pascalName}>> => {`,
+      () => {
+        code.line("await initDb();");
+        code.line();
+        code.line(`const result = await db.query<Types.${pascalName}>(`);
+        code.line(`  \`SELECT * FROM "${tableName}" WHERE "id" = $1\`,`);
+        code.line("  [id]");
+        code.line(");");
+        code.line();
+        code.line(`if (result.rows.length === 0) throw new Error('${pascalName} not found');`);
+        code.line();
+        if (jsonFields.length > 0) {
+          const jsonFieldsStr = jsonFields.map((f) => `'${f}'`).join(", ");
+          code.line(`let item = parseRow<Types.${pascalName}>(result.rows[0] as Record<string, unknown>, [${jsonFieldsStr}]);`);
+        } else {
+          code.line("let item = result.rows[0];");
+        }
+        code.line();
+        if (hasRelations) {
+          code.line("const resultObj = { ...item } as Record<string, unknown>;");
+          code.line();
+          code.block("if (options?.include?.length) {", () => {
+            for (const rel of relations) {
+              code.block(`if (options.include.includes('${rel.name}')) {`, () => {
+                generateRelationLoad2(code, schema, rel, allSchemas, "resultObj", "item");
+              });
+            }
+          });
+          code.line();
+          code.line(`return { data: resultObj as Types.${pascalName} };`);
+        } else {
+          code.line("return { data: item };");
+        }
+      },
+      "},"
+    );
+    code.line();
+    generateCreateMethod2(code, schema, allSchemas);
+    code.line();
+    code.block(
+      `update: async (id: string, input: Types.${pascalName}Update): Promise<Types.ItemResponse<Types.${pascalName}>> => {`,
+      () => {
+        code.line("await initDb();");
+        code.line();
+        code.line("const data = { ...input, updatedAt: new Date() };");
+        code.line("const fields = Object.keys(data);");
+        code.line("const values = Object.values(data);");
+        code.line();
+        code.line('const setClauses = fields.map((f, i) => `"${f}" = $${i + 1}`).join(", ");');
+        code.line();
+        code.line(`const result = await db.query<Types.${pascalName}>(`);
+        code.line(`  \`UPDATE "${tableName}" SET \${setClauses} WHERE "id" = $\${fields.length + 1} RETURNING *\`,`);
+        code.line("  [...values, id]");
+        code.line(");");
+        code.line();
+        code.line(`if (result.rows.length === 0) throw new Error('${pascalName} not found');`);
+        if (jsonFields.length > 0) {
+          const jsonFieldsStr = jsonFields.map((f) => `'${f}'`).join(", ");
+          code.line(`return { data: parseRow<Types.${pascalName}>(result.rows[0] as Record<string, unknown>, [${jsonFieldsStr}]) };`);
+        } else {
+          code.line("return { data: result.rows[0] };");
+        }
+      },
+      "},"
+    );
+    code.line();
+    code.block("delete: async (id: string): Promise<void> => {", () => {
+      code.line("await initDb();");
+      code.line();
+      code.line(`const result = await db.query(`);
+      code.line(`  \`DELETE FROM "${tableName}" WHERE "id" = $1 RETURNING "id"\`,`);
+      code.line("  [id]");
+      code.line(");");
+      code.line();
+      code.line(`if (result.rows.length === 0) throw new Error('${pascalName} not found');`);
+    }, "},");
+  }, "},");
+  code.line();
+}
+function generateRelationLoad2(code, schema, rel, allSchemas, resultVar = "result", itemVar = "item") {
+  const targetSchema = allSchemas.find((s) => s.name === rel.target);
+  if (!targetSchema) return;
+  if (rel.type === "hasMany") {
+    code.line(`const ${rel.name}Result = await db.query(`);
+    code.line(`  \`SELECT * FROM "${targetSchema.tableName}" WHERE "${rel.foreignKey}" = $1\`,`);
+    code.line(`  [${itemVar}.id]`);
+    code.line(");");
+    code.line(`${resultVar}.${rel.name} = ${rel.name}Result.rows;`);
+  } else if (rel.type === "hasOne") {
+    code.line(`const ${rel.name}Result = await db.query(`);
+    code.line(`  \`SELECT * FROM "${targetSchema.tableName}" WHERE "${rel.foreignKey}" = $1 LIMIT 1\`,`);
+    code.line(`  [${itemVar}.id]`);
+    code.line(");");
+    code.line(`${resultVar}.${rel.name} = ${rel.name}Result.rows[0] ?? null;`);
+  } else if (rel.type === "belongsTo") {
+    code.line(`const ${rel.name}Result = await db.query(`);
+    code.line(`  \`SELECT * FROM "${targetSchema.tableName}" WHERE "id" = $1 LIMIT 1\`,`);
+    code.line(`  [(${itemVar} as Record<string, unknown>).${rel.localField}]`);
+    code.line(");");
+    code.line(`${resultVar}.${rel.name} = ${rel.name}Result.rows[0] ?? null;`);
+  } else if (rel.type === "manyToMany") {
+    const throughSchema = allSchemas.find((s) => s.name === rel.through);
+    if (throughSchema) {
+      code.line(`const junctions = await db.query(`);
+      code.line(`  \`SELECT "${rel.otherKey}" FROM "${throughSchema.tableName}" WHERE "${rel.foreignKey}" = $1\`,`);
+      code.line(`  [${itemVar}.id]`);
+      code.line(");");
+      code.line(`const relatedIds = junctions.rows.map(j => (j as Record<string, unknown>).${rel.otherKey});`);
+      code.block("if (relatedIds.length > 0) {", () => {
+        code.line('const placeholders = relatedIds.map((_, i) => `$${i + 1}`).join(", ");');
+        code.line(`const related = await db.query(`);
+        code.line(`  \`SELECT * FROM "${targetSchema.tableName}" WHERE "id" IN (\${placeholders})\`,`);
+        code.line("  relatedIds");
+        code.line(");");
+        code.line(`${resultVar}.${rel.name} = related.rows;`);
+      }, "} else {");
+      code.indent();
+      code.line(`${resultVar}.${rel.name} = [];`);
+      code.dedent();
+      code.line("}");
+    }
+  }
+}
+function generateCreateMethod2(code, schema, allSchemas) {
+  const { name, pascalName, tableName, relations, fields } = schema;
+  const nestedRels = relations.filter((r) => r.type === "hasMany" || r.type === "hasOne");
+  const jsonFields = fields.filter((f) => f.isArray || f.isObject).map((f) => f.name);
+  code.block(
+    `create: async (input: Types.${pascalName}Create): Promise<Types.ItemResponse<Types.${pascalName}>> => {`,
+    () => {
+      code.line("await initDb();");
+      code.line();
+      if (nestedRels.length > 0) {
+        const relNames = nestedRels.map((r) => r.name).join(", ");
+        code.line(`const { ${relNames}, ...data } = input;`);
+      } else {
+        code.line("const data = input;");
+      }
+      code.line();
+      if (jsonFields.length > 0) {
+        code.line("const serialized = { ...data } as Record<string, unknown>;");
+        for (const jf of jsonFields) {
+          code.block(`if (serialized.${jf} !== undefined) {`, () => {
+            code.line(`serialized.${jf} = JSON.stringify(serialized.${jf});`);
+          });
+        }
+        code.line();
+        code.line("const fields = Object.keys(serialized);");
+        code.line("const values = Object.values(serialized);");
+      } else {
+        code.line("const fields = Object.keys(data);");
+        code.line("const values = Object.values(data);");
+      }
+      code.line();
+      code.line('const placeholders = fields.map((_, i) => `$${i + 1}`).join(", ");');
+      code.line('const columns = fields.map(f => `"${f}"`).join(", ");');
+      code.line();
+      code.line(`const result = await db.query<Types.${pascalName}>(`);
+      code.line(`  \`INSERT INTO "${tableName}" (\${columns}) VALUES (\${placeholders}) RETURNING *\`,`);
+      code.line("  values");
+      code.line(");");
+      code.line();
+      if (jsonFields.length > 0) {
+        const jsonFieldsStr = jsonFields.map((f) => `'${f}'`).join(", ");
+        code.line(`const item = parseRow<Types.${pascalName}>(result.rows[0] as Record<string, unknown>, [${jsonFieldsStr}]);`);
+      } else {
+        code.line("const item = result.rows[0];");
+      }
+      if (nestedRels.length > 0) {
+        code.line();
+        for (const rel of nestedRels) {
+          const targetSchema = allSchemas.find((s) => s.name === rel.target);
+          if (!targetSchema) continue;
+          code.block(`if (${rel.name}) {`, () => {
+            if (rel.type === "hasMany") {
+              code.block(`for (const nested of ${rel.name}) {`, () => {
+                code.line(`const nestedData = { ...nested, ${rel.foreignKey}: item.id };`);
+                code.line("const nestedFields = Object.keys(nestedData);");
+                code.line("const nestedValues = Object.values(nestedData);");
+                code.line('const nestedPlaceholders = nestedFields.map((_, i) => `$${i + 1}`).join(", ");');
+                code.line('const nestedColumns = nestedFields.map(f => `"${f}"`).join(", ");');
+                code.line("await db.query(");
+                code.line(`  \`INSERT INTO "${targetSchema.tableName}" (\${nestedColumns}) VALUES (\${nestedPlaceholders})\`,`);
+                code.line("  nestedValues");
+                code.line(");");
+              });
+            } else {
+              code.line(`const nestedData = { ...${rel.name}, ${rel.foreignKey}: item.id };`);
+              code.line("const nestedFields = Object.keys(nestedData);");
+              code.line("const nestedValues = Object.values(nestedData);");
+              code.line('const nestedPlaceholders = nestedFields.map((_, i) => `$${i + 1}`).join(", ");');
+              code.line('const nestedColumns = nestedFields.map(f => `"${f}"`).join(", ");');
+              code.line("await db.query(");
+              code.line(`  \`INSERT INTO "${targetSchema.tableName}" (\${nestedColumns}) VALUES (\${nestedPlaceholders})\`,`);
+              code.line("  nestedValues");
+              code.line(");");
+            }
+          });
+        }
+      }
+      code.line();
+      code.line("return { data: item };");
+    },
+    "},"
+  );
+}
+
+// src/cli/generators/pglite/seed.ts
+function generatePGliteSeed(schemas, config) {
+  const code = new CodeBuilder();
+  code.comment("GENERATED BY SCHEMOCK - DO NOT EDIT");
+  code.line("import { db, initDb, resetDb, tables } from './db';");
+  code.line("import { faker } from '@faker-js/faker';");
+  code.line();
+  if (config.fakerSeed !== void 0) {
+    code.line(`faker.seed(${config.fakerSeed});`);
+  } else {
+    code.line("faker.seed(Date.now());");
+  }
+  code.line();
+  code.block("export interface SeedCounts {", () => {
+    for (const schema of schemas) {
+      if (schema.isJunctionTable) continue;
+      code.line(`${schema.name}?: number;`);
+    }
+  });
+  code.line();
+  code.block("const defaultCounts: Required<SeedCounts> = {", () => {
+    for (const schema of schemas) {
+      if (schema.isJunctionTable) continue;
+      const count = config.seed?.[schema.name] ?? 10;
+      code.line(`${schema.name}: ${count},`);
+    }
+  }, "};");
+  code.line();
+  code.block("function pickRandom<T>(arr: T[]): T | undefined {", () => {
+    code.line("if (arr.length === 0) return undefined;");
+    code.line("return arr[Math.floor(Math.random() * arr.length)];");
+  });
+  code.line();
+  for (const schema of schemas) {
+    if (schema.isJunctionTable) continue;
+    generateEntityGenerator(code, schema);
+    code.line();
+  }
+  code.block("export async function seed(counts: SeedCounts = {}): Promise<void> {", () => {
+    code.line("await initDb();");
+    code.line("const merged = { ...defaultCounts, ...counts };");
+    code.line();
+    code.comment("Track created entity IDs for foreign key references");
+    code.line("const ids: Record<string, string[]> = {};");
+    code.line();
+    for (const schema of schemas) {
+      if (schema.isJunctionTable) continue;
+      const belongsToRels = schema.relations.filter((r) => r.type === "belongsTo");
+      code.line(`ids.${schema.name} = [];`);
+      code.block(`for (let i = 0; i < merged.${schema.name}; i++) {`, () => {
+        if (belongsToRels.length > 0) {
+          code.line(`const data = generate${schema.pascalName}();`);
+          for (const rel of belongsToRels) {
+            const localField = rel.localField || rel.foreignKey;
+            const field = schema.fields.find((f) => f.name === localField);
+            if (field?.nullable) {
+              code.line(`data.${localField} = Math.random() > 0.3 ? pickRandom(ids.${rel.target}) : null;`);
+            } else {
+              code.line(`data.${localField} = pickRandom(ids.${rel.target}) ?? null;`);
+            }
+          }
+        } else {
+          code.line(`const data = generate${schema.pascalName}();`);
+        }
+        code.line();
+        code.line("const fields = Object.keys(data).filter(k => data[k as keyof typeof data] !== undefined);");
+        code.line("const values = fields.map(k => data[k as keyof typeof data]);");
+        code.line('const placeholders = fields.map((_, i) => `$${i + 1}`).join(", ");');
+        code.line('const columns = fields.map(f => `"${f}"`).join(", ");');
+        code.line();
+        code.line(`const result = await db.query<{ id: string }>(`);
+        code.line(`  \`INSERT INTO "${schema.tableName}" (\${columns}) VALUES (\${placeholders}) RETURNING "id"\`,`);
+        code.line("  values");
+        code.line(");");
+        code.line(`ids.${schema.name}.push(result.rows[0].id);`);
+      });
+      code.line();
+    }
+    code.line("console.log('\u2713 Database seeded');");
+  });
+  code.line();
+  code.block("export async function reset(): Promise<void> {", () => {
+    code.line("await resetDb();");
+    code.line("console.log('\u2713 Database reset');");
+  });
+  code.line();
+  code.block("export async function getAll(): Promise<Record<string, unknown[]>> {", () => {
+    code.line("await initDb();");
+    code.block("return {", () => {
+      for (const schema of schemas) {
+        code.line(`${schema.name}: (await db.query(\`SELECT * FROM "${schema.tableName}"\`)).rows,`);
+      }
+    }, "};");
+  });
+  code.line();
+  code.block("export async function count(): Promise<Record<string, number>> {", () => {
+    code.line("await initDb();");
+    code.block("return {", () => {
+      for (const schema of schemas) {
+        code.line(
+          `${schema.name}: parseInt((await db.query<{ count: string }>(\`SELECT COUNT(*) as count FROM "${schema.tableName}"\`)).rows[0].count, 10),`
+        );
+      }
+    }, "};");
+  });
+  return code.toString();
+}
+function generateEntityGenerator(code, schema) {
+  const fieldTypes = [];
+  for (const field of schema.fields) {
+    if (field.name === "id") continue;
+    if (field.isRef) {
+      fieldTypes.push(`${field.name}: string | null`);
+    } else {
+      fieldTypes.push(`${field.name}: ${field.tsType}${field.nullable ? " | null" : ""}`);
+    }
+  }
+  code.block(`function generate${schema.pascalName}(): { ${fieldTypes.join("; ")} } {`, () => {
+    code.block("return {", () => {
+      for (const field of schema.fields) {
+        if (field.name === "id") continue;
+        if (field.isRef) {
+          code.line(`${field.name}: null,`);
+        } else {
+          generateFieldValue(code, field);
+        }
+      }
+    }, "};");
+  });
+}
+function generateFieldValue(code, field) {
+  if (field.nullable) {
+    code.line(`${field.name}: Math.random() > 0.1 ? ${field.fakerCall} : null,`);
+  } else {
+    code.line(`${field.name}: ${field.fakerCall},`);
+  }
+}
+
+// src/cli/generators/hooks.ts
+function generateHooks(schemas) {
+  const code = new CodeBuilder();
+  code.comment("GENERATED BY SCHEMOCK - DO NOT EDIT");
+  code.line("import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';");
+  code.line("import { useMemo } from 'react';");
+  code.line("import { api } from './client';");
+  code.line("import type * as Types from './types';");
+  code.line();
+  generateStableKeyHelper(code);
+  for (const schema of schemas) {
+    if (schema.isJunctionTable) continue;
+    generateEntityHooks(code, schema);
+  }
+  return code.toString();
+}
+function generateStableKeyHelper(code) {
+  code.comment("=============================================================================");
+  code.comment("Stable Query Key Helper");
+  code.comment("");
+  code.comment("Creates stable query keys from options objects to prevent unnecessary");
+  code.comment("refetches when object references change but values are the same.");
+  code.comment("=============================================================================");
+  code.line();
+  code.multiDocComment([
+    "Create a stable serialized key from an options object.",
+    "Uses JSON.stringify with sorted keys for consistent ordering.",
+    "",
+    "@param options - The options object to serialize",
+    "@returns A stable string representation of the options"
+  ]);
+  code.block("function stableKey(options: unknown): string {", () => {
+    code.line('if (options === undefined || options === null) return "";');
+    code.block("try {", () => {
+      code.comment("Sort object keys for consistent serialization");
+      code.line("return JSON.stringify(options, (_, value) => {");
+      code.line('  if (value && typeof value === "object" && !Array.isArray(value)) {');
+      code.line("    return Object.keys(value).sort().reduce((sorted, key) => {");
+      code.line("      sorted[key] = value[key];");
+      code.line("      return sorted;");
+      code.line("    }, {} as Record<string, unknown>);");
+      code.line("  }");
+      code.line("  return value;");
+      code.line("});");
+    }, "} catch {");
+    code.indent();
+    code.comment("Fallback for non-serializable values");
+    code.line("return String(options);");
+    code.dedent();
+    code.line("}");
+  });
+  code.line();
+  code.multiDocComment([
+    "React hook that memoizes a stable query key from options.",
+    "Only recomputes when the serialized value changes.",
+    "",
+    '@param baseKey - The base query key (e.g., "users")',
+    "@param options - Optional options to include in the key",
+    "@returns A stable query key array"
+  ]);
+  code.block("function useStableQueryKey(baseKey: string, ...parts: unknown[]): unknown[] {", () => {
+    code.line('const serialized = parts.map(p => stableKey(p)).join("|");');
+    code.line("return useMemo(() => [baseKey, ...parts], [baseKey, serialized]);");
+  });
+  code.line();
+}
+function generateEntityHooks(code, schema) {
+  const { name, pascalName, pluralName, pascalPluralName, relations } = schema;
+  const hasRelations = relations.length > 0;
+  code.comment(`==================== ${pascalName} Hooks ====================`);
+  code.line();
+  code.docComment(`Fetch list of ${pluralName}`);
+  code.block(`export function use${pascalPluralName}(options?: {`, () => {
+    code.line(`where?: Types.${pascalName}Filter;`);
+    if (hasRelations) {
+      code.line(`include?: Types.${pascalName}Include[];`);
+    }
+    code.line("orderBy?: Record<string, 'asc' | 'desc'>;");
+    code.line("limit?: number;");
+    code.line("offset?: number;");
+    code.line("enabled?: boolean;");
+  }, "}) {");
+  code.indent();
+  code.comment("Use stable query key to prevent unnecessary refetches");
+  code.line(`const queryKey = useStableQueryKey('${pluralName}', options);`);
+  code.block("return useQuery({", () => {
+    code.line("queryKey,");
+    code.line(`queryFn: () => api.${name}.list(options),`);
+    code.line("enabled: options?.enabled ?? true,");
+  }, "});");
+  code.dedent();
+  code.line("}");
+  code.line();
+  code.docComment(`Fetch single ${pascalName} by ID`);
+  code.block(`export function use${pascalName}(id: string | undefined, options?: {`, () => {
+    if (hasRelations) {
+      code.line(`include?: Types.${pascalName}Include[];`);
+    }
+    code.line("enabled?: boolean;");
+  }, "}) {");
+  code.indent();
+  if (hasRelations) {
+    code.comment("Use stable query key for includes array");
+    code.line(`const queryKey = useStableQueryKey('${pluralName}', id, options?.include);`);
+  }
+  code.block("return useQuery({", () => {
+    if (hasRelations) {
+      code.line("queryKey,");
+      code.line(`queryFn: () => api.${name}.get(id!, { include: options?.include }),`);
+    } else {
+      code.line(`queryKey: ['${pluralName}', id],`);
+      code.line(`queryFn: () => api.${name}.get(id!),`);
+    }
+    code.line("enabled: (options?.enabled ?? true) && !!id,");
+  }, "});");
+  code.dedent();
+  code.line("}");
+  code.line();
+  for (const rel of relations) {
+    const hookName = `use${pascalName}With${toPascalCase(rel.name)}`;
+    code.docComment(`Fetch ${pascalName} with ${rel.name} included`);
+    code.block(`export function ${hookName}(id: string | undefined) {`, () => {
+      code.line(`return use${pascalName}(id, { include: ['${rel.name}'] });`);
+    });
+    code.line();
+  }
+  code.docComment(`Create a new ${pascalName}`);
+  code.block(`export function useCreate${pascalName}() {`, () => {
+    code.line("const queryClient = useQueryClient();");
+    code.block("return useMutation({", () => {
+      code.line(`mutationFn: (data: Types.${pascalName}Create) => api.${name}.create(data),`);
+      code.block("onSuccess: () => {", () => {
+        code.line(`queryClient.invalidateQueries({ queryKey: ['${pluralName}'] });`);
+      }, "},");
+    }, "});");
+  });
+  code.line();
+  code.docComment(`Update an existing ${pascalName}`);
+  code.block(`export function useUpdate${pascalName}() {`, () => {
+    code.line("const queryClient = useQueryClient();");
+    code.block("return useMutation({", () => {
+      code.line(`mutationFn: ({ id, data }: { id: string; data: Types.${pascalName}Update }) =>`);
+      code.line(`  api.${name}.update(id, data),`);
+      code.block("onSuccess: (_, { id }) => {", () => {
+        code.line(`queryClient.invalidateQueries({ queryKey: ['${pluralName}'] });`);
+        code.line(`queryClient.invalidateQueries({ queryKey: ['${pluralName}', id] });`);
+      }, "},");
+    }, "});");
+  });
+  code.line();
+  code.docComment(`Delete a ${pascalName}`);
+  code.block(`export function useDelete${pascalName}() {`, () => {
+    code.line("const queryClient = useQueryClient();");
+    code.block("return useMutation({", () => {
+      code.line(`mutationFn: (id: string) => api.${name}.delete(id),`);
+      code.block("onSuccess: () => {", () => {
+        code.line(`queryClient.invalidateQueries({ queryKey: ['${pluralName}'] });`);
+      }, "},");
+    }, "});");
+  });
+  code.line();
+}
+
+// src/cli/commands/generate.ts
+async function generate(options) {
+  console.log("\n\u{1F50D} Schemock Generate\n");
+  const config = await loadConfig(options.config);
+  const adapter = options.adapter || config.adapter || "mock";
+  const outputDir = options.output || config.output || "./src/generated";
+  console.log(`  Adapter: ${adapter}`);
+  console.log(`  Output:  ${outputDir}
+`);
+  console.log("\u{1F4E6} Discovering schemas...");
+  const { schemas, endpoints, files } = await discoverSchemas(config.schemas);
+  for (const file of files) {
+    console.log(`   Found: ${getRelativePath(file)}`);
+  }
+  console.log(`   Total: ${schemas.length} schemas, ${endpoints.length} endpoints
+`);
+  const analyzed = analyzeSchemas(schemas, { ...config, adapter });
+  const analyzedEndpoints = analyzeEndpoints(endpoints);
+  if (options.verbose) {
+    console.log("\u{1F4CA} Analyzed schemas:");
+    for (const schema of analyzed) {
+      console.log(`   ${schema.pascalName}: ${schema.fields.length} fields, ${schema.relations.length} relations`);
+      if (schema.isJunctionTable) {
+        console.log(`      (junction table)`);
+      }
+    }
+    if (analyzedEndpoints.length > 0) {
+      console.log("\n\u{1F4CA} Analyzed endpoints:");
+      for (const endpoint of analyzedEndpoints) {
+        console.log(`   ${endpoint.method} ${endpoint.path} -> ${endpoint.name}`);
+      }
+    }
+    console.log();
+  }
+  if (!options.dryRun) {
+    await mkdir(outputDir, { recursive: true });
+  }
+  console.log("\u{1F4DD} Generating types...");
+  let typesCode = generateTypes(analyzed);
+  if (analyzedEndpoints.length > 0) {
+    typesCode += generateEndpointTypes(analyzedEndpoints);
+  }
+  await writeOutput(join(outputDir, "types.ts"), typesCode, options.dryRun);
+  const entityCount = analyzed.filter((s) => !s.isJunctionTable).length;
+  const endpointInfo = analyzedEndpoints.length > 0 ? ` + ${analyzedEndpoints.length} endpoint types` : "";
+  console.log(`   \u2713 types.ts (${entityCount} entities + Create/Update/Filter types${endpointInfo})
+`);
+  console.log(`\u{1F50C} Generating ${adapter} adapter...`);
+  switch (adapter) {
+    case "mock":
+      await generateMockAdapter(analyzed, analyzedEndpoints, outputDir, config, options);
+      break;
+    case "supabase":
+      await generateSupabaseAdapter(analyzed, outputDir, config, options);
+      break;
+    case "firebase":
+      await generateFirebaseAdapter(analyzed, outputDir, config, options);
+      break;
+    case "fetch":
+      await generateFetchAdapter(analyzed, outputDir, config, options);
+      break;
+    case "graphql":
+      console.log("   \u26A0\uFE0F  GraphQL adapter not yet implemented");
+      break;
+    case "pglite":
+      await generatePGliteAdapter(analyzed, outputDir, config, options);
+      break;
+    default:
+      throw new Error(`Unknown adapter: ${adapter}`);
+  }
+  console.log("\n\u269B\uFE0F  Generating React hooks...");
+  const hooksCode = generateHooks(analyzed);
+  await writeOutput(join(outputDir, "hooks.ts"), hooksCode, options.dryRun);
+  const hookCount = analyzed.filter((s) => !s.isJunctionTable).length * 5;
+  console.log(`   \u2713 hooks.ts (${hookCount} hooks)`);
+  console.log("\n\u{1F4E6} Generating barrel exports...");
+  const indexCode = generateIndex(adapter, analyzedEndpoints.length > 0);
+  await writeOutput(join(outputDir, "index.ts"), indexCode, options.dryRun);
+  console.log("   \u2713 index.ts");
+  console.log(`
+\u2705 Generated ${adapter} adapter in ${outputDir}
+`);
+  const firstSchema = analyzed.find((s) => !s.isJunctionTable);
+  if (firstSchema) {
+    console.log("Usage:");
+    console.log(`  import { use${firstSchema.pascalPluralName}, useCreate${firstSchema.pascalName} } from '${outputDir.replace("./", "")}';`);
+    console.log("");
+  }
+}
+async function generateMockAdapter(schemas, endpoints, outputDir, config, options) {
+  const mockConfig = config.adapters?.mock || {};
+  const hasEndpoints = endpoints.length > 0;
+  const dbCode = generateMockDb(schemas, mockConfig);
+  await writeOutput(join(outputDir, "db.ts"), dbCode, options.dryRun);
+  console.log(`   \u2713 db.ts (@mswjs/data factory with ${schemas.length} entities)`);
+  const routesCode = generateRoutes(schemas);
+  await writeOutput(join(outputDir, "routes.ts"), routesCode, options.dryRun);
+  const entityCount = schemas.filter((s) => !s.isJunctionTable).length;
+  console.log(`   \u2713 routes.ts (${entityCount} entity route definitions)`);
+  const handlersCode = generateMockHandlers(schemas, config.apiPrefix || "/api");
+  await writeOutput(join(outputDir, "handlers.ts"), handlersCode, options.dryRun);
+  const handlerCount = schemas.filter((s) => !s.isJunctionTable).length * 6;
+  console.log(`   \u2713 handlers.ts (${handlerCount} MSW handlers)`);
+  const seedCode = generateSeed(schemas, mockConfig);
+  await writeOutput(join(outputDir, "seed.ts"), seedCode, options.dryRun);
+  console.log("   \u2713 seed.ts (seed/reset utilities)");
+  const clientCode = generateMockClient(schemas);
+  await writeOutput(join(outputDir, "client.ts"), clientCode, options.dryRun);
+  console.log("   \u2713 client.ts (API client with relations support)");
+  if (hasEndpoints) {
+    console.log("\n\u{1F3AF} Generating custom endpoints...");
+    const endpointClientCode = generateEndpointClient(endpoints);
+    await writeOutput(join(outputDir, "endpoints.ts"), endpointClientCode, options.dryRun);
+    console.log(`   \u2713 endpoints.ts (${endpoints.length} endpoint client methods)`);
+    const endpointHandlersCode = generateEndpointHandlers(endpoints);
+    await writeOutput(join(outputDir, "endpoint-handlers.ts"), endpointHandlersCode, options.dryRun);
+    console.log(`   \u2713 endpoint-handlers.ts (${endpoints.length} MSW handlers)`);
+    const endpointResolversCode = generateEndpointResolvers(endpoints);
+    await writeOutput(join(outputDir, "endpoint-resolvers.ts"), endpointResolversCode, options.dryRun);
+    console.log(`   \u2713 endpoint-resolvers.ts (mock resolvers)`);
+  }
+  const allHandlersCode = generateAllHandlersExport(hasEndpoints);
+  await writeOutput(join(outputDir, "all-handlers.ts"), allHandlersCode, options.dryRun);
+  console.log("   \u2713 all-handlers.ts (combined handlers export)");
+}
+async function generateSupabaseAdapter(schemas, outputDir, config, options) {
+  const supabaseConfig = config.adapters?.supabase || {};
+  const clientCode = generateSupabaseClient(schemas, supabaseConfig);
+  await writeOutput(join(outputDir, "client.ts"), clientCode, options.dryRun);
+  console.log("   \u2713 client.ts (Supabase client)");
+}
+async function generateFirebaseAdapter(schemas, outputDir, config, options) {
+  const firebaseConfig = config.adapters?.firebase || {};
+  const clientCode = generateFirebaseClient(schemas, firebaseConfig);
+  await writeOutput(join(outputDir, "client.ts"), clientCode, options.dryRun);
+  console.log("   \u2713 client.ts (Firebase client)");
+}
+async function generateFetchAdapter(schemas, outputDir, config, options) {
+  const fetchConfig = config.adapters?.fetch || {};
+  const clientCode = generateFetchClient(schemas, fetchConfig);
+  await writeOutput(join(outputDir, "client.ts"), clientCode, options.dryRun);
+  console.log("   \u2713 client.ts (Fetch client)");
+}
+async function generatePGliteAdapter(schemas, outputDir, config, options) {
+  const pgliteConfig = config.adapters?.pglite || {};
+  const dbCode = generatePGliteDb(schemas, pgliteConfig);
+  await writeOutput(join(outputDir, "db.ts"), dbCode, options.dryRun);
+  console.log(`   \u2713 db.ts (PGlite schema with ${schemas.length} tables)`);
+  const clientCode = generatePGliteClient(schemas);
+  await writeOutput(join(outputDir, "client.ts"), clientCode, options.dryRun);
+  console.log("   \u2713 client.ts (SQL-based CRUD operations)");
+  const seedCode = generatePGliteSeed(schemas, pgliteConfig);
+  await writeOutput(join(outputDir, "seed.ts"), seedCode, options.dryRun);
+  console.log("   \u2713 seed.ts (seed/reset utilities)");
+}
+function generateIndex(adapter, hasEndpoints = false) {
+  const lines = [
+    "// GENERATED BY SCHEMOCK - DO NOT EDIT",
+    "",
+    "export * from './types';",
+    "export * from './hooks';",
+    "export { api } from './client';"
+  ];
+  if (adapter === "mock") {
+    lines.push("export { db } from './db';");
+    lines.push("export { handlers } from './handlers';");
+    lines.push("export { allHandlers } from './all-handlers';");
+    lines.push("export { seed, reset, getAll } from './seed';");
+    if (hasEndpoints) {
+      lines.push("export { endpoints } from './endpoints';");
+      lines.push("export { endpointHandlers } from './endpoint-handlers';");
+    }
+  }
+  if (adapter === "pglite") {
+    lines.push("export { db, initDb, resetDb, tables } from './db';");
+    lines.push("export { seed, reset, getAll, count } from './seed';");
+  }
+  if (adapter === "supabase") {
+    lines.push("export { supabase } from './client';");
+  }
+  return lines.join("\n");
+}
+async function writeOutput(path, content, dryRun) {
+  if (dryRun) {
+    console.log(`   [DRY RUN] Would write: ${path}`);
+    return;
+  }
+  await writeFile(path, content, "utf-8");
+}
+
+export { CodeBuilder, analyzeSchemas, defineConfig, discoverSchemas, fieldToFakerCall, fieldToTsType, generate, generateFetchClient, generateFirebaseClient, generateHooks, generateMockClient, generateMockDb, generateMockHandlers, generateSeed, generateSupabaseClient, generateTypes, getDefaultConfig, getRelativePath, loadConfig, pluralize, primitiveToTs, toCamelCase, toPascalCase };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map