@syncular/server 0.0.6-95 → 0.1.0

package/dist/postgres/index.js

@@ -0,0 +1,924 @@
+/**
+ * @syncular/server/postgres - PostgreSQL Server Sync Dialect
+ *
+ * Driver-agnostic PostgreSQL dialect for sync. Works with any Postgres-compatible
+ * Kysely dialect (pg, pglite, neon, etc.).
+ *
+ * Tables:
+ * - sync_commits: commit log (idempotency + ordering)
+ * - sync_table_commits: commit routing index (fast pull by table)
+ * - sync_changes: change log (JSONB scopes for filtering)
+ * - sync_client_cursors: per-client cursor tracking (pruning/observability)
+ */
+import { BaseServerSyncDialect, coerceIsoString, coerceNumber, createSavepointName, isActiveTransaction, parseScopes, } from '@syncular/server';
+import { sql } from 'kysely';
+function buildJsonbScopeContainmentFilter(columnReference, scopes) {
+    const fragments = [];
+    for (const [key, value] of Object.entries(scopes)) {
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                fragments.push(sql `FALSE`);
+                continue;
+            }
+            const anyValueMatches = sql.join(value.map((entry) => {
+                const scopeFilter = JSON.stringify({ [key]: entry });
+                return sql `${sql.ref(columnReference)} @> ${scopeFilter}::jsonb`;
+            }), sql ` OR `);
+            fragments.push(sql `(${anyValueMatches})`);
+            continue;
+        }
+        const scopeFilter = JSON.stringify({ [key]: value });
+        fragments.push(sql `${sql.ref(columnReference)} @> ${scopeFilter}::jsonb`);
+    }
+    if (fragments.length === 0) {
+        return sql `TRUE`;
+    }
+    return sql.join(fragments, sql ` AND `);
+}
+export class PostgresServerSyncDialect extends BaseServerSyncDialect {
+    family = 'postgres';
+    supportsForUpdate = true;
+    supportsSavepoints = true;
+    supportsInsertReturning = true;
+    // ===========================================================================
+    // SQL Fragment Hooks
+    // ===========================================================================
+    buildNumberListFilter(values) {
+        return sql `= ANY(${values}::bigint[])`;
+    }
+    buildStringListFilter(values) {
+        return sql `= ANY(${values}::text[])`;
+    }
+    // ===========================================================================
+    // Schema Setup
+    // ===========================================================================
+    async ensureSyncSchema(db) {
+        await db.schema
+            .createTable('sync_commits')
+            .ifNotExists()
+            .addColumn('commit_seq', 'bigserial', (col) => col.primaryKey())
+            .addColumn('partition_id', 'text', (col) => col.notNull().defaultTo('default'))
+            .addColumn('actor_id', 'text', (col) => col.notNull())
+            .addColumn('client_id', 'text', (col) => col.notNull())
+            .addColumn('client_commit_id', 'text', (col) => col.notNull())
+            .addColumn('created_at', 'timestamptz', (col) => col.notNull().defaultTo(sql `now()`))
+            .addColumn('meta', 'jsonb')
+            .addColumn('result_json', 'jsonb')
+            .addColumn('change_count', 'integer', (col) => col.notNull().defaultTo(0))
+            .addColumn('commit_digest', 'text')
+            .addColumn('commit_chain_root', 'text')
+            .addColumn('affected_tables', sql `text[]`, (col) => col.notNull().defaultTo(sql `ARRAY[]::text[]`))
+            .execute();
+        // Ensure new columns exist for dev environments that already created the table.
+        await sql `ALTER TABLE sync_commits
+      ADD COLUMN IF NOT EXISTS change_count integer NOT NULL DEFAULT 0`.execute(db);
+        await sql `ALTER TABLE sync_commits
+      ADD COLUMN IF NOT EXISTS affected_tables text[] NOT NULL DEFAULT ARRAY[]::text[]`.execute(db);
+        await sql `ALTER TABLE sync_commits
+      ADD COLUMN IF NOT EXISTS partition_id text NOT NULL DEFAULT 'default'`.execute(db);
+        await sql `ALTER TABLE sync_commits
+      ADD COLUMN IF NOT EXISTS commit_digest text`.execute(db);
+        await sql `ALTER TABLE sync_commits
+      ADD COLUMN IF NOT EXISTS commit_chain_root text`.execute(db);
+        await sql `DROP INDEX IF EXISTS idx_sync_commits_client_commit`.execute(db);
+        await db.schema
+            .createIndex('idx_sync_commits_client_commit')
+            .ifNotExists()
+            .on('sync_commits')
+            .columns(['partition_id', 'client_id', 'client_commit_id'])
+            .unique()
+            .execute();
+        await db.schema
+            .createIndex('idx_sync_commits_partition_client_commit_seq')
+            .ifNotExists()
+            .on('sync_commits')
+            .columns(['partition_id', 'client_id', 'commit_seq'])
+            .execute();
+        // Table-based commit routing index
+        await db.schema
+            .createTable('sync_table_commits')
+            .ifNotExists()
+            .addColumn('partition_id', 'text', (col) => col.notNull().defaultTo('default'))
+            .addColumn('table', 'text', (col) => col.notNull())
+            .addColumn('commit_seq', 'bigint', (col) => col.notNull().references('sync_commits.commit_seq').onDelete('cascade'))
+            .addPrimaryKeyConstraint('sync_table_commits_pk', [
+            'partition_id',
+            'table',
+            'commit_seq',
+        ])
+            .execute();
+        await sql `ALTER TABLE sync_table_commits
+      ADD COLUMN IF NOT EXISTS partition_id text NOT NULL DEFAULT 'default'`.execute(db);
+        await db.schema
+            .createIndex('idx_sync_table_commits_commit_seq')
+            .ifNotExists()
+            .on('sync_table_commits')
+            .columns(['partition_id', 'commit_seq'])
+            .execute();
+        await db.schema
+            .createTable('sync_scope_commits')
+            .ifNotExists()
+            .addColumn('partition_id', 'text', (col) => col.notNull().defaultTo('default'))
+            .addColumn('table', 'text', (col) => col.notNull())
+            .addColumn('scope_key', 'text', (col) => col.notNull())
+            .addColumn('commit_seq', 'bigint', (col) => col.notNull().references('sync_commits.commit_seq').onDelete('cascade'))
+            .addPrimaryKeyConstraint('sync_scope_commits_pk', [
+            'partition_id',
+            'table',
+            'scope_key',
+            'commit_seq',
+        ])
+            .execute();
+        await sql `ALTER TABLE sync_scope_commits
+      ADD COLUMN IF NOT EXISTS partition_id text NOT NULL DEFAULT 'default'`.execute(db);
+        await db.schema
+            .createIndex('idx_sync_scope_commits_commit_seq')
+            .ifNotExists()
+            .on('sync_scope_commits')
+            .columns(['partition_id', 'commit_seq'])
+            .execute();
+        // Changes table with JSONB scopes
+        await db.schema
+            .createTable('sync_changes')
+            .ifNotExists()
+            .addColumn('change_id', 'bigserial', (col) => col.primaryKey())
+            .addColumn('partition_id', 'text', (col) => col.notNull().defaultTo('default'))
+            .addColumn('commit_seq', 'bigint', (col) => col.notNull().references('sync_commits.commit_seq').onDelete('cascade'))
+            .addColumn('table', 'text', (col) => col.notNull())
+            .addColumn('row_id', 'text', (col) => col.notNull())
+            .addColumn('op', 'text', (col) => col.notNull())
+            .addColumn('row_json', 'jsonb')
+            .addColumn('row_version', 'bigint')
+            .addColumn('scopes', 'jsonb', (col) => col.notNull())
+            .execute();
+        await sql `ALTER TABLE sync_changes
+      ADD COLUMN IF NOT EXISTS partition_id text NOT NULL DEFAULT 'default'`.execute(db);
+        await db.schema
+            .createIndex('idx_sync_changes_commit_seq')
+            .ifNotExists()
+            .on('sync_changes')
+            .columns(['partition_id', 'commit_seq'])
+            .execute();
+        await db.schema
+            .createIndex('idx_sync_changes_table')
+            .ifNotExists()
+            .on('sync_changes')
+            .columns(['partition_id', 'table'])
+            .execute();
+        await db.schema
+            .createIndex('idx_sync_changes_table_commit_seq_change_id')
+            .ifNotExists()
+            .on('sync_changes')
+            .columns(['partition_id', 'table', 'commit_seq', 'change_id'])
+            .execute();
+        await this.ensureIndex(db, 'idx_sync_changes_scopes', 'CREATE INDEX idx_sync_changes_scopes ON sync_changes USING GIN (scopes)');
+        await db.schema
+            .createTable('sync_client_cursors')
+            .ifNotExists()
+            .addColumn('partition_id', 'text', (col) => col.notNull().defaultTo('default'))
+            .addColumn('client_id', 'text', (col) => col.notNull())
+            .addColumn('actor_id', 'text', (col) => col.notNull())
+            .addColumn('cursor', 'bigint', (col) => col.notNull().defaultTo(0))
+            .addColumn('effective_scopes', 'jsonb', (col) => col.notNull().defaultTo(sql `'{}'::jsonb`))
+            .addColumn('realtime_subscriptions', 'jsonb')
+            .addColumn('updated_at', 'timestamptz', (col) => col.notNull().defaultTo(sql `now()`))
+            .addPrimaryKeyConstraint('sync_client_cursors_pk', [
+            'partition_id',
+            'client_id',
+        ])
+            .execute();
+        await sql `ALTER TABLE sync_client_cursors
+      ADD COLUMN IF NOT EXISTS partition_id text NOT NULL DEFAULT 'default'`.execute(db);
+        await sql `ALTER TABLE sync_client_cursors
+      ADD COLUMN IF NOT EXISTS realtime_subscriptions jsonb`.execute(db);
+        await db.schema
+            .createIndex('idx_sync_client_cursors_updated_at')
+            .ifNotExists()
+            .on('sync_client_cursors')
+            .columns(['updated_at'])
+            .execute();
+        await db.schema
+            .createTable('sync_snapshot_chunks')
+            .ifNotExists()
+            .addColumn('chunk_id', 'text', (col) => col.primaryKey())
+            .addColumn('partition_id', 'text', (col) => col.notNull().defaultTo('default'))
+            .addColumn('scope_key', 'text', (col) => col.notNull())
+            .addColumn('scope', 'text', (col) => col.notNull())
+            .addColumn('as_of_commit_seq', 'bigint', (col) => col.notNull())
+            .addColumn('row_cursor', 'text', (col) => col.notNull().defaultTo(''))
+            .addColumn('row_limit', 'integer', (col) => col.notNull())
+            .addColumn('next_row_cursor', 'text')
+            .addColumn('is_last_page', 'integer', (col) => col.notNull().defaultTo(0))
+            .addColumn('encoding', 'text', (col) => col.notNull())
+            .addColumn('compression', 'text', (col) => col.notNull())
+            .addColumn('sha256', 'text', (col) => col.notNull())
+            .addColumn('byte_length', 'integer', (col) => col.notNull())
+            .addColumn('blob_hash', 'text', (col) => col.notNull().defaultTo(''))
+            .addColumn('body', 'bytea') // Deprecated: use blob storage
+            .addColumn('created_at', 'timestamptz', (col) => col.notNull().defaultTo(sql `now()`))
+            .addColumn('expires_at', 'timestamptz', (col) => col.notNull())
+            .execute();
+        await sql `ALTER TABLE sync_snapshot_chunks
+      ADD COLUMN IF NOT EXISTS partition_id text NOT NULL DEFAULT 'default'`.execute(db);
+        await sql `ALTER TABLE sync_snapshot_chunks
+      ADD COLUMN IF NOT EXISTS next_row_cursor text`.execute(db);
+        await sql `ALTER TABLE sync_snapshot_chunks
+      ADD COLUMN IF NOT EXISTS is_last_page integer NOT NULL DEFAULT 0`.execute(db);
+        await db.schema
+            .createIndex('idx_sync_snapshot_chunks_expires_at')
+            .ifNotExists()
+            .on('sync_snapshot_chunks')
+            .columns(['expires_at'])
+            .execute();
+        await db.schema
+            .createIndex('idx_sync_snapshot_chunks_page_key')
+            .ifNotExists()
+            .on('sync_snapshot_chunks')
+            .columns([
+            'partition_id',
+            'scope_key',
+            'scope',
+            'as_of_commit_seq',
+            'row_cursor',
+            'row_limit',
+            'encoding',
+            'compression',
+        ])
+            .unique()
+            .execute();
+        await db.schema
+            .createTable('sync_snapshot_artifacts')
+            .ifNotExists()
+            .addColumn('artifact_id', 'text', (col) => col.primaryKey())
+            .addColumn('partition_id', 'text', (col) => col.notNull().defaultTo('default'))
+            .addColumn('scope_key', 'text', (col) => col.notNull())
+            .addColumn('subscription_id', 'text', (col) => col.notNull())
+            .addColumn('table', 'text', (col) => col.notNull())
+            .addColumn('artifact_kind', 'text', (col) => col.notNull())
+            .addColumn('schema_version', 'text', (col) => col.notNull())
+            .addColumn('as_of_commit_seq', 'bigint', (col) => col.notNull())
+            .addColumn('row_cursor', 'text', (col) => col.notNull().defaultTo(''))
+            .addColumn('row_limit', 'integer', (col) => col.notNull())
+            .addColumn('row_count', 'integer', (col) => col.notNull())
+            .addColumn('next_row_cursor', 'text')
+            .addColumn('is_first_page', 'integer', (col) => col.notNull().defaultTo(0))
+            .addColumn('is_last_page', 'integer', (col) => col.notNull().defaultTo(0))
+            .addColumn('compression', 'text', (col) => col.notNull())
+            .addColumn('sha256', 'text', (col) => col.notNull())
+            .addColumn('byte_length', 'integer', (col) => col.notNull())
+            .addColumn('manifest_digest', 'text', (col) => col.notNull())
+            .addColumn('feature_set_json', 'text', (col) => col.notNull())
+            .addColumn('manifest_json', 'text', (col) => col.notNull())
+            .addColumn('blob_hash', 'text', (col) => col.notNull())
+            .addColumn('created_at', 'timestamptz', (col) => col.notNull().defaultTo(sql `now()`))
+            .addColumn('expires_at', 'timestamptz', (col) => col.notNull())
+            .execute();
+        await db.schema
+            .createIndex('idx_sync_snapshot_artifacts_expires_at')
+            .ifNotExists()
+            .on('sync_snapshot_artifacts')
+            .columns(['expires_at'])
+            .execute();
+        await db.schema
+            .createIndex('idx_sync_snapshot_artifacts_page_key')
+            .ifNotExists()
+            .on('sync_snapshot_artifacts')
+            .columns([
+            'partition_id',
+            'scope_key',
+            'subscription_id',
+            'table',
+            'as_of_commit_seq',
+            'row_cursor',
+            'row_limit',
+            'artifact_kind',
+            'schema_version',
+            'compression',
+        ])
+            .unique()
+            .execute();
+        await db.schema
+            .createTable('sync_crdt_updates')
+            .ifNotExists()
+            .addColumn('seq', 'bigserial', (col) => col.primaryKey())
+            .addColumn('partition_id', 'text', (col) => col.notNull().defaultTo('default'))
+            .addColumn('stream_id', 'text', (col) => col.notNull())
+            .addColumn('app_table', 'text', (col) => col.notNull())
+            .addColumn('row_id', 'text', (col) => col.notNull())
+            .addColumn('field_name', 'text', (col) => col.notNull())
+            .addColumn('update_id', 'text', (col) => col.notNull())
+            .addColumn('actor_id', 'text')
+            .addColumn('client_id', 'text')
+            .addColumn('key_id', 'text', (col) => col.notNull())
+            .addColumn('ciphertext', 'text', (col) => col.notNull())
+            .addColumn('scopes', 'jsonb', (col) => col.notNull().defaultTo(sql `'{}'::jsonb`))
+            .addColumn('created_at', 'timestamptz', (col) => col.notNull().defaultTo(sql `now()`))
+            .execute();
+        await sql `ALTER TABLE sync_crdt_updates
+      ADD COLUMN IF NOT EXISTS partition_id text NOT NULL DEFAULT 'default'`.execute(db);
+        await db.schema
+            .createIndex('idx_sync_crdt_updates_update_id')
+            .ifNotExists()
+            .on('sync_crdt_updates')
+            .columns(['partition_id', 'update_id'])
+            .unique()
+            .execute();
+        await db.schema
+            .createIndex('idx_sync_crdt_updates_stream_seq')
+            .ifNotExists()
+            .on('sync_crdt_updates')
+            .columns(['partition_id', 'stream_id', 'seq'])
+            .execute();
+        await db.schema
+            .createIndex('idx_sync_crdt_updates_scope_table')
+            .ifNotExists()
+            .on('sync_crdt_updates')
+            .columns(['partition_id', 'app_table', 'row_id', 'field_name'])
+            .execute();
+        await this.ensureIndex(db, 'idx_sync_crdt_updates_scopes', 'CREATE INDEX idx_sync_crdt_updates_scopes ON sync_crdt_updates USING GIN (scopes)');
+        await db.schema
+            .createTable('sync_crdt_checkpoints')
+            .ifNotExists()
+            .addColumn('seq', 'bigserial', (col) => col.primaryKey())
+            .addColumn('partition_id', 'text', (col) => col.notNull().defaultTo('default'))
+            .addColumn('stream_id', 'text', (col) => col.notNull())
+            .addColumn('app_table', 'text', (col) => col.notNull())
+            .addColumn('row_id', 'text', (col) => col.notNull())
+            .addColumn('field_name', 'text', (col) => col.notNull())
+            .addColumn('checkpoint_id', 'text', (col) => col.notNull())
+            .addColumn('covers_seq', 'bigint', (col) => col.notNull())
+            .addColumn('actor_id', 'text')
+            .addColumn('client_id', 'text')
+            .addColumn('key_id', 'text', (col) => col.notNull())
+            .addColumn('ciphertext', 'text', (col) => col.notNull())
+            .addColumn('scopes', 'jsonb', (col) => col.notNull().defaultTo(sql `'{}'::jsonb`))
+            .addColumn('created_at', 'timestamptz', (col) => col.notNull().defaultTo(sql `now()`))
+            .execute();
+        await sql `ALTER TABLE sync_crdt_checkpoints
+      ADD COLUMN IF NOT EXISTS partition_id text NOT NULL DEFAULT 'default'`.execute(db);
+        await db.schema
+            .createIndex('idx_sync_crdt_checkpoints_checkpoint_id')
+            .ifNotExists()
+            .on('sync_crdt_checkpoints')
+            .columns(['partition_id', 'checkpoint_id'])
+            .unique()
+            .execute();
+        await db.schema
+            .createIndex('idx_sync_crdt_checkpoints_stream_covers')
+            .ifNotExists()
+            .on('sync_crdt_checkpoints')
+            .columns(['partition_id', 'stream_id', 'covers_seq'])
+            .execute();
+        await db.schema
+            .createIndex('idx_sync_crdt_checkpoints_scope_table')
+            .ifNotExists()
+            .on('sync_crdt_checkpoints')
+            .columns(['partition_id', 'app_table', 'row_id', 'field_name'])
+            .execute();
+        await this.ensureIndex(db, 'idx_sync_crdt_checkpoints_scopes', 'CREATE INDEX idx_sync_crdt_checkpoints_scopes ON sync_crdt_checkpoints USING GIN (scopes)');
+    }
+    // ===========================================================================
+    // Transaction Control
+    // ===========================================================================
+    async executeInTransaction(db, fn) {
+        if (isActiveTransaction(db)) {
+            const savepoint = createSavepointName();
+            await sql.raw(`SAVEPOINT ${savepoint}`).execute(db);
+            try {
+                const result = await fn(db);
+                await sql.raw(`RELEASE SAVEPOINT ${savepoint}`).execute(db);
+                return result;
+            }
+            catch (error) {
+                await sql.raw(`ROLLBACK TO SAVEPOINT ${savepoint}`).execute(db);
+                await sql.raw(`RELEASE SAVEPOINT ${savepoint}`).execute(db);
+                throw error;
+            }
+        }
+        return db.transaction().execute(fn);
+    }
+    async setRepeatableRead(trx) {
+        await sql `SET TRANSACTION ISOLATION LEVEL REPEATABLE READ`.execute(trx);
+    }
+    // ===========================================================================
+    // Overrides (dialect-specific optimizations / casts)
+    // ===========================================================================
+    async readCommitSeqsForPull(db, args) {
+        const partitionId = args.partitionId ?? 'default';
+        if (args.tables.length === 0)
+            return [];
+        // Single-table fast path: skip DISTINCT since (partition_id, table, commit_seq) is PK
+        if (args.tables.length === 1) {
+            const res = await sql `
+        SELECT commit_seq
+        FROM sync_table_commits
+        WHERE partition_id = ${partitionId}
+          AND "table" = ${args.tables[0]}
+          AND commit_seq > ${args.cursor}
+        ORDER BY commit_seq ASC
+        LIMIT ${args.limitCommits}
+      `.execute(db);
+            return res.rows
+                .map((r) => coerceNumber(r.commit_seq))
+                .filter((n) => typeof n === 'number' && Number.isFinite(n) && n > args.cursor);
+        }
+        // Multi-table: use ANY() with DISTINCT
+        return super.readCommitSeqsForPull(db, args);
+    }
+    async recordClientCursor(db, args) {
+        const partitionId = args.partitionId ?? 'default';
+        const now = new Date().toISOString();
+        const scopesJson = JSON.stringify(args.effectiveScopes);
+        if (args.realtimeSubscriptions === undefined) {
+            await sql `
+        INSERT INTO sync_client_cursors (partition_id, client_id, actor_id, cursor, effective_scopes, updated_at)
+        VALUES (${partitionId}, ${args.clientId}, ${args.actorId}, ${args.cursor}, ${scopesJson}::jsonb, ${now})
+        ON CONFLICT(partition_id, client_id) DO UPDATE SET
+          actor_id = ${args.actorId},
+          cursor = ${args.cursor},
+          effective_scopes = ${scopesJson}::jsonb,
+          updated_at = ${now}
+      `.execute(db);
+            return;
+        }
+        const realtimeSubscriptionsJson = JSON.stringify(args.realtimeSubscriptions);
+        await sql `
+      INSERT INTO sync_client_cursors (partition_id, client_id, actor_id, cursor, effective_scopes, realtime_subscriptions, updated_at)
+      VALUES (${partitionId}, ${args.clientId}, ${args.actorId}, ${args.cursor}, ${scopesJson}::jsonb, ${realtimeSubscriptionsJson}::jsonb, ${now})
+      ON CONFLICT(partition_id, client_id) DO UPDATE SET
+        actor_id = ${args.actorId},
+        cursor = ${args.cursor},
+        effective_scopes = ${scopesJson}::jsonb,
+        realtime_subscriptions = ${realtimeSubscriptionsJson}::jsonb,
+        updated_at = ${now}
+    `.execute(db);
+    }
+    // ===========================================================================
+    // Commit/Change Log Queries (dialect-specific)
+    // ===========================================================================
+    async readChangesForCommits(db, args) {
+        const partitionId = args.partitionId ?? 'default';
+        if (args.commitSeqs.length === 0)
+            return [];
+        const scopeFilter = buildJsonbScopeContainmentFilter('scopes', args.scopes);
+        const res = await sql `
+      SELECT commit_seq, "table", row_id, op, row_json, row_version, scopes
+      FROM sync_changes
+      WHERE commit_seq = ANY(${args.commitSeqs}::bigint[])
+        AND partition_id = ${partitionId}
+        AND "table" = ${args.table}
+        AND (${scopeFilter})
+      ORDER BY commit_seq ASC, change_id ASC
+    `.execute(db);
+        return res.rows.map((row) => ({
+            commit_seq: coerceNumber(row.commit_seq) ?? 0,
+            table: row.table,
+            row_id: row.row_id,
+            op: row.op,
+            row_json: row.row_json ?? null,
+            row_version: coerceNumber(row.row_version),
+            scopes: parseScopes(row.scopes),
+        }));
+    }
+    async readAuditRowHistory(db, args) {
+        const partitionId = args.partitionId ?? 'default';
+        const scopeFilter = buildJsonbScopeContainmentFilter('c.scopes', args.scopes);
+        const limit = Math.max(1, Math.min(200, args.limit));
+        const whereClauses = [
+            sql `c.partition_id = ${partitionId}`,
+            sql `cm.partition_id = ${partitionId}`,
+            sql `c."table" = ${args.table}`,
+            sql `c.row_id = ${args.rowId}`,
+            sql `(${scopeFilter})`,
+        ];
+        if (args.beforeCommitSeq !== undefined) {
+            whereClauses.push(sql `c.commit_seq < ${args.beforeCommitSeq}`);
+        }
+        if (args.afterCommitSeq !== undefined) {
+            whereClauses.push(sql `c.commit_seq >= ${args.afterCommitSeq}`);
+        }
+        const res = await sql `
+      SELECT
+        c.commit_seq,
+        cm.actor_id,
+        cm.client_id,
+        cm.client_commit_id,
+        cm.created_at,
+        c.change_id,
+        c."table",
+        c.row_id,
+        c.op,
+        c.row_json,
+        c.row_version,
+        c.scopes
+      FROM sync_changes c
+      JOIN sync_commits cm
+        ON cm.partition_id = c.partition_id
+       AND cm.commit_seq = c.commit_seq
+      WHERE ${sql.join(whereClauses, sql ` AND `)}
+      ORDER BY c.commit_seq DESC, c.change_id DESC
+      LIMIT ${limit + 1}
+    `.execute(db);
+        return res.rows.map((row) => ({
+            commit_seq: coerceNumber(row.commit_seq) ?? 0,
+            actor_id: row.actor_id,
+            client_id: row.client_id,
+            client_commit_id: row.client_commit_id,
+            created_at: coerceIsoString(row.created_at),
+            change_id: coerceNumber(row.change_id) ?? 0,
+            table: row.table,
+            row_id: row.row_id,
+            op: row.op,
+            row_json: row.row_json ?? null,
+            row_version: coerceNumber(row.row_version),
+            scopes: parseScopes(row.scopes),
+        }));
+    }
+    async readIncrementalPullRowsBatch(db, args) {
+        const partitionId = args.partitionId ?? 'default';
+        const limitCommits = Math.max(1, Math.min(1000, args.limitCommits));
+        const scopeFilter = buildJsonbScopeContainmentFilter('c.scopes', args.scopes);
+        const scopeIndexedCommitSeqs = await this.readScopeIndexedCommitSeqsForPull(db, {
+            partitionId,
+            table: args.table,
+            scopes: args.scopes,
+            cursor: args.cursor,
+            limitCommits,
+        });
+        if (scopeIndexedCommitSeqs.length > 0) {
+            const commitSeqsFilter = this.buildNumberListFilter(scopeIndexedCommitSeqs);
+            const scannedMaxCommitSeq = scopeIndexedCommitSeqs[scopeIndexedCommitSeqs.length - 1] ??
+                args.cursor;
+            const res = await sql `
+        SELECT
+          cm.commit_seq,
+          cm.actor_id,
+          cm.created_at,
+          cm.commit_digest,
+          cm.commit_chain_root,
+          c.change_id,
+          c."table",
+          c.row_id,
+          c.op,
+          c.row_json,
+          c.row_version,
+          c.scopes
+        FROM sync_commits cm
+        JOIN sync_changes c ON c.commit_seq = cm.commit_seq
+        WHERE cm.commit_seq ${commitSeqsFilter}
+          AND cm.partition_id = ${partitionId}
+          AND c.partition_id = ${partitionId}
+          AND c."table" = ${args.table}
+          AND (${scopeFilter})
+        ORDER BY cm.commit_seq ASC, c.change_id ASC
+      `.execute(db);
+            return res.rows.map((row) => ({
+                commit_seq: coerceNumber(row.commit_seq) ?? 0,
+                scanned_max_commit_seq: scannedMaxCommitSeq,
+                actor_id: row.actor_id,
+                created_at: coerceIsoString(row.created_at),
+                commit_digest: row.commit_digest ?? null,
+                commit_chain_root: row.commit_chain_root ?? null,
+                change_id: coerceNumber(row.change_id) ?? 0,
+                table: row.table,
+                row_id: row.row_id,
+                op: row.op,
+                row_json: row.row_json ?? null,
+                row_version: coerceNumber(row.row_version),
+                scopes: parseScopes(row.scopes),
+            }));
+        }
+        const res = await sql `
+      WITH commit_window AS (
+        SELECT tc.commit_seq
+        FROM sync_table_commits tc
+        JOIN sync_commits cm ON cm.commit_seq = tc.commit_seq
+        WHERE tc.partition_id = ${partitionId}
+          AND tc."table" = ${args.table}
+          AND cm.partition_id = ${partitionId}
+          AND tc.commit_seq > ${args.cursor}
+        ORDER BY tc.commit_seq ASC
+        LIMIT ${limitCommits}
+      ),
+      commit_seqs AS (
+        SELECT cw.commit_seq
+        FROM commit_window cw
+        WHERE EXISTS (
+          SELECT 1
+          FROM sync_changes c
+          WHERE c.commit_seq = cw.commit_seq
+            AND c.partition_id = ${partitionId}
+            AND c."table" = ${args.table}
+            AND (${scopeFilter})
+        )
+        ORDER BY cw.commit_seq ASC
+      )
+      SELECT
+        cm.commit_seq,
+        (SELECT max(commit_seq) FROM commit_window) AS scanned_max_commit_seq,
+        cm.actor_id,
+        cm.created_at,
+        cm.commit_digest,
+        cm.commit_chain_root,
+        c.change_id,
+        c."table",
+        c.row_id,
+        c.op,
+        c.row_json,
+        c.row_version,
+        c.scopes
+      FROM commit_seqs cs
+      JOIN sync_commits cm ON cm.commit_seq = cs.commit_seq
+      JOIN sync_changes c ON c.commit_seq = cs.commit_seq
+      WHERE cm.partition_id = ${partitionId}
+        AND c.partition_id = ${partitionId}
+        AND c."table" = ${args.table}
+        AND (${scopeFilter})
+      ORDER BY cm.commit_seq ASC, c.change_id ASC
+    `.execute(db);
+        return res.rows.map((row) => ({
+            commit_seq: coerceNumber(row.commit_seq) ?? 0,
+            scanned_max_commit_seq: coerceNumber(row.scanned_max_commit_seq),
+            actor_id: row.actor_id,
+            created_at: coerceIsoString(row.created_at),
+            commit_digest: row.commit_digest ?? null,
+            commit_chain_root: row.commit_chain_root ?? null,
+            change_id: coerceNumber(row.change_id) ?? 0,
+            table: row.table,
+            row_id: row.row_id,
+            op: row.op,
+            row_json: row.row_json ?? null,
+            row_version: coerceNumber(row.row_version),
+            scopes: parseScopes(row.scopes),
+        }));
+    }
+    async compactChanges(db, args) {
+        const cutoffIso = new Date(Date.now() - args.fullHistoryHours * 60 * 60 * 1000).toISOString();
+        const res = await sql `
+      WITH ranked AS (
+        SELECT
+          c.change_id,
+          row_number() OVER (
+            PARTITION BY c.partition_id, c."table", c.row_id, c.scopes
+            ORDER BY c.commit_seq DESC, c.change_id DESC
+          ) AS rn
+        FROM sync_changes c
+        JOIN sync_commits cm ON cm.commit_seq = c.commit_seq
+        WHERE cm.created_at < ${cutoffIso}
+      )
+      DELETE FROM sync_changes
+      WHERE change_id IN (SELECT change_id FROM ranked WHERE rn > 1)
+    `.execute(db);
+        const deletedChanges = Number(res.numAffectedRows ?? 0);
+        // Remove routing index entries that no longer have any remaining changes
+        await sql `
+      DELETE FROM sync_scope_commits sc
+      USING sync_commits cm
+        WHERE cm.commit_seq = sc.commit_seq
+          AND cm.partition_id = sc.partition_id
+          AND cm.created_at < ${cutoffIso}
+        AND NOT EXISTS (
+          SELECT 1
+          FROM sync_changes c
+          WHERE c.commit_seq = sc.commit_seq
+            AND c.partition_id = sc.partition_id
+            AND c."table" = sc."table"
+        )
+    `.execute(db);
+        await sql `
+      DELETE FROM sync_table_commits tc
+      USING sync_commits cm
+        WHERE cm.commit_seq = tc.commit_seq
+          AND cm.partition_id = tc.partition_id
+          AND cm.created_at < ${cutoffIso}
+        AND NOT EXISTS (
+          SELECT 1
+          FROM sync_changes c
+          WHERE c.commit_seq = tc.commit_seq
+            AND c.partition_id = tc.partition_id
+            AND c."table" = tc."table"
+        )
+    `.execute(db);
+        return deletedChanges;
+    }
+    // ===========================================================================
+    // Scope Conversion Helpers
+    // ===========================================================================
+    scopesToDb(scopes) {
+        return scopes;
+    }
+    dbToArray(value) {
+        if (Array.isArray(value)) {
+            return value.filter((k) => typeof k === 'string');
+        }
+        return [];
+    }
+    arrayToDb(values) {
+        return values.filter((v) => v.length > 0);
+    }
+    // ===========================================================================
+    // Console Schema (Request Events)
+    // ===========================================================================
+    async ensureConsoleSchema(db) {
+        await sql `
+      CREATE TABLE IF NOT EXISTS sync_request_events (
+        event_id BIGSERIAL PRIMARY KEY,
+        partition_id TEXT NOT NULL DEFAULT 'default',
+        request_id TEXT,
+        trace_id TEXT,
+        span_id TEXT,
+        event_type TEXT NOT NULL,
+        actor_id TEXT NOT NULL,
+        client_id TEXT NOT NULL,
+        transport_path TEXT NOT NULL DEFAULT 'direct',
+        sync_path TEXT NOT NULL DEFAULT 'http-combined',
+        status_code INTEGER NOT NULL,
+        outcome TEXT NOT NULL,
+        response_status TEXT NOT NULL DEFAULT 'unknown',
+        error_code TEXT,
+        duration_ms INTEGER NOT NULL,
+        commit_seq BIGINT,
+        operation_count INTEGER,
+        row_count INTEGER,
+        subscription_count INTEGER,
+        scopes_summary JSONB,
+        response_summary JSONB,
+        tables TEXT[] NOT NULL DEFAULT ARRAY[]::TEXT[],
+        error_message TEXT,
+        payload_ref TEXT,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `.execute(db);
+        await sql `
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS partition_id TEXT NOT NULL DEFAULT 'default'
+    `.execute(db);
+        await sql `
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS request_id TEXT
+    `.execute(db);
+        await sql `
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS trace_id TEXT
+    `.execute(db);
+        await sql `
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS span_id TEXT
+    `.execute(db);
+        await sql `
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS transport_path TEXT NOT NULL DEFAULT 'direct'
+    `.execute(db);
+        await sql `
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS sync_path TEXT NOT NULL DEFAULT 'http-combined'
+    `.execute(db);
+        await sql `
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS response_status TEXT NOT NULL DEFAULT 'unknown'
+    `.execute(db);
+        await sql `
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS error_code TEXT
+    `.execute(db);
+        await sql `
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS subscription_count INTEGER
+    `.execute(db);
+        await sql `
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS scopes_summary JSONB
+    `.execute(db);
+        await sql `
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS response_summary JSONB
+    `.execute(db);
+        await sql `
+      ALTER TABLE sync_request_events
+      ADD COLUMN IF NOT EXISTS payload_ref TEXT
+    `.execute(db);
+        await this.ensureIndex(db, 'idx_sync_request_events_created_at', 'CREATE INDEX idx_sync_request_events_created_at ON sync_request_events(created_at DESC)');
+        await this.ensureIndex(db, 'idx_sync_request_events_event_type', 'CREATE INDEX idx_sync_request_events_event_type ON sync_request_events(event_type)');
+        await this.ensureIndex(db, 'idx_sync_request_events_client_id', 'CREATE INDEX idx_sync_request_events_client_id ON sync_request_events(client_id)');
+        await this.ensureIndex(db, 'idx_sync_request_events_request_id', 'CREATE INDEX idx_sync_request_events_request_id ON sync_request_events(request_id)');
+        await this.ensureIndex(db, 'idx_sync_request_events_trace_id', 'CREATE INDEX idx_sync_request_events_trace_id ON sync_request_events(trace_id)');
+        await this.ensureIndex(db, 'idx_sync_request_events_partition_created_at', 'CREATE INDEX idx_sync_request_events_partition_created_at ON sync_request_events(partition_id, created_at DESC)');
+        await sql `
+      CREATE TABLE IF NOT EXISTS sync_request_payloads (
+        payload_ref TEXT PRIMARY KEY,
+        partition_id TEXT NOT NULL DEFAULT 'default',
+        request_payload JSONB NOT NULL,
+        response_payload JSONB,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `.execute(db);
+        await this.ensureIndex(db, 'idx_sync_request_payloads_created_at', 'CREATE INDEX idx_sync_request_payloads_created_at ON sync_request_payloads(created_at DESC)');
+        await this.ensureIndex(db, 'idx_sync_request_payloads_partition_created_at', 'CREATE INDEX idx_sync_request_payloads_partition_created_at ON sync_request_payloads(partition_id, created_at DESC)');
+        await sql `
+      CREATE TABLE IF NOT EXISTS sync_operation_events (
+        operation_id BIGSERIAL PRIMARY KEY,
+        operation_type TEXT NOT NULL,
+        console_user_id TEXT,
+        partition_id TEXT,
+        target_client_id TEXT,
+        request_payload JSONB,
+        result_payload JSONB,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `.execute(db);
+        await this.ensureIndex(db, 'idx_sync_operation_events_created_at', 'CREATE INDEX idx_sync_operation_events_created_at ON sync_operation_events(created_at DESC)');
+        await this.ensureIndex(db, 'idx_sync_operation_events_type', 'CREATE INDEX idx_sync_operation_events_type ON sync_operation_events(operation_type)');
+        await sql `
+      CREATE TABLE IF NOT EXISTS sync_realtime_events (
+        event_id BIGSERIAL PRIMARY KEY,
+        partition_id TEXT NOT NULL DEFAULT 'default',
+        actor_id TEXT NOT NULL,
+        client_id TEXT NOT NULL,
+        transport_path TEXT NOT NULL DEFAULT 'direct',
+        event_type TEXT NOT NULL,
+        reason TEXT,
+        cursor BIGINT,
+        latest_cursor BIGINT,
+        commit_seq BIGINT,
+        scope_count INTEGER,
+        skipped_count INTEGER,
+        sync_pack_encoding TEXT,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `.execute(db);
+        await this.ensureIndex(db, 'idx_sync_realtime_events_created_at', 'CREATE INDEX idx_sync_realtime_events_created_at ON sync_realtime_events(created_at DESC)');
+        await this.ensureIndex(db, 'idx_sync_realtime_events_partition_client_created_at', 'CREATE INDEX idx_sync_realtime_events_partition_client_created_at ON sync_realtime_events(partition_id, client_id, created_at DESC)');
+        await sql `
+      CREATE TABLE IF NOT EXISTS sync_client_diagnostic_snapshots (
+        snapshot_id BIGSERIAL PRIMARY KEY,
+        partition_id TEXT NOT NULL DEFAULT 'default',
+        client_id TEXT NOT NULL,
+        actor_id TEXT,
+        runtime_kind TEXT,
+        runtime_version TEXT,
+        schema_version INTEGER,
+        reported_at TIMESTAMPTZ NOT NULL,
+        received_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        lifecycle_phase TEXT,
+        connection_state TEXT,
+        freshness_state TEXT NOT NULL,
+        health_max_severity TEXT,
+        diagnostic_codes_summary JSONB,
+        queue_summary JSONB,
+        timing_summary JSONB,
+        redaction_summary JSONB,
+        snapshot_json JSONB NOT NULL
+      )
+    `.execute(db);
+        await this.ensureIndex(db, 'idx_sync_client_diagnostic_snapshots_received_at', 'CREATE INDEX idx_sync_client_diagnostic_snapshots_received_at ON sync_client_diagnostic_snapshots(received_at DESC)');
+        await this.ensureIndex(db, 'idx_sync_client_diagnostic_snapshots_latest', 'CREATE INDEX idx_sync_client_diagnostic_snapshots_latest ON sync_client_diagnostic_snapshots(partition_id, client_id, received_at DESC)');
+        await this.ensureIndex(db, 'idx_sync_client_diagnostic_snapshots_health', 'CREATE INDEX idx_sync_client_diagnostic_snapshots_health ON sync_client_diagnostic_snapshots(partition_id, health_max_severity, received_at DESC)');
+        // API Keys table
+        await sql `
+      CREATE TABLE IF NOT EXISTS sync_api_keys (
+        key_id TEXT PRIMARY KEY,
+        key_hash TEXT NOT NULL,
+        key_prefix TEXT NOT NULL,
+        name TEXT NOT NULL,
+        key_type TEXT NOT NULL,
+        scope_keys TEXT[] DEFAULT ARRAY[]::TEXT[],
+        actor_id TEXT,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        expires_at TIMESTAMPTZ,
+        last_used_at TIMESTAMPTZ,
+        revoked_at TIMESTAMPTZ
+      )
+    `.execute(db);
+        await this.ensureIndex(db, 'idx_sync_api_keys_key_hash', 'CREATE INDEX idx_sync_api_keys_key_hash ON sync_api_keys(key_hash)');
+        await this.ensureIndex(db, 'idx_sync_api_keys_key_type', 'CREATE INDEX idx_sync_api_keys_key_type ON sync_api_keys(key_type)');
+    }
+    // ===========================================================================
+    // Private Helpers
+    // ===========================================================================
+    async ensureIndex(db, indexName, createSql) {
+        const exists = await sql `
+      SELECT 1 as ok
+      FROM pg_indexes
+      WHERE schemaname = 'public'
+        AND indexname = ${indexName}
+      LIMIT 1
+    `.execute(db);
+        if (exists.rows.length > 0)
+            return;
+        await sql.raw(createSql).execute(db);
+    }
+}
+export function createPostgresServerDialect() {
+    return new PostgresServerSyncDialect();
+}
+/**
+ * Explicit server-side dialect alias for Neon-backed Postgres runtimes.
+ *
+ * Neon uses the same SQL family and sync schema behavior as Postgres, but this
+ * helper makes the runtime/provider intent visible in app code and host
+ * integrations.
+ */
+export function createNeonServerDialect() {
+    return createPostgresServerDialect();
+}
+//# sourceMappingURL=index.js.map