lakesync 0.1.5 → 0.1.8

package/dist/{chunk-Z7FGLEQU.js → chunk-LPWXOYNS.js}

@@ -3,7 +3,7 @@ import {
   Err,
   Ok,
   toError
-} from "./chunk-7UBS6MFH.js";
+} from "./chunk-LDFFCG2K.js";
 
 // ../adapter/src/db-types.ts
 var BIGQUERY_TYPE_MAP = {
@@ -20,32 +20,29 @@ function isDatabaseAdapter(adapter) {
   return adapter !== null && typeof adapter === "object" && "insertDeltas" in adapter && "queryDeltasSince" in adapter && typeof adapter.insertDeltas === "function";
 }
 
-// ../adapter/src/materialise.ts
-function isMaterialisable(adapter) {
-  return adapter !== null && typeof adapter === "object" && "materialise" in adapter && typeof adapter.materialise === "function";
-}
-function groupDeltasByTable(deltas) {
-  const result = /* @__PURE__ */ new Map();
-  for (const delta of deltas) {
-    let rowIds = result.get(delta.table);
-    if (!rowIds) {
-      rowIds = /* @__PURE__ */ new Set();
-      result.set(delta.table, rowIds);
+// ../adapter/src/shared.ts
+function groupAndMerge(rows) {
+  const byRowId = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    let arr = byRowId.get(row.row_id);
+    if (!arr) {
+      arr = [];
+      byRowId.set(row.row_id, arr);
     }
-    rowIds.add(delta.rowId);
+    arr.push(row);
   }
-  return result;
-}
-function buildSchemaIndex(schemas) {
-  const index = /* @__PURE__ */ new Map();
-  for (const schema of schemas) {
-    const key = schema.sourceTable ?? schema.table;
-    index.set(key, schema);
+  const upserts = [];
+  const deleteIds = [];
+  for (const [rowId, group] of byRowId) {
+    const state = mergeLatestState(group);
+    if (state !== null) {
+      upserts.push({ rowId, state });
+    } else {
+      deleteIds.push(rowId);
+    }
   }
-  return index;
+  return { upserts, deleteIds };
 }
-
-// ../adapter/src/shared.ts
 function toCause(error) {
   return error instanceof Error ? error : void 0;
 }
@@ -80,6 +77,72 @@ function mergeLatestState(rows) {
   return state;
 }
 
+// ../adapter/src/materialise.ts
+function isMaterialisable(adapter) {
+  return adapter !== null && typeof adapter === "object" && "materialise" in adapter && typeof adapter.materialise === "function";
+}
+function resolvePrimaryKey(schema) {
+  return schema.primaryKey ?? ["row_id"];
+}
+function resolveConflictColumns(schema) {
+  return schema.externalIdColumn ? [schema.externalIdColumn] : resolvePrimaryKey(schema);
+}
+function isSoftDelete(schema) {
+  return schema.softDelete !== false;
+}
+function groupDeltasByTable(deltas) {
+  const result = /* @__PURE__ */ new Map();
+  for (const delta of deltas) {
+    let rowIds = result.get(delta.table);
+    if (!rowIds) {
+      rowIds = /* @__PURE__ */ new Set();
+      result.set(delta.table, rowIds);
+    }
+    rowIds.add(delta.rowId);
+  }
+  return result;
+}
+function buildSchemaIndex(schemas) {
+  const index = /* @__PURE__ */ new Map();
+  for (const schema of schemas) {
+    const key = schema.sourceTable ?? schema.table;
+    index.set(key, schema);
+  }
+  return index;
+}
+async function executeMaterialise(executor, dialect, deltas, schemas) {
+  if (deltas.length === 0) {
+    return Ok(void 0);
+  }
+  return wrapAsync(async () => {
+    const grouped = groupDeltasByTable(deltas);
+    const schemaIndex = buildSchemaIndex(schemas);
+    for (const [tableName, rowIds] of grouped) {
+      const schema = schemaIndex.get(tableName);
+      if (!schema) continue;
+      const dest = schema.table;
+      const pk = resolvePrimaryKey(schema);
+      const conflictCols = resolveConflictColumns(schema);
+      const soft = isSoftDelete(schema);
+      const createStmt = dialect.createDestinationTable(dest, schema, pk, soft);
+      await executor.query(createStmt.sql, createStmt.params);
+      const sourceTable = schema.sourceTable ?? schema.table;
+      const rowIdArray = [...rowIds];
+      const historyStmt = dialect.queryDeltaHistory(sourceTable, rowIdArray);
+      const rows = await executor.queryRows(historyStmt.sql, historyStmt.params);
+      const { upserts, deleteIds } = groupAndMerge(rows);
+      if (upserts.length > 0) {
+        const upsertStmt = dialect.buildUpsert(dest, schema, conflictCols, soft, upserts);
+        await executor.query(upsertStmt.sql, upsertStmt.params);
+      }
+      if (deleteIds.length > 0) {
+        const deleteStmt = dialect.buildDelete(dest, deleteIds, soft);
+        await executor.query(deleteStmt.sql, deleteStmt.params);
+      }
+    }
+  }, "Failed to materialise deltas");
+}
+
 // ../adapter/src/bigquery.ts
 import { BigQuery } from "@google-cloud/bigquery";
 function rowToRowDelta(row) {
@@ -96,6 +159,121 @@ function rowToRowDelta(row) {
     op: row.op
   };
 }
+var BigQuerySqlDialect = class {
+  constructor(dataset) {
+    this.dataset = dataset;
+  }
+  createDestinationTable(dest, schema, pk, softDelete) {
+    const colDefs = schema.columns.map((c) => `${c.name} ${lakeSyncTypeToBigQuery(c.type)}`).join(", ");
+    const deletedAtCol = softDelete ? `,
+	deleted_at TIMESTAMP` : "";
+    return {
+      sql: `CREATE TABLE IF NOT EXISTS \`${this.dataset}.${dest}\` (
+	row_id STRING NOT NULL,
+	${colDefs},
+	props JSON DEFAULT '{}'${deletedAtCol},
+	synced_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP()
+)
+CLUSTER BY ${pk.map((c) => c === "row_id" ? "row_id" : c).join(", ")}`,
+      params: []
+    };
+  }
+  queryDeltaHistory(sourceTable, rowIds) {
+    return {
+      sql: `SELECT row_id, columns, op FROM \`${this.dataset}.lakesync_deltas\`
+WHERE \`table\` = @sourceTable AND row_id IN UNNEST(@rowIds)
+ORDER BY hlc ASC`,
+      params: [
+        ["sourceTable", sourceTable],
+        ["rowIds", rowIds]
+      ]
+    };
+  }
+  buildUpsert(dest, schema, conflictCols, softDelete, upserts) {
+    const namedParams = [];
+    const selects = [];
+    for (let i = 0; i < upserts.length; i++) {
+      const u = upserts[i];
+      namedParams.push([`rid_${i}`, u.rowId]);
+      for (const col of schema.columns) {
+        namedParams.push([`c${schema.columns.indexOf(col)}_${i}`, u.state[col.name] ?? null]);
+      }
+      const colSelects = schema.columns.map((col, ci) => `@c${ci}_${i} AS ${col.name}`).join(", ");
+      const deletedAtSelect = softDelete ? ", CAST(NULL AS TIMESTAMP) AS deleted_at" : "";
+      selects.push(
+        `SELECT @rid_${i} AS row_id, ${colSelects}${deletedAtSelect}, CURRENT_TIMESTAMP() AS synced_at`
+      );
+    }
+    const mergeOn = conflictCols.map((c) => `t.${c === "row_id" ? "row_id" : c} = s.${c === "row_id" ? "row_id" : c}`).join(" AND ");
+    const updateSet = schema.columns.map((col) => `${col.name} = s.${col.name}`).join(", ");
+    const softUpdateExtra = softDelete ? ", deleted_at = s.deleted_at" : "";
+    const insertColsList = [
+      "row_id",
+      ...schema.columns.map((c) => c.name),
+      "props",
+      ...softDelete ? ["deleted_at"] : [],
+      "synced_at"
+    ].join(", ");
+    const insertValsList = [
+      "s.row_id",
+      ...schema.columns.map((c) => `s.${c.name}`),
+      "'{}'",
+      ...softDelete ? ["s.deleted_at"] : [],
+      "s.synced_at"
+    ].join(", ");
+    return {
+      sql: `MERGE \`${this.dataset}.${dest}\` AS t
+USING (${selects.join(" UNION ALL ")}) AS s
+ON ${mergeOn}
+WHEN MATCHED THEN UPDATE SET ${updateSet}${softUpdateExtra}, synced_at = s.synced_at
+WHEN NOT MATCHED THEN INSERT (${insertColsList})
+VALUES (${insertValsList})`,
+      params: namedParams
+    };
+  }
+  buildDelete(dest, deleteIds, softDelete) {
+    if (softDelete) {
+      return {
+        sql: `UPDATE \`${this.dataset}.${dest}\` SET deleted_at = CURRENT_TIMESTAMP(), synced_at = CURRENT_TIMESTAMP() WHERE row_id IN UNNEST(@rowIds)`,
+        params: [["rowIds", deleteIds]]
+      };
+    }
+    return {
+      sql: `DELETE FROM \`${this.dataset}.${dest}\` WHERE row_id IN UNNEST(@rowIds)`,
+      params: [["rowIds", deleteIds]]
+    };
+  }
+};
+function createBigQueryExecutor(client, location) {
+  function toNamedParams(params) {
+    if (params.length === 0) return void 0;
+    const result = {};
+    for (const entry of params) {
+      const [key, value] = entry;
+      result[key] = value;
+    }
+    return result;
+  }
+  return {
+    async query(sql, params) {
+      const namedParams = toNamedParams(params);
+      await client.query({
+        query: sql,
+        params: namedParams,
+        location
+      });
+    },
+    async queryRows(sql, params) {
+      const namedParams = toNamedParams(params);
+      const [rows] = await client.query({
+        query: sql,
+        params: namedParams,
+        location
+      });
+      return rows;
+    }
+  };
+}
 var BigQueryAdapter = class {
   /** @internal */
   client;
@@ -103,6 +281,8 @@ var BigQueryAdapter = class {
   dataset;
   /** @internal */
   location;
+  dialect;
+  executor;
   constructor(config) {
     this.client = new BigQuery({
       projectId: config.projectId,
@@ -110,6 +290,8 @@ var BigQueryAdapter = class {
     });
     this.dataset = config.dataset;
     this.location = config.location ?? "US";
+    this.dialect = new BigQuerySqlDialect(this.dataset);
+    this.executor = createBigQueryExecutor(this.client, this.location);
   }
   /**
    * Insert deltas into the database in a single batch.
@@ -222,106 +404,11 @@ CLUSTER BY \`table\`, hlc`,
   /**
    * Materialise deltas into destination tables.
    *
-   * For each affected table, queries the full delta history for touched rows,
-   * merges to latest state via column-level LWW, then upserts live rows and
-   * deletes tombstoned rows. The consumer-owned `props` column is never
-   * touched on UPDATE.
+   * Delegates to the shared `executeMaterialise` algorithm with the
+   * BigQuery SQL dialect.
    */
   async materialise(deltas, schemas) {
-    if (deltas.length === 0) {
-      return Ok(void 0);
-    }
-    return wrapAsync(async () => {
-      const tableRowIds = groupDeltasByTable(deltas);
-      const schemaIndex = buildSchemaIndex(schemas);
-      for (const [sourceTable, rowIds] of tableRowIds) {
-        const schema = schemaIndex.get(sourceTable);
-        if (!schema) continue;
-        const colDefs = schema.columns.map((c) => `${c.name} ${lakeSyncTypeToBigQuery(c.type)}`).join(", ");
-        await this.client.query({
-          query: `CREATE TABLE IF NOT EXISTS \`${this.dataset}.${schema.table}\` (
-	row_id STRING NOT NULL,
-	${colDefs},
-	props JSON DEFAULT '{}',
-	synced_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP()
-)`,
-          location: this.location
-        });
-        const rowIdArray = [...rowIds];
-        const [deltaRows] = await this.client.query({
-          query: `SELECT row_id, columns, op FROM \`${this.dataset}.lakesync_deltas\`
-WHERE \`table\` = @sourceTable AND row_id IN UNNEST(@rowIds)
-ORDER BY hlc ASC`,
-          params: { sourceTable, rowIds: rowIdArray },
-          location: this.location
-        });
-        const rowGroups = /* @__PURE__ */ new Map();
-        for (const row of deltaRows) {
-          let group = rowGroups.get(row.row_id);
-          if (!group) {
-            group = [];
-            rowGroups.set(row.row_id, group);
-          }
-          group.push({ columns: row.columns, op: row.op });
-        }
-        const upserts = [];
-        const deleteRowIds = [];
-        for (const [rowId, group] of rowGroups) {
-          const state = mergeLatestState(group);
-          if (state === null) {
-            deleteRowIds.push(rowId);
-          } else {
-            upserts.push({ rowId, state });
-          }
-        }
-        if (upserts.length > 0) {
-          const params = {};
-          const selects = [];
-          for (let i = 0; i < upserts.length; i++) {
-            const u = upserts[i];
-            params[`rid_${i}`] = u.rowId;
-            for (const col of schema.columns) {
-              params[`c${schema.columns.indexOf(col)}_${i}`] = u.state[col.name] ?? null;
-            }
-            const colSelects = schema.columns.map((col, ci) => `@c${ci}_${i} AS ${col.name}`).join(", ");
-            selects.push(
-              `SELECT @rid_${i} AS row_id, ${colSelects}, CURRENT_TIMESTAMP() AS synced_at`
-            );
-          }
-          const updateSet = schema.columns.map((col) => `${col.name} = s.${col.name}`).join(", ");
-          const insertCols = [
-            "row_id",
-            ...schema.columns.map((c) => c.name),
-            "props",
-            "synced_at"
-          ].join(", ");
-          const insertVals = [
-            "s.row_id",
-            ...schema.columns.map((c) => `s.${c.name}`),
-            "'{}'",
-            "s.synced_at"
-          ].join(", ");
-          const mergeSql = `MERGE \`${this.dataset}.${schema.table}\` AS t
-USING (${selects.join(" UNION ALL ")}) AS s
-ON t.row_id = s.row_id
-WHEN MATCHED THEN UPDATE SET ${updateSet}, synced_at = s.synced_at
-WHEN NOT MATCHED THEN INSERT (${insertCols})
-VALUES (${insertVals})`;
-          await this.client.query({
-            query: mergeSql,
-            params,
-            location: this.location
-          });
-        }
-        if (deleteRowIds.length > 0) {
-          await this.client.query({
-            query: `DELETE FROM \`${this.dataset}.${schema.table}\` WHERE row_id IN UNNEST(@rowIds)`,
-            params: { rowIds: deleteRowIds },
-            location: this.location
-          });
-        }
-      }
-    }, "Failed to materialise deltas");
+    return executeMaterialise(this.executor, this.dialect, deltas, schemas);
   }
   /**
    * No-op — BigQuery client is HTTP-based with no persistent connections.
@@ -432,12 +519,75 @@ var MYSQL_TYPE_MAP = {
 function lakeSyncTypeToMySQL(type) {
   return MYSQL_TYPE_MAP[type];
 }
+var MySqlDialect = class {
+  createDestinationTable(dest, schema, pk, softDelete) {
+    const typedCols = schema.columns.map((col) => `\`${col.name}\` ${lakeSyncTypeToMySQL(col.type)}`).join(", ");
+    const pkConstraint = `PRIMARY KEY (${pk.map((c) => `\`${c}\``).join(", ")})`;
+    const deletedAtCol = softDelete ? `, deleted_at TIMESTAMP NULL` : "";
+    const uniqueConstraint = schema.externalIdColumn ? `, UNIQUE KEY (\`${schema.externalIdColumn}\`)` : "";
+    return {
+      sql: `CREATE TABLE IF NOT EXISTS \`${dest}\` (row_id VARCHAR(255) NOT NULL, ${typedCols}, props JSON NOT NULL DEFAULT ('{}')${deletedAtCol}, synced_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, ${pkConstraint}${uniqueConstraint})`,
+      params: []
+    };
+  }
+  queryDeltaHistory(sourceTable, rowIds) {
+    const placeholders = rowIds.map(() => "?").join(", ");
+    return {
+      sql: `SELECT row_id, columns, op FROM lakesync_deltas WHERE \`table\` = ? AND row_id IN (${placeholders}) ORDER BY hlc ASC`,
+      params: [sourceTable, ...rowIds]
+    };
+  }
+  buildUpsert(dest, schema, _conflictCols, softDelete, upserts) {
+    const cols = schema.columns.map((c) => c.name);
+    const valuePlaceholders = softDelete ? upserts.map(() => `(?, ${cols.map(() => "?").join(", ")}, NULL, NOW())`).join(", ") : upserts.map(() => `(?, ${cols.map(() => "?").join(", ")}, NOW())`).join(", ");
+    const values = [];
+    for (const { rowId, state } of upserts) {
+      values.push(rowId);
+      for (const col of cols) {
+        values.push(state[col] ?? null);
+      }
+    }
+    const updateCols = cols.map((c) => `\`${c}\` = VALUES(\`${c}\`)`).join(", ");
+    const softUpdateExtra = softDelete ? ", deleted_at = NULL" : "";
+    const colList = softDelete ? `row_id, ${cols.map((c) => `\`${c}\``).join(", ")}, deleted_at, synced_at` : `row_id, ${cols.map((c) => `\`${c}\``).join(", ")}, synced_at`;
+    return {
+      sql: `INSERT INTO \`${dest}\` (${colList}) VALUES ${valuePlaceholders} ON DUPLICATE KEY UPDATE ${updateCols}${softUpdateExtra}, synced_at = VALUES(synced_at)`,
+      params: values
+    };
+  }
+  buildDelete(dest, deleteIds, softDelete) {
+    const placeholders = deleteIds.map(() => "?").join(", ");
+    if (softDelete) {
+      return {
+        sql: `UPDATE \`${dest}\` SET deleted_at = NOW(), synced_at = NOW() WHERE row_id IN (${placeholders})`,
+        params: deleteIds
+      };
+    }
+    return {
+      sql: `DELETE FROM \`${dest}\` WHERE row_id IN (${placeholders})`,
+      params: deleteIds
+    };
+  }
+};
 var MySQLAdapter = class {
   /** @internal */
   pool;
+  dialect = new MySqlDialect();
   constructor(config) {
     this.pool = mysql.createPool(config.connectionString);
   }
+  get executor() {
+    const pool = this.pool;
+    return {
+      async query(sql, params) {
+        await pool.execute(sql, params);
+      },
+      async queryRows(sql, params) {
+        const [rows] = await pool.execute(sql, params);
+        return rows;
+      }
+    };
+  }
   /**
    * Insert deltas into the database in a single batch.
    * Uses INSERT IGNORE for idempotent writes — duplicate deltaIds are silently skipped.
@@ -519,74 +669,11 @@ var MySQLAdapter = class {
   /**
    * Materialise deltas into destination tables.
    *
-   * For each table with a matching schema, merges delta history into the
-   * latest row state and upserts into the destination table. Tombstoned
-   * rows are deleted. The `props` column is never touched.
+   * Delegates to the shared `executeMaterialise` algorithm with the
+   * MySQL SQL dialect.
    */
   async materialise(deltas, schemas) {
-    if (deltas.length === 0) {
-      return Ok(void 0);
-    }
-    return wrapAsync(async () => {
-      const grouped = groupDeltasByTable(deltas);
-      const schemaIndex = buildSchemaIndex(schemas);
-      for (const [tableName, rowIds] of grouped) {
-        const schema = schemaIndex.get(tableName);
-        if (!schema) continue;
-        const typedCols = schema.columns.map((col) => `\`${col.name}\` ${lakeSyncTypeToMySQL(col.type)}`).join(", ");
-        await this.pool.execute(
-          `CREATE TABLE IF NOT EXISTS \`${schema.table}\` (row_id VARCHAR(255) PRIMARY KEY, ${typedCols}, props JSON NOT NULL DEFAULT ('{}'), synced_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP)`
-        );
-        const rowIdArray = [...rowIds];
-        const placeholders = rowIdArray.map(() => "?").join(", ");
-        const [rows] = await this.pool.execute(
-          `SELECT row_id, columns, op FROM lakesync_deltas WHERE \`table\` = ? AND row_id IN (${placeholders}) ORDER BY hlc ASC`,
-          [tableName, ...rowIdArray]
-        );
-        const byRow = /* @__PURE__ */ new Map();
-        for (const row of rows) {
-          let list = byRow.get(row.row_id);
-          if (!list) {
-            list = [];
-            byRow.set(row.row_id, list);
-          }
-          list.push(row);
-        }
-        const upserts = [];
-        const deleteIds = [];
-        for (const [rowId, rowDeltas] of byRow) {
-          const state = mergeLatestState(rowDeltas);
-          if (state === null) {
-            deleteIds.push(rowId);
-          } else {
-            upserts.push({ rowId, state });
-          }
-        }
-        if (upserts.length > 0) {
-          const cols = schema.columns.map((c) => c.name);
-          const valuePlaceholders = upserts.map(() => `(?, ${cols.map(() => "?").join(", ")}, NOW())`).join(", ");
-          const values = [];
-          for (const { rowId, state } of upserts) {
-            values.push(rowId);
-            for (const col of cols) {
-              values.push(state[col] ?? null);
-            }
-          }
-          const updateCols = cols.map((c) => `\`${c}\` = VALUES(\`${c}\`)`).join(", ");
-          await this.pool.execute(
-            `INSERT INTO \`${schema.table}\` (row_id, ${cols.map((c) => `\`${c}\``).join(", ")}, synced_at) VALUES ${valuePlaceholders} ON DUPLICATE KEY UPDATE ${updateCols}, synced_at = VALUES(synced_at)`,
-            values
-          );
-        }
-        if (deleteIds.length > 0) {
-          const delPlaceholders = deleteIds.map(() => "?").join(", ");
-          await this.pool.execute(
-            `DELETE FROM \`${schema.table}\` WHERE row_id IN (${delPlaceholders})`,
-            deleteIds
-          );
-        }
-      }
-    }, "Failed to materialise deltas");
+    return executeMaterialise(this.executor, this.dialect, deltas, schemas);
   }
   /** Close the database connection pool and release resources. */
   async close() {
@@ -614,15 +701,94 @@ var POSTGRES_TYPE_MAP = {
   json: "JSONB",
   null: "TEXT"
 };
+var PostgresSqlDialect = class {
+  createDestinationTable(dest, schema, pk, softDelete) {
+    const columnDefs = schema.columns.map((c) => `"${c.name}" ${POSTGRES_TYPE_MAP[c.type]}`).join(", ");
+    const pkConstraint = `PRIMARY KEY (${pk.map((c) => `"${c}"`).join(", ")})`;
+    const deletedAtCol = softDelete ? `,
+	deleted_at TIMESTAMPTZ` : "";
+    const uniqueConstraint = schema.externalIdColumn ? `,
+	UNIQUE ("${schema.externalIdColumn}")` : "";
+    return {
+      sql: `CREATE TABLE IF NOT EXISTS "${dest}" (
+	row_id TEXT NOT NULL,
+	${columnDefs},
+	props JSONB NOT NULL DEFAULT '{}'${deletedAtCol},
+	synced_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+	${pkConstraint}${uniqueConstraint}
+)`,
+      params: []
+    };
+  }
+  queryDeltaHistory(sourceTable, rowIds) {
+    return {
+      sql: `SELECT row_id, columns, op FROM lakesync_deltas WHERE "table" = $1 AND row_id = ANY($2) ORDER BY hlc ASC`,
+      params: [sourceTable, rowIds]
+    };
+  }
+  buildUpsert(dest, schema, conflictCols, softDelete, upserts) {
+    const colNames = schema.columns.map((c) => c.name);
+    const baseCols = ["row_id", ...colNames];
+    const allCols = softDelete ? [...baseCols, "deleted_at", "synced_at"] : [...baseCols, "synced_at"];
+    const colList = allCols.map((c) => `"${c}"`).join(", ");
+    const values = [];
+    const valueRows = [];
+    const paramsPerRow = allCols.length;
+    for (let i = 0; i < upserts.length; i++) {
+      const u = upserts[i];
+      const offset = i * paramsPerRow;
+      const placeholders = allCols.map((_, j) => `$${offset + j + 1}`);
+      valueRows.push(`(${placeholders.join(", ")})`);
+      values.push(u.rowId);
+      for (const col of colNames) {
+        values.push(u.state[col] ?? null);
+      }
+      if (softDelete) values.push(null);
+      values.push(/* @__PURE__ */ new Date());
+    }
+    const conflictList = conflictCols.map((c) => `"${c}"`).join(", ");
+    const updateCols = softDelete ? [...colNames, "deleted_at", "synced_at"] : [...colNames, "synced_at"];
+    const updateSet = updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ");
+    return {
+      sql: `INSERT INTO "${dest}" (${colList}) VALUES ${valueRows.join(", ")} ON CONFLICT (${conflictList}) DO UPDATE SET ${updateSet}`,
+      params: values
+    };
+  }
+  buildDelete(dest, deleteIds, softDelete) {
+    if (softDelete) {
+      return {
+        sql: `UPDATE "${dest}" SET deleted_at = now(), synced_at = now() WHERE row_id = ANY($1)`,
+        params: [deleteIds]
+      };
+    }
+    return {
+      sql: `DELETE FROM "${dest}" WHERE row_id = ANY($1)`,
+      params: [deleteIds]
+    };
+  }
+};
 var PostgresAdapter = class {
   /** @internal */
   pool;
+  dialect = new PostgresSqlDialect();
   constructor(config) {
     const poolConfig = {
       connectionString: config.connectionString
     };
     this.pool = new Pool(poolConfig);
   }
+  get executor() {
+    const pool = this.pool;
+    return {
+      async query(sql, params) {
+        await pool.query(sql, params);
+      },
+      async queryRows(sql, params) {
+        const result = await pool.query(sql, params);
+        return result.rows;
+      }
+    };
+  }
   /**
    * Insert deltas into the database in a single batch.
    * Idempotent via `ON CONFLICT (delta_id) DO NOTHING`.
@@ -719,85 +885,11 @@ CREATE INDEX IF NOT EXISTS idx_lakesync_deltas_table_row ON lakesync_deltas ("ta
   /**
    * Materialise deltas into destination tables.
    *
-   * For each table with a matching schema, merges delta history into the
-   * latest row state and upserts into the destination table. Tombstoned
-   * rows are deleted. The `props` column is never touched.
+   * Delegates to the shared `executeMaterialise` algorithm with the
+   * Postgres SQL dialect.
    */
   async materialise(deltas, schemas) {
-    if (deltas.length === 0) {
-      return Ok(void 0);
-    }
-    return wrapAsync(async () => {
-      const grouped = groupDeltasByTable(deltas);
-      const schemaIndex = buildSchemaIndex(schemas);
-      for (const [tableName, rowIds] of grouped) {
-        const schema = schemaIndex.get(tableName);
-        if (!schema) continue;
-        const dest = schema.table;
-        const columnDefs = schema.columns.map((c) => `"${c.name}" ${POSTGRES_TYPE_MAP[c.type]}`).join(", ");
-        await this.pool.query(
-          `CREATE TABLE IF NOT EXISTS "${dest}" (
-	row_id TEXT PRIMARY KEY,
-	${columnDefs},
-	props JSONB NOT NULL DEFAULT '{}',
-	synced_at TIMESTAMPTZ NOT NULL DEFAULT now()
-)`
-        );
-        const sourceTable = schema.sourceTable ?? schema.table;
-        const rowIdArray = [...rowIds];
-        const deltaResult = await this.pool.query(
-          `SELECT row_id, columns, op FROM lakesync_deltas WHERE "table" = $1 AND row_id = ANY($2) ORDER BY hlc ASC`,
-          [sourceTable, rowIdArray]
-        );
-        const byRowId = /* @__PURE__ */ new Map();
-        for (const row of deltaResult.rows) {
-          const rid = row.row_id;
-          let arr = byRowId.get(rid);
-          if (!arr) {
-            arr = [];
-            byRowId.set(rid, arr);
-          }
-          arr.push(row);
-        }
-        const upserts = [];
-        const deleteIds = [];
-        for (const [rowId, rows] of byRowId) {
-          const state = mergeLatestState(rows);
-          if (state !== null) {
-            upserts.push({ rowId, state });
-          } else {
-            deleteIds.push(rowId);
-          }
-        }
-        if (upserts.length > 0) {
-          const colNames = schema.columns.map((c) => c.name);
-          const allCols = ["row_id", ...colNames, "synced_at"];
-          const colList = allCols.map((c) => `"${c}"`).join(", ");
-          const values = [];
-          const valueRows = [];
-          const paramsPerRow = allCols.length;
-          for (let i = 0; i < upserts.length; i++) {
-            const u = upserts[i];
-            const offset = i * paramsPerRow;
-            const placeholders = allCols.map((_, j) => `$${offset + j + 1}`);
-            valueRows.push(`(${placeholders.join(", ")})`);
-            values.push(u.rowId);
-            for (const col of colNames) {
-              values.push(u.state[col] ?? null);
-            }
-            values.push(/* @__PURE__ */ new Date());
-          }
-          const updateSet = [...colNames, "synced_at"].map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ");
-          await this.pool.query(
-            `INSERT INTO "${dest}" (${colList}) VALUES ${valueRows.join(", ")} ON CONFLICT (row_id) DO UPDATE SET ${updateSet}`,
-            values
-          );
-        }
-        if (deleteIds.length > 0) {
-          await this.pool.query(`DELETE FROM "${dest}" WHERE row_id = ANY($1)`, [deleteIds]);
-        }
-      }
-    }, "Failed to materialise deltas");
+    return executeMaterialise(this.executor, this.dialect, deltas, schemas);
   }
   /** Close the database connection pool and release resources. */
   async close() {
@@ -821,30 +913,19 @@ function rowToRowDelta2(row) {
 function createDatabaseAdapter(config) {
   try {
     switch (config.type) {
-      case "postgres": {
-        if (!config.postgres) {
-          return Err(new AdapterError("Postgres connector config missing postgres field"));
-        }
+      case "postgres":
         return Ok(
           new PostgresAdapter({
             connectionString: config.postgres.connectionString
           })
         );
-      }
-      case "mysql": {
-        if (!config.mysql) {
-          return Err(new AdapterError("MySQL connector config missing mysql field"));
-        }
+      case "mysql":
         return Ok(
           new MySQLAdapter({
             connectionString: config.mysql.connectionString
           })
         );
-      }
-      case "bigquery": {
-        if (!config.bigquery) {
-          return Err(new AdapterError("BigQuery connector config missing bigquery field"));
-        }
+      case "bigquery":
         return Ok(
           new BigQueryAdapter({
             projectId: config.bigquery.projectId,
@@ -853,9 +934,11 @@ function createDatabaseAdapter(config) {
             location: config.bigquery.location
           })
         );
-      }
-      default:
-        return Err(new AdapterError(`Unsupported connector type: ${config.type}`));
+      case "jira":
+      case "salesforce":
+        return Err(
+          new AdapterError(`Connector type "${config.type}" does not use a DatabaseAdapter`)
+        );
     }
   } catch (err) {
     return Err(new AdapterError(`Failed to create adapter: ${toError(err).message}`));
@@ -1151,7 +1234,6 @@ var MinIOAdapter = class {
 async function createQueryFn(config) {
   switch (config.type) {
     case "postgres": {
-      if (!config.postgres) return null;
       const { Pool: Pool2 } = await import("pg");
       const pool = new Pool2({ connectionString: config.postgres.connectionString });
       return async (sql, params) => {
@@ -1160,7 +1242,6 @@ async function createQueryFn(config) {
       };
     }
     case "mysql": {
-      if (!config.mysql) return null;
       const mysql2 = await import("mysql2/promise");
       const pool = mysql2.createPool(config.mysql.connectionString);
       return async (sql, params) => {
@@ -1176,15 +1257,23 @@ async function createQueryFn(config) {
 export {
   lakeSyncTypeToBigQuery,
   isDatabaseAdapter,
-  isMaterialisable,
-  groupDeltasByTable,
-  buildSchemaIndex,
+  groupAndMerge,
   toCause,
   wrapAsync,
   mergeLatestState,
+  isMaterialisable,
+  resolvePrimaryKey,
+  resolveConflictColumns,
+  isSoftDelete,
+  groupDeltasByTable,
+  buildSchemaIndex,
+  executeMaterialise,
+  BigQuerySqlDialect,
   BigQueryAdapter,
   CompositeAdapter,
+  MySqlDialect,
   MySQLAdapter,
+  PostgresSqlDialect,
   PostgresAdapter,
   createDatabaseAdapter,
   FanOutAdapter,
@@ -1194,4 +1283,4 @@ export {
   MinIOAdapter,
   createQueryFn
 };
-//# sourceMappingURL=chunk-Z7FGLEQU.js.map
+//# sourceMappingURL=chunk-LPWXOYNS.js.map