schema-seed-core 0.1.0

package/dist/index.js

@@ -0,0 +1,908 @@
+// src/random.ts
+var Random = class {
+  state;
+  constructor(seed) {
+    this.state = typeof seed === "string" ? this.hashString(seed) : seed;
+  }
+  hashString(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash |= 0;
+    }
+    return hash;
+  }
+  next() {
+    let t = this.state += 1831565813;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  }
+  nextInt(min, max) {
+    return Math.floor(this.next() * (max - min + 1)) + min;
+  }
+  pick(array, weights) {
+    if (!weights) {
+      return array[this.nextInt(0, array.length - 1)];
+    }
+    const totalWeight = weights.reduce((a, b) => a + b, 0);
+    let r = this.next() * totalWeight;
+    for (let i = 0; i < array.length; i++) {
+      r -= weights[i] || 0;
+      if (r <= 0) return array[i];
+    }
+    return array[array.length - 1];
+  }
+  boolean(probability = 0.5) {
+    return this.next() < probability;
+  }
+};
+
+// src/types.ts
+var NormalizedSqlType = /* @__PURE__ */ ((NormalizedSqlType2) => {
+  NormalizedSqlType2["STRING"] = "string";
+  NormalizedSqlType2["TEXT"] = "text";
+  NormalizedSqlType2["INT"] = "int";
+  NormalizedSqlType2["BIGINT"] = "bigint";
+  NormalizedSqlType2["FLOAT"] = "float";
+  NormalizedSqlType2["DECIMAL"] = "decimal";
+  NormalizedSqlType2["BOOLEAN"] = "boolean";
+  NormalizedSqlType2["DATE"] = "date";
+  NormalizedSqlType2["DATETIME"] = "datetime";
+  NormalizedSqlType2["JSON"] = "json";
+  NormalizedSqlType2["UUID"] = "uuid";
+  NormalizedSqlType2["ENUM"] = "enum";
+  NormalizedSqlType2["BINARY"] = "binary";
+  NormalizedSqlType2["OBJECTID"] = "objectid";
+  return NormalizedSqlType2;
+})(NormalizedSqlType || {});
+
+// src/uniqueness.ts
+var UniquenessRegistry = class {
+  registry = /* @__PURE__ */ new Map();
+  /**
+   * Generates a unique key for a table and column.
+   */
+  getRegistryKey(table, column) {
+    return `${table}.${column}`;
+  }
+  /**
+   * Attempts to generate a unique value using a generator function.
+   * If the generated value is already in the registry, it retries up to `maxRetries` times.
+   * If it still fails, it uses a deterministic fallback.
+   * 
+   * @param table Table name
+   * @param column Column name
+   * @param generator Function that generates a value
+   * @param maxRetries Maximum number of retries before fallback
+   * @returns A unique value
+   */
+  async ensureUnique(table, column, generator, maxRetries = 100) {
+    const key = this.getRegistryKey(table, column);
+    if (!this.registry.has(key)) {
+      this.registry.set(key, /* @__PURE__ */ new Set());
+    }
+    const usedValues = this.registry.get(key);
+    for (let i = 0; i < maxRetries; i++) {
+      const value = await generator();
+      if (!usedValues.has(value)) {
+        usedValues.add(value);
+        return value;
+      }
+    }
+    const fallbackValue = await generator();
+    const finalValue = `${fallbackValue}_${usedValues.size}`;
+    usedValues.add(finalValue);
+    return finalValue;
+  }
+  /**
+   * Clears the registry for a specific table/column or all.
+   */
+  clear(table, column) {
+    if (table && column) {
+      this.registry.delete(this.getRegistryKey(table, column));
+    } else {
+      this.registry.clear();
+    }
+  }
+};
+
+// src/redaction.ts
+var Redactor = class {
+  static SENSITIVE_PATTERNS = [
+    /password/i,
+    /token/i,
+    /secret/i,
+    /api_?key/i,
+    /auth/i,
+    /cookie/i,
+    /credit_?card/i,
+    /ssn/i
+  ];
+  /**
+   * Checks if a column name is considered sensitive.
+   */
+  static isSensitive(columnName) {
+    return this.SENSITIVE_PATTERNS.some((pattern) => pattern.test(columnName));
+  }
+  /**
+   * Redacts sensitive values in a row object.
+   * @param row The row data to redact
+   * @returns A new object with sensitive values replaced by a placeholder
+   */
+  static redactRow(row) {
+    const redacted = {};
+    for (const [key, value] of Object.entries(row)) {
+      if (this.isSensitive(key)) {
+        redacted[key] = "[REDACTED]";
+      } else {
+        redacted[key] = value;
+      }
+    }
+    return redacted;
+  }
+  /**
+   * Redacts sensitive values in a list of rows.
+   */
+  static redactRows(rows) {
+    return rows.map((row) => this.redactRow(row));
+  }
+};
+
+// src/planner/graph.ts
+var DependencyGraph = class {
+  nodes = /* @__PURE__ */ new Map();
+  constructor(schema) {
+    for (const tableName of Object.keys(schema.tables)) {
+      this.nodes.set(tableName, {
+        tableName,
+        dependencies: /* @__PURE__ */ new Set(),
+        dependents: /* @__PURE__ */ new Set()
+      });
+    }
+    for (const [tableName, table] of Object.entries(schema.tables)) {
+      const node = this.nodes.get(tableName);
+      for (const fk of table.foreignKeys) {
+        if (fk.referencedTable === tableName) continue;
+        if (this.nodes.has(fk.referencedTable)) {
+          node.dependencies.add(fk.referencedTable);
+          this.nodes.get(fk.referencedTable).dependents.add(tableName);
+        }
+      }
+    }
+  }
+  getNodes() {
+    return Array.from(this.nodes.values());
+  }
+  getNode(tableName) {
+    return this.nodes.get(tableName);
+  }
+};
+
+// src/planner/toposort.ts
+function topologicalSort(graph) {
+  const order = [];
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const recStack = /* @__PURE__ */ new Set();
+  const path = [];
+  function visit(tableName) {
+    if (recStack.has(tableName)) {
+      const cycleStart = path.indexOf(tableName);
+      cycles.push(path.slice(cycleStart));
+      return;
+    }
+    if (visited.has(tableName)) return;
+    visited.add(tableName);
+    recStack.add(tableName);
+    path.push(tableName);
+    const node = graph.getNode(tableName);
+    if (node) {
+      for (const dep of node.dependencies) {
+        visit(dep);
+      }
+    }
+    recStack.delete(tableName);
+    path.pop();
+    order.push(tableName);
+  }
+  for (const node of graph.getNodes()) {
+    if (!visited.has(node.tableName)) {
+      visit(node.tableName);
+    }
+  }
+  return { order, cycles };
+}
+
+// src/planner/cycles.ts
+function resolveCycles(cycles, schema, supportsDeferrable) {
+  return cycles.map((cycle) => {
+    if (supportsDeferrable) {
+      return { resolved: true, strategy: "DEFERRABLE" };
+    }
+    for (let i = 0; i < cycle.length; i++) {
+      const currentTable = cycle[i];
+      const nextTable = cycle[(i + 1) % cycle.length];
+      const tableSchema = schema.tables[currentTable];
+      const nullableFk = tableSchema.foreignKeys.find((fk) => {
+        if (fk.referencedTable !== nextTable) return false;
+        return fk.columns.every((colName) => tableSchema.columns[colName]?.nullable);
+      });
+      if (nullableFk) {
+        return {
+          resolved: true,
+          strategy: "NULLABLE_FK",
+          breakingTable: currentTable,
+          breakingColumn: nullableFk.columns[0]
+          // Simplified: just track one
+        };
+      }
+    }
+    return { resolved: false };
+  });
+}
+
+// src/planner/plan.ts
+function createSeedPlan(schema, options, supportsDeferrable = false) {
+  const graph = new DependencyGraph(schema);
+  const { order, cycles } = topologicalSort(graph);
+  if (cycles.length > 0) {
+    const resolutions = resolveCycles(cycles, schema, supportsDeferrable);
+    const unresolvable = resolutions.filter((r) => !r.resolved);
+    if (unresolvable.length > 0) {
+      const cyclePaths = cycles.filter((_, i) => !resolutions[i].resolved).map((c) => c.join(" -> ")).join("\n");
+      throw new Error(
+        `Unresolvable cycles detected in schema:
+${cyclePaths}
+Try making one of the foreign keys nullable or use a database that supports deferrable constraints.`
+      );
+    }
+  }
+  let finalOrder = order;
+  if (options.includeTables) {
+    const includeSet = new Set(options.includeTables);
+    if (options.withParents) {
+      const expanded = /* @__PURE__ */ new Set();
+      const walk = (tableName) => {
+        if (expanded.has(tableName)) return;
+        expanded.add(tableName);
+        const node = graph.getNode(tableName);
+        if (node) {
+          for (const dep of node.dependencies) {
+            walk(dep);
+          }
+        }
+      };
+      options.includeTables.forEach(walk);
+      finalOrder = finalOrder.filter((t) => expanded.has(t));
+    } else {
+      finalOrder = finalOrder.filter((t) => includeSet.has(t));
+    }
+  }
+  if (options.excludeTables) {
+    const excludeSet = new Set(options.excludeTables);
+    finalOrder = finalOrder.filter((t) => !excludeSet.has(t));
+  }
+  return {
+    insertOrder: finalOrder,
+    batches: [],
+    // To be populated by the generator
+    referencesMap: /* @__PURE__ */ new Map()
+  };
+}
+function isJoinTable(table) {
+  const fkColumnCount = new Set(table.foreignKeys.flatMap((fk) => fk.columns)).size;
+  const totalColumnCount = Object.keys(table.columns).length;
+  return table.foreignKeys.length >= 2 && fkColumnCount >= totalColumnCount * 0.7;
+}
+
+// src/generate/refs.ts
+var ReferenceRegistry = class {
+  refs = /* @__PURE__ */ new Map();
+  /**
+   * Records an inserted primary key for a table.
+   */
+  addReference(table, pk) {
+    if (!this.refs.has(table)) {
+      this.refs.set(table, []);
+    }
+    this.refs.get(table).push(pk);
+  }
+  /**
+   * Picks a random primary key from the specified table.
+   */
+  getRandomReference(table, random) {
+    const tableRefs = this.refs.get(table);
+    if (!tableRefs || tableRefs.length === 0) {
+      return null;
+    }
+    return random.pick(tableRefs);
+  }
+  /**
+   * Returns all recorded references for a table.
+   */
+  getReferences(table) {
+    return this.refs.get(table) || [];
+  }
+  clear() {
+    this.refs.clear();
+  }
+};
+
+// src/generate/row.ts
+async function generateRows(table, count, context) {
+  const rows = [];
+  for (let i = 0; i < count; i++) {
+    rows.push(await generateRow(table, { ...context, i }));
+  }
+  return rows;
+}
+async function generateRow(table, context) {
+  const row = {};
+  for (const column of Object.values(table.columns)) {
+    if (column.isAutoIncrement) continue;
+    const fk = table.foreignKeys.find((f) => f.columns.includes(column.name));
+    if (fk) {
+      const ref = context.refs.getRandomReference(fk.referencedTable, context.random);
+      if (ref !== null) {
+        row[column.name] = ref;
+        continue;
+      }
+    }
+    const tableOverride = context.overrides?.[table.name]?.[column.name];
+    const globalOverride = context.overrides?.[column.name];
+    const override = tableOverride !== void 0 ? tableOverride : globalOverride;
+    if (override !== void 0) {
+      if (typeof override === "function") {
+        row[column.name] = await override({ i: context.i, random: context.random, refs: context.refs });
+        continue;
+      } else if (typeof override === "object" && override !== null) {
+        if ("enum" in override) {
+          const values = override.enum;
+          const weights = override.weights;
+          row[column.name] = context.random.pick(values, weights);
+          continue;
+        } else if ("dateBetween" in override) {
+          const [start, end] = override.dateBetween;
+          const startTime = new Date(start).getTime();
+          const endTime = new Date(end).getTime();
+          const randomTime = context.random.nextInt(startTime, endTime);
+          row[column.name] = new Date(randomTime).toISOString();
+          continue;
+        }
+      }
+      row[column.name] = override;
+      continue;
+    }
+    const { generatorId, options } = context.inferGenerator(column.name, column.type);
+    const generator = context.generators[generatorId];
+    if (generator) {
+      const isUnique = table.uniqueConstraints.some((uc) => uc.columns.includes(column.name)) || table.primaryKey?.columns.includes(column.name);
+      if (isUnique) {
+        row[column.name] = await context.uniqueness.ensureUnique(
+          table.name,
+          column.name,
+          () => generator({ ...context, options })
+        );
+      } else {
+        row[column.name] = generator({ ...context, options });
+      }
+    } else {
+      row[column.name] = generateDefaultValue(column, context.random);
+    }
+  }
+  return row;
+}
+function generateDefaultValue(column, random) {
+  if (column.defaultValue !== void 0) return column.defaultValue;
+  if (column.nullable && random.boolean(0.1)) return null;
+  switch (column.type) {
+    case "int" /* INT */:
+    case "bigint" /* BIGINT */:
+      return random.nextInt(1, 1e3);
+    case "float" /* FLOAT */:
+    case "decimal" /* DECIMAL */:
+      return parseFloat((random.next() * 100).toFixed(2));
+    case "boolean" /* BOOLEAN */:
+      return random.boolean();
+    case "date" /* DATE */:
+    case "datetime" /* DATETIME */:
+      return (/* @__PURE__ */ new Date()).toISOString();
+    case "json" /* JSON */:
+      return { mock: "data" };
+    case "enum" /* ENUM */:
+      return column.enumValues ? random.pick(column.enumValues) : "VALUE";
+    default:
+      return "mock-string";
+  }
+}
+
+// src/plugins.ts
+async function loadPlugins(options, context) {
+  if (!options.plugins) return;
+  for (const pluginRef of options.plugins) {
+    let plugin;
+    if (typeof pluginRef === "string") {
+      try {
+        const module = await import(pluginRef);
+        plugin = module.default || module;
+      } catch (err) {
+        throw new Error(`Failed to load plugin ${pluginRef}: ${err.message}`);
+      }
+    } else {
+      plugin = pluginRef;
+    }
+    if (plugin.generators) {
+      context.generators = { ...context.generators, ...plugin.generators };
+    }
+    if (plugin.overrides) {
+      options.overrides = mergeOverrides(options.overrides || {}, plugin.overrides);
+    }
+    if (plugin.hooks) {
+      options.hooks = mergeHooks(options.hooks || {}, plugin.hooks);
+    }
+  }
+}
+function mergeOverrides(base, plugin) {
+  const merged = { ...base };
+  for (const [table, tableOverrides] of Object.entries(plugin)) {
+    merged[table] = { ...merged[table] || {}, ...tableOverrides };
+  }
+  return merged;
+}
+function mergeHooks(base, plugin) {
+  return {
+    beforeInsert: async (table, rows) => {
+      let currentRows = rows;
+      if (base.beforeInsert) currentRows = await base.beforeInsert(table, currentRows);
+      if (plugin.beforeInsert) currentRows = await plugin.beforeInsert(table, currentRows);
+      return currentRows;
+    },
+    afterInsert: async (table, result) => {
+      if (base.afterInsert) await base.afterInsert(table, result);
+      if (plugin.afterInsert) await plugin.afterInsert(table, result);
+    }
+  };
+}
+
+// src/validation.ts
+function validateOptions(options) {
+  if (options.overrides) {
+    for (const [tableName, tableOverrides] of Object.entries(options.overrides)) {
+      if (typeof tableOverrides !== "object" || tableOverrides === null) {
+        throw new Error(`Invalid override for table "${tableName}": must be an object.`);
+      }
+      for (const [columnName, override] of Object.entries(tableOverrides)) {
+        validateOverride(tableName, columnName, override);
+      }
+    }
+  }
+}
+function validateOverride(table, column, override) {
+  if (typeof override === "function") return;
+  if (typeof override === "object" && override !== null) {
+    if ("enum" in override) {
+      if (!Array.isArray(override.enum)) {
+        throw new Error(`Invalid enum override for "${table}.${column}": "enum" must be an array.`);
+      }
+      if (override.weights && (!Array.isArray(override.weights) || override.weights.length !== override.enum.length)) {
+        throw new Error(`Invalid weights for "${table}.${column}": "weights" must be an array of the same length as "enum".`);
+      }
+      return;
+    }
+    if ("dateBetween" in override) {
+      if (!Array.isArray(override.dateBetween) || override.dateBetween.length !== 2) {
+        throw new Error(`Invalid dateBetween override for "${table}.${column}": must be an array of [start, end].`);
+      }
+      return;
+    }
+  }
+}
+
+// src/runner.ts
+function checkProductionSafety(options, dbUrl) {
+  if (options.allowProduction) return;
+  if (process.env.NODE_ENV === "production") {
+    throw new Error("Refusing to run in production environment (NODE_ENV=production). Use --allow-production to override.");
+  }
+  if (dbUrl) {
+    const prodKeywords = ["prod", "production", "live", "cloud", "aws", "azure", "gcp"];
+    try {
+      const url = new URL(dbUrl.includes("://") ? dbUrl : `sqlite://${dbUrl}`);
+      const host = url.hostname.toLowerCase();
+      if (prodKeywords.some((kw) => host.includes(kw))) {
+        throw new Error(`Refusing to run against a potential production database (${host}). Use --allow-production to override.`);
+      }
+    } catch (e) {
+      const lowerUrl = dbUrl.toLowerCase();
+      if (prodKeywords.some((kw) => lowerUrl.includes(kw))) {
+        throw new Error("Refusing to run against a potential production database. Use --allow-production to override.");
+      }
+    }
+  }
+}
+async function runSeedSql(adapter, schema, plan, options, context) {
+  const startTime = Date.now();
+  const report = {
+    success: true,
+    durationMs: 0,
+    tables: {},
+    errors: []
+  };
+  const random = new Random(options.seed || Date.now());
+  const uniqueness = new UniquenessRegistry();
+  const refs = new ReferenceRegistry();
+  await loadPlugins(options, context);
+  validateOptions(options);
+  checkProductionSafety(options, adapter.config?.connectionString || adapter.config);
+  try {
+    await adapter.connect();
+    if (options.truncate && plan.insertOrder.length > 0) {
+      if (!options.allowProduction) {
+      }
+      if (!options.dryRun) {
+        await adapter.truncateTables([...plan.insertOrder].reverse());
+      }
+    }
+    if (!options.dryRun) {
+      await adapter.begin();
+    }
+    for (const tableName of plan.insertOrder) {
+      const tableStartTime = Date.now();
+      const tableSchema = schema.tables[tableName];
+      const rowCount = typeof options.rows === "number" ? options.rows : options.rows?.[tableName] ?? 10;
+      try {
+        const genCtx = {
+          random,
+          uniqueness,
+          refs,
+          generators: context.generators,
+          inferGenerator: context.inferGenerator,
+          overrides: context.overrides
+        };
+        let rows = await generateRows(tableSchema, rowCount, genCtx);
+        if (!options.dryRun) {
+          if (options.hooks?.beforeInsert) {
+            rows = await options.hooks.beforeInsert(tableName, rows);
+          }
+          const batchSize = options.batchSize || 1e3;
+          for (let i = 0; i < rows.length; i += batchSize) {
+            const batch = rows.slice(i, i + batchSize);
+            await adapter.insertBatch({ tableName, rows: batch });
+          }
+          for (const row of rows) {
+            if (tableSchema.primaryKey) {
+              const pkCol = tableSchema.primaryKey.columns[0];
+              if (row[pkCol] !== void 0) {
+                refs.addReference(tableName, row[pkCol]);
+              }
+            }
+          }
+        }
+        report.tables[tableName] = {
+          insertedCount: rows.length,
+          durationMs: Date.now() - tableStartTime
+        };
+        if (!options.dryRun && options.hooks?.afterInsert) {
+          await options.hooks.afterInsert(tableName, report.tables[tableName]);
+        }
+      } catch (err) {
+        report.success = false;
+        report.tables[tableName] = {
+          insertedCount: 0,
+          durationMs: Date.now() - tableStartTime,
+          error: err.message
+        };
+        report.errors.push(err);
+        if (!options.dryRun) {
+          await adapter.rollback();
+          throw err;
+        }
+      }
+    }
+    if (!options.dryRun) {
+      await adapter.commit();
+    }
+  } catch (err) {
+    report.success = false;
+    report.errors.push(err);
+  } finally {
+    await adapter.disconnect();
+    report.durationMs = Date.now() - startTime;
+  }
+  return report;
+}
+
+// src/mongo/planner.ts
+function createMongoPlan(config) {
+  const collections = Object.keys(config.mongodb.collections);
+  const adj = /* @__PURE__ */ new Map();
+  for (const [name, coll] of Object.entries(config.mongodb.collections)) {
+    const deps = [];
+    for (const field of Object.values(coll.fields)) {
+      if (typeof field === "object" && field.ref) {
+        const [refColl] = field.ref.split(".");
+        if (!config.mongodb.collections[refColl]) {
+          throw new Error(`Reference ${field.ref} not found. Ensure ${refColl} collection is defined in config.`);
+        }
+        if (refColl !== name) {
+          deps.push(refColl);
+        }
+      }
+    }
+    adj.set(name, deps);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const order = [];
+  function visit(name) {
+    if (visiting.has(name)) {
+      throw new Error(`Circular reference detected involving collection: ${name}`);
+    }
+    if (visited.has(name)) return;
+    visiting.add(name);
+    for (const dep of adj.get(name) || []) {
+      visit(dep);
+    }
+    visiting.delete(name);
+    visited.add(name);
+    order.push(name);
+  }
+  for (const name of collections) {
+    visit(name);
+  }
+  return order;
+}
+
+// src/mongo/generator.ts
+function generateMongoDocument(fields, ctx) {
+  const doc = {};
+  for (const [name, config] of Object.entries(fields)) {
+    doc[name] = generateFieldValue(config, ctx);
+  }
+  return doc;
+}
+function generateFieldValue(config, ctx) {
+  if (typeof config === "string") {
+    return generateByType(config, {}, ctx);
+  }
+  const cfg = config;
+  if (cfg.ref) {
+    const [refColl, refField] = cfg.ref.split(".");
+    const val = ctx.refs.getRandomReference(refColl, ctx.random);
+    if (val === null) {
+      throw new Error(`Reference ${cfg.ref} not found. Ensure ${refColl} collection is seeded first.`);
+    }
+    return val;
+  }
+  if (cfg.type === "enum") {
+    return ctx.random.pick(cfg.values || [], cfg.weights);
+  }
+  if (cfg.type === "object") {
+    return generateMongoDocument(cfg.fields || {}, ctx);
+  }
+  if (cfg.type === "array") {
+    const count = ctx.random.nextInt(cfg.minItems ?? 1, cfg.maxItems ?? 5);
+    return Array.from({ length: count }, () => generateFieldValue(cfg.of, ctx));
+  }
+  return generateByType(cfg.type, cfg, ctx);
+}
+function generateByType(type, config, ctx) {
+  switch (type) {
+    case "objectId":
+      return generateObjectId(ctx.random);
+    case "int":
+      return ctx.random.nextInt(config.min ?? 0, config.max ?? 1e6);
+    case "float":
+    case "decimal":
+      return parseFloat((ctx.random.next() * ((config.max ?? 100) - (config.min ?? 0)) + (config.min ?? 0)).toFixed(2));
+    case "boolean":
+      return ctx.random.boolean();
+    case "date":
+      return new Date(ctx.random.nextInt(0, Date.now())).toISOString();
+    case "dateRecent":
+      return ctx.generators.dateRecent(ctx);
+    case "dateBetween": {
+      const from = new Date(config.from ?? "2020-01-01").getTime();
+      const to = new Date(config.to ?? Date.now()).getTime();
+      return new Date(ctx.random.nextInt(from, to)).toISOString();
+    }
+    case "email":
+      return ctx.generators.email(ctx);
+    case "firstName":
+      return ctx.generators.firstName(ctx);
+    case "lastName":
+      return ctx.generators.lastName(ctx);
+    case "fullName":
+      return ctx.generators.fullName(ctx);
+    case "city":
+      return ctx.generators.city(ctx);
+    case "country":
+      return ctx.generators.country(ctx);
+    case "street":
+      return ctx.generators.address(ctx);
+    case "phone":
+      return ctx.generators.phone(ctx);
+    case "uuid":
+      return ctx.generators.uuid(ctx);
+    case "string":
+      return ctx.generators.firstName(ctx);
+    // Fallback
+    default:
+      if (ctx.generators[type]) {
+        return ctx.generators[type](ctx);
+      }
+      return null;
+  }
+}
+function generateObjectId(random) {
+  const chars = "0123456789abcdef";
+  let id = "";
+  for (let i = 0; i < 24; i++) {
+    id += chars[random.nextInt(0, 15)];
+  }
+  return id;
+}
+
+// src/mongo/runner.ts
+function checkProductionSafety2(options, dbUrl) {
+  if (options.allowProduction) return;
+  if (process.env.NODE_ENV === "production") {
+    throw new Error("Refusing to run in production environment (NODE_ENV=production). Use --allow-production to override.");
+  }
+  if (dbUrl) {
+    const prodKeywords = ["prod", "production", "live", "cloud", "aws", "azure", "gcp"];
+    try {
+      const url = new URL(dbUrl.includes("://") ? dbUrl : `sqlite://${dbUrl}`);
+      const host = url.hostname.toLowerCase();
+      if (prodKeywords.some((kw) => host.includes(kw))) {
+        throw new Error(`Refusing to run against a potential production database (${host}). Use --allow-production to override.`);
+      }
+    } catch (e) {
+      const lowerUrl = dbUrl.toLowerCase();
+      if (prodKeywords.some((kw) => lowerUrl.includes(kw))) {
+        throw new Error("Refusing to run against a potential production database. Use --allow-production to override.");
+      }
+    }
+  }
+}
+async function runSeedMongo(adapter, config, options = {}, context) {
+  const startTime = Date.now();
+  const report = {
+    success: true,
+    durationMs: 0,
+    tables: {},
+    errors: []
+  };
+  const random = new Random(config.seed || Date.now());
+  const refs = new ReferenceRegistry();
+  checkProductionSafety2(options, config.mongodb.uri);
+  if (!config.mongodb?.collections || Object.keys(config.mongodb.collections).length === 0) {
+    throw new Error("No collections defined in MongoDB config.");
+  }
+  for (const [name, coll] of Object.entries(config.mongodb.collections)) {
+    if (coll.rows <= 0) {
+      throw new Error(`Collection ${name} must have rows > 0.`);
+    }
+    if (!coll.fields || Object.keys(coll.fields).length === 0) {
+      throw new Error(`Collection ${name} must have fields defined.`);
+    }
+    for (const [fieldName, field] of Object.entries(coll.fields)) {
+      if (typeof field === "object" && field !== null && "type" in field && field.type === "enum") {
+        const enumField = field;
+        if (enumField.weights && enumField.values && enumField.weights.length !== enumField.values.length) {
+          throw new Error(`Enum weights and values length mismatch in ${name}.${fieldName}`);
+        }
+      }
+    }
+  }
+  try {
+    await adapter.connect();
+    const plan = createMongoPlan(config);
+    for (const collName of plan) {
+      const collStartTime = Date.now();
+      const collConfig = config.mongodb.collections[collName];
+      const docs = [];
+      try {
+        for (let i = 0; i < collConfig.rows; i++) {
+          const doc = generateMongoDocument(collConfig.fields, {
+            random,
+            refs,
+            generators: context.generators
+          });
+          docs.push(doc);
+        }
+        if (!options.dryRun) {
+          await adapter.insertMany(collName, docs);
+          for (const doc of docs) {
+            if (doc._id) {
+              refs.addReference(collName, doc._id);
+            }
+          }
+        }
+        report.tables[collName] = {
+          insertedCount: docs.length,
+          durationMs: Date.now() - collStartTime
+        };
+      } catch (err) {
+        report.success = false;
+        report.tables[collName] = {
+          insertedCount: 0,
+          durationMs: Date.now() - collStartTime,
+          error: err.message
+        };
+        report.errors.push(err);
+      }
+    }
+  } catch (err) {
+    report.success = false;
+    report.errors.push(err);
+  } finally {
+    await adapter.disconnect();
+    report.durationMs = Date.now() - startTime;
+  }
+  return report;
+}
+
+// src/reporters/console.ts
+function reportToConsole(report) {
+  console.log("\n\u{1F680} Seed Report");
+  console.log("====================================");
+  console.log(`Status:   ${report.success ? "\u2705 Success" : "\u274C Failed"}`);
+  console.log(`Duration: ${report.durationMs}ms`);
+  console.log("------------------------------------");
+  console.table(
+    Object.entries(report.tables).map(([name, stats]) => ({
+      Table: name,
+      Rows: stats.insertedCount,
+      Time: `${stats.durationMs}ms`,
+      Status: stats.error ? "\u274C" : "\u2705"
+    }))
+  );
+  if (report.errors.length > 0) {
+    console.log("\nErrors:");
+    report.errors.forEach((err, i) => {
+      console.log(`${i + 1}. ${err.message}`);
+    });
+  }
+  console.log("====================================\n");
+}
+
+// src/reporters/json.ts
+function reportToJson(report) {
+  return JSON.stringify(report, (key, value) => {
+    if (value instanceof Error) {
+      return { message: value.message, stack: value.stack };
+    }
+    return value;
+  }, 2);
+}
+
+// src/index.ts
+var version = "0.0.1";
+function defineSeed(options) {
+  return options;
+}
+export {
+  DependencyGraph,
+  NormalizedSqlType,
+  Random,
+  Redactor,
+  ReferenceRegistry,
+  UniquenessRegistry,
+  createSeedPlan,
+  defineSeed,
+  generateRow,
+  generateRows,
+  isJoinTable,
+  loadPlugins,
+  reportToConsole,
+  reportToJson,
+  resolveCycles,
+  runSeedMongo,
+  runSeedSql,
+  topologicalSort,
+  version
+};
+//# sourceMappingURL=index.js.map