tina4-nodejs 3.13.97 → 3.13.99

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

@@ -58,6 +58,22 @@ export class MssqlAdapter implements DatabaseAdapter {
   constructor(private config: MssqlConfig | string) {}
 
   /** Connect to MSSQL. Must be called before using the adapter. */
+  /** ADR-0044 required adapter capability. */
+  getDatabaseType(): string {
+    return 'mssql';
+  }
+
+  /** ADR-0044: readable/writable native boolean. */
+  autocommit = true;
+
+  /**
+   * ADR-0044 / DBA-P02: every built-in adapter can guarantee an atomic
+   * multi-row batch by default. A test-only deployment representing one
+   * that cannot sets this false so executeMany rejects BEFORE the first
+   * write rather than risking partial durability.
+   */
+  supportsAtomicBatch = true;
+
   async connect(): Promise<void> {
     const tediousModule = requireTedious();
     const Connection = tediousModule.Connection;
@@ -176,7 +192,11 @@ export class MssqlAdapter implements DatabaseAdapter {
         params.forEach((p, i) => {
           const paramName = `p${i}`;
           let type = TYPES.NVarChar;
-          if (typeof p === "number") type = Number.isInteger(p) ? TYPES.Int : TYPES.Float;
+          // MSSQL-BUFFER-NODE: a Buffer is raw bytes -> VarBinary. Checked FIRST so
+          // it can never fall through to the NVarChar default, which applied a text
+          // encoding to the bytes and corrupted every binary write.
+          if (Buffer.isBuffer(p)) type = TYPES.VarBinary;
+          else if (typeof p === "number") type = Number.isInteger(p) ? TYPES.Int : TYPES.Float;
           else if (typeof p === "boolean") type = TYPES.Bit;
           else if (p instanceof Date) type = TYPES.DateTime;
           request.addParameter(paramName, type, p);
@@ -267,17 +287,22 @@ export class MssqlAdapter implements DatabaseAdapter {
 
   async fetchAsync<T = Record<string, unknown>>(sql: string, params?: unknown[], limit?: number, skip?: number): Promise<T[]> {
     let effectiveSql = sql;
-    if (limit !== undefined) {
-      if (skip !== undefined && skip > 0) {
-        // MSSQL uses OFFSET...FETCH for pagination (requires ORDER BY)
-        if (!/ORDER BY/i.test(effectiveSql)) {
-          effectiveSql += " ORDER BY (SELECT NULL)";
-        }
-        effectiveSql += ` OFFSET ${skip} ROWS FETCH NEXT ${limit} ROWS ONLY`;
-      } else {
-        // Use TOP for simple limit
-        effectiveSql = effectiveSql.replace(/^(SELECT)\b/i, `$1 TOP ${limit}`);
+    if (limit !== undefined && limit > 0) {
+      // MSSQL-PAGINATION-DIVERGE: ONE pagination strategy across all four
+      // frameworks - OFFSET/FETCH (the modern standard, requiring an ORDER BY),
+      // matching Python/PHP/Ruby. Node used to branch to `TOP n` for the first
+      // page (skip 0): it returned the same window but diverged the generated SQL
+      // and the `^SELECT` regex could not prefix a CTE / leading-comment / nested
+      // SELECT. OFFSET/FETCH appended after the ORDER BY is uniform and robust.
+      if (!/ORDER BY/i.test(effectiveSql)) {
+        effectiveSql += " ORDER BY (SELECT NULL)";
       }
+      effectiveSql += ` OFFSET ${skip ?? 0} ROWS FETCH NEXT ${limit} ROWS ONLY`;
+    } else if (limit === 0) {
+      // limit 0 == "zero rows" (the LIMIT 0 semantics the other Node adapters
+      // keep). OFFSET/FETCH cannot express `FETCH NEXT 0`, so TOP 0 remains for
+      // this one degenerate case only.
+      effectiveSql = effectiveSql.replace(/^(\s*SELECT)\b/i, "$1 TOP 0");
     }
     return this.queryAsync<T>(effectiveSql, params);
   }
@@ -580,6 +605,8 @@ function fieldTypeToMssql(def: FieldDefinition): string {
     case "number":
     case "numeric":
       return "FLOAT";
+    case "decimal":
+      return `DECIMAL(${def.precision ?? 10},${def.scale ?? 2})`;
     case "boolean":
       return "BIT";
     case "datetime":

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

@@ -57,6 +57,22 @@ export class MysqlAdapter implements DatabaseAdapter {
   constructor(private config: MysqlConfig | string) {}
 
   /** Connect to MySQL. Must be called before using the adapter. */
+  /** ADR-0044 required adapter capability. */
+  getDatabaseType(): string {
+    return 'mysql';
+  }
+
+  /** ADR-0044: readable/writable native boolean. */
+  autocommit = true;
+
+  /**
+   * ADR-0044 / DBA-P02: every built-in adapter can guarantee an atomic
+   * multi-row batch by default. A test-only deployment representing one
+   * that cannot sets this false so executeMany rejects BEFORE the first
+   * write rather than risking partial durability.
+   */
+  supportsAtomicBatch = true;
+
   async connect(): Promise<void> {
     const mod = requireMysql2();
 
@@ -368,8 +384,13 @@ export class MysqlAdapter implements DatabaseAdapter {
   async columnsAsync(table: string): Promise<ColumnInfo[]> {
     // v3.13.14 (#48): a qualified name ("db.table") must back-quote each part
     // separately, otherwise the dot is read as part of one identifier.
+    // MYSQL-DESCRIBE-UNPARAM: DESCRIBE takes an IDENTIFIER, not a bind parameter,
+    // so each part is STRICT-quoted with embedded backticks ESCAPED (doubled) -
+    // a crafted/odd name becomes ONE escaped identifier (a clean "unknown table",
+    // never runnable SQL) instead of a backtick in the name closing the quote.
     const [schema, tbl] = SQLTranslator.splitSchema(table);
-    const target = schema ? `\`${schema}\`.\`${tbl}\`` : `\`${tbl}\``;
+    const q = (part: string): string => "`" + String(part).replace(/`/g, "``") + "`";
+    const target = schema ? `${q(schema)}.${q(tbl)}` : q(tbl);
     const rows = await this.queryAsync<{
       Field: string;
       Type: string;
@@ -455,6 +476,8 @@ function fieldTypeToMysql(def: FieldDefinition): string {
     case "number":
     case "numeric":
       return "DOUBLE";
+    case "decimal":
+      return `DECIMAL(${def.precision ?? 10},${def.scale ?? 2})`;
     case "boolean":
       return "TINYINT(1)";
     case "datetime":

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

@@ -36,6 +36,10 @@ function requireOdbc(): any {
 export interface OdbcConfig {
   /** Full ODBC connection string, e.g. "DSN=MyDSN" or "DRIVER={SQL Server};SERVER=host;DATABASE=db" */
   connectionString: string;
+  /** Optional username; appended as UID when not already in the connection string. */
+  username?: string;
+  /** Optional password; appended as PWD when not already in the connection string. */
+  password?: string;
 }
 
 export class OdbcAdapter implements DatabaseAdapter {
@@ -56,6 +60,22 @@ export class OdbcAdapter implements DatabaseAdapter {
     return this.config.connectionString;
   }
 
+  /**
+   * The connection string with credentials applied. ODBC has no separate-
+   * credentials API (odbc.connect() reads only the string), so a username/
+   * password passed to Database.create() must be folded in as UID/PWD - the
+   * adapter used to drop them. Never used for diagnostics (describeTarget reads
+   * the raw string), so the password never reaches an error message.
+   */
+  private effectiveConnectionString(): string {
+    let connStr = this.getConnectionString();
+    if (typeof this.config === "string") return connStr;
+    const { username, password } = this.config;
+    if (username && !/(?:^|;)\s*UID\s*=/i.test(connStr)) connStr += `;UID=${username}`;
+    if (password && !/(?:^|;)\s*PWD\s*=/i.test(connStr)) connStr += `;PWD=${password}`;
+    return connStr;
+  }
+
   /**
    * The address for a diagnostic message. ODBC hides it inside an opaque
    * driver keyword string, so this reads the standard keywords and falls back to
@@ -72,9 +92,25 @@ export class OdbcAdapter implements DatabaseAdapter {
   }
 
   /** Connect to the ODBC data source. Must be called before using the adapter. */
+  /** ADR-0044 required adapter capability. */
+  getDatabaseType(): string {
+    return 'odbc';
+  }
+
+  /** ADR-0044: readable/writable native boolean. */
+  autocommit = true;
+
+  /**
+   * ADR-0044 / DBA-P02: every built-in adapter can guarantee an atomic
+   * multi-row batch by default. A test-only deployment representing one
+   * that cannot sets this false so executeMany rejects BEFORE the first
+   * write rather than risking partial durability.
+   */
+  supportsAtomicBatch = true;
+
   async connect(): Promise<void> {
     const odbc = requireOdbc();
-    const connStr = this.getConnectionString();
+    const connStr = this.effectiveConnectionString();
     // odbc package may expose connect as default export or named export
     const connectFn = odbc.connect ?? odbc.default?.connect;
     if (!connectFn) {
@@ -192,22 +228,31 @@ export class OdbcAdapter implements DatabaseAdapter {
   async executeManyAsync(sql: string, paramsList: unknown[][]): Promise<{ totalAffected: number; lastId?: number | bigint }> {
     this.ensureConnected();
     let totalAffected = 0;
-    let lastId: number | bigint | undefined;
 
-    await this.startTransactionAsync();
+    // Owns-guard (mirrors pg/mysql/mssql + the Python master): only manage the
+    // transaction when NOT already inside an explicit one. Without it, nested in
+    // a caller's transaction this method's commit() committed the OUTER
+    // transaction early.
+    const owns = !this._inTransaction;
+    if (owns) await this.startTransactionAsync();
     try {
       for (const params of paramsList) {
-        await this.connection.query(sql, params);
-        totalAffected++;
+        const result = await this.connection.query(sql, params);
+        totalAffected += this.affectedCount(result);
       }
-      await this.commitAsync();
+      if (owns) await this.commitAsync();
     } catch (e) {
-      await this.rollbackAsync();
+      if (owns) await this.rollbackAsync();
       throw e;
     }
 
-    if (lastId !== undefined) this._lastInsertId = lastId;
-    return { totalAffected, lastId: lastId };
+    return { totalAffected };
+  }
+
+  /** The real affected-row count from an odbc result, when the driver reports it. */
+  private affectedCount(result: any): number {
+    const n = result?.count;
+    return typeof n === "number" && n >= 0 ? n : 1;
   }
 
   /** Run a SELECT and return all matching rows. */
@@ -238,32 +283,64 @@ export class OdbcAdapter implements DatabaseAdapter {
     return rows[0] ?? null;
   }
 
-  /** Insert a single row into a table. */
-  async insertAsync(table: string, data: Record<string, unknown>): Promise<DatabaseResult> {
+  /** Insert a single row, or a list of rows as a batch. */
+  async insertAsync(table: string, data: Record<string, unknown> | Record<string, unknown>[]): Promise<DatabaseResult> {
     this.ensureConnected();
+
+    // A list of rows is a batch: ONE parameterised statement run per row through
+    // executeManyAsync (owns-guarded, one transaction), matching pg/mysql and the
+    // Python master. The single-object path used to run Object.keys() over the
+    // array here -> ["0","1",...], a broken INSERT, so batch insert never worked.
+    if (Array.isArray(data)) {
+      if (data.length === 0) return { success: true, affectedRows: 0 };
+      const keys = Object.keys(data[0]);
+      const sql = buildInsert(ANSI_DIALECT, table, keys);
+      const paramsList = data.map((row) => keys.map((k) => (row as Record<string, unknown>)[k]));
+      const { totalAffected } = await this.executeManyAsync(sql, paramsList);
+      return { success: true, affectedRows: totalAffected };
+    }
+
     const keys = Object.keys(data);
     const sql = buildInsert(ANSI_DIALECT, table, keys);
     const values = Object.values(data);
 
     try {
-      await this.connection.query(sql, values);
-      return { success: true, affectedRows: 1, lastId: this._lastInsertId ?? undefined };
+      const result = await this.connection.query(sql, values);
+      return { success: true, affectedRows: this.affectedCount(result), lastId: this._lastInsertId ?? undefined };
     } catch (e) {
       return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 
   /** Update rows in a table matching filter. */
-  async updateAsync(table: string, data: Record<string, unknown>, filter: Record<string, unknown>): Promise<DatabaseResult> {
+  async updateAsync(
+    table: string,
+    data: Record<string, unknown>,
+    filter: Record<string, unknown> | string,
+    params?: unknown[],
+  ): Promise<DatabaseResult> {
     this.ensureConnected();
     const setClauses = buildSetClause(ANSI_DIALECT, Object.keys(data));
-    const whereClauses = buildWhereClause(ANSI_DIALECT, Object.keys(filter));
-    const sql = `UPDATE ${ANSI_DIALECT.quote(table)} SET ${setClauses} WHERE ${whereClauses}`;
-    const values = [...Object.values(data), ...Object.values(filter)];
+
+    let whereSql: string;
+    let values: unknown[];
+    if (typeof filter === "string") {
+      // The string form ("id = ?" + params). Without this branch Object.keys()
+      // walked the STRING -> ["0","1",...], building a nonsense WHERE clause -
+      // the exact bug the pg/mysql/mssql adapters guard against. params was also
+      // dropped entirely (the method never took it), so a parameterised string
+      // filter could not bind at all.
+      whereSql = filter;
+      values = [...Object.values(data), ...(params ?? [])];
+    } else {
+      whereSql = buildWhereClause(ANSI_DIALECT, Object.keys(filter));
+      values = [...Object.values(data), ...Object.values(filter)];
+    }
+    const sql = `UPDATE ${ANSI_DIALECT.quote(table)} SET ${setClauses} WHERE ${whereSql}`;
 
     try {
-      await this.connection.query(sql, values);
-      return { success: true, affectedRows: 1 };
+      const result = await this.connection.query(sql, values);
+      return { success: true, affectedRows: this.affectedCount(result) };
     } catch (e) {
       return { success: false, affectedRows: 0, error: (e as Error).message };
     }
@@ -273,6 +350,7 @@ export class OdbcAdapter implements DatabaseAdapter {
   async deleteAsync(
     table: string,
     filter: Record<string, unknown> | string | Record<string, unknown>[],
+    params?: unknown[],
   ): Promise<DatabaseResult> {
     this.ensureConnected();
 
@@ -286,12 +364,13 @@ export class OdbcAdapter implements DatabaseAdapter {
     }
 
     if (typeof filter === "string") {
+      // The string form binds its own params (was dropped: query ran with []).
       const sql = filter
         ? `DELETE FROM "${table}" WHERE ${filter}`
         : `DELETE FROM "${table}"`;
       try {
-        await this.connection.query(sql, []);
-        return { success: true, affectedRows: 1 };
+        const result = await this.connection.query(sql, params ?? []);
+        return { success: true, affectedRows: this.affectedCount(result) };
       } catch (e) {
         return { success: false, affectedRows: 0, error: (e as Error).message };
       }
@@ -302,8 +381,8 @@ export class OdbcAdapter implements DatabaseAdapter {
     const values = Object.values(filter);
 
     try {
-      await this.connection.query(sql, values);
-      return { success: true, affectedRows: 1 };
+      const result = await this.connection.query(sql, values);
+      return { success: true, affectedRows: this.affectedCount(result) };
     } catch (e) {
       return { success: false, affectedRows: 0, error: (e as Error).message };
     }
@@ -349,17 +428,35 @@ export class OdbcAdapter implements DatabaseAdapter {
   /** Get column metadata for a table using ODBC catalog functions. */
   async columnsAsync(table: string): Promise<ColumnInfo[]> {
     this.ensureConnected();
-    // odbc.Connection.getColumns(catalog, schema, table, column)
+    // odbc.Connection.columns(catalog, schema, table, column)
     const rows: any[] = await this.connection.columns(null, null, table, null);
+    // Real PK, from the ODBC catalog (SQLPrimaryKeys) - not the old `false` stub.
+    // Feature 4's filterless-write guard reads primaryKey, so without this a
+    // PK-keyed update(table, data) on ODBC could not introspect the key.
+    const pk = await this.primaryKeyColumns(table);
     return rows.map((r: any) => ({
       name: r.COLUMN_NAME ?? r.column_name,
       type: r.TYPE_NAME ?? r.type_name ?? r.DATA_TYPE ?? "",
       nullable: (r.NULLABLE ?? r.nullable) === 1,
       default: r.COLUMN_DEF ?? r.column_def ?? null,
-      primaryKey: false, // ODBC catalog doesn't easily expose PK; requires separate primaryKeys() call
+      primaryKey: pk.has(String(r.COLUMN_NAME ?? r.column_name ?? "").toLowerCase()),
     }));
   }
 
+  /**
+   * The table's primary-key columns from the ODBC catalog (SQLPrimaryKeys),
+   * lower-cased for case-insensitive matching. Empty on any target that does not
+   * report them - the write-guard then requires an explicit filter.
+   */
+  private async primaryKeyColumns(table: string): Promise<Set<string>> {
+    try {
+      const rows: any[] = await this.connection.primaryKeys(null, null, table);
+      return new Set(rows.map((r: any) => String(r.COLUMN_NAME ?? r.column_name ?? "").toLowerCase()));
+    } catch {
+      return new Set();
+    }
+  }
+
   /** Check whether a table exists. */
   async tableExistsAsync(name: string): Promise<boolean> {
     this.ensureConnected();
@@ -371,7 +468,7 @@ export class OdbcAdapter implements DatabaseAdapter {
   async createTableAsync(name: string, columns: Record<string, FieldDefinition>): Promise<void> {
     const colDefs: string[] = [];
     for (const [colName, def] of Object.entries(columns)) {
-      const sqlType = fieldTypeToOdbc(def.type);
+      const sqlType = fieldTypeToOdbc(def);
       const parts = [`"${colName}" ${sqlType}`];
       if (def.primaryKey) parts.push("PRIMARY KEY");
       if (def.autoIncrement) parts.push("GENERATED ALWAYS AS IDENTITY"); // ANSI SQL
@@ -395,7 +492,7 @@ export class OdbcAdapter implements DatabaseAdapter {
 
   /** Add a column to an existing table. */
   async addColumnAsync(table: string, colName: string, def: FieldDefinition): Promise<void> {
-    const sqlType = fieldTypeToOdbc(def.type);
+    const sqlType = fieldTypeToOdbc(def);
     let sql = `ALTER TABLE "${table}" ADD COLUMN "${colName}" ${sqlType}`;
     if (def.default !== undefined && def.default !== "now") {
       sql += ` DEFAULT ${sqlDefault(def.default)}`;
@@ -422,11 +519,12 @@ export class OdbcAdapter implements DatabaseAdapter {
 // Helpers
 // ---------------------------------------------------------------------------
 
-function fieldTypeToOdbc(type: string): string {
-  switch (type) {
+function fieldTypeToOdbc(def: FieldDefinition): string {
+  switch (def.type) {
     case "integer": return "INTEGER";
     case "number":
     case "numeric": return "DOUBLE PRECISION";
+    case "decimal": return `DECIMAL(${def.precision ?? 10},${def.scale ?? 2})`;
     case "boolean": return "SMALLINT";
     case "datetime": return "TIMESTAMP";
     case "text": return "CLOB";

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

@@ -90,6 +90,22 @@ export class PostgresAdapter implements DatabaseAdapter {
   constructor(private config: PostgresConfig | string) {}
 
   /** Connect to PostgreSQL. Must be called before using the adapter. */
+  /** ADR-0044 required adapter capability. */
+  getDatabaseType(): string {
+    return 'postgres';
+  }
+
+  /** ADR-0044: readable/writable native boolean. */
+  autocommit = true;
+
+  /**
+   * ADR-0044 / DBA-P02: every built-in adapter can guarantee an atomic
+   * multi-row batch by default. A test-only deployment representing one
+   * that cannot sets this false so executeMany rejects BEFORE the first
+   * write rather than risking partial durability.
+   */
+  supportsAtomicBatch = true;
+
   async connect(): Promise<void> {
     const pgModule = requirePg();
     const Client = pgModule.Client ?? (pgModule as any).default?.Client;
@@ -559,6 +575,8 @@ function fieldTypeToPostgres(def: FieldDefinition): string {
     case "number":
     case "numeric":
       return "DOUBLE PRECISION";
+    case "decimal":
+      return `DECIMAL(${def.precision ?? 10},${def.scale ?? 2})`;
     case "boolean":
       return "BOOLEAN";
     case "datetime":

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

@@ -100,6 +100,32 @@ export class SQLiteAdapter implements DatabaseAdapter {
   private db: DatabaseSync;
   private _lastInsertId: number | bigint | null = null;
 
+  /** ADR-0044: readable/writable native boolean. */
+  autocommit = true;
+
+  /**
+   * ADR-0044 / DBA-P02: every built-in adapter can guarantee an atomic
+   * multi-row batch by default. A test-only deployment representing one that
+   * cannot (a standalone MongoDB without a replica set is the motivating real
+   * case) sets this false so executeMany rejects BEFORE the first write.
+   */
+  supportsAtomicBatch = true;
+
+  /** ADR-0044 required adapter capability. */
+  getDatabaseType(): string {
+    return "sqlite";
+  }
+
+  /**
+   * ADR-0044 canonical lifecycle name. A genuine no-op: `node:sqlite` opens
+   * the file synchronously in the constructor (see the timeout note below),
+   * so by the time a caller could reach connect() the adapter is already
+   * connected — repeated calls open no additional physical connection.
+   */
+  connect(): void {
+    // Already connected by the constructor.
+  }
+
   /**
    * TINA4_DATABASE_CONNECT_TIMEOUT DOES NOT APPLY HERE, deliberately.
    *
@@ -128,12 +154,48 @@ export class SQLiteAdapter implements DatabaseAdapter {
     return result;
   }
 
-  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastId?: number | bigint } {
+  executeMany(sql: string, paramsList: unknown[][]): DatabaseResult {
+    // ADR-0044 (DBA-B01): empty input is a successful no-op — it opens no
+    // transaction and performs no write.
+    if (paramsList.length === 0) {
+      return { success: true, affectedRows: 0 };
+    }
+
+    // ADR-0044 (DBA-B05): a ragged parameter set must fail BEFORE any durable
+    // partial success — checked against the FIRST row's length generically
+    // (no per-dialect placeholder parsing needed).
+    const expected = paramsList[0].length;
+    for (const params of paramsList) {
+      if (params.length !== expected) {
+        throw new Error(
+          `executeMany binding count mismatch - expected ${expected} parameters, got ${params.length}`,
+        );
+      }
+    }
+
+    // ADR-0044 (DBA-P02): reject an unsupported multi-row batch before the
+    // first write rather than risking partial durability.
+    if (!this.supportsAtomicBatch && paramsList.length > 1) {
+      throw new Error(
+        `provider "sqlite" cannot guarantee an atomic batch write on this deployment ` +
+        `(required deployment capability: a transaction-capable configuration) - ` +
+        `rejected before the first write rather than risking partial durability`,
+      );
+    }
+
     const stmt = this.db.prepare(sql);
     let totalAffected = 0;
     let lastId: number | bigint | undefined;
 
-    this.db.exec("BEGIN TRANSACTION");
+    // Own the transaction only when not ALREADY inside one — Database#execute
+    // Many (ADR-0044) already brackets ONE call to this method in its own
+    // start/commit/rollback when the caller is standalone, so this must join
+    // rather than double-BEGIN when called from there. Still safe to call
+    // directly/standalone (a caller bypassing the facade): startTransaction()/
+    // commit()/rollback() already guard on _inTransaction, exactly mirroring
+    // the facade's own owns-guard.
+    const owns = !this._inTransaction;
+    if (owns) this.startTransaction();
     try {
       for (const params of paramsList) {
         const result = stmt.run(...toSqlParams(params));
@@ -143,13 +205,13 @@ export class SQLiteAdapter implements DatabaseAdapter {
           this._lastInsertId = result.lastInsertRowid;
         }
       }
-      this.db.exec("COMMIT");
+      if (owns) this.commit();
     } catch (e) {
-      this.db.exec("ROLLBACK");
+      if (owns) this.rollback();
       throw e;
     }
 
-    return { totalAffected, lastId: lastId };
+    return { success: true, affectedRows: totalAffected, lastId };
   }
 
   query<T = Record<string, unknown>>(sql: string, params?: unknown[]): T[] {
@@ -181,7 +243,7 @@ export class SQLiteAdapter implements DatabaseAdapter {
       const sql = buildInsert(ANSI_DIALECT, table, keys);
       const paramsList = data.map((row) => keys.map((k) => row[k]));
       const result = this.executeMany(sql, paramsList);
-      return { success: true, affectedRows: result.totalAffected, lastId: result.lastId };
+      return { success: true, affectedRows: result.affectedRows, lastId: result.lastId };
     }
 
     const keys = Object.keys(data);
@@ -305,16 +367,32 @@ export class SQLiteAdapter implements DatabaseAdapter {
     const rows = this.db.prepare(pragma).all() as Array<{
       name: string; type: string; notnull: number; dflt_value: unknown; pk: number;
     }>;
-    return rows.map((r) => ({
+    return rows.map((r) => {
       // PRAGMA table_info reports `pk` as the 1-BASED POSITION within the primary
       // key, not a boolean: a composite key gives pk=1, pk=2, ... Testing `=== 1`
       // reported only the first column of a composite key.
-      name: r.name, type: r.type, nullable: r.notnull === 0, default: r.dflt_value, primaryKey: Number(r.pk) > 0,
-    }));
+      const pk = Number(r.pk);
+      return {
+        name: r.name, type: r.type, nullable: r.notnull === 0, default: r.dflt_value, primaryKey: pk > 0,
+        // ADR-0044 amendment (Feature 5 Decision 7): null for a non-key
+        // column; for a composite key this IS the declared PRIMARY KEY (...)
+        // order, not table-column order.
+        primaryKeyPosition: pk > 0 ? pk : null,
+      };
+    });
   }
 
   lastInsertId(): number | bigint | null { return this._lastInsertId; }
-  close(): void { this.db.close(); }
+  private _closed = false;
+
+  /** ADR-0044 (DBA-L02): idempotent — node:sqlite's DatabaseSync.close()
+   * throws when called on an already-closed database, so a second close()
+   * must not reach it. */
+  close(): void {
+    if (this._closed) return;
+    this.db.close();
+    this._closed = true;
+  }
 
   /**
    * Atomically increment and return the next value of a tina4_sequences row.
@@ -397,7 +475,7 @@ export class SQLiteAdapter implements DatabaseAdapter {
     const pkCols = Object.entries(columns).filter(([, d]) => d.primaryKey).map(([c]) => c);
     const composite = pkCols.length > 1;
     for (const [colName, def] of Object.entries(columns)) {
-      const sqlType = fieldTypeToSQLite(def.type);
+      const sqlType = fieldTypeToSQLite(def);
       const parts = [`"${colName}" ${sqlType}`];
       if (def.primaryKey && !composite) parts.push("PRIMARY KEY");
       if (def.autoIncrement) parts.push("AUTOINCREMENT");
@@ -419,7 +497,7 @@ export class SQLiteAdapter implements DatabaseAdapter {
   }
 
   addColumn(table: string, colName: string, def: FieldDefinition): void {
-    const sqlType = fieldTypeToSQLite(def.type);
+    const sqlType = fieldTypeToSQLite(def);
     let sql = `ALTER TABLE "${table}" ADD COLUMN "${colName}" ${sqlType}`;
     if (def.default !== undefined && def.default !== "now") sql += ` DEFAULT ${sqlDefault(def.default)}`;
     else if (def.default === "now") sql += " DEFAULT CURRENT_TIMESTAMP";
@@ -427,10 +505,11 @@ export class SQLiteAdapter implements DatabaseAdapter {
   }
 }
 
-function fieldTypeToSQLite(type: string): string {
-  switch (type) {
+function fieldTypeToSQLite(def: FieldDefinition): string {
+  switch (def.type) {
     case "integer": return "INTEGER";
     case "number": case "numeric": return "REAL";
+    case "decimal": return `DECIMAL(${def.precision ?? 10},${def.scale ?? 2})`;
     case "boolean": return "INTEGER";
     case "datetime": return "TEXT";
     case "text": return "TEXT";