tina4-nodejs 3.13.94 → 3.13.95

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

@@ -4,8 +4,10 @@
  * Install: npm install node-firebird
  * URL format: firebird://user:pass@host:port/path/to/database.fdb
  */
+import { firebirdDialect, buildInsert, buildSetClause, buildWhereClause } from "./sqlDialect.js";
 import type { DatabaseAdapter, DatabaseResult, ColumnInfo, FieldDefinition } from "../types.js";
 import { SQLTranslator } from "../sqlTranslator.js";
+import { connectTimeoutMillis, withConnectTimeout } from "../connectTimeout.js";
 import { createRequire } from "node:module";
 
 let firebird: any = null;
@@ -135,6 +137,66 @@ export interface FirebirdConfig {
   charset?: string;
 }
 
+/**
+ * Quote an identifier the way Firebird actually stores it: UPPERCASE.
+ *
+ * Firebird folds an UNQUOTED identifier to upper case and treats a QUOTED one as
+ * case-sensitive. So after the ordinary `CREATE TABLE probe_t (...)` the table is
+ * PROBE_T, and `INSERT INTO "probe_t"` matches nothing:
+ *
+ *     Dynamic SQL Error / Table unknown / probe_t
+ *
+ * That broke the insert path against every conventionally-created table, columns
+ * included. A name the caller has ALREADY quoted is passed through untouched,
+ * which is the escape hatch for a genuinely case-sensitive `CREATE TABLE "orders"`.
+ */
+export function fbQuote(name: string): string {
+  if (!name) return name;
+  const trimmed = name.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) return trimmed;
+  return `"${trimmed.toUpperCase().replace(/"/g, '""')}"`;
+}
+
+/**
+ * Firebird's dialect for the shared CRUD builder: its own upper-casing quoter,
+ * plain "?" markers. Defined here rather than in sqlDialect.ts because the
+ * quoting rule is a Firebird fact, not a generic one.
+ */
+const FB_DIALECT = firebirdDialect(fbQuote);
+
+/**
+ * Firebird's stored column name, folded back only when it was folded.
+ *
+ * Firebird's identifier folding is ASYMMETRIC. An unquoted `AS x` is stored
+ * UPPERCASE, so the driver hands back "X" where every other engine Tina4
+ * supports gives "x" — PostgreSQL folds to lower, and MySQL, SQLite and MSSQL
+ * preserve what you wrote. Portable code reading row.x broke on Firebird alone.
+ *
+ * A QUOTED `AS "MyCol"` is stored exactly as written, and that case is
+ * deliberate — the caller asked for it — so it is left alone. Folding
+ * unconditionally makes a mixed-case key unreachable, the same asymmetric trap
+ * that made tableExists miss quoted tables.
+ *
+ * So: fold back only a name carrying no lowercase letter, the only thing
+ * unquoted folding can produce. A quoted ALL-CAPS name is genuinely
+ * indistinguishable from a folded one and is lowercased too; that ambiguity is
+ * Firebird's, and it is the one spelling this cannot round-trip.
+ */
+export function firebirdColumnName(raw: string): string {
+  const name = raw.trim();
+  return name === name.toUpperCase() ? name.toLowerCase() : name;
+}
+
+/** Apply {@link firebirdColumnName} across one row's keys. */
+function foldColumnNames<T>(row: T): T {
+  if (row === null || typeof row !== "object" || Array.isArray(row)) return row;
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(row as Record<string, unknown>)) {
+    out[firebirdColumnName(k)] = v;
+  }
+  return out as T;
+}
+
 export class FirebirdAdapter implements DatabaseAdapter {
   private db: any = null;
   private transaction: any = null;
@@ -191,15 +253,20 @@ export class FirebirdAdapter implements DatabaseAdapter {
       fbConfig.database = normalizeFirebirdDbIdentifier(fbConfig.database);
     }
 
-    await new Promise<void>((resolve, reject) => {
-      fb.attach(fbConfig, (err: Error | null, db: any) => {
-        if (err) reject(err);
-        else {
-          this.db = db;
-          resolve();
-        }
-      });
-    });
+    // node-firebird has NO connect-timeout option of its own, so there is no
+    // driver timer to translate and the outer bound is the ONLY thing standing
+    // between a silent driver and a permanently hung boot. This is the adapter
+    // the 16-minute probe measured.
+    this.db = await withConnectTimeout(
+      () => new Promise<any>((resolve, reject) => {
+        fb.attach(fbConfig, (err: Error | null, db: any) => (err ? reject(err) : resolve(db)));
+      }),
+      connectTimeoutMillis(),
+      fbConfig.host,
+      fbConfig.port,
+      // Answered after we gave up: detach so the socket does not outlive the boot.
+      (db: any) => { try { db?.detach?.(() => {}); } catch { /* already gone */ } },
+    );
   }
 
   private parseUrl(url: string): { host?: string; port?: number; user?: string; password?: string; database?: string } {
@@ -312,7 +379,7 @@ export class FirebirdAdapter implements DatabaseAdapter {
   async queryAsync<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]> {
     this.ensureConnected();
     const rows = await this.queryPromise(sql, params);
-    return (rows as T[]).map(row => this.decodeBlobs(row));
+    return (rows as T[]).map(row => this.decodeBlobs(foldColumnNames(row)));
   }
 
   /** Ensure BLOB columns are readable — node-firebird may return callback-based
@@ -361,69 +428,81 @@ export class FirebirdAdapter implements DatabaseAdapter {
     if (Array.isArray(data)) {
       if (data.length === 0) return { success: true, affectedRows: 0 };
       const keys = Object.keys(data[0]);
-      const placeholders = keys.map(() => "?").join(", ");
-      const sql = `INSERT INTO "${table}" ("${keys.join('", "')}") VALUES (${placeholders})`;
+      const sql = buildInsert(FB_DIALECT, table, keys);
       const paramsList = data.map((row) => keys.map((k) => row[k]));
-      try {
-        const result = await this.executeManyAsync(sql, paramsList);
-        return { success: true, affectedRows: result.totalAffected, lastId: result.lastId };
-      } catch (e) {
-        return { success: false, affectedRows: 0, error: (e as Error).message };
-      }
+      const result = await this.executeManyAsync(sql, paramsList);
+      return { success: true, affectedRows: result.totalAffected, lastId: result.lastId };
     }
 
     const keys = Object.keys(data);
-    const placeholders = keys.map(() => "?").join(", ");
-    const sql = `INSERT INTO "${table}" ("${keys.join('", "')}") VALUES (${placeholders})`;
+    const sql = buildInsert(FB_DIALECT, table, keys);
     const values = Object.values(data);
 
-    try {
-      await this.executePromise(sql, values);
-      // Firebird doesn't have a generic last_insert_id — return success without id
-      return {
-        success: true,
-        affectedRows: 1,
-      };
-    } catch (e) {
-      return { success: false, affectedRows: 0, error: (e as Error).message };
-    }
+    // FAIL LOUD, like fetch/execute and the other three frameworks: a bad statement
+    // RAISES and never returns a falsy result. Swallowing it into {success:false}
+    // is what hid a wholly broken write path — the caller awaited a resolved
+    // promise, read back zero rows, and no error surfaced anywhere.
+    await this.executePromise(sql, values);
+    // Firebird doesn't have a generic last_insert_id — return success without id
+    return { success: true, affectedRows: 1 };
   }
 
   update(table: string, data: Record<string, unknown>, filter: Record<string, unknown>, params?: unknown[]): DatabaseResult {
     throw new Error("Use updateAsync() for Firebird.");
   }
 
-  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 = Object.keys(data).map((k) => `"${k}" = ?`).join(", ");
-    const whereClauses = Object.keys(filter).map((k) => `"${k}" = ?`).join(" AND ");
-    const sql = `UPDATE "${table}" SET ${setClauses} WHERE ${whereClauses}`;
-    const values = [...Object.values(data), ...Object.values(filter)];
-
-    try {
-      await this.executePromise(sql, values);
+    // Identifiers go through fbQuote, exactly like insertAsync. Firebird folds an
+    // UNQUOTED identifier to uppercase, so a conventional `CREATE TABLE probe_t`
+    // stores PROBE_T/ID — and a hand-rolled `"${k}"` emits lowercase-quoted "id",
+    // which is a DIFFERENT, non-existent column. update and delete were therefore
+    // broken on every conventionally-created Firebird table while insert worked.
+    const setClauses = buildSetClause(FB_DIALECT, Object.keys(data));
+
+    // A raw WHERE fragment + params is half the write_path contract's filter
+    // form. Without this branch Object.keys("id = ?") yields the STRING INDICES
+    // ["0","1",...] and the statement addresses columns that do not exist.
+    // Firebird already uses `?`, so the fragment needs no rewriting.
+    if (typeof filter === "string") {
+      const where = filter ? ` WHERE ${filter}` : "";
+      await this.executePromise(
+        `UPDATE ${fbQuote(table)} SET ${setClauses}${where}`,
+        [...Object.values(data), ...(params ?? [])],
+      );
       return { success: true, affectedRows: 1 };
-    } catch (e) {
-      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
+
+    const whereClauses = buildWhereClause(FB_DIALECT, Object.keys(filter));
+    const sql = `UPDATE ${FB_DIALECT.quote(table)} SET ${setClauses} WHERE ${whereClauses}`;
+    const values = [...Object.values(data), ...Object.values(filter)];
+
+    await this.executePromise(sql, values);
+    return { success: true, affectedRows: 1 };
   }
 
   delete(table: string, filter: Record<string, unknown>, params?: unknown[]): DatabaseResult {
     throw new Error("Use deleteAsync() for Firebird.");
   }
 
-  async deleteAsync(table: string, filter: Record<string, unknown>): Promise<DatabaseResult> {
+  async deleteAsync(table: string, filter: Record<string, unknown> | string, params?: unknown[]): Promise<DatabaseResult> {
     this.ensureConnected();
-    const whereClauses = Object.keys(filter).map((k) => `"${k}" = ?`).join(" AND ");
-    const sql = `DELETE FROM "${table}" WHERE ${whereClauses}`;
-    const values = Object.values(filter);
 
-    try {
-      await this.executePromise(sql, values);
+    // See updateAsync: truncate() calls this with "1 = 1", which walked the
+    // string as an object — db.truncate() was broken outright.
+    if (typeof filter === "string") {
+      const where = filter ? ` WHERE ${filter}` : "";
+      await this.executePromise(`DELETE FROM ${fbQuote(table)}${where}`, params ?? []);
       return { success: true, affectedRows: 1 };
-    } catch (e) {
-      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
+
+    // Same fbQuote policy as insert/update — see updateAsync.
+    const whereClauses = buildWhereClause(FB_DIALECT, Object.keys(filter));
+    const sql = `DELETE FROM ${FB_DIALECT.quote(table)} WHERE ${whereClauses}`;
+    const values = Object.values(filter);
+
+    await this.executePromise(sql, values);
+    return { success: true, affectedRows: 1 };
   }
 
   startTransaction(): void {
@@ -477,7 +556,7 @@ export class FirebirdAdapter implements DatabaseAdapter {
     });
   }
 
-  tables(): string[] {
+  getTables(): string[] {
     throw new Error("Use tablesAsync() for Firebird.");
   }
 
@@ -491,7 +570,7 @@ export class FirebirdAdapter implements DatabaseAdapter {
     });
   }
 
-  columns(table: string): ColumnInfo[] {
+  getColumns(table: string): ColumnInfo[] {
     throw new Error("Use columnsAsync() for Firebird.");
   }
 
@@ -503,6 +582,29 @@ export class FirebirdAdapter implements DatabaseAdapter {
        WHERE RF.RDB$RELATION_NAME = ?`,
       [table.toUpperCase()],
     );
+
+    // The primary key comes from the constraint catalogue. This used to be
+    // hardcoded false for every column, so the key was invisible to anything
+    // that introspects it -- including the filterless-write guard that lifts the
+    // PK out of `data`. Same bug the Python master and the Ruby driver carried.
+    const pkNames = new Set<string>();
+    try {
+      const pkRows = await this.queryAsync<Record<string, unknown>>(
+        `SELECT SG.RDB$FIELD_NAME FROM RDB$INDEX_SEGMENTS SG
+         JOIN RDB$RELATION_CONSTRAINTS RC ON SG.RDB$INDEX_NAME = RC.RDB$INDEX_NAME
+         WHERE RC.RDB$CONSTRAINT_TYPE = 'PRIMARY KEY' AND RC.RDB$RELATION_NAME = ?
+         ORDER BY SG.RDB$FIELD_POSITION`,
+        [table.toUpperCase()],
+      );
+      for (const row of pkRows) {
+        const raw = (row["RDB$FIELD_NAME"] ?? row["rdb$field_name"] ?? "") as string;
+        const trimmed = String(raw).trim().toUpperCase();
+        if (trimmed) pkNames.add(trimmed);
+      }
+    } catch {
+      // A table with no primary key is not an error.
+    }
+
     return rows.map((r) => {
       const name = (r["RDB$FIELD_NAME"] ?? r["rdb$field_name"] ?? "") as string;
       return {
@@ -510,7 +612,9 @@ export class FirebirdAdapter implements DatabaseAdapter {
         type: firebirdFieldTypeToString(r["RDB$FIELD_TYPE"] ?? r["rdb$field_type"]),
         nullable: (r["RDB$NULL_FLAG"] ?? r["rdb$null_flag"]) === null,
         default: r["RDB$DEFAULT_SOURCE"] ?? r["rdb$default_source"],
-        primaryKey: false,
+        primaryKey: pkNames.has(
+          (typeof name === "string" ? name.trim() : String(name).trim()).toUpperCase(),
+        ),
       };
     });
   }
@@ -531,10 +635,28 @@ export class FirebirdAdapter implements DatabaseAdapter {
     throw new Error("Use tableExistsAsync() for Firebird.");
   }
 
+  /**
+   * Is this table present, under either spelling Firebird could have stored?
+   *
+   * Firebird's folding rule is ASYMMETRIC:
+   *     CREATE TABLE foo     -> stored as FOO   (unquoted folds to UPPER)
+   *     CREATE TABLE "Foo"   -> stored as Foo   (quoted keeps its case)
+   *
+   * So upper-casing is CORRECT for the unquoted case - the common one - and
+   * WRONG for a quoted mixed-case table, which is a real thing on Firebird.
+   * Dropping the upper-case would not fix that, it would invert which half is
+   * broken.
+   *
+   * tableExistsAsync("Foo") is genuinely AMBIGUOUS: the caller could mean the
+   * quoted `Foo` or the unquoted `FOO`. Match EITHER. Do not "simplify" this
+   * back to one comparison - that is the bug it replaces, where a quoted
+   * mixed-case table read as absent and createTableAsync's idempotency guard
+   * (below) never fired.
+   */
   async tableExistsAsync(name: string): Promise<boolean> {
     const rows = await this.queryAsync<Record<string, unknown>>(
-      "SELECT RDB$RELATION_NAME FROM RDB$RELATIONS WHERE RDB$RELATION_NAME = ?",
-      [name.toUpperCase()],
+      "SELECT RDB$RELATION_NAME FROM RDB$RELATIONS WHERE RDB$RELATION_NAME = ? OR RDB$RELATION_NAME = ?",
+      [name, name.toUpperCase()],
     );
     return rows.length > 0;
   }
@@ -552,7 +674,12 @@ export class FirebirdAdapter implements DatabaseAdapter {
 
     for (const [colName, def] of Object.entries(columns)) {
       const sqlType = fieldTypeToFirebird(def);
-      const parts = [`"${colName}" ${sqlType}`];
+      // fbQuote, not a hand-rolled `"${colName}"` — DDL must agree with the write
+      // path or the ORM creates a table it cannot write to. Lowercase-quoted "id"
+      // is a case-sensitive column; every insert/update/delete addresses ID.
+      // tableExistsAsync looks up name.toUpperCase() and would not have found it
+      // either, so createTableAsync would re-run and fail already-exists.
+      const parts = [`${fbQuote(colName)} ${sqlType}`];
 
       if (def.primaryKey && !def.autoIncrement) parts.push("PRIMARY KEY");
       if (def.required && !def.primaryKey) parts.push("NOT NULL");
@@ -568,7 +695,7 @@ export class FirebirdAdapter implements DatabaseAdapter {
       colDefs.push(parts.join(" "));
     }
 
-    const sql = `CREATE TABLE "${name}" (${colDefs.join(", ")})`;
+    const sql = `CREATE TABLE ${fbQuote(name)} (${colDefs.join(", ")})`;
     await this.executeAsync(sql);
 
     // Create sequences and triggers for auto-increment columns
@@ -579,7 +706,7 @@ export class FirebirdAdapter implements DatabaseAdapter {
 
         await this.executeAsync(`CREATE SEQUENCE "${seqName}"`);
         await this.executeAsync(
-          `CREATE TRIGGER "${trigName}" FOR "${name}" ACTIVE BEFORE INSERT POSITION 0 AS BEGIN IF (NEW."${colName}" IS NULL) THEN NEW."${colName}" = NEXT VALUE FOR "${seqName}"; END`,
+          `CREATE TRIGGER "${trigName}" FOR ${fbQuote(name)} ACTIVE BEFORE INSERT POSITION 0 AS BEGIN IF (NEW.${fbQuote(colName)} IS NULL) THEN NEW.${fbQuote(colName)} = NEXT VALUE FOR "${seqName}"; END`,
         );
       }
     }

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

@@ -5,6 +5,7 @@
  * URL format: mongodb://host:port/dbname  or  mongodb+srv://user:pass@host/dbname
  */
 import type { DatabaseAdapter, DatabaseResult, ColumnInfo, FieldDefinition } from "../types.js";
+import { connectTarget, connectTimeoutMillis, driverConnectTimeoutMillis, withConnectTimeout } from "../connectTimeout.js";
 
 export interface MongoConfig {
   host?: string;
@@ -309,8 +310,28 @@ export class MongodbAdapter implements DatabaseAdapter {
       );
     }
 
-    this.client = new MongoClient(this._connectionString);
-    await this.client.connect();
+    // The driver's own budget is 30s (serverSelectionTimeoutMS and
+    // connectTimeoutMS both). It is set from the Tina4 budget so ONE variable
+    // governs, and omitted when the bound is disabled so the driver keeps its
+    // own 30s exactly as before.
+    const budgetMs = connectTimeoutMillis();
+    const driverMs = driverConnectTimeoutMillis(budgetMs);
+    const timeoutOptions = driverMs === null
+      ? {}
+      : { serverSelectionTimeoutMS: driverMs, connectTimeoutMS: driverMs };
+
+    const { host, port } = connectTarget(this._connectionString, 27017);
+    await withConnectTimeout(
+      () => {
+        this.client = new MongoClient(this._connectionString, timeoutOptions);
+        return this.client.connect();
+      },
+      budgetMs,
+      host,
+      port,
+      // Answered after we gave up: close it so the pool does not outlive the boot.
+      () => { void Promise.resolve(this.client?.close()).catch(() => { /* already gone */ }); },
+    );
     this.db = this.client.db(this._dbName);
   }
 
@@ -556,7 +577,7 @@ export class MongodbAdapter implements DatabaseAdapter {
     this._inTransaction = false;
   }
 
-  tables(): string[] {
+  getTables(): string[] {
     throw new Error("Use tablesAsync() for MongoDB — async adapter requires async methods.");
   }
 
@@ -566,7 +587,7 @@ export class MongodbAdapter implements DatabaseAdapter {
     return collections.map((c: any) => c.name as string);
   }
 
-  columns(table: string): ColumnInfo[] {
+  getColumns(table: string): ColumnInfo[] {
     throw new Error("Use columnsAsync() for MongoDB — async adapter requires async methods.");
   }
 

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

@@ -4,8 +4,10 @@
  * Install: npm install tedious
  * URL format: mssql://user:pass@host:port/database
  */
+import { ANSI_DIALECT, MSSQL_DIALECT, buildInsert, buildSetClause, buildWhereClause } from "./sqlDialect.js";
 import type { DatabaseAdapter, DatabaseResult, ColumnInfo, FieldDefinition } from "../types.js";
 import { SQLTranslator } from "../sqlTranslator.js";
+import { connectTimeoutMillis, driverConnectTimeoutMillis, withConnectTimeout } from "../connectTimeout.js";
 import { createRequire } from "node:module";
 
 let tedious: any = null;
@@ -38,6 +40,14 @@ export interface MssqlConfig {
 }
 
 export class MssqlAdapter implements DatabaseAdapter {
+  /**
+   * Postgres, MySQL and MSSQL all REQUIRE a name for a derived table, so
+   * the COUNT probe in Database.countProbe wraps as
+   * `FROM (sql) AS _count_query`. SQLite and Firebird leave this unset and
+   * get no alias - Firebird rejects `AS` in that position.
+   */
+  readonly countSubqueryAlias = "_count_query";
+
   private connection: any = null;
   private _lastInsertId: number | bigint | null = null;
   // True between startTransactionAsync() and commit/rollback. executeManyAsync
@@ -52,6 +62,14 @@ export class MssqlAdapter implements DatabaseAdapter {
     const tediousModule = requireTedious();
     const Connection = tediousModule.Connection;
 
+    // tedious has its own connectTimeout (15s by default). It is set from the
+    // Tina4 budget so ONE variable governs - otherwise a configured 60s would
+    // still fail at tedious's 15s, with tedious's message, and the variable
+    // would be a lie. Omitted when the bound is disabled, restoring the old 15s.
+    const budgetMs = connectTimeoutMillis();
+    const driverMs = driverConnectTimeoutMillis(budgetMs);
+    const timeoutOption = driverMs === null ? {} : { connectTimeout: driverMs };
+
     let tediousConfig: any;
 
     if (typeof this.config === "string") {
@@ -70,6 +88,7 @@ export class MssqlAdapter implements DatabaseAdapter {
           port: parsed.port ?? 1433,
           trustServerCertificate: true,
           encrypt: false,
+          ...timeoutOption,
         },
       };
     } else {
@@ -87,19 +106,29 @@ export class MssqlAdapter implements DatabaseAdapter {
           port: this.config.port ?? 1433,
           trustServerCertificate: true,
           encrypt: false,
+          ...timeoutOption,
           ...this.config.options,
         },
       };
     }
 
-    await new Promise<void>((resolve, reject) => {
-      this.connection = new Connection(tediousConfig);
-      this.connection.on("connect", (err: Error | null) => {
-        if (err) reject(err);
-        else resolve();
-      });
-      this.connection.connect();
-    });
+    // Inside the thunk so the Tina4 clock starts before tedious arms its own
+    // connectTimer (connection.js, at the top of its connect flow).
+    await withConnectTimeout(
+      () => new Promise<void>((resolve, reject) => {
+        this.connection = new Connection(tediousConfig);
+        this.connection.on("connect", (err: Error | null) => {
+          if (err) reject(err);
+          else resolve();
+        });
+        this.connection.connect();
+      }),
+      budgetMs,
+      tediousConfig.server ?? "localhost",
+      tediousConfig.options?.port ?? 1433,
+      // Answered after we gave up: close it so the socket does not outlive the boot.
+      () => { try { this.connection?.close?.(); } catch { /* already gone */ } },
+    );
   }
 
   private parseUrl(url: string): { host: string; port?: number; user?: string; password?: string; database?: string } {
@@ -166,9 +195,15 @@ export class MssqlAdapter implements DatabaseAdapter {
     });
   }
 
-  /** Convert ? placeholders to @p0, @p1, ... for tedious. */
-  private convertPlaceholders(sql: string): string {
-    let count = 0;
+  /**
+   * Convert ? placeholders to @p0, @p1, ... for tedious.
+   *
+   * `startAt` lets a caller that has already consumed N placeholders (an UPDATE
+   * whose SET values are @p0..@p{N-1}) continue the numbering into a raw WHERE
+   * fragment instead of restarting at @p0.
+   */
+  private convertPlaceholders(sql: string, startAt = 0): string {
+    let count = startAt;
     return sql.replace(/\?/g, () => {
       return `@p${count++}`;
     });
@@ -272,8 +307,8 @@ export class MssqlAdapter implements DatabaseAdapter {
       const keys = Object.keys(data[0]);
       // `?` placeholders — executeManyAsync -> executeAsync runs convertPlaceholders,
       // which rewrites them to @p0, @p1, ... for tedious.
-      const placeholders = keys.map(() => "?").join(", ");
-      const sql = `INSERT INTO [${table}] ([${keys.join("], [")}]) VALUES (${placeholders})`;
+      // The batch path binds through executeMany, which converts "?" itself.
+      const sql = buildInsert({ quote: MSSQL_DIALECT.quote, marker: ANSI_DIALECT.marker }, table, keys);
       const paramsList = data.map((row) => keys.map((k) => row[k]));
       try {
         const result = await this.executeManyAsync(sql, paramsList);
@@ -285,8 +320,9 @@ export class MssqlAdapter implements DatabaseAdapter {
     }
 
     const keys = Object.keys(data);
-    const placeholders = keys.map((_, i) => `@p${i}`).join(", ");
-    const sql = `INSERT INTO [${table}] ([${keys.join("], [")}]) VALUES (${placeholders}); SELECT SCOPE_IDENTITY() AS id`;
+    // startAt 0: MSSQL BINDS by the marker name, so @p must start where the
+    // binding loop starts. Shifting to 1 would name parameters that do not exist.
+    const sql = buildInsert(MSSQL_DIALECT, table, keys, "; SELECT SCOPE_IDENTITY() AS id", 0);
     const values = Object.values(data);
 
     try {
@@ -311,15 +347,33 @@ export class MssqlAdapter implements DatabaseAdapter {
     throw new Error("Use updateAsync() for MSSQL.");
   }
 
-  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 dataKeys = Object.keys(data);
-    const filterKeys = Object.keys(filter);
     let paramIndex = 0;
+    const setClauses = buildSetClause(MSSQL_DIALECT, dataKeys, paramIndex);
+    paramIndex += dataKeys.length;
+
+    // A raw WHERE fragment + params is half the write_path contract's filter
+    // form. Without this branch Object.keys("id = ?") yields the STRING INDICES
+    // ["0","1",...], producing `WHERE [0] = @p1 AND [1] = @p2` — SQL Server then
+    // reports an invalid column name '0'.
+    if (typeof filter === "string") {
+      const where = filter ? ` WHERE ${this.convertPlaceholders(filter, paramIndex)}` : "";
+      const sql = `UPDATE ${MSSQL_DIALECT.quote(table)} SET ${setClauses}${where}`;
+      const values = [...Object.values(data), ...(params ?? [])];
+      try {
+        const result = await this.execSqlPromise(sql, values);
+        return { success: true, affectedRows: result.rowCount };
+      } catch (e) {
+        return { success: false, affectedRows: 0, error: (e as Error).message };
+      }
+    }
 
-    const setClauses = dataKeys.map((k) => `[${k}] = @p${paramIndex++}`).join(", ");
-    const whereClauses = filterKeys.map((k) => `[${k}] = @p${paramIndex++}`).join(" AND ");
-    const sql = `UPDATE [${table}] SET ${setClauses} WHERE ${whereClauses}`;
+    const filterKeys = Object.keys(filter);
+    const whereClauses = buildWhereClause(MSSQL_DIALECT, filterKeys, paramIndex);
+    paramIndex += filterKeys.length;
+    const sql = `UPDATE ${MSSQL_DIALECT.quote(table)} SET ${setClauses} WHERE ${whereClauses}`;
     const values = [...Object.values(data), ...Object.values(filter)];
 
     try {
@@ -334,12 +388,28 @@ export class MssqlAdapter implements DatabaseAdapter {
     throw new Error("Use deleteAsync() for MSSQL.");
   }
 
-  async deleteAsync(table: string, filter: Record<string, unknown>): Promise<DatabaseResult> {
+  async deleteAsync(table: string, filter: Record<string, unknown> | string, params?: unknown[]): Promise<DatabaseResult> {
     this.ensureConnected();
+
+    // See updateAsync: truncate() calls this with "1 = 1", which became
+    // `WHERE [0] = @p0 AND [1] = @p1 ...` — db.truncate() was broken outright.
+    if (typeof filter === "string") {
+      const sql = filter
+        ? `DELETE FROM [${table}] WHERE ${this.convertPlaceholders(filter)}`
+        : `DELETE FROM [${table}]`;
+      try {
+        const result = await this.execSqlPromise(sql, params ?? []);
+        return { success: true, affectedRows: result.rowCount };
+      } catch (e) {
+        return { success: false, affectedRows: 0, error: (e as Error).message };
+      }
+    }
+
     const filterKeys = Object.keys(filter);
     let paramIndex = 0;
-    const whereClauses = filterKeys.map((k) => `[${k}] = @p${paramIndex++}`).join(" AND ");
-    const sql = `DELETE FROM [${table}] WHERE ${whereClauses}`;
+    const whereClauses = buildWhereClause(MSSQL_DIALECT, filterKeys, paramIndex);
+    paramIndex += filterKeys.length;
+    const sql = `DELETE FROM ${MSSQL_DIALECT.quote(table)} WHERE ${whereClauses}`;
     const values = Object.values(filter);
 
     try {
@@ -389,7 +459,7 @@ export class MssqlAdapter implements DatabaseAdapter {
     this._inTransaction = false;
   }
 
-  tables(): string[] {
+  getTables(): string[] {
     throw new Error("Use tablesAsync() for MSSQL.");
   }
 
@@ -400,7 +470,7 @@ export class MssqlAdapter implements DatabaseAdapter {
     return rows.map((r) => r.TABLE_NAME);
   }
 
-  columns(table: string): ColumnInfo[] {
+  getColumns(table: string): ColumnInfo[] {
     throw new Error("Use columnsAsync() for MSSQL.");
   }
 
@@ -413,17 +483,32 @@ export class MssqlAdapter implements DatabaseAdapter {
       DATA_TYPE: string;
       IS_NULLABLE: string;
       COLUMN_DEFAULT: string | null;
+      is_primary: number;
     }>(
-      "SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT FROM INFORMATION_SCHEMA.COLUMNS " +
-        "WHERE TABLE_NAME = ? AND (? IS NULL OR TABLE_SCHEMA = ?)",
-      [tbl, schema, schema],
+      `SELECT c.COLUMN_NAME, c.DATA_TYPE, c.IS_NULLABLE, c.COLUMN_DEFAULT,
+              CASE WHEN pk.COLUMN_NAME IS NOT NULL THEN 1 ELSE 0 END AS is_primary
+       FROM INFORMATION_SCHEMA.COLUMNS c
+       LEFT JOIN (
+         SELECT ku.COLUMN_NAME
+         FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+         JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE ku
+           ON tc.CONSTRAINT_NAME = ku.CONSTRAINT_NAME
+         WHERE tc.TABLE_NAME = ? AND (? IS NULL OR tc.TABLE_SCHEMA = ?)
+           AND tc.CONSTRAINT_TYPE = 'PRIMARY KEY'
+       ) pk ON c.COLUMN_NAME = pk.COLUMN_NAME
+       WHERE c.TABLE_NAME = ? AND (? IS NULL OR c.TABLE_SCHEMA = ?)
+       ORDER BY c.ORDINAL_POSITION`,
+      [tbl, schema, schema, tbl, schema, schema],
     );
     return rows.map((r) => ({
       name: r.COLUMN_NAME,
       type: r.DATA_TYPE,
       nullable: r.IS_NULLABLE === "YES",
       default: r.COLUMN_DEFAULT,
-      primaryKey: false,
+      // Same hole PostgreSQL had: hardcoded false meant primaryKey(table)
+      // introspected NOTHING on SQL Server, so the feature-4 filterless-write
+      // guard rejected every PK-keyed update. Ported from the Python master.
+      primaryKey: Number(r.is_primary) === 1,
     }));
   }