tina4-nodejs 3.13.92 → 3.13.95

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

@@ -4,8 +4,10 @@
  * Install: npm install mysql2
  * URL format: mysql://user:pass@host:port/database
  */
+import { MYSQL_DIALECT, buildInsert, buildSetClause, buildWhereClause } from "./sqlDialect.js";
 import type { DatabaseAdapter, DatabaseResult, ColumnInfo, FieldDefinition } from "../types.js";
 import { SQLTranslator } from "../sqlTranslator.js";
+import { connectTarget, connectTimeoutMillis, driverConnectTimeoutMillis, withConnectTimeout } from "../connectTimeout.js";
 import { createRequire } from "node:module";
 
 let mysql2: any = null;
@@ -37,6 +39,14 @@ export interface MysqlConfig {
 }
 
 export class MysqlAdapter 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
@@ -50,33 +60,55 @@ export class MysqlAdapter implements DatabaseAdapter {
   async connect(): Promise<void> {
     const mod = requireMysql2();
 
-    if (typeof this.config === "string") {
-      // Parse URL: mysql://user:pass@host:port/database
-      const url = new URL(this.config);
-      this.connection = mod.createConnection({
-        host: url.hostname || "localhost",
-        port: url.port ? parseInt(url.port, 10) : 3306,
-        user: decodeURIComponent(url.username),
-        password: decodeURIComponent(url.password),
-        database: url.pathname.replace(/^\//, ""),
-      });
-    } else {
-      this.connection = mod.createConnection({
-        host: this.config.host ?? "localhost",
-        port: this.config.port ?? 3306,
-        user: this.config.user,
-        password: this.config.password,
-        database: this.config.database,
-      });
-    }
-
-    // Promisify the connection
-    await new Promise<void>((resolve, reject) => {
-      this.connection.connect((err: Error | null) => {
-        if (err) reject(err);
-        else resolve();
-      });
-    });
+    // mysql2 has its own connectTimeout (10s by default). It is set from the
+    // Tina4 budget so ONE variable governs, and omitted when the bound is
+    // disabled so the driver keeps exactly the behaviour it had before.
+    const budgetMs = connectTimeoutMillis();
+    const driverMs = driverConnectTimeoutMillis(budgetMs);
+    const timeoutOption = driverMs === null ? {} : { connectTimeout: driverMs };
+
+    const { host, port } = connectTarget(this.config, 3306);
+    // createConnection() IS the arming point - mysql2 starts its connectTimeout
+    // at the END OF ITS CONSTRUCTOR (base/connection.js), not inside connect() -
+    // so it has to sit inside the thunk for the Tina4 clock to start first.
+    await withConnectTimeout(
+      () => {
+        if (typeof this.config === "string") {
+          // Parse URL: mysql://user:pass@host:port/database
+          const url = new URL(this.config);
+          this.connection = mod.createConnection({
+            host: url.hostname || "localhost",
+            port: url.port ? parseInt(url.port, 10) : 3306,
+            user: decodeURIComponent(url.username),
+            password: decodeURIComponent(url.password),
+            database: url.pathname.replace(/^\//, ""),
+            ...timeoutOption,
+          });
+        } else {
+          this.connection = mod.createConnection({
+            host: this.config.host ?? "localhost",
+            port: this.config.port ?? 3306,
+            user: this.config.user,
+            password: this.config.password,
+            database: this.config.database,
+            ...timeoutOption,
+          });
+        }
+
+        // Promisify the connection
+        return new Promise<void>((resolve, reject) => {
+          this.connection.connect((err: Error | null) => {
+            if (err) reject(err);
+            else resolve();
+          });
+        });
+      },
+      budgetMs,
+      host,
+      port,
+      // Answered after we gave up: destroy it so the socket does not outlive the boot.
+      () => { try { this.connection?.destroy?.(); } catch { /* already gone */ } },
+    );
   }
 
   private ensureConnected(): void {
@@ -195,8 +227,7 @@ export class MysqlAdapter 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(MYSQL_DIALECT, table, keys);
       const paramsList = data.map((row) => keys.map((k) => row[k]));
       try {
         const result = await this.executeManyAsync(sql, paramsList);
@@ -208,8 +239,7 @@ export class MysqlAdapter implements DatabaseAdapter {
     }
 
     const keys = Object.keys(data);
-    const placeholders = keys.map(() => "?").join(", ");
-    const sql = `INSERT INTO \`${table}\` (\`${keys.join("`, `")}\`) VALUES (${placeholders})`;
+    const sql = buildInsert(MYSQL_DIALECT, table, keys);
     const values = Object.values(data);
 
     try {
@@ -229,11 +259,29 @@ export class MysqlAdapter implements DatabaseAdapter {
     throw new Error("Use updateAsync() for MySQL.");
   }
 
-  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 setClauses = buildSetClause(MYSQL_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",...], producing `WHERE \`0\` = ? AND \`1\` = ?` — MySQL then
+    // reports an unknown column '0'. MySQL already uses `?`, so the fragment
+    // needs no placeholder rewriting.
+    if (typeof filter === "string") {
+      const where = filter ? ` WHERE ${filter}` : "";
+      const sql = `UPDATE ${MYSQL_DIALECT.quote(table)} SET ${setClauses}${where}`;
+      const values = [...Object.values(data), ...(params ?? [])];
+      try {
+        const result = await this.queryPromise(sql, values);
+        return { success: true, affectedRows: result.affectedRows ?? 0 };
+      } catch (e) {
+        return { success: false, affectedRows: 0, error: (e as Error).message };
+      }
+    }
+
+    const whereClauses = buildWhereClause(MYSQL_DIALECT, Object.keys(filter));
+    const sql = `UPDATE ${MYSQL_DIALECT.quote(table)} SET ${setClauses} WHERE ${whereClauses}`;
     const values = [...Object.values(data), ...Object.values(filter)];
 
     try {
@@ -248,10 +296,25 @@ export class MysqlAdapter implements DatabaseAdapter {
     throw new Error("Use deleteAsync() for MySQL.");
   }
 
-  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}`;
+
+    // See updateAsync: truncate() calls this with "1 = 1", which became
+    // `WHERE \`0\` = ? AND \`1\` = ? ...` — db.truncate() was broken outright.
+    if (typeof filter === "string") {
+      const sql = filter
+        ? `DELETE FROM \`${table}\` WHERE ${filter}`
+        : `DELETE FROM \`${table}\``;
+      try {
+        const result = await this.queryPromise(sql, params ?? []);
+        return { success: true, affectedRows: result.affectedRows ?? 0 };
+      } catch (e) {
+        return { success: false, affectedRows: 0, error: (e as Error).message };
+      }
+    }
+
+    const whereClauses = buildWhereClause(MYSQL_DIALECT, Object.keys(filter));
+    const sql = `DELETE FROM ${MYSQL_DIALECT.quote(table)} WHERE ${whereClauses}`;
     const values = Object.values(filter);
 
     try {
@@ -289,7 +352,7 @@ export class MysqlAdapter implements DatabaseAdapter {
     this._inTransaction = false;
   }
 
-  tables(): string[] {
+  getTables(): string[] {
     throw new Error("Use tablesAsync() for MySQL.");
   }
 
@@ -298,7 +361,7 @@ export class MysqlAdapter implements DatabaseAdapter {
     return rows.map((r) => Object.values(r)[0]);
   }
 
-  columns(table: string): ColumnInfo[] {
+  getColumns(table: string): ColumnInfo[] {
     throw new Error("Use columnsAsync() for MySQL.");
   }
 

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

@@ -8,8 +8,11 @@
  * The connection string after stripping the "odbc:///" prefix is passed
  * directly to odbc.connect(), so any valid ODBC connection string works.
  */
+import { ANSI_DIALECT, buildInsert, buildSetClause, buildWhereClause } from "./sqlDialect.js";
 import type { DatabaseAdapter, DatabaseResult, ColumnInfo, FieldDefinition } from "../types.js";
 import { createRequire } from "node:module";
+import { SQLTranslator } from "../sqlTranslator.js";
+import { connectTimeoutMillis, withConnectTimeout } from "../connectTimeout.js";
 
 let odbcModule: any = null;
 
@@ -53,6 +56,21 @@ export class OdbcAdapter implements DatabaseAdapter {
     return this.config.connectionString;
   }
 
+  /**
+   * 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
+   * the data-source name - it is never used to connect, only to say which target
+   * hung.
+   */
+  private describeTarget(): { host: string; port: number | string } {
+    const connectionString = this.getConnectionString();
+    const host = /(?:^|;)\s*(?:SERVER|SERVERNAME|HOST)\s*=\s*([^;]+)/i.exec(connectionString)?.[1]?.trim()
+      ?? /(?:^|;)\s*DSN\s*=\s*([^;]+)/i.exec(connectionString)?.[1]?.trim()
+      ?? "the ODBC data source";
+    const port = /(?:^|;)\s*PORT\s*=\s*(\d+)/i.exec(connectionString)?.[1] ?? "unspecified";
+    return { host, port };
+  }
+
   /** Connect to the ODBC data source. Must be called before using the adapter. */
   async connect(): Promise<void> {
     const odbc = requireOdbc();
@@ -62,7 +80,19 @@ export class OdbcAdapter implements DatabaseAdapter {
     if (!connectFn) {
       throw new Error("odbc module does not export a connect() function. Check your odbc package version.");
     }
-    this.connection = await connectFn(connStr);
+    // Outer bound only: the connection string is the driver's, and injecting a
+    // CONNECTIONTIMEOUT keyword into a string the operator wrote would be this
+    // adapter editing configuration it does not own. The bound frees the CALLER;
+    // the native driver thread it is waiting on cannot be cancelled from JS.
+    const { host, port } = this.describeTarget();
+    this.connection = await withConnectTimeout(
+      () => connectFn(connStr),
+      connectTimeoutMillis(),
+      host,
+      port,
+      // Answered after we gave up: close it so the handle does not outlive the boot.
+      (arrived: any) => { try { void arrived?.close?.(); } catch { /* already gone */ } },
+    );
   }
 
   private ensureConnected(): void {
@@ -119,11 +149,11 @@ export class OdbcAdapter implements DatabaseAdapter {
     throw new Error("Use rollbackAsync() for ODBC — async adapter requires async methods.");
   }
 
-  tables(): string[] {
+  getTables(): string[] {
     throw new Error("Use tablesAsync() for ODBC — async adapter requires async methods.");
   }
 
-  columns(table: string): ColumnInfo[] {
+  getColumns(table: string): ColumnInfo[] {
     throw new Error("Use columnsAsync() for ODBC — async adapter requires async methods.");
   }
 
@@ -195,16 +225,10 @@ export class OdbcAdapter implements DatabaseAdapter {
     limit?: number,
     skip?: number,
   ): Promise<T[]> {
-    let effectiveSql = sql;
-    if (limit !== undefined) {
-      const sqlUpper = sql.toUpperCase().split("--")[0];
-      if (!sqlUpper.includes("LIMIT")) {
-        effectiveSql += ` LIMIT ${limit}`;
-        if (skip !== undefined && skip > 0) {
-          effectiveSql += ` OFFSET ${skip}`;
-        }
-      }
-    }
+    // See SQLTranslator.appendLimit: the old inline check was a substring search,
+    // so a LIMIT in a string literal or a trailing comment silently dropped the
+    // row cap and returned every row.
+    const effectiveSql = SQLTranslator.appendLimit(sql, limit, skip);
     return this.queryAsync<T>(effectiveSql, params);
   }
 
@@ -218,8 +242,7 @@ export class OdbcAdapter implements DatabaseAdapter {
   async insertAsync(table: string, data: Record<string, unknown>): Promise<DatabaseResult> {
     this.ensureConnected();
     const keys = Object.keys(data);
-    const placeholders = keys.map(() => "?").join(", ");
-    const sql = `INSERT INTO "${table}" ("${keys.join('", "')}") VALUES (${placeholders})`;
+    const sql = buildInsert(ANSI_DIALECT, table, keys);
     const values = Object.values(data);
 
     try {
@@ -233,9 +256,9 @@ export class OdbcAdapter implements DatabaseAdapter {
   /** Update rows in a table matching filter. */
   async updateAsync(table: string, data: Record<string, unknown>, filter: Record<string, 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 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)];
 
     try {
@@ -274,8 +297,8 @@ export class OdbcAdapter implements DatabaseAdapter {
       }
     }
 
-    const whereClauses = Object.keys(filter).map((k) => `"${k}" = ?`).join(" AND ");
-    const sql = `DELETE FROM "${table}" WHERE ${whereClauses}`;
+    const whereClauses = buildWhereClause(ANSI_DIALECT, Object.keys(filter));
+    const sql = `DELETE FROM ${ANSI_DIALECT.quote(table)} WHERE ${whereClauses}`;
     const values = Object.values(filter);
 
     try {
@@ -326,7 +349,7 @@ 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.columns(catalog, schema, table, column)
+    // odbc.Connection.getColumns(catalog, schema, table, column)
     const rows: any[] = await this.connection.columns(null, null, table, null);
     return rows.map((r: any) => ({
       name: r.COLUMN_NAME ?? r.column_name,

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

@@ -4,8 +4,10 @@
  * Install: npm install pg @types/pg
  * URL format: postgresql://user:pass@host:port/database
  */
+import { ANSI_DIALECT, POSTGRES_DIALECT, buildInsert, buildSetClause, buildWhereClause } from "./sqlDialect.js";
 import type { DatabaseAdapter, DatabaseResult, ColumnInfo, FieldDefinition } from "../types.js";
 import { SQLTranslator } from "../sqlTranslator.js";
+import { connectTarget, connectTimeoutMillis, driverConnectTimeoutMillis, withConnectTimeout } from "../connectTimeout.js";
 
 import { createRequire } from "node:module";
 
@@ -67,6 +69,14 @@ export interface PostgresConfig {
 }
 
 export class PostgresAdapter 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 client: InstanceType<typeof import("pg").Client> | null = null;
   // string is included for non-integer primary keys: a UUID PK (the common
   // `id uuid PRIMARY KEY DEFAULT gen_random_uuid()` shape) returns its id as a
@@ -84,13 +94,31 @@ export class PostgresAdapter implements DatabaseAdapter {
     const pgModule = requirePg();
     const Client = pgModule.Client ?? (pgModule as any).default?.Client;
 
-    if (typeof this.config === "string") {
-      this.client = new Client({ connectionString: this.config });
-    } else {
-      this.client = new Client(this.config);
-    }
-
-    await this.client!.connect();
+    // pg's own connectionTimeoutMillis defaults to 0 - no timeout at all - so
+    // without this a server that accepts and never completes the startup
+    // handshake hangs the boot forever. Omitted entirely when the bound is
+    // disabled, which restores exactly the old (unbounded) behaviour.
+    const budgetMs = connectTimeoutMillis();
+    const driverMs = driverConnectTimeoutMillis(budgetMs);
+    const timeoutOption = driverMs === null ? {} : { connectionTimeoutMillis: driverMs };
+
+    const { host, port } = connectTarget(this.config, 5432);
+    // Everything that touches pg lives inside the thunk so the Tina4 clock
+    // starts before pg arms its own timer (client.js `_connect`, cleared only at
+    // ReadyForQuery - so the knob covers the whole handshake, not just the TCP).
+    await withConnectTimeout(
+      () => {
+        this.client = typeof this.config === "string"
+          ? new Client({ connectionString: this.config, ...timeoutOption })
+          : new Client({ ...this.config, ...timeoutOption });
+        return this.client!.connect();
+      },
+      budgetMs,
+      host,
+      port,
+      // Answered after we gave up: end it so the socket does not outlive the boot.
+      () => { void Promise.resolve(this.client?.end()).catch(() => { /* already gone */ }); },
+    );
   }
 
   // NOTE: a plain runtime guard, not an `asserts this is ...` predicate. A
@@ -112,8 +140,11 @@ export class PostgresAdapter implements DatabaseAdapter {
     return row;
   }
 
-  private convertPlaceholders(sql: string): string {
-    let count = 0;
+  // `startAt` lets a caller that has already consumed N placeholders (an UPDATE
+  // whose SET values are $1..$N) continue the numbering into a raw WHERE
+  // fragment instead of restarting at $1.
+  private convertPlaceholders(sql: string, startAt = 1): string {
+    let count = startAt - 1;
     return sql.replace(/\?/g, () => {
       count++;
       return `$${count}`;
@@ -244,8 +275,8 @@ export class PostgresAdapter 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})`;
+      // The batch path binds through executeManyAsync, which converts "?" itself.
+      const sql = buildInsert(ANSI_DIALECT, table, keys);
       const paramsList = data.map((row) => keys.map((k) => row[k]));
       try {
         const result = await this.executeManyAsync(sql, paramsList);
@@ -257,8 +288,7 @@ export class PostgresAdapter implements DatabaseAdapter {
     }
 
     const keys = Object.keys(data);
-    const placeholders = keys.map((_, i) => `$${i + 1}`).join(", ");
-    const sql = `INSERT INTO "${table}" ("${keys.join('", "')}") VALUES (${placeholders}) RETURNING *`;
+    const sql = buildInsert(POSTGRES_DIALECT, table, keys, " RETURNING *");
     const values = Object.values(data);
 
     try {
@@ -280,15 +310,35 @@ export class PostgresAdapter implements DatabaseAdapter {
     throw new Error("Use updateAsync() for PostgreSQL.");
   }
 
-  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 = 1;
+    const setClauses = buildSetClause(POSTGRES_DIALECT, dataKeys, paramIndex);
+    paramIndex += dataKeys.length;
+
+    // A raw WHERE fragment + params is half the write_path contract's filter
+    // form ("a string filter with params works the same as a hash filter").
+    // Without this branch Object.keys("id = ?") yields the STRING INDICES
+    // ["0","1",...], producing `WHERE "0" = $2 AND "1" = $3` — the engine then
+    // reports `column "0" does not exist`. sqlite/mongodb/odbc already carried
+    // this branch; postgres/mysql/mssql/firebird did not.
+    if (typeof filter === "string") {
+      const where = filter ? ` WHERE ${this.convertPlaceholders(filter, paramIndex)}` : "";
+      const sql = `UPDATE ${POSTGRES_DIALECT.quote(table)} SET ${setClauses}${where}`;
+      const values = [...Object.values(data), ...(params ?? [])];
+      try {
+        const result = await this.client!.query(sql, values);
+        return { success: true, affectedRows: result.rowCount ?? 0 };
+      } catch (e) {
+        return { success: false, affectedRows: 0, error: (e as Error).message };
+      }
+    }
 
-    const setClauses = dataKeys.map((k) => `"${k}" = $${paramIndex++}`).join(", ");
-    const whereClauses = filterKeys.map((k) => `"${k}" = $${paramIndex++}`).join(" AND ");
-    const sql = `UPDATE "${table}" SET ${setClauses} WHERE ${whereClauses}`;
+    const filterKeys = Object.keys(filter);
+    const whereClauses = buildWhereClause(POSTGRES_DIALECT, filterKeys, paramIndex);
+    paramIndex += filterKeys.length;
+    const sql = `UPDATE ${POSTGRES_DIALECT.quote(table)} SET ${setClauses} WHERE ${whereClauses}`;
     const values = [...Object.values(data), ...Object.values(filter)];
 
     try {
@@ -303,12 +353,30 @@ export class PostgresAdapter implements DatabaseAdapter {
     throw new Error("Use deleteAsync() for PostgreSQL.");
   }
 
-  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: a raw WHERE fragment must not be walked as an object.
+    // truncate() calls this with "1 = 1", which became `WHERE "0" = $1 AND
+    // "1" = $2 ...` and failed with `column "0" does not exist` — db.truncate()
+    // was broken outright on PostgreSQL.
+    if (typeof filter === "string") {
+      const sql = filter
+        ? `DELETE FROM "${table}" WHERE ${this.convertPlaceholders(filter)}`
+        : `DELETE FROM "${table}"`;
+      try {
+        const result = await this.client!.query(sql, params ?? []);
+        return { success: true, affectedRows: result.rowCount ?? 0 };
+      } catch (e) {
+        return { success: false, affectedRows: 0, error: (e as Error).message };
+      }
+    }
+
     const filterKeys = Object.keys(filter);
     let paramIndex = 1;
-    const whereClauses = filterKeys.map((k) => `"${k}" = $${paramIndex++}`).join(" AND ");
-    const sql = `DELETE FROM "${table}" WHERE ${whereClauses}`;
+    const whereClauses = buildWhereClause(POSTGRES_DIALECT, filterKeys, paramIndex);
+    paramIndex += filterKeys.length;
+    const sql = `DELETE FROM ${POSTGRES_DIALECT.quote(table)} WHERE ${whereClauses}`;
     const values = Object.values(filter);
 
     try {
@@ -354,7 +422,7 @@ export class PostgresAdapter implements DatabaseAdapter {
     this._inTransaction = false;
   }
 
-  tables(): string[] {
+  getTables(): string[] {
     throw new Error("Use tablesAsync() for PostgreSQL.");
   }
 
@@ -371,28 +439,52 @@ export class PostgresAdapter implements DatabaseAdapter {
     );
   }
 
-  columns(table: string): ColumnInfo[] {
+  getColumns(table: string): ColumnInfo[] {
     throw new Error("Use columnsAsync() for PostgreSQL.");
   }
 
   async columnsAsync(table: string): Promise<ColumnInfo[]> {
     // v3.13.14 (#48): honour a schema-qualified name; default to public.
     const [schema, tbl] = SQLTranslator.splitSchema(table);
+    // primaryKey was hardcoded false, so primaryKey(table) introspected NOTHING
+    // on PostgreSQL. The filterless-write guard (feature 4) reads it, so
+    // update(table, data) keyed on the primary key in `data` threw "update
+    // requires a filter or the complete primary key in the data" against every
+    // PostgreSQL table. Port the Python master's LEFT JOIN so the cross-engine
+    // columns() contract (#48) actually holds here — the subquery yields every
+    // column of the PK, so a COMPOSITE key reports true on each of its columns,
+    // not just the first.
     const rows = await this.queryAsync<{
       column_name: string;
       data_type: string;
       is_nullable: string;
       column_default: string | null;
+      is_primary: boolean | string;
     }>(
-      "SELECT column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_name = $1 AND table_schema = $2",
-      [tbl, schema ?? "public"],
+      `SELECT c.column_name, c.data_type, c.is_nullable, c.column_default,
+              CASE WHEN pk.column_name IS NOT NULL THEN true ELSE false 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
+          AND tc.table_schema = ku.table_schema
+         WHERE tc.table_name = $1 AND tc.table_schema = $2
+           AND tc.constraint_type = 'PRIMARY KEY'
+       ) pk ON c.column_name = pk.column_name
+       WHERE c.table_name = $3 AND c.table_schema = $4
+       ORDER BY c.ordinal_position`,
+      [tbl, schema ?? "public", tbl, schema ?? "public"],
     );
     return rows.map((r) => ({
       name: r.column_name,
       type: r.data_type,
       nullable: r.is_nullable === "YES",
       default: r.column_default,
-      primaryKey: false,
+      // node-postgres decodes bool to true/false; stay tolerant of the raw
+      // "t" text form in case the type parser is bypassed.
+      primaryKey: r.is_primary === true || r.is_primary === "t",
     }));
   }