@nurix/nustack 0.24.0 → 0.25.1

package/dist/lib/sync/outbox.js

@@ -0,0 +1,104 @@
+import { sharedTable } from "./manifest.js";
+const RETRY_BASE_MS = 30_000;
+const RETRY_CEILING_MS = 60 * 60 * 1000;
+export function retryDelayMs(attempts) {
+    return Math.min(RETRY_BASE_MS * 2 ** Math.max(0, attempts - 1), RETRY_CEILING_MS);
+}
+function entryOf(row) {
+    let changed = [];
+    try {
+        changed = JSON.parse(String(row.changed_json));
+    }
+    catch {
+        changed = [];
+    }
+    return {
+        tableName: row.table_name,
+        rowKey: row.row_key,
+        op: row.op,
+        baseVersion: Number(row.base_version),
+        changed,
+        enqueuedAt: Number(row.enqueued_at),
+        attempts: Number(row.attempts),
+        nextAttemptAt: row.next_attempt_at ?? null,
+        lastError: row.last_error ?? null,
+    };
+}
+export function selectDueEntries(db, now) {
+    const rows = db
+        .prepare("SELECT * FROM sync_outbox WHERE next_attempt_at IS NULL OR next_attempt_at <= ? ORDER BY enqueued_at, rowid")
+        .all(now);
+    return rows.map(entryOf);
+}
+export function entryFor(db, tableName, rowKey) {
+    const row = db.prepare("SELECT * FROM sync_outbox WHERE table_name = ? AND row_key = ?").get(tableName, rowKey);
+    return row ? entryOf(row) : null;
+}
+export function hasDueEntry(db, now, canSendDevice) {
+    return (db
+        .prepare(`SELECT 1 FROM sync_outbox o WHERE (o.next_attempt_at IS NULL OR o.next_attempt_at <= ?)
+                   AND (? OR NOT EXISTS (SELECT 1 FROM harness_records r
+                        WHERE o.table_name = 'harness_records' AND r.id = o.row_key AND r.written_by_kind = 'agent'))
+                 LIMIT 1`)
+        .get(now, canSendDevice ? 1 : 0) !== undefined);
+}
+export function currentRow(db, tableName, rowKey) {
+    const table = sharedTable(tableName);
+    if (!table)
+        return null;
+    const row = db.prepare(`SELECT * FROM "${table.name}" WHERE "${table.key}" = ?`).get(rowKey);
+    return row ?? null;
+}
+export function deltaOf(db, entry) {
+    const table = sharedTable(entry.tableName);
+    if (!table?.machineColumns)
+        return null;
+    if (entry.op === "delete")
+        return { table: entry.tableName, key: entry.rowKey, baseVersion: entry.baseVersion, op: "delete", columns: {} };
+    const row = currentRow(db, entry.tableName, entry.rowKey);
+    if (!row)
+        return null;
+    const isUnacknowledged = row.sync_seq === null || row.sync_seq === undefined;
+    const allowed = new Set(table.machineColumns);
+    const names = isUnacknowledged ? table.machineColumns : entry.changed;
+    const columns = {};
+    for (const name of names)
+        if (allowed.has(name) && Object.hasOwn(row, name))
+            columns[name] = row[name] ?? null;
+    return { table: entry.tableName, key: entry.rowKey, baseVersion: isUnacknowledged ? 0 : entry.baseVersion, op: "upsert", columns };
+}
+const CAS = "table_name = :table_name AND row_key = :row_key AND enqueued_at = :enqueued_at";
+function casOf(entry) {
+    return { table_name: entry.tableName, row_key: entry.rowKey, enqueued_at: entry.enqueuedAt };
+}
+export function settleEntry(db, entry) {
+    return Number(db.prepare(`DELETE FROM sync_outbox WHERE ${CAS}`).run(casOf(entry)).changes) > 0;
+}
+export function backoffEntry(db, entry, error, now) {
+    db.prepare(`UPDATE sync_outbox SET attempts = attempts + 1, next_attempt_at = :next_attempt_at, last_error = :last_error WHERE ${CAS}`).run({
+        ...casOf(entry),
+        next_attempt_at: now + retryDelayMs(entry.attempts + 1),
+        last_error: error,
+    });
+}
+export function deferEntry(db, entry, now) {
+    db.prepare(`UPDATE sync_outbox SET next_attempt_at = :next_attempt_at WHERE ${CAS}`).run({
+        ...casOf(entry),
+        next_attempt_at: now + retryDelayMs(Math.max(1, entry.attempts)),
+    });
+}
+export function dropEntry(db, tableName, rowKey) {
+    db.prepare("DELETE FROM sync_outbox WHERE table_name = ? AND row_key = ?").run(tableName, rowKey);
+}
+export function countOutbox(db, now) {
+    return db
+        .prepare(`SELECT table_name AS "table", count(*) AS pending,
+                    sum(CASE WHEN next_attempt_at IS NULL OR next_attempt_at <= ? THEN 1 ELSE 0 END) AS due,
+                    sum(CASE WHEN last_error IS NOT NULL THEN 1 ELSE 0 END) AS failing
+                 FROM sync_outbox GROUP BY table_name ORDER BY table_name`)
+        .all(now).map((row) => ({ table: row.table, pending: Number(row.pending), due: Number(row.due), failing: Number(row.failing) }));
+}
+export function newestOutboxError(db) {
+    const row = db.prepare("SELECT last_error FROM sync_outbox WHERE last_error IS NOT NULL ORDER BY enqueued_at DESC LIMIT 1").get();
+    return row?.last_error ?? null;
+}