lakesync 0.1.0

package/dist/chunk-X3RO5SYJ.js

@@ -0,0 +1,880 @@
+import {
+  AdapterError,
+  Err,
+  Ok,
+  toError
+} from "./chunk-ICNT7I3K.js";
+
+// ../adapter/src/shared.ts
+function toCause(error) {
+  return error instanceof Error ? error : void 0;
+}
+async function wrapAsync(operation, errorMessage) {
+  try {
+    const value = await operation();
+    return Ok(value);
+  } catch (error) {
+    if (error instanceof AdapterError) {
+      return Err(error);
+    }
+    return Err(new AdapterError(errorMessage, toCause(error)));
+  }
+}
+function mergeLatestState(rows) {
+  if (rows.length === 0) return null;
+  const lastRow = rows[rows.length - 1];
+  if (lastRow.op === "DELETE") return null;
+  const state = {};
+  for (const row of rows) {
+    if (row.op === "DELETE") {
+      for (const key of Object.keys(state)) {
+        delete state[key];
+      }
+      continue;
+    }
+    const columns = typeof row.columns === "string" ? JSON.parse(row.columns) : row.columns;
+    for (const col of columns) {
+      state[col.column] = col.value;
+    }
+  }
+  return state;
+}
+
+// ../adapter/src/bigquery.ts
+import { BigQuery } from "@google-cloud/bigquery";
+function rowToRowDelta(row) {
+  const columns = typeof row.columns === "string" ? JSON.parse(row.columns) : row.columns;
+  const hlcRaw = row.hlc;
+  const hlcString = typeof hlcRaw === "object" && hlcRaw !== null && "value" in hlcRaw ? hlcRaw.value : String(hlcRaw);
+  return {
+    deltaId: row.delta_id,
+    table: row.table,
+    rowId: row.row_id,
+    columns,
+    hlc: BigInt(hlcString),
+    clientId: row.client_id,
+    op: row.op
+  };
+}
+var BigQueryAdapter = class {
+  /** @internal */
+  client;
+  /** @internal */
+  dataset;
+  /** @internal */
+  location;
+  constructor(config) {
+    this.client = new BigQuery({
+      projectId: config.projectId,
+      keyFilename: config.keyFilename
+    });
+    this.dataset = config.dataset;
+    this.location = config.location ?? "US";
+  }
+  /**
+   * Insert deltas into the database in a single batch.
+   * Idempotent via MERGE — existing deltaIds are silently skipped.
+   */
+  async insertDeltas(deltas) {
+    if (deltas.length === 0) {
+      return Ok(void 0);
+    }
+    return wrapAsync(async () => {
+      const params = {};
+      const selects = [];
+      for (let i = 0; i < deltas.length; i++) {
+        const d = deltas[i];
+        params[`did_${i}`] = d.deltaId;
+        params[`tbl_${i}`] = d.table;
+        params[`rid_${i}`] = d.rowId;
+        params[`col_${i}`] = JSON.stringify(d.columns);
+        params[`hlc_${i}`] = d.hlc.toString();
+        params[`cid_${i}`] = d.clientId;
+        params[`op_${i}`] = d.op;
+        selects.push(
+          `SELECT @did_${i} AS delta_id, @tbl_${i} AS \`table\`, @rid_${i} AS row_id, @col_${i} AS columns, CAST(@hlc_${i} AS INT64) AS hlc, @cid_${i} AS client_id, @op_${i} AS op`
+        );
+      }
+      const sql = `MERGE \`${this.dataset}.lakesync_deltas\` AS target
+USING (${selects.join(" UNION ALL ")}) AS source
+ON target.delta_id = source.delta_id
+WHEN NOT MATCHED THEN INSERT (delta_id, \`table\`, row_id, columns, hlc, client_id, op)
+VALUES (source.delta_id, source.\`table\`, source.row_id, source.columns, source.hlc, source.client_id, source.op)`;
+      await this.client.query({ query: sql, params, location: this.location });
+    }, "Failed to insert deltas");
+  }
+  /**
+   * Query deltas with HLC greater than the given timestamp, optionally filtered by table.
+   */
+  async queryDeltasSince(hlc, tables) {
+    return wrapAsync(async () => {
+      let sql;
+      const params = {
+        sinceHlc: hlc.toString()
+      };
+      if (tables && tables.length > 0) {
+        sql = `SELECT delta_id, \`table\`, row_id, columns, hlc, client_id, op
+FROM \`${this.dataset}.lakesync_deltas\`
+WHERE hlc > CAST(@sinceHlc AS INT64) AND \`table\` IN UNNEST(@tables)
+ORDER BY hlc ASC`;
+        params.tables = tables;
+      } else {
+        sql = `SELECT delta_id, \`table\`, row_id, columns, hlc, client_id, op
+FROM \`${this.dataset}.lakesync_deltas\`
+WHERE hlc > CAST(@sinceHlc AS INT64)
+ORDER BY hlc ASC`;
+      }
+      const [rows] = await this.client.query({
+        query: sql,
+        params,
+        location: this.location
+      });
+      return rows.map(rowToRowDelta);
+    }, "Failed to query deltas");
+  }
+  /**
+   * Get the latest merged state for a specific row using column-level LWW.
+   * Returns null if no deltas exist for this row.
+   */
+  async getLatestState(table, rowId) {
+    return wrapAsync(async () => {
+      const sql = `SELECT columns, hlc, client_id, op
+FROM \`${this.dataset}.lakesync_deltas\`
+WHERE \`table\` = @tbl AND row_id = @rid
+ORDER BY hlc ASC`;
+      const [rows] = await this.client.query({
+        query: sql,
+        params: { tbl: table, rid: rowId },
+        location: this.location
+      });
+      return mergeLatestState(rows);
+    }, `Failed to get latest state for ${table}:${rowId}`);
+  }
+  /**
+   * Ensure the BigQuery dataset and lakesync_deltas table exist.
+   * The `schema` parameter is accepted for interface compliance but the
+   * internal table structure is fixed (deltas store column data as JSON).
+   */
+  async ensureSchema(_schema) {
+    return wrapAsync(async () => {
+      const datasetRef = this.client.dataset(this.dataset);
+      const [datasetExists] = await datasetRef.exists();
+      if (!datasetExists) {
+        await this.client.createDataset(this.dataset, {
+          location: this.location
+        });
+      }
+      await this.client.query({
+        query: `CREATE TABLE IF NOT EXISTS \`${this.dataset}.lakesync_deltas\` (
+	delta_id STRING NOT NULL,
+	\`table\` STRING NOT NULL,
+	row_id STRING NOT NULL,
+	columns JSON NOT NULL,
+	hlc INT64 NOT NULL,
+	client_id STRING NOT NULL,
+	op STRING NOT NULL
+)
+CLUSTER BY \`table\`, hlc`,
+        location: this.location
+      });
+    }, "Failed to ensure schema");
+  }
+  /**
+   * No-op — BigQuery client is HTTP-based with no persistent connections.
+   */
+  async close() {
+  }
+};
+
+// ../adapter/src/composite.ts
+var CompositeAdapter = class {
+  routeMap;
+  adapters;
+  defaultAdapter;
+  constructor(config) {
+    this.routeMap = /* @__PURE__ */ new Map();
+    this.adapters = /* @__PURE__ */ new Set();
+    this.defaultAdapter = config.defaultAdapter;
+    this.adapters.add(config.defaultAdapter);
+    for (const route of config.routes) {
+      this.adapters.add(route.adapter);
+      for (const table of route.tables) {
+        if (this.routeMap.has(table)) {
+          throw new Error(`Duplicate table route: "${table}" appears in multiple routes`);
+        }
+        this.routeMap.set(table, route.adapter);
+      }
+    }
+  }
+  /** Insert deltas, routing each group to the correct adapter by table. */
+  async insertDeltas(deltas) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const delta of deltas) {
+      const adapter = this.routeMap.get(delta.table) ?? this.defaultAdapter;
+      let group = groups.get(adapter);
+      if (!group) {
+        group = [];
+        groups.set(adapter, group);
+      }
+      group.push(delta);
+    }
+    for (const [adapter, group] of groups) {
+      const result = await adapter.insertDeltas(group);
+      if (!result.ok) {
+        return result;
+      }
+    }
+    return Ok(void 0);
+  }
+  /** Query deltas since a given HLC, fanning out to relevant adapters and merging results. */
+  async queryDeltasSince(hlc, tables) {
+    const adapterSet = /* @__PURE__ */ new Set();
+    const adapterTables = /* @__PURE__ */ new Map();
+    if (tables && tables.length > 0) {
+      for (const table of tables) {
+        const adapter = this.routeMap.get(table) ?? this.defaultAdapter;
+        adapterSet.add(adapter);
+        let existing = adapterTables.get(adapter);
+        if (!existing) {
+          existing = [];
+          adapterTables.set(adapter, existing);
+        }
+        existing.push(table);
+      }
+    } else {
+      for (const adapter of this.adapters) {
+        adapterSet.add(adapter);
+      }
+    }
+    const merged = [];
+    for (const adapter of adapterSet) {
+      const filterTables = adapterTables.get(adapter);
+      const result = await adapter.queryDeltasSince(hlc, filterTables);
+      if (!result.ok) {
+        return result;
+      }
+      merged.push(...result.value);
+    }
+    merged.sort((a, b) => a.hlc < b.hlc ? -1 : a.hlc > b.hlc ? 1 : 0);
+    return Ok(merged);
+  }
+  /** Get the latest state for a row, routing to the correct adapter. */
+  async getLatestState(table, rowId) {
+    const adapter = this.routeMap.get(table) ?? this.defaultAdapter;
+    return adapter.getLatestState(table, rowId);
+  }
+  /** Ensure schema exists, routing to the correct adapter for the table. */
+  async ensureSchema(schema) {
+    const adapter = this.routeMap.get(schema.table) ?? this.defaultAdapter;
+    return adapter.ensureSchema(schema);
+  }
+  /** Close all unique adapters (routes + default, deduplicated). */
+  async close() {
+    for (const adapter of this.adapters) {
+      await adapter.close();
+    }
+  }
+};
+
+// ../adapter/src/db-types.ts
+var BIGQUERY_TYPE_MAP = {
+  string: "STRING",
+  number: "FLOAT64",
+  boolean: "BOOL",
+  json: "JSON",
+  null: "STRING"
+};
+function lakeSyncTypeToBigQuery(type) {
+  return BIGQUERY_TYPE_MAP[type];
+}
+function isDatabaseAdapter(adapter) {
+  return adapter !== null && typeof adapter === "object" && "insertDeltas" in adapter && "queryDeltasSince" in adapter && typeof adapter.insertDeltas === "function";
+}
+
+// ../adapter/src/mysql.ts
+import mysql from "mysql2/promise";
+var MYSQL_TYPE_MAP = {
+  string: "TEXT",
+  number: "DOUBLE",
+  boolean: "TINYINT(1)",
+  json: "JSON",
+  null: "TEXT"
+};
+function lakeSyncTypeToMySQL(type) {
+  return MYSQL_TYPE_MAP[type];
+}
+var MySQLAdapter = class {
+  /** @internal */
+  pool;
+  constructor(config) {
+    this.pool = mysql.createPool(config.connectionString);
+  }
+  /**
+   * Insert deltas into the database in a single batch.
+   * Uses INSERT IGNORE for idempotent writes — duplicate deltaIds are silently skipped.
+   */
+  async insertDeltas(deltas) {
+    if (deltas.length === 0) {
+      return Ok(void 0);
+    }
+    return wrapAsync(async () => {
+      const sql = `INSERT IGNORE INTO lakesync_deltas (delta_id, \`table\`, row_id, columns, hlc, client_id, op) VALUES ${deltas.map(() => "(?, ?, ?, ?, ?, ?, ?)").join(", ")}`;
+      const values = [];
+      for (const delta of deltas) {
+        values.push(
+          delta.deltaId,
+          delta.table,
+          delta.rowId,
+          JSON.stringify(delta.columns),
+          delta.hlc.toString(),
+          delta.clientId,
+          delta.op
+        );
+      }
+      await this.pool.execute(sql, values);
+    }, "Failed to insert deltas");
+  }
+  /**
+   * Query deltas with HLC greater than the given timestamp.
+   * Optionally filtered by table name(s).
+   */
+  async queryDeltasSince(hlc, tables) {
+    return wrapAsync(async () => {
+      let sql = "SELECT delta_id, `table`, row_id, columns, hlc, client_id, op FROM lakesync_deltas WHERE hlc > ?";
+      const params = [hlc.toString()];
+      if (tables && tables.length > 0) {
+        sql += ` AND \`table\` IN (${tables.map(() => "?").join(", ")})`;
+        params.push(...tables);
+      }
+      sql += " ORDER BY hlc ASC";
+      const [rows] = await this.pool.execute(sql, params);
+      return rows.map(rowToDelta);
+    }, "Failed to query deltas");
+  }
+  /**
+   * Get the latest merged state for a specific row using column-level LWW.
+   * Returns null if no deltas exist or if the row is tombstoned by DELETE.
+   */
+  async getLatestState(table, rowId) {
+    return wrapAsync(async () => {
+      const sql = "SELECT columns, hlc, client_id, op FROM lakesync_deltas WHERE `table` = ? AND row_id = ? ORDER BY hlc ASC";
+      const [rows] = await this.pool.execute(sql, [table, rowId]);
+      return mergeLatestState(rows);
+    }, `Failed to get latest state for ${table}:${rowId}`);
+  }
+  /**
+   * Ensure the database schema exists. Creates the lakesync_deltas table
+   * and a user table matching the given TableSchema definition.
+   */
+  async ensureSchema(schema) {
+    return wrapAsync(async () => {
+      await this.pool.execute(`
+				CREATE TABLE IF NOT EXISTS lakesync_deltas (
+					delta_id VARCHAR(255) PRIMARY KEY,
+					\`table\` VARCHAR(255) NOT NULL,
+					row_id VARCHAR(255) NOT NULL,
+					columns JSON NOT NULL,
+					hlc BIGINT NOT NULL,
+					client_id VARCHAR(255) NOT NULL,
+					op VARCHAR(50) NOT NULL DEFAULT 'upsert',
+					INDEX idx_hlc (hlc),
+					INDEX idx_table_row (\`table\`, row_id)
+				)
+			`);
+      const columnDefs = 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, ${columnDefs})`
+      );
+    }, `Failed to ensure schema for table ${schema.table}`);
+  }
+  /** Close the database connection pool and release resources. */
+  async close() {
+    await this.pool.end();
+  }
+};
+function rowToDelta(row) {
+  return {
+    deltaId: row.delta_id,
+    table: row.table,
+    rowId: row.row_id,
+    columns: typeof row.columns === "string" ? JSON.parse(row.columns) : row.columns,
+    hlc: BigInt(row.hlc),
+    clientId: row.client_id,
+    op: row.op
+  };
+}
+
+// ../adapter/src/postgres.ts
+import { Pool } from "pg";
+var PostgresAdapter = class {
+  /** @internal */
+  pool;
+  constructor(config) {
+    const poolConfig = {
+      connectionString: config.connectionString
+    };
+    this.pool = new Pool(poolConfig);
+  }
+  /**
+   * Insert deltas into the database in a single batch.
+   * Idempotent via `ON CONFLICT (delta_id) DO NOTHING`.
+   */
+  async insertDeltas(deltas) {
+    if (deltas.length === 0) {
+      return Ok(void 0);
+    }
+    return wrapAsync(async () => {
+      const values = [];
+      const rows = [];
+      for (let i = 0; i < deltas.length; i++) {
+        const d = deltas[i];
+        const offset = i * 7;
+        rows.push(
+          `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6}, $${offset + 7})`
+        );
+        values.push(
+          d.deltaId,
+          d.table,
+          d.rowId,
+          JSON.stringify(d.columns),
+          d.hlc.toString(),
+          d.clientId,
+          d.op
+        );
+      }
+      const sql = `INSERT INTO lakesync_deltas (delta_id, "table", row_id, columns, hlc, client_id, op)
+VALUES ${rows.join(", ")}
+ON CONFLICT (delta_id) DO NOTHING`;
+      await this.pool.query(sql, values);
+    }, "Failed to insert deltas");
+  }
+  /**
+   * Query deltas with HLC greater than the given timestamp, optionally filtered by table.
+   */
+  async queryDeltasSince(hlc, tables) {
+    return wrapAsync(async () => {
+      let sql;
+      let params;
+      if (tables && tables.length > 0) {
+        sql = `SELECT delta_id, "table", row_id, columns, hlc, client_id, op
+FROM lakesync_deltas
+WHERE hlc > $1 AND "table" = ANY($2)
+ORDER BY hlc ASC`;
+        params = [hlc.toString(), tables];
+      } else {
+        sql = `SELECT delta_id, "table", row_id, columns, hlc, client_id, op
+FROM lakesync_deltas
+WHERE hlc > $1
+ORDER BY hlc ASC`;
+        params = [hlc.toString()];
+      }
+      const result = await this.pool.query(sql, params);
+      return result.rows.map(rowToRowDelta2);
+    }, "Failed to query deltas");
+  }
+  /**
+   * Get the latest merged state for a specific row using column-level LWW.
+   * Returns null if no deltas exist for this row.
+   */
+  async getLatestState(table, rowId) {
+    return wrapAsync(async () => {
+      const sql = `SELECT columns, hlc, client_id, op
+FROM lakesync_deltas
+WHERE "table" = $1 AND row_id = $2
+ORDER BY hlc ASC`;
+      const result = await this.pool.query(sql, [table, rowId]);
+      return mergeLatestState(result.rows);
+    }, `Failed to get latest state for ${table}:${rowId}`);
+  }
+  /**
+   * Ensure the lakesync_deltas table and indices exist.
+   * The `schema` parameter is accepted for interface compliance but the
+   * internal table structure is fixed (deltas store column data as JSONB).
+   */
+  async ensureSchema(_schema) {
+    return wrapAsync(async () => {
+      await this.pool.query(`
+CREATE TABLE IF NOT EXISTS lakesync_deltas (
+	delta_id TEXT PRIMARY KEY,
+	"table" TEXT NOT NULL,
+	row_id TEXT NOT NULL,
+	columns JSONB NOT NULL,
+	hlc BIGINT NOT NULL,
+	client_id TEXT NOT NULL,
+	op TEXT NOT NULL DEFAULT 'INSERT'
+);
+CREATE INDEX IF NOT EXISTS idx_lakesync_deltas_hlc ON lakesync_deltas (hlc);
+CREATE INDEX IF NOT EXISTS idx_lakesync_deltas_table_row ON lakesync_deltas ("table", row_id);
+`);
+    }, "Failed to ensure schema");
+  }
+  /** Close the database connection pool and release resources. */
+  async close() {
+    await this.pool.end();
+  }
+};
+function rowToRowDelta2(row) {
+  const columns = typeof row.columns === "string" ? JSON.parse(row.columns) : row.columns;
+  return {
+    deltaId: row.delta_id,
+    table: row.table,
+    rowId: row.row_id,
+    columns,
+    hlc: BigInt(row.hlc),
+    clientId: row.client_id,
+    op: row.op
+  };
+}
+
+// ../adapter/src/factory.ts
+function createDatabaseAdapter(config) {
+  try {
+    switch (config.type) {
+      case "postgres": {
+        if (!config.postgres) {
+          return Err(new AdapterError("Postgres connector config missing postgres field"));
+        }
+        return Ok(
+          new PostgresAdapter({
+            connectionString: config.postgres.connectionString
+          })
+        );
+      }
+      case "mysql": {
+        if (!config.mysql) {
+          return Err(new AdapterError("MySQL connector config missing mysql field"));
+        }
+        return Ok(
+          new MySQLAdapter({
+            connectionString: config.mysql.connectionString
+          })
+        );
+      }
+      case "bigquery": {
+        if (!config.bigquery) {
+          return Err(new AdapterError("BigQuery connector config missing bigquery field"));
+        }
+        return Ok(
+          new BigQueryAdapter({
+            projectId: config.bigquery.projectId,
+            dataset: config.bigquery.dataset,
+            keyFilename: config.bigquery.keyFilename,
+            location: config.bigquery.location
+          })
+        );
+      }
+      default:
+        return Err(new AdapterError(`Unsupported connector type: ${config.type}`));
+    }
+  } catch (err) {
+    return Err(new AdapterError(`Failed to create adapter: ${toError(err).message}`));
+  }
+}
+
+// ../adapter/src/fan-out.ts
+var FanOutAdapter = class {
+  primary;
+  secondaries;
+  constructor(config) {
+    this.primary = config.primary;
+    this.secondaries = config.secondaries;
+  }
+  /** Insert deltas into the primary, then replicate to secondaries (fire-and-forget). */
+  async insertDeltas(deltas) {
+    const result = await this.primary.insertDeltas(deltas);
+    if (!result.ok) {
+      return result;
+    }
+    for (const secondary of this.secondaries) {
+      secondary.insertDeltas(deltas).catch(() => {
+      });
+    }
+    return Ok(void 0);
+  }
+  /** Query deltas from the primary adapter only. */
+  async queryDeltasSince(hlc, tables) {
+    return this.primary.queryDeltasSince(hlc, tables);
+  }
+  /** Get the latest state from the primary adapter only. */
+  async getLatestState(table, rowId) {
+    return this.primary.getLatestState(table, rowId);
+  }
+  /** Ensure schema on the primary first, then best-effort on secondaries. */
+  async ensureSchema(schema) {
+    const result = await this.primary.ensureSchema(schema);
+    if (!result.ok) {
+      return result;
+    }
+    for (const secondary of this.secondaries) {
+      secondary.ensureSchema(schema).catch(() => {
+      });
+    }
+    return Ok(void 0);
+  }
+  /** Close primary and all secondary adapters. */
+  async close() {
+    await this.primary.close();
+    for (const secondary of this.secondaries) {
+      await secondary.close();
+    }
+  }
+};
+
+// ../adapter/src/lifecycle.ts
+var LifecycleAdapter = class {
+  hot;
+  cold;
+  maxAgeMs;
+  constructor(config) {
+    this.hot = config.hot.adapter;
+    this.cold = config.cold.adapter;
+    this.maxAgeMs = config.hot.maxAgeMs;
+  }
+  /** Insert deltas into the hot adapter — new data is always hot. */
+  async insertDeltas(deltas) {
+    return this.hot.insertDeltas(deltas);
+  }
+  /**
+   * Query deltas since the given HLC.
+   *
+   * If `sinceHlc` is older than `now - maxAgeMs`, queries both hot and cold
+   * adapters and merges the results sorted by HLC. Otherwise queries hot only.
+   */
+  async queryDeltasSince(hlc, tables) {
+    const sinceWallMs = Number(hlc >> 16n);
+    const thresholdMs = Date.now() - this.maxAgeMs;
+    if (sinceWallMs < thresholdMs) {
+      const [hotResult, coldResult] = await Promise.all([
+        this.hot.queryDeltasSince(hlc, tables),
+        this.cold.queryDeltasSince(hlc, tables)
+      ]);
+      if (!hotResult.ok) return hotResult;
+      if (!coldResult.ok) return coldResult;
+      const merged = [...hotResult.value, ...coldResult.value];
+      merged.sort((a, b) => a.hlc < b.hlc ? -1 : a.hlc > b.hlc ? 1 : 0);
+      return Ok(merged);
+    }
+    return this.hot.queryDeltasSince(hlc, tables);
+  }
+  /** Get latest state — try hot first, fall back to cold if hot returns null. */
+  async getLatestState(table, rowId) {
+    const hotResult = await this.hot.getLatestState(table, rowId);
+    if (!hotResult.ok) return hotResult;
+    if (hotResult.value !== null) {
+      return hotResult;
+    }
+    return this.cold.getLatestState(table, rowId);
+  }
+  /** Ensure schema exists on both hot and cold adapters. */
+  async ensureSchema(schema) {
+    const hotResult = await this.hot.ensureSchema(schema);
+    if (!hotResult.ok) return hotResult;
+    return this.cold.ensureSchema(schema);
+  }
+  /** Close both hot and cold adapters. */
+  async close() {
+    await this.hot.close();
+    await this.cold.close();
+  }
+};
+async function migrateToTier(hot, cold, maxAgeMs) {
+  const thresholdMs = Date.now() - maxAgeMs;
+  const thresholdHlc = BigInt(0) << 16n;
+  const result = await hot.queryDeltasSince(thresholdHlc);
+  if (!result.ok) return result;
+  const oldDeltas = result.value.filter((delta) => {
+    const wallMs = Number(delta.hlc >> 16n);
+    return wallMs < thresholdMs;
+  });
+  if (oldDeltas.length === 0) {
+    return Ok({ migrated: 0 });
+  }
+  const insertResult = await cold.insertDeltas(oldDeltas);
+  if (!insertResult.ok) return insertResult;
+  return Ok({ migrated: oldDeltas.length });
+}
+
+// ../adapter/src/migrate.ts
+async function migrateAdapter(opts) {
+  const batchSize = opts.batchSize ?? 1e3;
+  const readResult = await opts.from.queryDeltasSince(BigInt(0), opts.tables);
+  if (!readResult.ok) {
+    return readResult;
+  }
+  const deltas = readResult.value;
+  if (deltas.length === 0) {
+    return Ok({ totalDeltas: 0, batches: 0 });
+  }
+  let batchCount = 0;
+  let totalSoFar = 0;
+  for (let i = 0; i < deltas.length; i += batchSize) {
+    const batch = deltas.slice(i, i + batchSize);
+    const writeResult = await opts.to.insertDeltas(batch);
+    if (!writeResult.ok) {
+      return writeResult;
+    }
+    batchCount++;
+    totalSoFar += batch.length;
+    opts.onProgress?.({ batch: batchCount, totalSoFar });
+  }
+  return Ok({ totalDeltas: totalSoFar, batches: batchCount });
+}
+
+// ../adapter/src/minio.ts
+import {
+  DeleteObjectCommand,
+  DeleteObjectsCommand,
+  GetObjectCommand,
+  HeadObjectCommand,
+  ListObjectsV2Command,
+  PutObjectCommand,
+  S3Client
+} from "@aws-sdk/client-s3";
+var MinIOAdapter = class {
+  client;
+  bucket;
+  constructor(config) {
+    this.bucket = config.bucket;
+    this.client = new S3Client({
+      endpoint: config.endpoint,
+      region: config.region ?? "us-east-1",
+      credentials: config.credentials,
+      forcePathStyle: true
+      // Required for MinIO
+    });
+  }
+  /** Store an object in the lake */
+  async putObject(path, data, contentType) {
+    return wrapAsync(async () => {
+      await this.client.send(
+        new PutObjectCommand({
+          Bucket: this.bucket,
+          Key: path,
+          Body: data,
+          ContentType: contentType
+        })
+      );
+    }, `Failed to put object: ${path}`);
+  }
+  /** Retrieve an object from the lake */
+  async getObject(path) {
+    return wrapAsync(async () => {
+      const response = await this.client.send(
+        new GetObjectCommand({
+          Bucket: this.bucket,
+          Key: path
+        })
+      );
+      const bytes = await response.Body?.transformToByteArray();
+      if (!bytes) {
+        throw new AdapterError(`Empty response for object: ${path}`);
+      }
+      return bytes;
+    }, `Failed to get object: ${path}`);
+  }
+  /** Get object metadata without retrieving the body */
+  async headObject(path) {
+    return wrapAsync(async () => {
+      const response = await this.client.send(
+        new HeadObjectCommand({
+          Bucket: this.bucket,
+          Key: path
+        })
+      );
+      return {
+        size: response.ContentLength ?? 0,
+        lastModified: response.LastModified ?? /* @__PURE__ */ new Date(0)
+      };
+    }, `Failed to head object: ${path}`);
+  }
+  /** List objects matching a given prefix */
+  async listObjects(prefix) {
+    return wrapAsync(async () => {
+      const response = await this.client.send(
+        new ListObjectsV2Command({
+          Bucket: this.bucket,
+          Prefix: prefix
+        })
+      );
+      return (response.Contents ?? []).map((item) => ({
+        key: item.Key ?? "",
+        size: item.Size ?? 0,
+        lastModified: item.LastModified ?? /* @__PURE__ */ new Date(0)
+      }));
+    }, `Failed to list objects with prefix: ${prefix}`);
+  }
+  /** Delete a single object from the lake */
+  async deleteObject(path) {
+    return wrapAsync(async () => {
+      await this.client.send(
+        new DeleteObjectCommand({
+          Bucket: this.bucket,
+          Key: path
+        })
+      );
+    }, `Failed to delete object: ${path}`);
+  }
+  /** Delete multiple objects from the lake in a single batch operation */
+  async deleteObjects(paths) {
+    if (paths.length === 0) {
+      return Ok(void 0);
+    }
+    return wrapAsync(async () => {
+      await this.client.send(
+        new DeleteObjectsCommand({
+          Bucket: this.bucket,
+          Delete: {
+            Objects: paths.map((key) => ({ Key: key })),
+            Quiet: true
+          }
+        })
+      );
+    }, `Failed to batch delete ${paths.length} objects`);
+  }
+};
+
+// ../adapter/src/query-fn.ts
+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) => {
+        const result = await pool.query(sql, params);
+        return result.rows;
+      };
+    }
+    case "mysql": {
+      if (!config.mysql) return null;
+      const mysql2 = await import("mysql2/promise");
+      const pool = mysql2.createPool(config.mysql.connectionString);
+      return async (sql, params) => {
+        const [rows] = await pool.query(sql, params);
+        return rows;
+      };
+    }
+    default:
+      return null;
+  }
+}
+
+export {
+  toCause,
+  wrapAsync,
+  mergeLatestState,
+  BigQueryAdapter,
+  CompositeAdapter,
+  lakeSyncTypeToBigQuery,
+  isDatabaseAdapter,
+  MySQLAdapter,
+  PostgresAdapter,
+  createDatabaseAdapter,
+  FanOutAdapter,
+  LifecycleAdapter,
+  migrateToTier,
+  migrateAdapter,
+  MinIOAdapter,
+  createQueryFn
+};
+//# sourceMappingURL=chunk-X3RO5SYJ.js.map