@hasna/cloud 0.1.2 → 0.1.4

package/dist/mcp/index.js

@@ -6629,7 +6629,7 @@ var require_arrayParser = __commonJS((exports, module) => {
   };
 });
 
-// node_modules/postgres-date/index.js
+// node_modules/pg-types/node_modules/postgres-date/index.js
 var require_postgres_date = __commonJS((exports, module) => {
   var DATE_TIME = /(\d{1,})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})(\.\d{1,})?.*?( BC)?$/;
   var DATE = /^(\d{1,})-(\d{2})-(\d{2})( BC)?$/;
@@ -6731,7 +6731,7 @@ var require_mutable = __commonJS((exports, module) => {
   }
 });
 
-// node_modules/postgres-interval/index.js
+// node_modules/pg-types/node_modules/postgres-interval/index.js
 var require_postgres_interval = __commonJS((exports, module) => {
   var extend2 = require_mutable();
   module.exports = PostgresInterval;
@@ -6823,7 +6823,7 @@ var require_postgres_interval = __commonJS((exports, module) => {
   }
 });
 
-// node_modules/postgres-bytea/index.js
+// node_modules/pg-types/node_modules/postgres-bytea/index.js
 var require_postgres_bytea = __commonJS((exports, module) => {
   var bufferFrom = Buffer.from || Buffer;
   module.exports = function parseBytea(input) {
@@ -24656,17 +24656,88 @@ function createDatabase(options) {
 }
 
 // src/sync.ts
-function syncPush(local, cloud, options) {
-  return syncTransfer(local, cloud, options, "push");
+async function syncPush(local, remote, options) {
+  const orderedTables = await getTableOrder(remote, options.tables);
+  return syncTransfer(local, remote, { ...options, tables: orderedTables }, "push");
 }
-function syncPull(local, cloud, options) {
-  return syncTransfer(cloud, local, options, "pull");
+async function syncPull(remote, local, options) {
+  const orderedTables = await getTableOrder(remote, options.tables);
+  return syncTransfer(remote, local, { ...options, tables: orderedTables }, "pull");
 }
-function syncTransfer(source, target, options, _direction) {
+async function getTableOrder(remote, tables) {
+  if (tables.length <= 1)
+    return tables;
+  try {
+    const fks = await remote.all(`
+      SELECT DISTINCT
+        tc.table_name AS source_table,
+        ccu.table_name AS referenced_table
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.constraint_column_usage ccu
+        ON tc.constraint_name = ccu.constraint_name
+        AND tc.table_schema = ccu.table_schema
+      WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_schema = 'public'
+    `);
+    if (fks.length > 0) {
+      return topoSort(tables, fks);
+    }
+  } catch {}
+  return heuristicOrder(tables);
+}
+function topoSort(tables, fks) {
+  const tableSet = new Set(tables);
+  const deps = new Map;
+  for (const t of tables) {
+    deps.set(t, new Set);
+  }
+  for (const fk of fks) {
+    if (tableSet.has(fk.source_table) && tableSet.has(fk.referenced_table)) {
+      deps.get(fk.source_table).add(fk.referenced_table);
+    }
+  }
+  const sorted = [];
+  const visited = new Set;
+  const visiting = new Set;
+  function visit(table) {
+    if (visited.has(table))
+      return;
+    if (visiting.has(table)) {
+      sorted.push(table);
+      visited.add(table);
+      return;
+    }
+    visiting.add(table);
+    const tableDeps = deps.get(table) ?? new Set;
+    for (const dep of tableDeps) {
+      visit(dep);
+    }
+    visiting.delete(table);
+    visited.add(table);
+    sorted.push(table);
+  }
+  for (const t of tables) {
+    visit(t);
+  }
+  return sorted;
+}
+function heuristicOrder(tables) {
+  const sorted = [...tables].sort((a, b) => {
+    const aIsChild = a.includes("_") && tables.some((t) => a.startsWith(t + "_") || a.endsWith("_" + t));
+    const bIsChild = b.includes("_") && tables.some((t) => b.startsWith(t + "_") || b.endsWith("_" + t));
+    if (aIsChild && !bIsChild)
+      return 1;
+    if (!aIsChild && bIsChild)
+      return -1;
+    return a.localeCompare(b);
+  });
+  return sorted;
+}
+async function syncTransfer(source, target, options, _direction) {
   const {
     tables,
     onProgress,
-    batchSize = 500,
+    batchSize = 100,
     conflictColumn = "updated_at",
     primaryKey = "id"
   } = options;
@@ -24689,7 +24760,7 @@ function syncTransfer(source, target, options, _direction) {
         totalTables: tables.length,
         currentTableIndex: i
       });
-      const rows = source.all(`SELECT * FROM "${table}"`);
+      const rows = await readAll(source, `SELECT * FROM "${table}"`);
       result.rowsRead = rows.length;
       if (rows.length === 0) {
         onProgress?.({
@@ -24704,7 +24775,6 @@ function syncTransfer(source, target, options, _direction) {
         continue;
       }
       const columns = Object.keys(rows[0]);
-      const hasConflictCol = columns.includes(conflictColumn);
       const hasPrimaryKey = columns.includes(primaryKey);
       if (!hasPrimaryKey) {
         result.errors.push(`Table "${table}" has no "${primaryKey}" column — skipping`);
@@ -24719,34 +24789,18 @@ function syncTransfer(source, target, options, _direction) {
         totalTables: tables.length,
         currentTableIndex: i
       });
+      const updateCols = columns.filter((c) => c !== primaryKey);
       for (let offset = 0;offset < rows.length; offset += batchSize) {
         const batch = rows.slice(offset, offset + batchSize);
-        for (const row of batch) {
-          try {
-            const existing = target.get(`SELECT "${primaryKey}"${hasConflictCol ? `, "${conflictColumn}"` : ""} FROM "${table}" WHERE "${primaryKey}" = ?`, row[primaryKey]);
-            if (existing) {
-              if (hasConflictCol && existing[conflictColumn] && row[conflictColumn]) {
-                const existingTime = new Date(existing[conflictColumn]).getTime();
-                const incomingTime = new Date(row[conflictColumn]).getTime();
-                if (existingTime >= incomingTime) {
-                  result.rowsSkipped++;
-                  continue;
-                }
-              }
-              const setClauses = columns.filter((c) => c !== primaryKey).map((c) => `"${c}" = ?`).join(", ");
-              const values = columns.filter((c) => c !== primaryKey).map((c) => row[c]);
-              values.push(row[primaryKey]);
-              target.run(`UPDATE "${table}" SET ${setClauses} WHERE "${primaryKey}" = ?`, ...values);
-            } else {
-              const placeholders = columns.map(() => "?").join(", ");
-              const colList = columns.map((c) => `"${c}"`).join(", ");
-              const values = columns.map((c) => row[c]);
-              target.run(`INSERT INTO "${table}" (${colList}) VALUES (${placeholders})`, ...values);
-            }
-            result.rowsWritten++;
-          } catch (err) {
-            result.errors.push(`Row ${row[primaryKey]}: ${err?.message ?? String(err)}`);
+        try {
+          if (isAsyncAdapter(target)) {
+            await batchUpsertPg(target, table, columns, updateCols, primaryKey, batch);
+          } else {
+            batchUpsertSqlite(target, table, columns, updateCols, primaryKey, batch);
           }
+          result.rowsWritten += batch.length;
+        } catch (err) {
+          result.errors.push(`Batch at offset ${offset}: ${err?.message ?? String(err)}`);
         }
         onProgress?.({
           table,
@@ -24772,10 +24826,46 @@ function syncTransfer(source, target, options, _direction) {
   }
   return results;
 }
+async function batchUpsertPg(target, table, columns, updateCols, primaryKey, batch) {
+  if (batch.length === 0)
+    return;
+  const colList = columns.map((c) => `"${c}"`).join(", ");
+  const valuePlaceholders = batch.map((_, rowIdx) => {
+    const offset = rowIdx * columns.length;
+    return `(${columns.map((_2, colIdx) => `$${offset + colIdx + 1}`).join(", ")})`;
+  }).join(", ");
+  const setClause = updateCols.length > 0 ? updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ") : `"${primaryKey}" = EXCLUDED."${primaryKey}"`;
+  const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}
+    ON CONFLICT ("${primaryKey}") DO UPDATE SET ${setClause}`;
+  const params = batch.flatMap((row) => columns.map((c) => row[c] ?? null));
+  await target.run(sql, ...params);
+}
+function batchUpsertSqlite(target, table, columns, updateCols, primaryKey, batch) {
+  if (batch.length === 0)
+    return;
+  const colList = columns.map((c) => `"${c}"`).join(", ");
+  const valuePlaceholders = batch.map(() => `(${columns.map(() => "?").join(", ")})`).join(", ");
+  const setClause = updateCols.length > 0 ? updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ") : `"${primaryKey}" = EXCLUDED."${primaryKey}"`;
+  const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}
+    ON CONFLICT ("${primaryKey}") DO UPDATE SET ${setClause}`;
+  const params = batch.flatMap((row) => columns.map((c) => row[c] ?? null));
+  target.run(sql, ...params);
+}
+function isAsyncAdapter(adapter) {
+  return adapter.constructor.name === "PgAdapterAsync" || typeof adapter.raw?.connect === "function";
+}
+async function readAll(adapter, sql) {
+  const result = adapter.all(sql);
+  return result instanceof Promise ? await result : result;
+}
 function listSqliteTables(db) {
   const rows = db.all(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name`);
   return rows.map((r) => r.name);
 }
+async function listPgTables(db) {
+  const rows = await db.all(`SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename`);
+  return rows.map((r) => r.tablename);
+}
 
 // src/feedback.ts
 import { hostname as hostname2 } from "os";
@@ -24951,10 +25041,8 @@ class SqliteAdapter2 {
     return this.db;
   }
 }
-
-class PgAdapter2 {
+class PgAdapterAsync {
   pool;
-  _client = null;
   constructor(arg) {
     if (typeof arg === "string") {
       this.pool = new esm_default.Pool({ connectionString: arg });
@@ -24962,118 +25050,47 @@ class PgAdapter2 {
       this.pool = arg;
     }
   }
-  runSync(fn) {
-    let result;
-    let error2;
-    let done = false;
-    fn().then((r) => {
-      result = r;
-      done = true;
-    }).catch((e) => {
-      error2 = e;
-      done = true;
-    });
-    const deadline = Date.now() + 30000;
-    while (!done && Date.now() < deadline) {
-      Bun.sleepSync(1);
-    }
-    if (error2)
-      throw error2;
-    if (!done)
-      throw new Error("PgAdapter: query timed out (30s)");
-    return result;
-  }
-  run(sql, ...params) {
+  async run(sql, ...params) {
     const pgSql = translateSql(sql, "pg");
     const pgParams = translateParams(params);
-    return this.runSync(async () => {
-      const res = await this.pool.query(pgSql, pgParams);
-      return {
-        changes: res.rowCount ?? 0,
-        lastInsertRowid: res.rows?.[0]?.id ?? 0
-      };
-    });
+    const res = await this.pool.query(pgSql, pgParams);
+    return {
+      changes: res.rowCount ?? 0,
+      lastInsertRowid: res.rows?.[0]?.id ?? 0
+    };
   }
-  get(sql, ...params) {
+  async get(sql, ...params) {
     const pgSql = translateSql(sql, "pg");
     const pgParams = translateParams(params);
-    return this.runSync(async () => {
-      const res = await this.pool.query(pgSql, pgParams);
-      return res.rows[0] ?? null;
-    });
+    const res = await this.pool.query(pgSql, pgParams);
+    return res.rows[0] ?? null;
   }
-  all(sql, ...params) {
+  async all(sql, ...params) {
     const pgSql = translateSql(sql, "pg");
     const pgParams = translateParams(params);
-    return this.runSync(async () => {
-      const res = await this.pool.query(pgSql, pgParams);
-      return res.rows;
-    });
+    const res = await this.pool.query(pgSql, pgParams);
+    return res.rows;
   }
-  exec(sql) {
+  async exec(sql) {
     const pgSql = translateSql(sql, "pg");
-    this.runSync(async () => {
-      await this.pool.query(pgSql);
-    });
+    await this.pool.query(pgSql);
   }
-  prepare(sql) {
-    const pgSql = translateSql(sql, "pg");
-    const adapter = this;
-    return {
-      run(...params) {
-        const pgParams = translateParams(params);
-        return adapter.runSync(async () => {
-          const res = await adapter.pool.query(pgSql, pgParams);
-          return {
-            changes: res.rowCount ?? 0,
-            lastInsertRowid: res.rows?.[0]?.id ?? 0
-          };
-        });
-      },
-      get(...params) {
-        const pgParams = translateParams(params);
-        return adapter.runSync(async () => {
-          const res = await adapter.pool.query(pgSql, pgParams);
-          return res.rows[0] ?? null;
-        });
-      },
-      all(...params) {
-        const pgParams = translateParams(params);
-        return adapter.runSync(async () => {
-          const res = await adapter.pool.query(pgSql, pgParams);
-          return res.rows;
-        });
-      },
-      finalize() {}
-    };
-  }
-  close() {
-    this.runSync(async () => {
-      await this.pool.end();
-    });
+  async close() {
+    await this.pool.end();
   }
-  transaction(fn) {
-    return this.runSync(async () => {
-      const client = await this.pool.connect();
-      try {
-        await client.query("BEGIN");
-        const origQuery = this.pool.query.bind(this.pool);
-        this.pool.query = client.query.bind(client);
-        let result;
-        try {
-          result = fn();
-        } finally {
-          this.pool.query = origQuery;
-        }
-        await client.query("COMMIT");
-        return result;
-      } catch (err) {
-        await client.query("ROLLBACK");
-        throw err;
-      } finally {
-        client.release();
-      }
-    });
+  async transaction(fn) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const result = await fn(client);
+      await client.query("COMMIT");
+      return result;
+    } catch (err) {
+      await client.query("ROLLBACK");
+      throw err;
+    } finally {
+      client.release();
+    }
   }
   get raw() {
     return this.pool;
@@ -25098,10 +25115,10 @@ server.tool("cloud_status", "Show cloud configuration and connection health", {}
   if (config2.rds.host && config2.rds.username) {
     try {
       const connStr = getConnectionString("postgres");
-      const pg2 = new PgAdapter2(connStr);
-      pg2.get("SELECT 1 as ok");
+      const pg2 = new PgAdapterAsync(connStr);
+      await pg2.get("SELECT 1 as ok");
       lines.push("PostgreSQL: connected");
-      pg2.close();
+      await pg2.close();
     } catch (err) {
       lines.push(`PostgreSQL: connection failed \u2014 ${err?.message}`);
     }
@@ -25128,16 +25145,16 @@ server.tool("sync_push", "Push local SQLite data to cloud PostgreSQL", {
   const dbPath = getDbPath2(service);
   const local = new SqliteAdapter2(dbPath);
   const connStr = getConnectionString(service);
-  const cloud = new PgAdapter2(connStr);
+  const cloud = new PgAdapterAsync(connStr);
   let tableList;
   if (tablesStr) {
     tableList = tablesStr.split(",").map((t) => t.trim());
   } else {
     tableList = listSqliteTables(local);
   }
-  const results = syncPush(local, cloud, { tables: tableList });
+  const results = await syncPush(local, cloud, { tables: tableList });
   local.close();
-  cloud.close();
+  await cloud.close();
   const totalWritten = results.reduce((s, r) => s + r.rowsWritten, 0);
   const totalErrors = results.reduce((s, r) => s + r.errors.length, 0);
   const lines = [
@@ -25171,17 +25188,16 @@ server.tool("sync_pull", "Pull cloud PostgreSQL data to local SQLite", {
   const dbPath = getDbPath2(service);
   const local = new SqliteAdapter2(dbPath);
   const connStr = getConnectionString(service);
-  const cloud = new PgAdapter2(connStr);
+  const cloud = new PgAdapterAsync(connStr);
   let tableList;
   if (tablesStr) {
     tableList = tablesStr.split(",").map((t) => t.trim());
   } else {
     try {
-      const rows = cloud.all(`SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename`);
-      tableList = rows.map((r) => r.tablename);
+      tableList = await listPgTables(cloud);
     } catch {
       local.close();
-      cloud.close();
+      await cloud.close();
       return {
         content: [
           { type: "text", text: "Error: failed to list tables from cloud." }
@@ -25190,9 +25206,9 @@ server.tool("sync_pull", "Pull cloud PostgreSQL data to local SQLite", {
       };
     }
   }
-  const results = syncPull(local, cloud, { tables: tableList });
+  const results = await syncPull(cloud, local, { tables: tableList });
   local.close();
-  cloud.close();
+  await cloud.close();
   const totalWritten = results.reduce((s, r) => s + r.rowsWritten, 0);
   const totalErrors = results.reduce((s, r) => s + r.errors.length, 0);
   const lines = [

package/dist/mcp-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-helpers.d.ts","sourceRoot":"","sources":["../src/mcp-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAYzE;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,SAAS,EACjB,WAAW,EAAE,MAAM,GAClB,IAAI,CAuJN"}
+{"version":3,"file":"mcp-helpers.d.ts","sourceRoot":"","sources":["../src/mcp-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAYzE;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,SAAS,EACjB,WAAW,EAAE,MAAM,GAClB,IAAI,CAoJN"}

package/dist/sync-conflicts.d.ts

@@ -0,0 +1,76 @@
+import type { DbAdapter } from "./adapter.js";
+export interface SyncConflict {
+    table: string;
+    row_id: string;
+    local_updated_at: string;
+    remote_updated_at: string;
+    local_data: Record<string, any>;
+    remote_data: Record<string, any>;
+    resolved: boolean;
+    resolution?: "local-wins" | "remote-wins" | "newest-wins" | "manual";
+}
+export type ConflictStrategy = "local-wins" | "remote-wins" | "newest-wins";
+export interface StoredConflict {
+    id: string;
+    table_name: string;
+    row_id: string;
+    local_data: string;
+    remote_data: string;
+    local_updated_at: string;
+    remote_updated_at: string;
+    resolution: string | null;
+    resolved_at: string | null;
+    created_at: string;
+}
+/**
+ * Find rows that exist in BOTH local and remote datasets with DIFFERENT
+ * `updated_at` values. Returns a list of SyncConflict objects.
+ *
+ * @param local - Array of rows from the local database
+ * @param remote - Array of rows from the remote database
+ * @param table - The table name these rows belong to
+ * @param primaryKey - Column used as primary key (default: "id")
+ * @param conflictColumn - Column used for timestamp comparison (default: "updated_at")
+ */
+export declare function detectConflicts(local: Record<string, any>[], remote: Record<string, any>[], table: string, primaryKey?: string, conflictColumn?: string): SyncConflict[];
+/**
+ * Resolve a list of conflicts using the given strategy.
+ * Returns the winning row data for each conflict.
+ *
+ * @param conflicts - The conflicts to resolve
+ * @param strategy - Resolution strategy (default: "newest-wins")
+ * @returns Array of resolved conflicts with `resolved: true` and `resolution` set
+ */
+export declare function resolveConflicts(conflicts: SyncConflict[], strategy?: ConflictStrategy): SyncConflict[];
+/**
+ * Get the winning data for a resolved conflict.
+ */
+export declare function getWinningData(conflict: SyncConflict): Record<string, any>;
+/**
+ * Ensure the _sync_conflicts table exists.
+ */
+export declare function ensureConflictsTable(db: DbAdapter): void;
+/**
+ * Store unresolved conflicts in the database for later review.
+ */
+export declare function storeConflicts(db: DbAdapter, conflicts: SyncConflict[]): void;
+/**
+ * List all stored conflicts, optionally filtered by resolved status.
+ */
+export declare function listConflicts(db: DbAdapter, opts?: {
+    resolved?: boolean;
+    table?: string;
+}): StoredConflict[];
+/**
+ * Resolve a stored conflict by ID using the given strategy.
+ */
+export declare function resolveConflict(db: DbAdapter, conflictId: string, strategy: ConflictStrategy | "manual"): StoredConflict | null;
+/**
+ * Get a single stored conflict by ID.
+ */
+export declare function getConflict(db: DbAdapter, conflictId: string): StoredConflict | null;
+/**
+ * Delete all resolved conflicts (cleanup).
+ */
+export declare function purgeResolvedConflicts(db: DbAdapter): number;
+//# sourceMappingURL=sync-conflicts.d.ts.map

package/dist/sync-conflicts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-conflicts.d.ts","sourceRoot":"","sources":["../src/sync-conflicts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAM9C,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACjC,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,YAAY,GAAG,aAAa,GAAG,aAAa,GAAG,QAAQ,CAAC;CACtE;AAED,MAAM,MAAM,gBAAgB,GAAG,YAAY,GAAG,aAAa,GAAG,aAAa,CAAC;AAE5E,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;CACpB;AAMD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EAC7B,KAAK,EAAE,MAAM,EACb,UAAU,SAAO,EACjB,cAAc,SAAe,GAC5B,YAAY,EAAE,CAkChB;AAMD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,YAAY,EAAE,EACzB,QAAQ,GAAE,gBAAgC,GACzC,YAAY,EAAE,CA4BhB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAyB1E;AAMD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI,CAexD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,GAAG,IAAI,CAmB7E;AAMD;;GAEG;AACH,wBAAgB,aAAa,CAC3B,EAAE,EAAE,SAAS,EACb,IAAI,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5C,cAAc,EAAE,CAsBlB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,SAAS,EACb,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,gBAAgB,GAAG,QAAQ,GACpC,cAAc,GAAG,IAAI,CAoBvB;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAMpF;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,SAAS,GAAG,MAAM,CAM5D"}

package/dist/sync-incremental.d.ts

@@ -0,0 +1,62 @@
+import type { DbAdapter } from "./adapter.js";
+export interface IncrementalSyncStats {
+    table: string;
+    total_rows: number;
+    synced_rows: number;
+    skipped_rows: number;
+    errors: string[];
+    first_sync: boolean;
+}
+export interface SyncMeta {
+    table_name: string;
+    last_synced_at: string;
+    last_synced_row_count: number;
+    direction: "push" | "pull";
+}
+export interface IncrementalSyncOptions {
+    /** Primary key column name (default: "id"). */
+    primaryKey?: string;
+    /** Conflict resolution column (default: "updated_at"). */
+    conflictColumn?: string;
+    /** Batch size for writes (default: 500). */
+    batchSize?: number;
+}
+/**
+ * Ensure the `_sync_meta` table exists in the given database.
+ */
+export declare function ensureSyncMetaTable(db: DbAdapter): void;
+/**
+ * Push only changed rows (since last sync) from local to remote.
+ *
+ * - Checks `_sync_meta` in the local DB for `last_synced_at`.
+ * - If found: only selects rows where `updated_at > last_synced_at`.
+ * - If not found: full push (first-time sync).
+ * - After push, updates `_sync_meta` with current timestamp and row count.
+ */
+export declare function incrementalSyncPush(local: DbAdapter, remote: DbAdapter, tables: string[], options?: IncrementalSyncOptions): IncrementalSyncStats[];
+/**
+ * Pull only changed rows (since last sync) from remote to local.
+ *
+ * - Checks `_sync_meta` in the local DB for `last_synced_at`.
+ * - If found: only selects rows where `updated_at > last_synced_at`.
+ * - If not found: full pull (first-time sync).
+ * - After pull, updates `_sync_meta` with current timestamp and row count.
+ */
+export declare function incrementalSyncPull(remote: DbAdapter, local: DbAdapter, tables: string[], options?: IncrementalSyncOptions): IncrementalSyncStats[];
+/**
+ * Get the sync metadata for all tables or a specific table.
+ */
+export declare function getSyncMetaAll(db: DbAdapter): SyncMeta[];
+/**
+ * Get sync metadata for a specific table.
+ */
+export declare function getSyncMetaForTable(db: DbAdapter, table: string): SyncMeta | null;
+/**
+ * Reset sync metadata for a table (forces full re-sync on next run).
+ */
+export declare function resetSyncMeta(db: DbAdapter, table: string): void;
+/**
+ * Reset all sync metadata (forces full re-sync for all tables).
+ */
+export declare function resetAllSyncMeta(db: DbAdapter): void;
+//# sourceMappingURL=sync-incremental.d.ts.map

package/dist/sync-incremental.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-incremental.d.ts","sourceRoot":"","sources":["../src/sync-incremental.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAM9C,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,QAAQ;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,sBAAsB;IACrC,+CAA+C;IAC/C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,4CAA4C;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAcD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI,CAEvD;AAkID;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,MAAM,EAAE,EAChB,OAAO,GAAE,sBAA2B,GACnC,oBAAoB,EAAE,CAyExB;AAMD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,MAAM,EAAE,EAChB,OAAO,GAAE,sBAA2B,GACnC,oBAAoB,EAAE,CAyExB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,SAAS,GAAG,QAAQ,EAAE,CAKxD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,SAAS,EACb,KAAK,EAAE,MAAM,GACZ,QAAQ,GAAG,IAAI,CAEjB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAGhE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI,CAGpD"}

package/dist/sync-progress.d.ts

@@ -0,0 +1,68 @@
+import type { DbAdapter } from "./adapter.js";
+export interface SyncProgressInfo {
+    table: string;
+    total: number;
+    done: number;
+    percent: number;
+    elapsed_ms: number;
+    eta_ms: number;
+    status: "pending" | "in_progress" | "completed" | "failed" | "resumed";
+}
+export type ProgressCallback = (progress: SyncProgressInfo) => void;
+export interface ResumePoint {
+    table_name: string;
+    last_row_id: string;
+    direction: string;
+    started_at: string;
+    status: string;
+}
+export declare class SyncProgressTracker {
+    private db;
+    private progress;
+    private startTimes;
+    private callback?;
+    constructor(db: DbAdapter, callback?: ProgressCallback);
+    private ensureResumeTable;
+    /**
+     * Start tracking a table sync. Sets status to in_progress or resumed.
+     */
+    start(table: string, total: number, direction: string): void;
+    /**
+     * Update progress for a table after processing rows.
+     */
+    update(table: string, done: number, lastRowId: string): void;
+    /**
+     * Mark a table sync as completed.
+     */
+    markComplete(table: string): void;
+    /**
+     * Mark a table sync as failed.
+     */
+    markFailed(table: string, _error: string): void;
+    /**
+     * Check if a previous sync was interrupted (status is 'in_progress' or 'resumed').
+     */
+    canResume(table: string): boolean;
+    /**
+     * Returns the last successfully synced row ID for a table, or null.
+     */
+    getResumePoint(table: string): ResumePoint | null;
+    /**
+     * Clear resume state for a table (e.g., after a fresh sync starts).
+     */
+    clearResume(table: string): void;
+    /**
+     * Get current progress info for a table.
+     */
+    getProgress(table: string): SyncProgressInfo | null;
+    /**
+     * Get progress info for all tracked tables.
+     */
+    getAllProgress(): SyncProgressInfo[];
+    /**
+     * List all resume records from the database (including historical).
+     */
+    listResumeRecords(): ResumePoint[];
+    private notify;
+}
+//# sourceMappingURL=sync-progress.d.ts.map