@syncular/server 0.0.1 → 0.0.2-126

package/dist/push.js

@@ -1,3 +1,4 @@
+import { captureSyncException, countSyncMetric, distributionSyncMetric, startSyncSpan, } from '@syncular/core';
 import { sql } from 'kysely';
 class RejectCommitError extends Error {
     response;
@@ -7,12 +8,13 @@ class RejectCommitError extends Error {
         this.name = 'RejectCommitError';
     }
 }
-async function readCommitAffectedTables(db, dialect, commitSeq) {
+async function readCommitAffectedTables(db, dialect, commitSeq, partitionId) {
     try {
         const commitsQ = db.selectFrom('sync_commits');
         const row = await commitsQ
             .selectAll()
             .where(sql `commit_seq = ${commitSeq}`)
+            .where(sql `partition_id = ${partitionId}`)
             .executeTakeFirst();
         const raw = row?.affected_tables;
         return dialect.dbToArray(raw);
@@ -21,87 +23,96 @@ async function readCommitAffectedTables(db, dialect, commitSeq) {
         // ignore and fall back to scanning changes (best-effort)
     }
     // Fallback: read from changes using dialect-specific implementation
-    return dialect.readAffectedTablesFromChanges(db, commitSeq);
+    return dialect.readAffectedTablesFromChanges(db, commitSeq, { partitionId });
+}
+function scopeKeysFromEmitted(emitted) {
+    const keys = new Set();
+    for (const c of emitted) {
+        for (const [key, value] of Object.entries(c.scopes)) {
+            if (!value)
+                continue;
+            const prefix = key.replace(/_id$/, '');
+            keys.add(`${prefix}:${value}`);
+        }
+    }
+    return Array.from(keys);
+}
+function recordPushMetrics(args) {
+    const { status, durationMs, operationCount, emittedChangeCount, affectedTableCount, } = args;
+    countSyncMetric('sync.server.push.requests', 1, {
+        attributes: { status },
+    });
+    countSyncMetric('sync.server.push.operations', operationCount, {
+        attributes: { status },
+    });
+    distributionSyncMetric('sync.server.push.duration_ms', durationMs, {
+        unit: 'millisecond',
+        attributes: { status },
+    });
+    distributionSyncMetric('sync.server.push.emitted_changes', emittedChangeCount, {
+        attributes: { status },
+    });
+    distributionSyncMetric('sync.server.push.affected_tables', affectedTableCount, {
+        attributes: { status },
+    });
 }
 export async function pushCommit(args) {
     const { request, dialect } = args;
     const db = args.db;
-    if (!request.clientId || !request.clientCommitId) {
-        return {
-            response: {
-                ok: true,
-                status: 'rejected',
-                results: [
-                    {
-                        opIndex: 0,
-                        status: 'error',
-                        error: 'INVALID_REQUEST',
-                        code: 'INVALID_REQUEST',
-                        retriable: false,
-                    },
-                ],
-            },
-            affectedTables: [],
+    const partitionId = args.partitionId ?? 'default';
+    const requestedOps = Array.isArray(request.operations)
+        ? request.operations
+        : [];
+    const operationCount = requestedOps.length;
+    const startedAtMs = Date.now();
+    return startSyncSpan({
+        name: 'sync.server.push',
+        op: 'sync.push',
+        attributes: {
+            operation_count: operationCount,
+        },
+    }, async (span) => {
+        const finalizeResult = (result) => {
+            const durationMs = Math.max(0, Date.now() - startedAtMs);
+            const status = result.response.status;
+            span.setAttribute('status', status);
+            span.setAttribute('duration_ms', durationMs);
+            span.setAttribute('emitted_change_count', result.emittedChanges.length);
+            span.setAttribute('affected_table_count', result.affectedTables.length);
+            span.setStatus('ok');
+            recordPushMetrics({
+                status,
+                durationMs,
+                operationCount,
+                emittedChangeCount: result.emittedChanges.length,
+                affectedTableCount: result.affectedTables.length,
+            });
+            return result;
         };
-    }
-    const ops = request.operations ?? [];
-    if (!Array.isArray(ops) || ops.length === 0) {
-        return {
-            response: {
-                ok: true,
-                status: 'rejected',
-                results: [
-                    {
-                        opIndex: 0,
-                        status: 'error',
-                        error: 'EMPTY_COMMIT',
-                        code: 'EMPTY_COMMIT',
-                        retriable: false,
+        try {
+            if (!request.clientId || !request.clientCommitId) {
+                return finalizeResult({
+                    response: {
+                        ok: true,
+                        status: 'rejected',
+                        results: [
+                            {
+                                opIndex: 0,
+                                status: 'error',
+                                error: 'INVALID_REQUEST',
+                                code: 'INVALID_REQUEST',
+                                retriable: false,
+                            },
+                        ],
                     },
-                ],
-            },
-            affectedTables: [],
-        };
-    }
-    return dialect.executeInTransaction(db, async (trx) => {
-        const syncTrx = trx;
-        // Clean up any stale commit row with null result_json.
-        // This can happen when a previous push inserted the commit row but crashed
-        // before writing the result (e.g., on D1 without transaction support).
-        await syncTrx
-            .deleteFrom('sync_commits')
-            .where('client_id', '=', request.clientId)
-            .where('client_commit_id', '=', request.clientCommitId)
-            .where('result_json', 'is', null)
-            .execute();
-        // Insert commit row (idempotency key)
-        const commitRow = {
-            actor_id: args.actorId,
-            client_id: request.clientId,
-            client_commit_id: request.clientCommitId,
-            meta: null,
-            result_json: null,
-        };
-        const insertResult = await syncTrx
-            .insertInto('sync_commits')
-            .values(commitRow)
-            .onConflict((oc) => oc.columns(['client_id', 'client_commit_id']).doNothing())
-            .executeTakeFirstOrThrow();
-        const insertedRows = Number(insertResult.numInsertedOrUpdatedRows ?? 0);
-        if (insertedRows === 0) {
-            // Existing commit: return cached response (applied or rejected)
-            // Use forUpdate() for row locking on databases that support it
-            let query = syncTrx.selectFrom('sync_commits')
-                .selectAll()
-                .where('client_id', '=', request.clientId)
-                .where('client_commit_id', '=', request.clientCommitId);
-            if (dialect.supportsForUpdate) {
-                query = query.forUpdate();
+                    affectedTables: [],
+                    scopeKeys: [],
+                    emittedChanges: [],
+                });
             }
-            const existing = await query.executeTakeFirstOrThrow();
-            const cached = existing.result_json;
-            if (!cached || cached.ok !== true) {
-                return {
+            const ops = request.operations ?? [];
+            if (!Array.isArray(ops) || ops.length === 0) {
+                return finalizeResult({
                     response: {
                         ok: true,
                         status: 'rejected',
@@ -109,173 +120,292 @@ export async function pushCommit(args) {
                             {
                                 opIndex: 0,
                                 status: 'error',
-                                error: 'IDEMPOTENCY_CACHE_MISS',
-                                code: 'INTERNAL',
-                                retriable: true,
+                                error: 'EMPTY_COMMIT',
+                                code: 'EMPTY_COMMIT',
+                                retriable: false,
                             },
                         ],
                     },
                     affectedTables: [],
-                };
+                    scopeKeys: [],
+                    emittedChanges: [],
+                });
             }
-            const base = {
-                ...cached,
-                commitSeq: Number(existing.commit_seq),
-            };
-            if (cached.status === 'applied') {
-                const tablesFromDb = dialect.dbToArray(existing.affected_tables);
-                return {
-                    response: { ...base, status: 'cached' },
-                    affectedTables: tablesFromDb.length > 0
-                        ? tablesFromDb
-                        : await readCommitAffectedTables(trx, dialect, Number(existing.commit_seq)),
+            return finalizeResult(await dialect.executeInTransaction(db, async (trx) => {
+                const syncTrx = trx;
+                // Clean up any stale commit row with null result_json.
+                // This can happen when a previous push inserted the commit row but crashed
+                // before writing the result (e.g., on D1 without transaction support).
+                await syncTrx
+                    .deleteFrom('sync_commits')
+                    .where('partition_id', '=', partitionId)
+                    .where('client_id', '=', request.clientId)
+                    .where('client_commit_id', '=', request.clientCommitId)
+                    .where('result_json', 'is', null)
+                    .execute();
+                // Insert commit row (idempotency key)
+                const commitRow = {
+                    partition_id: partitionId,
+                    actor_id: args.actorId,
+                    client_id: request.clientId,
+                    client_commit_id: request.clientCommitId,
+                    meta: null,
+                    result_json: null,
                 };
-            }
-            return { response: base, affectedTables: [] };
-        }
-        const insertedCommit = await syncTrx.selectFrom('sync_commits')
-            .selectAll()
-            .where('client_id', '=', request.clientId)
-            .where('client_commit_id', '=', request.clientCommitId)
-            .executeTakeFirstOrThrow();
-        const commitSeq = Number(insertedCommit.commit_seq);
-        const commitId = `${request.clientId}:${request.clientCommitId}`;
-        const savepointName = 'sync_apply';
-        const useSavepoints = dialect.supportsSavepoints;
-        let savepointCreated = false;
-        try {
-            // Apply the commit under a savepoint so we can roll back app writes on conflict
-            // while still persisting the commit-level cached response.
-            if (useSavepoints) {
-                await sql.raw(`SAVEPOINT ${savepointName}`).execute(trx);
-                savepointCreated = true;
-            }
-            const allEmitted = [];
-            const results = [];
-            const affectedTablesSet = new Set();
-            for (let i = 0; i < ops.length; i++) {
-                const op = ops[i];
-                const handler = args.shapes.getOrThrow(op.table);
-                const applied = await handler.applyOperation({
-                    db: trx,
-                    trx,
-                    actorId: args.actorId,
-                    clientId: request.clientId,
-                    commitId,
-                    schemaVersion: request.schemaVersion,
-                }, op, i);
-                if (applied.result.status !== 'applied') {
-                    results.push(applied.result);
-                    throw new RejectCommitError({
+                const insertResult = await syncTrx
+                    .insertInto('sync_commits')
+                    .values(commitRow)
+                    .onConflict((oc) => oc
+                    .columns(['partition_id', 'client_id', 'client_commit_id'])
+                    .doNothing())
+                    .executeTakeFirstOrThrow();
+                const insertedRows = Number(insertResult.numInsertedOrUpdatedRows ?? 0);
+                if (insertedRows === 0) {
+                    // Existing commit: return cached response (applied or rejected)
+                    // Use forUpdate() for row locking on databases that support it
+                    let query = syncTrx.selectFrom('sync_commits')
+                        .selectAll()
+                        .where('partition_id', '=', partitionId)
+                        .where('client_id', '=', request.clientId)
+                        .where('client_commit_id', '=', request.clientCommitId);
+                    if (dialect.supportsForUpdate) {
+                        query = query.forUpdate();
+                    }
+                    const existing = await query.executeTakeFirstOrThrow();
+                    const cached = existing.result_json;
+                    if (!cached || cached.ok !== true) {
+                        return {
+                            response: {
+                                ok: true,
+                                status: 'rejected',
+                                results: [
+                                    {
+                                        opIndex: 0,
+                                        status: 'error',
+                                        error: 'IDEMPOTENCY_CACHE_MISS',
+                                        code: 'INTERNAL',
+                                        retriable: true,
+                                    },
+                                ],
+                            },
+                            affectedTables: [],
+                            scopeKeys: [],
+                            emittedChanges: [],
+                        };
+                    }
+                    const base = {
+                        ...cached,
+                        commitSeq: Number(existing.commit_seq),
+                    };
+                    if (cached.status === 'applied') {
+                        const tablesFromDb = dialect.dbToArray(existing.affected_tables);
+                        return {
+                            response: { ...base, status: 'cached' },
+                            affectedTables: tablesFromDb.length > 0
+                                ? tablesFromDb
+                                : await readCommitAffectedTables(trx, dialect, Number(existing.commit_seq), partitionId),
+                            scopeKeys: [],
+                            emittedChanges: [],
+                        };
+                    }
+                    return {
+                        response: base,
+                        affectedTables: [],
+                        scopeKeys: [],
+                        emittedChanges: [],
+                    };
+                }
+                const insertedCommit = await syncTrx.selectFrom('sync_commits')
+                    .selectAll()
+                    .where('partition_id', '=', partitionId)
+                    .where('client_id', '=', request.clientId)
+                    .where('client_commit_id', '=', request.clientCommitId)
+                    .executeTakeFirstOrThrow();
+                const commitSeq = Number(insertedCommit.commit_seq);
+                const commitId = `${request.clientId}:${request.clientCommitId}`;
+                const savepointName = 'sync_apply';
+                const useSavepoints = dialect.supportsSavepoints;
+                let savepointCreated = false;
+                try {
+                    // Apply the commit under a savepoint so we can roll back app writes on conflict
+                    // while still persisting the commit-level cached response.
+                    if (useSavepoints) {
+                        await sql.raw(`SAVEPOINT ${savepointName}`).execute(trx);
+                        savepointCreated = true;
+                    }
+                    const allEmitted = [];
+                    const results = [];
+                    const affectedTablesSet = new Set();
+                    for (let i = 0; i < ops.length; i++) {
+                        const op = ops[i];
+                        const handler = args.handlers.getOrThrow(op.table);
+                        const applied = await handler.applyOperation({
+                            db: trx,
+                            trx,
+                            actorId: args.actorId,
+                            clientId: request.clientId,
+                            commitId,
+                            schemaVersion: request.schemaVersion,
+                        }, op, i);
+                        if (applied.result.status !== 'applied') {
+                            results.push(applied.result);
+                            throw new RejectCommitError({
+                                ok: true,
+                                status: 'rejected',
+                                commitSeq,
+                                results,
+                            });
+                        }
+                        // Framework-level enforcement: emitted changes must have scopes
+                        for (const c of applied.emittedChanges ?? []) {
+                            const scopes = c?.scopes;
+                            if (!scopes || typeof scopes !== 'object') {
+                                results.push({
+                                    opIndex: i,
+                                    status: 'error',
+                                    error: 'MISSING_SCOPES',
+                                    code: 'INVALID_SCOPE',
+                                    retriable: false,
+                                });
+                                throw new RejectCommitError({
+                                    ok: true,
+                                    status: 'rejected',
+                                    commitSeq,
+                                    results,
+                                });
+                            }
+                        }
+                        results.push(applied.result);
+                        allEmitted.push(...applied.emittedChanges);
+                        for (const c of applied.emittedChanges) {
+                            affectedTablesSet.add(c.table);
+                        }
+                    }
+                    if (allEmitted.length > 0) {
+                        const changeRows = allEmitted.map((c) => ({
+                            partition_id: partitionId,
+                            commit_seq: commitSeq,
+                            table: c.table,
+                            row_id: c.row_id,
+                            op: c.op,
+                            row_json: c.row_json,
+                            row_version: c.row_version,
+                            scopes: dialect.scopesToDb(c.scopes),
+                        }));
+                        await syncTrx
+                            .insertInto('sync_changes')
+                            .values(changeRows)
+                            .execute();
+                    }
+                    const appliedResponse = {
                         ok: true,
-                        status: 'rejected',
+                        status: 'applied',
                         commitSeq,
                         results,
-                    });
-                }
-                // Framework-level enforcement: emitted changes must have scopes
-                for (const c of applied.emittedChanges ?? []) {
-                    const scopes = c?.scopes;
-                    if (!scopes || typeof scopes !== 'object') {
-                        results.push({
-                            opIndex: i,
-                            status: 'error',
-                            error: 'MISSING_SCOPES',
-                            code: 'INVALID_SCOPE',
-                            retriable: false,
-                        });
-                        throw new RejectCommitError({
-                            ok: true,
-                            status: 'rejected',
-                            commitSeq,
-                            results,
-                        });
+                    };
+                    const affectedTables = Array.from(affectedTablesSet).sort();
+                    const appliedCommitUpdate = {
+                        result_json: appliedResponse,
+                        change_count: allEmitted.length,
+                        affected_tables: affectedTables,
+                    };
+                    await syncTrx
+                        .updateTable('sync_commits')
+                        .set(appliedCommitUpdate)
+                        .where('commit_seq', '=', commitSeq)
+                        .execute();
+                    // Insert table commits for subscription filtering
+                    if (affectedTables.length > 0) {
+                        const tableCommits = affectedTables.map((table) => ({
+                            partition_id: partitionId,
+                            table,
+                            commit_seq: commitSeq,
+                        }));
+                        await syncTrx
+                            .insertInto('sync_table_commits')
+                            .values(tableCommits)
+                            .onConflict((oc) => oc
+                            .columns(['partition_id', 'table', 'commit_seq'])
+                            .doNothing())
+                            .execute();
                     }
+                    if (useSavepoints) {
+                        await sql
+                            .raw(`RELEASE SAVEPOINT ${savepointName}`)
+                            .execute(trx);
+                    }
+                    return {
+                        response: appliedResponse,
+                        affectedTables,
+                        scopeKeys: scopeKeysFromEmitted(allEmitted),
+                        emittedChanges: allEmitted.map((c) => ({
+                            table: c.table,
+                            row_id: c.row_id,
+                            op: c.op,
+                            row_json: c.row_json,
+                            row_version: c.row_version,
+                            scopes: c.scopes,
+                        })),
+                    };
                 }
-                results.push(applied.result);
-                allEmitted.push(...applied.emittedChanges);
-                for (const c of applied.emittedChanges) {
-                    affectedTablesSet.add(c.table);
+                catch (err) {
+                    // Roll back app writes but keep the commit row.
+                    if (savepointCreated) {
+                        try {
+                            await sql
+                                .raw(`ROLLBACK TO SAVEPOINT ${savepointName}`)
+                                .execute(trx);
+                            await sql
+                                .raw(`RELEASE SAVEPOINT ${savepointName}`)
+                                .execute(trx);
+                        }
+                        catch (savepointErr) {
+                            // If savepoint rollback fails, the transaction may be in an
+                            // inconsistent state. Log and rethrow to fail the entire commit
+                            // rather than risk data corruption.
+                            console.error('[pushCommit] Savepoint rollback failed:', savepointErr);
+                            throw savepointErr;
+                        }
+                    }
+                    if (!(err instanceof RejectCommitError))
+                        throw err;
+                    const rejectedCommitUpdate = {
+                        result_json: err.response,
+                        change_count: 0,
+                        affected_tables: [],
+                    };
+                    // Persist the rejected response for commit-level idempotency.
+                    await syncTrx
+                        .updateTable('sync_commits')
+                        .set(rejectedCommitUpdate)
+                        .where('commit_seq', '=', commitSeq)
+                        .execute();
+                    return {
+                        response: err.response,
+                        affectedTables: [],
+                        scopeKeys: [],
+                        emittedChanges: [],
+                    };
                 }
-            }
-            if (allEmitted.length > 0) {
-                const changeRows = allEmitted.map((c) => ({
-                    commit_seq: commitSeq,
-                    table: c.table,
-                    row_id: c.row_id,
-                    op: c.op,
-                    row_json: c.row_json,
-                    row_version: c.row_version,
-                    scopes: dialect.scopesToDb(c.scopes),
-                }));
-                await syncTrx.insertInto('sync_changes').values(changeRows).execute();
-            }
-            const appliedResponse = {
-                ok: true,
-                status: 'applied',
-                commitSeq,
-                results,
-            };
-            const affectedTables = Array.from(affectedTablesSet).sort();
-            const appliedCommitUpdate = {
-                result_json: appliedResponse,
-                change_count: allEmitted.length,
-                affected_tables: affectedTables,
-            };
-            await syncTrx
-                .updateTable('sync_commits')
-                .set(appliedCommitUpdate)
-                .where('commit_seq', '=', commitSeq)
-                .execute();
-            // Insert table commits for subscription filtering
-            if (affectedTables.length > 0) {
-                const tableCommits = affectedTables.map((table) => ({
-                    table,
-                    commit_seq: commitSeq,
-                }));
-                await syncTrx
-                    .insertInto('sync_table_commits')
-                    .values(tableCommits)
-                    .onConflict((oc) => oc.columns(['table', 'commit_seq']).doNothing())
-                    .execute();
-            }
-            if (useSavepoints) {
-                await sql.raw(`RELEASE SAVEPOINT ${savepointName}`).execute(trx);
-            }
-            return {
-                response: appliedResponse,
-                affectedTables,
-            };
+            }));
         }
-        catch (err) {
-            // Roll back app writes but keep the commit row.
-            if (savepointCreated) {
-                try {
-                    await sql.raw(`ROLLBACK TO SAVEPOINT ${savepointName}`).execute(trx);
-                    await sql.raw(`RELEASE SAVEPOINT ${savepointName}`).execute(trx);
-                }
-                catch (savepointErr) {
-                    // If savepoint rollback fails, the transaction may be in an
-                    // inconsistent state. Log and rethrow to fail the entire commit
-                    // rather than risk data corruption.
-                    console.error('[pushCommit] Savepoint rollback failed:', savepointErr);
-                    throw savepointErr;
-                }
-            }
-            if (!(err instanceof RejectCommitError))
-                throw err;
-            const rejectedCommitUpdate = {
-                result_json: err.response,
-                change_count: 0,
-                affected_tables: [],
-            };
-            // Persist the rejected response for commit-level idempotency.
-            await syncTrx
-                .updateTable('sync_commits')
-                .set(rejectedCommitUpdate)
-                .where('commit_seq', '=', commitSeq)
-                .execute();
-            return { response: err.response, affectedTables: [] };
+        catch (error) {
+            const durationMs = Math.max(0, Date.now() - startedAtMs);
+            span.setAttribute('status', 'error');
+            span.setAttribute('duration_ms', durationMs);
+            span.setStatus('error');
+            recordPushMetrics({
+                status: 'error',
+                durationMs,
+                operationCount,
+                emittedChangeCount: 0,
+                affectedTableCount: 0,
+            });
+            captureSyncException(error, {
+                event: 'sync.server.push',
+                operationCount,
+            });
+            throw error;
         }
     });
 }