tina4-nodejs 3.13.124 → 3.13.130

package/packages/orm/dist/index.js

@@ -915,6 +915,38 @@ var init_sqlTranslator = __esm({
             return sql;
         }
       }
+      /**
+       * Translate SQLite-canonical DDL column TYPES + CREATE-TABLE options to the
+       * target engine.
+       *
+       * ONLY acts on `CREATE TABLE` / `ALTER TABLE` statements, so a query or INSERT
+       * that happens to contain the word `TEXT` (a column name, a string literal) is
+       * never rewritten. Complements `autoIncrementSyntax` (which maps the id
+       * keyword) so ONE portable migration — and every `Model.createTable()` DDL,
+       * which is also SQLite-canonical — applies on every engine instead of failing
+       * on Firebird/MSSQL.
+       *
+       *   * Firebird has no `TEXT` (-607), no `REAL`, and no `CREATE TABLE IF NOT
+       *     EXISTS`.
+       *   * MSSQL has no `CREATE TABLE IF NOT EXISTS` and its `TIMESTAMP` is a
+       *     rowversion, not a datetime — a `created_at TIMESTAMP` there is wrong.
+       *   * MySQL's `TIMESTAMP` carries auto-update / 2038 surprises, so a datetime
+       *     column maps to `DATETIME` (matching the adapters' createTableAsync).
+       */
+      static ddlTypes(sql, engine) {
+        const head = sql.replace(/^(?:\s*--[^\n]*\n)+/, "");
+        if (!/^\s*(?:CREATE\s+TABLE|ALTER\s+TABLE)\b/i.test(head)) return sql;
+        switch ((engine ?? "").toLowerCase()) {
+          case "firebird":
+            return sql.replace(/\bIF\s+NOT\s+EXISTS\b/gi, "").replace(/\bBLOB\s+SUB_TYPE\s+TEXT\b/gi, "\0FBTEXT\0").replace(/\bTEXT\b/gi, "BLOB SUB_TYPE TEXT").replaceAll("\0FBTEXT\0", "BLOB SUB_TYPE TEXT").replace(/\bREAL\b/gi, "DOUBLE PRECISION");
+          case "mssql":
+            return sql.replace(/\bIF\s+NOT\s+EXISTS\b/gi, "").replace(/\bTIMESTAMP\b/gi, "DATETIME2");
+          case "mysql":
+            return sql.replace(/\bTIMESTAMP\b/gi, "DATETIME");
+          default:
+            return sql;
+        }
+      }
       /**
        * Convert ? placeholders to engine-specific style.
        *
@@ -12729,6 +12761,7 @@ __export(generate_exports, {
   parseEvery: () => parseEvery,
   parseFields: () => parseFields,
   pluralizeReserved: () => pluralizeReserved,
+  resolveTable: () => resolveTable,
   toPascal: () => toPascal,
   toSnake: () => toSnake,
   toTableName: () => toTableName
@@ -12771,12 +12804,35 @@ function toTableName(name) {
       from: raw,
       to: safe,
       reason: `SQL reserved word '${raw}' would break CREATE TABLE`,
-      override: `--table ${raw} --quote (requires quoted-identifier mode, not yet implemented)`
+      override: `--table-name <name> (table names interpolate unquoted; forcing a reserved name is yours to quote in raw SQL)`
     });
     return safe;
   }
   return raw;
 }
+function resolveTable(name, flags, opts = {}) {
+  const announce = opts.announce ?? false;
+  const override = (flags ?? {})["table-name"];
+  if (typeof override === "string" && override) {
+    if (announce && SQL_RESERVED_TABLE_NAMES.has(toSnake(override))) {
+      console.error(
+        `  ! table_name '${override}' is a SQL reserved word. Tina4 interpolates table names UNQUOTED, so the ORM's generated SQL will fail on it -- quote it yourself in raw SQL and migrations.`
+      );
+    }
+    return override;
+  }
+  const bare = toSnake(name);
+  if (!SQL_RESERVED_TABLE_NAMES.has(bare)) {
+    return bare;
+  }
+  const table2 = toTableName(name);
+  if (announce) {
+    console.error(
+      `  \xB7 '${bare}' is a SQL reserved word; using table_name '${table2}' (Tina4 interpolates table names unquoted). Override with --table-name <name>.`
+    );
+  }
+  return table2;
+}
 function resetResolution(target, input, opts) {
   __resolution.target = target;
   __resolution.input = input;
@@ -12875,10 +12931,11 @@ function printResolution() {
     lines.push(`  migration  ${b.migration_path}`);
   }
   const reserved = b.transformations.find((t) => t.kind === "reserved_word_pluralize");
-  if (reserved && reserved.from && reserved.override) {
+  if (reserved && reserved.from) {
     lines.push("");
-    lines.push(`  To keep the raw name '${reserved.from}' as the table:`);
-    lines.push(`    tina4nodejs generate ${__resolution.target} ${__resolution.input.name} ${reserved.override}`);
+    lines.push(`  To set the table name yourself:`);
+    lines.push(`    tina4nodejs generate ${__resolution.target} ${__resolution.input.name} --table-name <name>`);
+    lines.push(`  Tina4 interpolates table names unquoted; if you force the reserved '${reserved.from}', you own the quoting in raw SQL.`);
   }
   if (b.test_paths && b.test_paths.length > 0) {
     lines.push("");
@@ -13014,6 +13071,7 @@ async function generate(what, name, extraArgs = []) {
     console.error("  Usage: tina4nodejs generate <what> <name> [options]");
     console.error(`  Generators: ${GENERATOR_LIST}`);
     console.error('  Options:    --fields "name:string,price:float"  --model ModelName');
+    console.error("              --table-name <name>       force the model's table name (else derived; reserved words auto-pluralise)");
     console.error("              --public                 open a route's writes (default: secure)");
     console.error('              --every 5m | --cron "\u2026"   service schedule');
     console.error("              --json                    emit machine-readable resolution envelope on stdout");
@@ -13064,7 +13122,7 @@ async function generateProgrammatic(what, name, extraArgs = []) {
 }
 function generateModel(name, flags, emitTest = true) {
   const fields = fieldsOrDefault(flags.fields || "");
-  const table2 = toTableName(name);
+  const table2 = resolveTable(name, flags, { announce: true });
   const dir = resolve6("src/models");
   ensureDir(dir);
   const path8 = join15(dir, `${name}.ts`);
@@ -13115,7 +13173,7 @@ function generateRoute(name, flags, emitTest = true) {
   if (__resolution.target === "route") {
     setResolutionField("file_path", `src/routes/api/${routePath}/get.ts`);
   }
-  const table2 = model ? toTableName(model) : "";
+  const table2 = model ? resolveTable(model, flags, { announce: false }) : "";
   const modelImportBase = model ? `import ${model} from "../../../models/${model}.js";
 ` : "";
   const modelImportId = model ? `import ${model} from "../../../../models/${model}.js";
@@ -13336,7 +13394,7 @@ ${aiFill(`delete_${singular}`, {
   }
 }
 function generateCrud(name, flags) {
-  const table2 = toTableName(name);
+  const table2 = resolveTable(name, flags, { announce: false });
   const routeName = toPlural(table2);
   const isPublic = Boolean(flags.public);
   if (!__resolution.jsonMode) console.log(`
@@ -13363,7 +13421,7 @@ function generateMigration(name, flags, fieldsOverride, tableOverride, emitTest
     table2 = tableOverride;
   } else {
     const raw = name.replace(/^create_/, "").replace(/^add_/, "").replace(/^drop_/, "");
-    table2 = toTableName(raw);
+    table2 = resolveTable(raw, flags, { announce: false });
   }
   if (__resolution.target === "migration") {
     setResolutionField("table_name", table2);
@@ -13386,7 +13444,7 @@ function generateMigration(name, flags, fieldsOverride, tableOverride, emitTest
       const defaultClause = info.defaultVal !== "NULL" ? ` DEFAULT ${info.defaultVal}` : "";
       colLines.push(`    ${fname} ${info.sql}${defaultClause}`);
     }
-    colLines.push("    created_at TEXT DEFAULT CURRENT_TIMESTAMP");
+    colLines.push("    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP");
     upSql = `CREATE TABLE IF NOT EXISTS ${table2} (
     -- tina4:edit  add columns beyond id + created_at
 ${colLines.join(",\n")}
@@ -13589,7 +13647,7 @@ void test${titleName};
 }
 function generateForm(name, flags) {
   const fields = fieldsOrDefault(flags.fields || "");
-  const table2 = toTableName(name);
+  const table2 = resolveTable(name, flags, { announce: false });
   const routeName = toPlural(table2);
   const inputTypes = {
     string: "text",
@@ -13655,7 +13713,7 @@ function generateForm(name, flags) {
 }
 function generateView(name, flags) {
   const fields = fieldsOrDefault(flags.fields || "");
-  const table2 = toTableName(name);
+  const table2 = resolveTable(name, flags, { announce: false });
   const routeName = toPlural(table2);
   const cols = fields.map(([f]) => f);
   const dir = resolve6("src/templates/pages");
@@ -14010,8 +14068,8 @@ ${rules}  validator.required("name");   // starter rule (matches the model's def
   writeFileSafe(path8, content);
   emitValidatorTest(name, toSnake(name), toPascal(name));
 }
-function generateSeeder(name, _flags) {
-  const table2 = toTableName(name);
+function generateSeeder(name, flags) {
+  const table2 = resolveTable(name, flags, { announce: false });
   const dir = resolve6("src/seeds");
   ensureDir(dir);
   const path8 = join15(dir, `${table2}_seeder.ts`);
@@ -14529,8 +14587,8 @@ var init_generate = __esm({
   "../cli/src/commands/generate.ts"() {
     "use strict";
     FIELD_TYPE_MAP = {
-      string: { orm: '"string"', sql: "TEXT", defaultVal: "''" },
-      str: { orm: '"string"', sql: "TEXT", defaultVal: "''" },
+      string: { orm: '"string"', sql: "VARCHAR(255)", defaultVal: "''" },
+      str: { orm: '"string"', sql: "VARCHAR(255)", defaultVal: "''" },
       int: { orm: '"integer"', sql: "INTEGER", defaultVal: "0" },
       integer: { orm: '"integer"', sql: "INTEGER", defaultVal: "0" },
       float: { orm: '"number"', sql: "REAL", defaultVal: "0" },
@@ -14540,7 +14598,7 @@ var init_generate = __esm({
       bool: { orm: '"boolean"', sql: "INTEGER", defaultVal: "0" },
       boolean: { orm: '"boolean"', sql: "INTEGER", defaultVal: "0" },
       text: { orm: '"string"', sql: "TEXT", defaultVal: "''" },
-      datetime: { orm: '"datetime"', sql: "TEXT", defaultVal: "NULL" },
+      datetime: { orm: '"datetime"', sql: "TIMESTAMP", defaultVal: "NULL" },
       blob: { orm: '"string"', sql: "BLOB", defaultVal: "NULL" }
     };
     SQL_RESERVED_TABLE_NAMES = /* @__PURE__ */ new Set([
@@ -14636,7 +14694,7 @@ var init_generate = __esm({
     TINA4_EDIT_MARKER = /^\s*(?:\/\/|--|\{#|#)\s*tina4:edit\s+(.+?)(?:\s*#\})?\s*$/;
     DEFAULT_FIELDS = [["name", "string"]];
     GENERATORS = {
-      model: { handler: generateModel, usage: '<Name> [--fields "name:string,price:float"]', summary: "ORM model + matching migration" },
+      model: { handler: generateModel, usage: '<Name> [--fields "name:string,price:float"] [--table-name <name>]', summary: "ORM model + matching migration" },
       route: { handler: generateRoute, usage: "<name> [--model Name] [--public]", summary: "CRUD route file, secure by default (--public opens writes)" },
       crud: { handler: generateCrud, usage: '<Name> [--fields "..."] [--public]', summary: "Model + migration + routes + form + view + test" },
       migration: { handler: (n, f) => generateMigration(n, f, void 0, void 0, !f["no-test"]), usage: "<description>", summary: "Timestamped migration file (UP/DOWN)" },
@@ -28091,7 +28149,7 @@ function mulberry32(seed) {
     return ((t ^ t >>> 14) >>> 0) / 4294967296;
   };
 }
-var FIRST_NAMES, LAST_NAMES, DOMAINS, WORDS, CITIES, COUNTRIES, STREETS, JOB_TITLES, CURRENCIES, FakeData;
+var FIRST_NAMES, LAST_NAMES, DOMAINS, WORDS, CITIES, COUNTRIES, STREETS, JOB_TITLES, CURRENCIES, PRODUCT_ADJECTIVES, PRODUCT_NOUNS, FakeData;
 var init_fakeData = __esm({
   "../core/src/fakeData.ts"() {
     "use strict";
@@ -28353,6 +28411,59 @@ var init_fakeData = __esm({
       "ZAR",
       "INR"
     ];
+    PRODUCT_ADJECTIVES = [
+      "Wireless",
+      "Organic",
+      "Premium",
+      "Classic",
+      "Eco",
+      "Smart",
+      "Portable",
+      "Deluxe",
+      "Compact",
+      "Rustic",
+      "Handcrafted",
+      "Vintage",
+      "Modern",
+      "Ergonomic",
+      "Stainless",
+      "Bamboo",
+      "Recycled",
+      "Artisan",
+      "Professional",
+      "Ultra",
+      "Insulated",
+      "Lightweight",
+      "Adjustable",
+      "Foldable"
+    ];
+    PRODUCT_NOUNS = [
+      "Keyboard",
+      "Coffee Beans",
+      "Backpack",
+      "Water Bottle",
+      "Desk Lamp",
+      "Headphones",
+      "Notebook",
+      "Sneakers",
+      "Sunglasses",
+      "Wallet",
+      "Mug",
+      "Chair",
+      "Blender",
+      "Speaker",
+      "Charger",
+      "Umbrella",
+      "Toothbrush",
+      "Jacket",
+      "Watch",
+      "Kettle",
+      "Picture Frame",
+      "Planter",
+      "Cutlery Set",
+      "Yoga Mat",
+      "Phone Case"
+    ];
     FakeData = class _FakeData {
       rng;
       seeded;
@@ -28424,6 +28535,16 @@ var init_fakeData = __esm({
       jobTitle() {
         return this.pick(JOB_TITLES);
       }
+      /**
+       * A plausible product name, e.g. "Wireless Keyboard" or "Organic Coffee
+       * Beans" — an adjective + noun from the product vocabulary. Deterministic
+       * under a seed like every other generator (draws from the same instance
+       * PRNG). Used to seed a generic `name` column on a product-ish table instead
+       * of a person name (see the ORM FakeData `forField` heuristic).
+       */
+      product() {
+        return `${this.pick(PRODUCT_ADJECTIVES)} ${this.pick(PRODUCT_NOUNS)}`;
+      }
       paragraph(sentences = 4) {
         const parts = [];
         for (let i = 0; i < sentences; i++) {
@@ -37310,6 +37431,8 @@ var init_mysql = __esm({
       translateSql(sql) {
         let translated = SQLTranslator.concatPipesToFunc(sql);
         translated = SQLTranslator.ilikeToLike(translated);
+        translated = SQLTranslator.autoIncrementSyntax(translated, "mysql");
+        translated = SQLTranslator.ddlTypes(translated, "mysql");
         return translated;
       }
       execute(sql, params) {
@@ -37731,6 +37854,9 @@ var init_mssql = __esm({
         let translated = SQLTranslator.limitToTop(sql);
         translated = SQLTranslator.concatPipesToFunc(translated);
         translated = SQLTranslator.ilikeToLike(translated);
+        translated = SQLTranslator.autoIncrementSyntax(translated, "mssql");
+        translated = SQLTranslator.booleanToInt(translated);
+        translated = SQLTranslator.ddlTypes(translated, "mssql");
         return translated;
       }
       execSqlPromise(sql, params) {
@@ -38361,6 +38487,8 @@ var init_firebird = __esm({
         let translated = SQLTranslator.limitToRows(sql);
         translated = SQLTranslator.booleanToInt(translated);
         translated = SQLTranslator.ilikeToLike(translated);
+        translated = SQLTranslator.autoIncrementSyntax(translated, "firebird");
+        translated = SQLTranslator.ddlTypes(translated, "firebird");
         return translated;
       }
       /**
@@ -44300,11 +44428,27 @@ var init_baseModel = __esm({
 });
 
 // src/fakeData.ts
-var FakeData2;
+function isProductTable(table2) {
+  const t = (table2 ?? "").toLowerCase();
+  return PRODUCT_TABLE_HINTS.some((hint) => t.includes(hint));
+}
+var PRODUCT_TABLE_HINTS, FakeData2;
 var init_fakeData2 = __esm({
   "src/fakeData.ts"() {
     "use strict";
     init_fakeData();
+    PRODUCT_TABLE_HINTS = [
+      "product",
+      "item",
+      "catalog",
+      "inventory",
+      "goods",
+      "merchandise",
+      "sku",
+      "listing",
+      "stock",
+      "ware"
+    ];
     FakeData2 = class extends FakeData {
       constructor(seed) {
         super(seed);
@@ -44326,8 +44470,11 @@ var init_fakeData2 = __esm({
        *
        * @param fieldDef - An ORM FieldDefinition object
        * @param columnName - Optional column name for heuristic matching (e.g. "email", "phone")
+       * @param table - Optional table/model name. A generic `name`/`full_name`
+       *   column on a product-ish table (see {@link isProductTable}) gets a
+       *   product name; with no table context it stays a person name (back-compat).
        */
-      forField(fieldDef, columnName) {
+      forField(fieldDef, columnName, table2) {
         if (fieldDef.primaryKey && fieldDef.autoIncrement) {
           return void 0;
         }
@@ -44337,7 +44484,9 @@ var init_fakeData2 = __esm({
         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 this.name();
+        if (col === "name" || col === "full_name" || col === "fullname") {
+          return isProductTable(table2) ? 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();
@@ -44424,7 +44573,7 @@ async function autoFieldMap(db, table2, fake = new FakeData2()) {
       continue;
     }
     const fieldType = sqlTypeToFieldType(sqlType);
-    fieldMap[name] = () => fake.forField({ type: fieldType }, name);
+    fieldMap[name] = () => fake.forField({ type: fieldType }, name, table2);
   }
   return fieldMap;
 }
@@ -44570,7 +44719,7 @@ async function seedOrm(ormClass, count = 10, overrides, seed, opts, fkPools) {
         } else if (pools[name] && pools[name].length > 0) {
           attrs[name] = fake.choice(pools[name]);
         } else {
-          attrs[name] = fake.forField(def, name);
+          attrs[name] = fake.forField(def, name, modelName);
         }
       }
       validateTypes(fields, attrs, modelName);

package/packages/orm/src/adapters/firebird.ts

@@ -395,6 +395,13 @@ export class FirebirdAdapter implements DatabaseAdapter {
     let translated = SQLTranslator.limitToRows(sql);
     translated = SQLTranslator.booleanToInt(translated);
     translated = SQLTranslator.ilikeToLike(translated);
+    // DDL: strip AUTOINCREMENT (Firebird uses generators) and rewrite the
+    // SQLite-canonical column TYPES so ONE portable migration applies here —
+    // TEXT -> BLOB SUB_TYPE TEXT, REAL -> DOUBLE PRECISION, IF NOT EXISTS
+    // dropped. Both are DDL-only, so DML is untouched. Mirrors the Python
+    // master's firebird.py::_translate_sql.
+    translated = SQLTranslator.autoIncrementSyntax(translated, "firebird");
+    translated = SQLTranslator.ddlTypes(translated, "firebird");
     return translated;
   }
 

package/packages/orm/src/adapters/mssql.ts

@@ -172,6 +172,16 @@ export class MssqlAdapter implements DatabaseAdapter {
     let translated = SQLTranslator.limitToTop(sql);
     translated = SQLTranslator.concatPipesToFunc(translated);
     translated = SQLTranslator.ilikeToLike(translated);
+    // DDL: AUTOINCREMENT -> IDENTITY(1,1), drop IF NOT EXISTS (unsupported), and
+    // TIMESTAMP -> DATETIME2 (MSSQL's TIMESTAMP is a rowversion, not a datetime)
+    // so ONE portable migration applies here. Both are DDL-only, so DML is
+    // untouched. Mirrors the Python master's mssql.py::_translate_sql.
+    translated = SQLTranslator.autoIncrementSyntax(translated, "mssql");
+    // MSSQL has BIT, not a boolean type, so bare TRUE/FALSE must become 1/0
+    // (a TRUE/FALSE inside a string literal is data and is left untouched).
+    // Mirrors the Python master's mssql.py::_translate_sql.
+    translated = SQLTranslator.booleanToInt(translated);
+    translated = SQLTranslator.ddlTypes(translated, "mssql");
     return translated;
   }
 

package/packages/orm/src/adapters/mysql.ts

@@ -148,6 +148,12 @@ export class MysqlAdapter implements DatabaseAdapter {
     let translated = SQLTranslator.concatPipesToFunc(sql);
     // MySQL uses LOWER() LIKE instead of ILIKE
     translated = SQLTranslator.ilikeToLike(translated);
+    // DDL: AUTOINCREMENT -> AUTO_INCREMENT and TIMESTAMP -> DATETIME (MySQL's
+    // TIMESTAMP carries auto-update / 2038 surprises) so ONE portable migration
+    // applies here. Both are DDL-only, so DML is untouched. Mirrors the Python
+    // master's mysql.py::_translate_sql.
+    translated = SQLTranslator.autoIncrementSyntax(translated, "mysql");
+    translated = SQLTranslator.ddlTypes(translated, "mysql");
     return translated;
   }
 

package/packages/orm/src/fakeData.ts

@@ -5,6 +5,26 @@
 import { FakeData as CoreFakeData } from "../../core/src/fakeData.js";
 import type { FieldDefinition } from "./types.js";
 
+// A table/model whose name contains any of these gets product names on its
+// generic `name`/`full_name` column instead of a person name. Mirrors the
+// Python master's `_PRODUCT_TABLE_HINTS`.
+const PRODUCT_TABLE_HINTS = [
+  "product", "item", "catalog", "inventory", "goods", "merchandise",
+  "sku", "listing", "stock", "ware",
+] as const;
+
+/**
+ * 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
+ * context (undefined/null/empty) this is false, so the person-name default is
+ * kept — back-compat. Exported (not via the barrel) so seeding tests can assert
+ * it directly, mirroring the Python master's `_is_product_table`.
+ */
+export function isProductTable(table?: string | null): boolean {
+  const t = (table ?? "").toLowerCase();
+  return PRODUCT_TABLE_HINTS.some((hint) => t.includes(hint));
+}
+
 /**
  * ORM-aware FakeData — wraps the core FakeData and adds forField()
  * which generates appropriate fake data based on an ORM FieldDefinition.
@@ -32,8 +52,11 @@ export class FakeData extends CoreFakeData {
    *
    * @param fieldDef - An ORM FieldDefinition object
    * @param columnName - Optional column name for heuristic matching (e.g. "email", "phone")
+   * @param table - Optional table/model name. A generic `name`/`full_name`
+   *   column on a product-ish table (see {@link isProductTable}) gets a
+   *   product name; with no table context it stays a person name (back-compat).
    */
-  forField(fieldDef: FieldDefinition, columnName?: string): unknown {
+  forField(fieldDef: FieldDefinition, columnName?: string, table?: string): unknown {
     // Auto-increment primary keys should not be generated
     if (fieldDef.primaryKey && fieldDef.autoIncrement) {
       return undefined;
@@ -53,7 +76,9 @@ export class FakeData extends CoreFakeData {
 
     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 this.name();
+    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();

package/packages/orm/src/seeder.ts

@@ -143,8 +143,10 @@ export async function autoFieldMap(
     }
     const fieldType = sqlTypeToFieldType(sqlType);
     // Bind the type + name per column; forField applies the name heuristics
-    // (email/phone/name/...) before falling back to the type.
-    fieldMap[name] = () => fake.forField({ type: fieldType }, name);
+    // (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;
 }
@@ -427,7 +429,10 @@ export async function seedOrm(
         } else if (pools[name] && pools[name].length > 0) {
           attrs[name] = fake.choice(pools[name]);
         } else {
-          attrs[name] = fake.forField(def, name);
+          // Thread the MODEL name so a generic `name` column on a product-ish
+          // model seeds a product name, not a person name (Python seed_orm
+          // passes orm_class.__name__; modelName is name ?? tableName).
+          attrs[name] = fake.forField(def, name, modelName);
         }
       }
       validateTypes(fields, attrs, modelName);

package/packages/orm/src/sqlTranslator.ts

@@ -269,6 +269,51 @@ export class SQLTranslator {
     }
   }
 
+  /**
+   * Translate SQLite-canonical DDL column TYPES + CREATE-TABLE options to the
+   * target engine.
+   *
+   * ONLY acts on `CREATE TABLE` / `ALTER TABLE` statements, so a query or INSERT
+   * that happens to contain the word `TEXT` (a column name, a string literal) is
+   * never rewritten. Complements `autoIncrementSyntax` (which maps the id
+   * keyword) so ONE portable migration — and every `Model.createTable()` DDL,
+   * which is also SQLite-canonical — applies on every engine instead of failing
+   * on Firebird/MSSQL.
+   *
+   *   * Firebird has no `TEXT` (-607), no `REAL`, and no `CREATE TABLE IF NOT
+   *     EXISTS`.
+   *   * MSSQL has no `CREATE TABLE IF NOT EXISTS` and its `TIMESTAMP` is a
+   *     rowversion, not a datetime — a `created_at TIMESTAMP` there is wrong.
+   *   * MySQL's `TIMESTAMP` carries auto-update / 2038 surprises, so a datetime
+   *     column maps to `DATETIME` (matching the adapters' createTableAsync).
+   */
+  static ddlTypes(sql: string, engine: string): string {
+    // Gate to DDL only, tolerating leading `-- ...` comment lines / blank lines
+    // that a migration file carries before its CREATE TABLE. A SELECT or INSERT
+    // that merely mentions a type keyword is never rewritten.
+    const head = sql.replace(/^(?:\s*--[^\n]*\n)+/, "");
+    if (!/^\s*(?:CREATE\s+TABLE|ALTER\s+TABLE)\b/i.test(head)) return sql;
+    switch ((engine ?? "").toLowerCase()) {
+      case "firebird":
+        return sql
+          .replace(/\bIF\s+NOT\s+EXISTS\b/gi, "")
+          // Map bare TEXT -> BLOB SUB_TYPE TEXT, but leave an existing
+          // "BLOB SUB_TYPE TEXT" intact (it already contains the word TEXT).
+          .replace(/\bBLOB\s+SUB_TYPE\s+TEXT\b/gi, "\x00FBTEXT\x00")
+          .replace(/\bTEXT\b/gi, "BLOB SUB_TYPE TEXT")
+          .replaceAll("\x00FBTEXT\x00", "BLOB SUB_TYPE TEXT")
+          .replace(/\bREAL\b/gi, "DOUBLE PRECISION");
+      case "mssql":
+        return sql
+          .replace(/\bIF\s+NOT\s+EXISTS\b/gi, "")
+          .replace(/\bTIMESTAMP\b/gi, "DATETIME2");
+      case "mysql":
+        return sql.replace(/\bTIMESTAMP\b/gi, "DATETIME");
+      default:
+        return sql;
+    }
+  }
+
   /**
    * Convert ? placeholders to engine-specific style.
    *

package/types/cli/src/commands/generate.d.ts

@@ -10,6 +10,35 @@ export declare function pluralizeReserved(name: string): string;
  * routes and tests all agree on the same table name.
  */
 export declare function toTableName(name: string): string;
+/**
+ * The table name a generator uses (issue #123) — honours `--table-name` and
+ * speaks up instead of renaming SILENTLY. Mirrors the Python master's
+ * `_resolve_table` (tina4-python/tina4_python/cli/__init__.py).
+ *
+ * `announce` prints the note/warning; it is TRUE only for `generateModel` (where
+ * the table is born). Composite generators (crud) let the model sub-call
+ * announce, and generators that target an EXISTING table (route/seeder/form/view/
+ * migration) still honour `--table-name` but stay quiet so the note is not
+ * repeated — the note prints exactly once per `generate`.
+ *
+ *  • `--table-name <name>` wins verbatim. If that name is ITSELF a reserved word,
+ *    warn loudly (when announcing): Tina4 interpolates table names UNQUOTED, so
+ *    the ORM's generated SQL will fail on it — quoting it in raw SQL + migrations
+ *    is now the developer's job (we do NOT silently quote; identifier quoting is a
+ *    global storage invariant, not a local fix).
+ *  • Otherwise fall back to `toTableName` (snake + reserved-word pluralise). When
+ *    that auto-pluralises a reserved-word class name (`Order` -> `orders`), print a
+ *    one-line NOTE (when announcing) naming the rename and the `--table-name`
+ *    escape hatch, so the developer is informed rather than surprised.
+ *
+ * The note/warning goes to STDERR (console.error) so a `generate … --json` run
+ * keeps its stdout envelope pristine for a downstream `| jq`. `toTableName`'s
+ * `reserved_word_pluralize` envelope transformation is UNCHANGED (this ADDS the
+ * announce path; it does not touch the envelope contract).
+ */
+export declare function resolveTable(name: string, flags: Record<string, string | boolean> | undefined, opts?: {
+    announce?: boolean;
+}): string;
 /** One transformation the resolver made — visible to the caller so an AI
  * agent (or human) knows exactly why the output differs from the input. */
 export interface ResolutionTransformation {

package/types/cli/src/commands/lint.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Lint the project's source. Exits 0 = clean, 1 = findings (parity with the
+ * Python master and with `tina4nodejs test`'s exit-code contract).
+ */
+export declare function runLint(args: string[]): void;

package/types/core/src/fakeData.d.ts

@@ -1,3 +1,7 @@
+export declare const FIRST_NAMES: string[];
+export declare const LAST_NAMES: string[];
+export declare const PRODUCT_ADJECTIVES: string[];
+export declare const PRODUCT_NOUNS: string[];
 export declare class FakeData {
     private rng;
     private seeded;
@@ -19,6 +23,14 @@ export declare class FakeData {
     zipCode(): string;
     company(): string;
     jobTitle(): string;
+    /**
+     * A plausible product name, e.g. "Wireless Keyboard" or "Organic Coffee
+     * Beans" — an adjective + noun from the product vocabulary. Deterministic
+     * under a seed like every other generator (draws from the same instance
+     * PRNG). Used to seed a generic `name` column on a product-ish table instead
+     * of a person name (see the ORM FakeData `forField` heuristic).
+     */
+    product(): string;
     paragraph(sentences?: number): string;
     sentence(words?: number): string;
     word(): string;

package/types/orm/src/fakeData.d.ts

@@ -1,5 +1,13 @@
 import { FakeData as CoreFakeData } from "../../core/src/fakeData.js";
 import type { FieldDefinition } from "./types.js";
+/**
+ * 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
+ * context (undefined/null/empty) this is false, so the person-name default is
+ * kept — back-compat. Exported (not via the barrel) so seeding tests can assert
+ * it directly, mirroring the Python master's `_is_product_table`.
+ */
+export declare function isProductTable(table?: string | null): boolean;
 /**
  * ORM-aware FakeData — wraps the core FakeData and adds forField()
  * which generates appropriate fake data based on an ORM FieldDefinition.
@@ -17,6 +25,9 @@ export declare class FakeData extends CoreFakeData {
      *
      * @param fieldDef - An ORM FieldDefinition object
      * @param columnName - Optional column name for heuristic matching (e.g. "email", "phone")
+     * @param table - Optional table/model name. A generic `name`/`full_name`
+     *   column on a product-ish table (see {@link isProductTable}) gets a
+     *   product name; with no table context it stays a person name (back-compat).
      */
-    forField(fieldDef: FieldDefinition, columnName?: string): unknown;
+    forField(fieldDef: FieldDefinition, columnName?: string, table?: string): unknown;
 }