tina4-nodejs 3.13.133 → 3.13.134

package/packages/orm/src/fakeData.ts

@@ -13,6 +13,43 @@ const PRODUCT_TABLE_HINTS = [
   "sku", "listing", "stock", "ware",
 ] as const;
 
+const COLUMN_HEURISTICS: Array<[RegExp, string]> = [
+  [/email/, "email"],
+  [/(phone|mobile|tel)/, "phone"],
+  [/^(name|full_name|fullname)$/, "name"],
+  [/^(first_name|firstname)$/, "firstName"],
+  [/^(last_name|lastname|surname)$/, "lastName"],
+  [/address/, "address"],
+  [/city/, "city"],
+  [/country/, "country"],
+  [/(zip|postal)/, "zipCode"],
+  [/(company|org)/, "company"],
+  [/(job|title|position)/, "jobTitle"],
+  [/(url|website|link)/, "url"],
+  [/(color|colour)/, "colorHex"],
+  [/(uuid|guid)/, "uuid"],
+  [/^(ip|ip_address|ipaddress)$/, "ipAddress"],
+  [/currency/, "currency"],
+];
+
+const HEURISTIC_METHODS: Record<string, string> = {
+  email: "email",
+  phone: "phone",
+  firstName: "firstName",
+  lastName: "lastName",
+  address: "address",
+  city: "city",
+  country: "country",
+  zipCode: "zipCode",
+  company: "company",
+  jobTitle: "jobTitle",
+  url: "url",
+  colorHex: "colorHex",
+  uuid: "uuid",
+  ipAddress: "ipAddress",
+  currency: "currency",
+};
+
 /**
  * True when the table/model name looks like a product catalogue, so a generic
  * `name` column should seed a product name, not a person name. With NO table
@@ -46,6 +83,39 @@ export class FakeData extends CoreFakeData {
     return new Date(startMs + offset * 86400000);
   }
 
+  private heuristicValue(key: string, table?: string): unknown {
+    if (key === "name") return isProductTable(table) ? this.product() : this.name();
+    const methodName = HEURISTIC_METHODS[key];
+    const method = methodName
+      ? (this as unknown as Record<string, unknown>)[methodName]
+      : undefined;
+    return typeof method === "function" ? method.call(this) : undefined;
+  }
+
+  private stringValue(fieldDef: FieldDefinition): string {
+    const maxLen = fieldDef.maxLength ?? 50;
+    const minLen = fieldDef.minLength ?? 3;
+    let value = this.sentence(Math.max(2, Math.ceil(maxLen / 6)));
+    if (value.length > maxLen) value = value.slice(0, maxLen);
+    if (value.length < minLen) {
+      while (value.length < minLen) value += " " + this.word();
+      value = value.slice(0, maxLen);
+    }
+    return value;
+  }
+
+  private typedValue(fieldDef: FieldDefinition): unknown {
+    if (fieldDef.type === "string") return this.stringValue(fieldDef);
+    if (fieldDef.type === "text") return this.paragraph(3);
+    if (fieldDef.type === "integer") return this.integer(fieldDef.min ?? 0, fieldDef.max ?? 10000);
+    if (fieldDef.type === "number" || fieldDef.type === "numeric") {
+      return this.numeric(fieldDef.min ?? 0, fieldDef.max ?? 10000, 2);
+    }
+    if (fieldDef.type === "boolean") return this.boolean();
+    if (fieldDef.type === "datetime") return this.datetime().toISOString();
+    return this.sentence(4);
+  }
+
   /**
    * Generate a fake value appropriate for an ORM field definition.
    * Respects min/max, minLength/maxLength, and type constraints.
@@ -71,67 +141,9 @@ export class FakeData extends CoreFakeData {
       return fieldDef.default;
     }
 
-    // Heuristic: use column name to pick a smarter generator
     const col = (columnName ?? "").toLowerCase();
-
-    if (col.includes("email")) return this.email();
-    if (col.includes("phone") || col.includes("mobile") || col.includes("tel")) return this.phone();
-    if (col === "name" || col === "full_name" || col === "fullname") {
-      return isProductTable(table) ? this.product() : this.name();
-    }
-    if (col === "first_name" || col === "firstname") return this.firstName();
-    if (col === "last_name" || col === "lastname" || col === "surname") return this.lastName();
-    if (col.includes("address")) return this.address();
-    if (col.includes("city")) return this.city();
-    if (col.includes("country")) return this.country();
-    if (col.includes("zip") || col.includes("postal")) return this.zipCode();
-    if (col.includes("company") || col.includes("org")) return this.company();
-    if (col.includes("job") || col.includes("title") || col.includes("position")) return this.jobTitle();
-    if (col.includes("url") || col.includes("website") || col.includes("link")) return this.url();
-    if (col.includes("color") || col.includes("colour")) return this.colorHex();
-    if (col.includes("uuid") || col === "guid") return this.uuid();
-    if (col === "ip" || col === "ip_address" || col === "ipaddress") return this.ipAddress();
-    if (col.includes("currency")) return this.currency();
-
-    // Fall back to type-based generation
-    switch (fieldDef.type) {
-      case "string": {
-        const maxLen = fieldDef.maxLength ?? 50;
-        const minLen = fieldDef.minLength ?? 3;
-        // Generate a sentence and trim to fit
-        let value = this.sentence(Math.max(2, Math.ceil(maxLen / 6)));
-        if (value.length > maxLen) value = value.slice(0, maxLen);
-        if (value.length < minLen) {
-          while (value.length < minLen) value += " " + this.word();
-          value = value.slice(0, maxLen);
-        }
-        return value;
-      }
-
-      case "text":
-        return this.paragraph(3);
-
-      case "integer": {
-        const min = (fieldDef.min as number) ?? 0;
-        const max = (fieldDef.max as number) ?? 10000;
-        return this.integer(min, max);
-      }
-
-      case "number":
-      case "numeric": {
-        const min = (fieldDef.min as number) ?? 0;
-        const max = (fieldDef.max as number) ?? 10000;
-        return this.numeric(min, max, 2);
-      }
-
-      case "boolean":
-        return this.boolean();
-
-      case "datetime":
-        return this.datetime().toISOString();
-
-      default:
-        return this.sentence(4);
-    }
+    const heuristic = COLUMN_HEURISTICS.find(([pattern]) => pattern.test(col));
+    if (heuristic) return this.heuristicValue(heuristic[1], table);
+    return this.typedValue(fieldDef);
   }
 }

package/packages/orm/src/migration.ts

@@ -811,6 +811,85 @@ export function parseSetTerm(statement: string): string | null {
   return m ? m[1] : null;
 }
 
+interface SplitState {
+  sql: string;
+  statements: string[];
+  current: string;
+  delimiter: string;
+  dlen: number;
+  i: number;
+  inDollarBlock: boolean;
+  inSlashBlock: boolean;
+}
+
+function consumeQuotedSql(state: SplitState, quote: string): void {
+  state.current += quote;
+  state.i += 1;
+  while (state.i < state.sql.length) {
+    if (state.sql[state.i] === quote && state.sql[state.i + 1] === quote) {
+      state.current += quote + quote;
+      state.i += 2;
+    } else {
+      state.current += state.sql[state.i];
+      state.i += 1;
+      if (state.sql[state.i - 1] === quote) break;
+    }
+  }
+}
+
+function consumeSpecialSqlToken(state: SplitState): boolean {
+  const { sql, i } = state;
+  const ch = sql[i];
+  if (!state.inSlashBlock && ch === "$" && sql[i + 1] === "$") {
+    state.current += "$$";
+    state.i += 2;
+    state.inDollarBlock = !state.inDollarBlock;
+    return true;
+  }
+  if (!state.inDollarBlock && ch === "/" && sql[i + 1] === "/" && !(i > 0 && sql[i - 1] === ":")) {
+    state.current += "//";
+    state.i += 2;
+    state.inSlashBlock = !state.inSlashBlock;
+    return true;
+  }
+  if (state.inDollarBlock || state.inSlashBlock) {
+    state.current += ch;
+    state.i += 1;
+    return true;
+  }
+  if (ch === "/" && sql[i + 1] === "*") {
+    const end = sql.indexOf("*/", i + 2);
+    state.i = end === -1 ? sql.length : end + 2;
+    return true;
+  }
+  if (ch === "-" && sql[i + 1] === "-") {
+    const end = sql.indexOf("\n", i + 2);
+    state.i = end === -1 ? sql.length : end;
+    return true;
+  }
+  if (ch === "'" || ch === '"') {
+    consumeQuotedSql(state, ch);
+    return true;
+  }
+  return false;
+}
+
+function consumeSqlDelimiter(state: SplitState): boolean {
+  if (state.dlen === 0 || !state.sql.startsWith(state.delimiter, state.i)) return false;
+  state.i += state.dlen;
+  const statement = state.current.trim();
+  state.current = "";
+  if (!statement) return true;
+  const newTerm = parseSetTerm(statement);
+  if (newTerm !== null) {
+    state.delimiter = newTerm;
+    state.dlen = newTerm.length;
+  } else {
+    state.statements.push(statement);
+  }
+  return true;
+}
+
 /**
  * Split SQL text into individual statements with a single-pass, quote- and
  * comment-aware scanner. The split decision is made character by character so
@@ -836,133 +915,24 @@ export function parseSetTerm(statement: string): string | null {
  * Mirrors the tina4-python `_split_statements` / tina4-php / tina4-ruby scanner (parity).
  */
 export function splitStatements(sql: string, delimiter = ";"): string[] {
-  // Normalize smart/curly quotes to straight ASCII first, so SQL pasted from
-  // an editor/doc (which converts " → “ ” and ' → ‘ ’) actually runs.
-  sql = normalizeQuotes(sql);
-
-  const statements: string[] = [];
-  let current = "";
-  const n = sql.length;
-  // Active statement terminator. Starts as the delimiter argument; a SET TERM
-  // directive can switch it mid-script (dlen recomputed) so a statement whose
-  // own body contains the default terminator stays intact.
-  let dlen = delimiter.length;
-  let i = 0;
-  let inDollarBlock = false;
-  let inSlashBlock = false;
-
-  while (i < n) {
-    const ch = sql[i];
-
-    // $$ … $$ stored-proc block (toggle).
-    if (!inSlashBlock && ch === "$" && i + 1 < n && sql[i + 1] === "$") {
-      current += "$$";
-      i += 2;
-      inDollarBlock = !inDollarBlock;
-      continue;
-    }
-
-    // // … // stored-proc block (toggle) — but NOT a `://` URL scheme.
-    if (
-      !inDollarBlock && ch === "/" && i + 1 < n && sql[i + 1] === "/" &&
-      !(i > 0 && sql[i - 1] === ":")
-    ) {
-      current += "//";
-      i += 2;
-      inSlashBlock = !inSlashBlock;
-      continue;
-    }
-
-    // Inside a stored-proc block: consume verbatim (inner ; never splits).
-    if (inDollarBlock || inSlashBlock) {
-      current += ch;
-      i += 1;
-      continue;
-    }
-
-    // Block comment /* … */ — stripped.
-    if (ch === "/" && i + 1 < n && sql[i + 1] === "*") {
-      const end = sql.indexOf("*/", i + 2);
-      i = end !== -1 ? end + 2 : n;
-      continue;
-    }
-
-    // Line comment -- … — stripped to end of line; the newline is left for the
-    // next iteration so line structure (and NEXT-line boundaries) survive.
-    if (ch === "-" && i + 1 < n && sql[i + 1] === "-") {
-      const end = sql.indexOf("\n", i + 2);
-      i = end !== -1 ? end : n;
-      continue;
-    }
-
-    // Single-quoted string literal — '' escapes a quote. Copied verbatim.
-    if (ch === "'") {
-      current += "'";
-      i += 1;
-      while (i < n) {
-        if (sql[i] === "'" && i + 1 < n && sql[i + 1] === "'") {
-          current += "''";
-          i += 2;
-        } else if (sql[i] === "'") {
-          current += "'";
-          i += 1;
-          break;
-        } else {
-          current += sql[i];
-          i += 1;
-        }
-      }
-      continue;
-    }
-
-    // Double-quoted identifier — "" escapes a quote. Same verbatim handling.
-    if (ch === '"') {
-      current += '"';
-      i += 1;
-      while (i < n) {
-        if (sql[i] === '"' && i + 1 < n && sql[i + 1] === '"') {
-          current += '""';
-          i += 2;
-        } else if (sql[i] === '"') {
-          current += '"';
-          i += 1;
-          break;
-        } else {
-          current += sql[i];
-          i += 1;
-        }
-      }
-      continue;
-    }
-
-    // Statement delimiter — only reached outside blocks/comments/strings. A
-    // SET TERM directive switches the active terminator and is consumed (never
-    // emitted); any other completed statement is collected.
-    if (dlen > 0 && sql.startsWith(delimiter, i)) {
-      i += dlen;
-      const stmt = current.trim();
-      current = "";
-      if (stmt) {
-        const newTerm = parseSetTerm(stmt);
-        if (newTerm !== null) {
-          delimiter = newTerm;
-          dlen = delimiter.length;
-        } else {
-          statements.push(stmt);
-        }
-      }
-      continue;
-    }
-
-    current += ch;
-    i += 1;
+  const state: SplitState = {
+    sql: normalizeQuotes(sql),
+    statements: [],
+    current: "",
+    delimiter,
+    dlen: delimiter.length,
+    i: 0,
+    inDollarBlock: false,
+    inSlashBlock: false,
+  };
+  while (state.i < state.sql.length) {
+    if (consumeSpecialSqlToken(state) || consumeSqlDelimiter(state)) continue;
+    state.current += state.sql[state.i];
+    state.i += 1;
   }
-
-  // Trailing statement (may not end with a delimiter). A trailing SET TERM
-  // directive is a no-op — consume it, don't emit it.
-  const stmt = current.trim();
-  if (stmt && parseSetTerm(stmt) === null) statements.push(stmt);
-  return statements;
+  const trailing = state.current.trim();
+  if (trailing && parseSetTerm(trailing) === null) state.statements.push(trailing);
+  return state.statements;
 }
 
 /**

package/packages/orm/src/seeder.ts

@@ -14,247 +14,15 @@
 //         real parent PKs, and warns on clear type mismatches.
 
 import { FakeData } from "./fakeData.js";
-import { adapterExecute, adapterFetch, adapterColumns, adapterInsert } from "./database.js";
+import { adapterFetch, adapterInsert } from "./database.js";
 import { Log } from "../../core/src/index.js";
-import type { DatabaseAdapter, FieldDefinition, FieldType } from "./types.js";
+import type { DatabaseAdapter, FieldDefinition } from "./types.js";
+import { clearTable } from "./seederTable.js";
+import type { SeedOptions, SeedSummary } from "./seederTypes.js";
 
-/**
- * Result of a seed run — `{ seeded, failed, errors }`.
- *
- * `errors` is a list of `{ row, message }` describing every skipped row
- * (`row` is the 0-based index). Mirrors the Python `SeedSummary`; Node tests
- * compare `.seeded` / `.failed` rather than the bare integer.
- */
-export interface SeedSummary {
-  seeded: number;
-  failed: number;
-  errors: Array<{ row: number; message: string }>;
-}
-
-/** Options shared by seedTable / seedOrm / seedModels. */
-export interface SeedOptions {
-  /** Static values applied to every row (overrides generated values). */
-  overrides?: Record<string, unknown>;
-  /** Delete every existing row in the target before seeding (P2). */
-  clear?: boolean;
-  /**
-   * PRNG seed for reproducible FakeData output (P3). Honoured by seedOrm and
-   * seedModels, which build and seed their own FakeData internally.
-   *
-   * NOT honoured by seedTable (SEED-TABLE-SEED-INERT, SEED-DEC-01, ratified
-   * 2026-08-11 — same principle as the no-op ForeignKeyField on_delete):
-   * seedTable has no generators of its own to seed — fieldMap callables are
-   * opaque — so this used to be a silent no-op there. Passing it to seedTable
-   * now THROWS instead. Build your own `new FakeData(seed)` and close over it
-   * in fieldMap: `const fake = new FakeData(42); seedTable(db, table, count,
-   * { name: () => fake.name() })`.
-   */
-  seed?: number;
-  /** Re-raise on the first failed row instead of skipping it (P1). */
-  strict?: boolean;
-}
-
-/**
- * Normalise the legacy positional `overrides` argument and the new options
- * object into a single SeedOptions. Backward compatible: callers passing a
- * plain overrides object as the 5th positional arg still work.
- */
-function normaliseOptions(
-  overrides?: Record<string, unknown>,
-  opts?: SeedOptions,
-): Required<Pick<SeedOptions, "clear" | "strict">> & { overrides?: Record<string, unknown> } {
-  const merged: SeedOptions = { ...(opts ?? {}) };
-  // The new `opts.overrides` takes precedence if both are supplied.
-  const effectiveOverrides = merged.overrides ?? overrides;
-  return {
-    overrides: effectiveOverrides,
-    clear: merged.clear ?? false,
-    strict: merged.strict ?? false,
-  };
-}
-
-/**
- * Delete every row in `table`. Tolerant — logs and continues on error so the
- * summary itself never crashes (mirrors Python `_clear_table`).
- */
-async function clearTable(db: DatabaseAdapter, tableName: string): Promise<void> {
-  try {
-    await adapterExecute(db, `DELETE FROM "${tableName}"`);
-  } catch (e) {
-    Log.warning(`Seeder: could not clear '${tableName}': ${(e as Error).message}`);
-  }
-}
-
-/**
- * Map a raw SQL column type string to a Tina4 FieldType so FakeData.forField()
- * can pick a generator. Substring match (case-insensitive) covers the engine
- * spellings — INTEGER/INT, REAL/FLOAT/DOUBLE/NUMERIC/DECIMAL, BOOL, DATE/TIME,
- * TEXT/CLOB. Anything else is a plain string.
- */
-function sqlTypeToFieldType(sqlType: string): FieldType {
-  const t = (sqlType || "").toUpperCase();
-  if (t.includes("INT")) return "integer";
-  if (t.includes("BOOL")) return "boolean";
-  if (t.includes("REAL") || t.includes("FLOA") || t.includes("DOUB") || t.includes("NUM") || t.includes("DEC")) return "number";
-  if (t.includes("DATE") || t.includes("TIME")) return "datetime";
-  if (t.includes("TEXT") || t.includes("CLOB")) return "text";
-  return "string";
-}
+export { autoFieldMap, seedTable } from "./seederTable.js";
+export type { SeedOptions, SeedSummary } from "./seederTypes.js";
 
-/**
- * Introspect `table`'s columns and build a column->generator field map for
- * {@link seedTable}, skipping the auto-increment / `id` primary key (the engine
- * assigns it). Mirrors the Python master's `auto_field_map`
- * (tina4_python/seeder/__init__.py): the shared "seed a table I did not
- * hand-write generators for" helper that both the dev-admin seed endpoint and
- * the MCP `seed_table` dev tool use — `seedTable` itself stays explicit
- * (no map = no rows), and this is how a caller opts into automatic generation.
- *
- * Reuses `FakeData.forField()` (column-name + type heuristics) so the generated
- * data matches every other Tina4 seeding path. Returns an empty map when the
- * table has no seedable columns, so `seedTable` then seeds nothing rather than
- * crashing.
- *
- * @param db - A DatabaseAdapter instance (pass `getAdapter()`, NOT the Database
- *             wrapper — the wrapper has no `columns()`).
- * @param table - The table to introspect.
- * @param fake - Optional shared FakeData (pass one seeded via `new FakeData(n)`
- *               for reproducible output).
- * @returns `{ column -> () => value }`, ready to hand to `seedTable`.
- */
-export async function autoFieldMap(
-  db: DatabaseAdapter,
-  table: string,
-  fake: FakeData = new FakeData(),
-): Promise<Record<string, () => unknown>> {
-  const columns = await adapterColumns(db, table);
-  const fieldMap: Record<string, () => unknown> = {};
-  for (const col of columns) {
-    const name = col.name;
-    const sqlType = String(col.type ?? "").toUpperCase();
-    // Skip the auto-increment surrogate key so the INSERT omits it and the
-    // engine assigns it. Mirrors Python: primary key AND (AUTO/SERIAL/IDENTITY
-    // in the type OR the column is literally `id` — SQLite reports just
-    // "INTEGER" for an AUTOINCREMENT rowid alias, so the name catch is needed).
-    if (col.primaryKey === true &&
-        (sqlType.includes("AUTO") || sqlType.includes("SERIAL") ||
-         sqlType.includes("IDENTITY") || name.toLowerCase() === "id")) {
-      continue;
-    }
-    const fieldType = sqlTypeToFieldType(sqlType);
-    // Bind the type + name per column; forField applies the name heuristics
-    // (email/phone/name/...) before falling back to the type. The TABLE name is
-    // threaded so a generic `name` column on a product-ish table seeds a
-    // product name, not a person name (parity with the Python auto_field_map).
-    fieldMap[name] = () => fake.forField({ type: fieldType }, name, table);
-  }
-  return fieldMap;
-}
-
-/**
- * Seed a database table with fake data using raw SQL inserts.
- *
- * Visible-but-resilient (P1): each row is wrapped. On a row failure the cause
- * is logged (with the row index) and the row is skipped — unless `strict: true`,
- * in which case the first failure RE-RAISES. At the end a one-line summary is
- * logged ("seeded N, M failed").
- *
- * @param db - A DatabaseAdapter instance
- * @param tableName - The table to insert into
- * @param count - Number of rows to insert (default 10)
- * @param fieldMap - Dict of column_name -> callable that generates a value
- *                   (or a static value). If not provided, no rows are inserted.
- * @param overrides - (legacy positional) Static values applied to every row.
- *                   Prefer `opts.overrides`.
- * @param opts - Seed options: `{ overrides, clear, strict }`. `opts.seed` is
- *   NOT honoured here (see {@link SeedOptions.seed}) and throws if supplied.
- * @returns A SeedSummary `{ seeded, failed, errors }`.
- * @throws {Error} If `opts.seed` is defined (SEED-TABLE-SEED-INERT removal).
- *
- * @example
- *   const fake = new FakeData();
- *   await seedTable(db, "users", 50, {
- *     name: () => fake.name(),
- *     email: () => fake.email(),
- *   }, undefined, { clear: true });
- */
-export async function seedTable(
-  db: DatabaseAdapter,
-  tableName: string,
-  count = 10,
-  fieldMap?: Record<string, (() => unknown) | unknown>,
-  overrides?: Record<string, unknown>,
-  opts?: SeedOptions,
-): Promise<SeedSummary> {
-  if (opts?.seed !== undefined) {
-    throw new Error(
-      "seedTable() no longer accepts opts.seed: it has no generators of its own to seed " +
-        "(fieldMap callables are opaque). Build a seeded FakeData yourself and close over it " +
-        "in fieldMap, e.g. const fake = new FakeData(42); seedTable(db, table, count, " +
-        "{ name: () => fake.name() }).",
-    );
-  }
-
-  const { overrides: effectiveOverrides, clear, strict } = normaliseOptions(overrides, opts);
-
-  if (!fieldMap || Object.keys(fieldMap).length === 0) {
-    return { seeded: 0, failed: 0, errors: [] };
-  }
-
-  if (clear) {
-    await clearTable(db, tableName);
-  }
-
-  let seeded = 0;
-  let failed = 0;
-  const errors: Array<{ row: number; message: string }> = [];
-
-  for (let i = 0; i < count; i++) {
-    try {
-      const row: Record<string, unknown> = {};
-
-      // Generate values from fieldMap
-      for (const [col, generator] of Object.entries(fieldMap)) {
-        row[col] = typeof generator === "function" ? (generator as () => unknown)() : generator;
-      }
-
-      // Apply static overrides
-      if (effectiveOverrides) {
-        for (const [col, value] of Object.entries(effectiveOverrides)) {
-          row[col] = value;
-        }
-      }
-
-      // Route through the adapter's OWN native insert path (feature 3's
-      // shared buildInsert()/Dialect) instead of hand-built SQL with a fixed
-      // quote style. A hardcoded double-quote works on PostgreSQL/MSSQL/
-      // SQLite but breaks Firebird: an unquoted CREATE TABLE folds the name
-      // to UPPERCASE, so a quoted lower-case INSERT target is a DIFFERENT,
-      // unfindable identifier ("Table unknown" -204) — the SAME class of
-      // engine-portability bug as PHP's old backtick-quoted seed_table.
-      // adapterInsert() RAISES on a constraint/SQL error since v3.13.x — the
-      // try/except is what turns that into a counted, logged, skipped failure.
-      await adapterInsert(
-        db,
-        tableName,
-        row,
-      );
-      seeded++;
-    } catch (e) {
-      const message = (e as Error).message ?? String(e);
-      if (strict) {
-        Log.error(`Seeder: row ${i} failed seeding '${tableName}' (strict): ${message}`);
-        throw e;
-      }
-      failed++;
-      errors.push({ row: i, message });
-      Log.warning(`Seeder: row ${i} failed seeding '${tableName}', skipped: ${message}`);
-    }
-  }
-
-  Log.info(`Seeder: '${tableName}' — seeded ${seeded}, ${failed} failed`);
-  return { seeded, failed, errors };
-}
 
 /** A model-like shape the seeder can drive (real BaseModel subclass or mock). */
 interface SeedableModel {