tina4-nodejs 3.13.125 → 3.13.130

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

@@ -177,6 +177,10 @@ export class MssqlAdapter implements DatabaseAdapter {
     // 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/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/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;
 }