@syncular/server 0.0.1-60 → 0.0.1

package/src/push.ts

@@ -1,8 +1,4 @@
-import type {
-  SyncChange,
-  SyncPushRequest,
-  SyncPushResponse,
-} from '@syncular/core';
+import type { SyncPushRequest, SyncPushResponse } from '@syncular/core';
 import type {
   Insertable,
   Kysely,
@@ -25,17 +21,6 @@ export interface PushCommitResult {
    * Empty for rejected commits and for commits that emit no changes.
    */
   affectedTables: string[];
-  /**
-   * Scope keys derived from emitted changes (e.g. "org:abc", "team:xyz").
-   * Computed in-transaction so callers don't need an extra DB query.
-   * Empty for rejected/cached commits.
-   */
-  scopeKeys: string[];
-  /**
-   * Changes emitted by this commit. Available for WS data delivery.
-   * Empty for rejected/cached commits.
-   */
-  emittedChanges: SyncChange[];
 }
 
 class RejectCommitError extends Error {
@@ -48,8 +33,7 @@ class RejectCommitError extends Error {
 async function readCommitAffectedTables<DB extends SyncCoreDb>(
   db: Kysely<DB>,
   dialect: ServerSyncDialect,
-  commitSeq: number,
-  partitionId: string
+  commitSeq: number
 ): Promise<string[]> {
   try {
     const commitsQ = db.selectFrom('sync_commits') as SelectQueryBuilder<
@@ -61,7 +45,6 @@ async function readCommitAffectedTables<DB extends SyncCoreDb>(
     const row = await commitsQ
       .selectAll()
       .where(sql<SqlBool>`commit_seq = ${commitSeq}`)
-      .where(sql<SqlBool>`partition_id = ${partitionId}`)
       .executeTakeFirst();
 
     const raw = row?.affected_tables;
@@ -71,21 +54,7 @@ async function readCommitAffectedTables<DB extends SyncCoreDb>(
   }
 
   // Fallback: read from changes using dialect-specific implementation
-  return dialect.readAffectedTablesFromChanges(db, commitSeq, { partitionId });
-}
-
-function scopeKeysFromEmitted(
-  emitted: Array<{ scopes: Record<string, string> }>
-): string[] {
-  const keys = new Set<string>();
-  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);
+  return dialect.readAffectedTablesFromChanges(db, commitSeq);
 }
 
 export async function pushCommit<DB extends SyncCoreDb>(args: {
@@ -93,12 +62,10 @@ export async function pushCommit<DB extends SyncCoreDb>(args: {
   dialect: ServerSyncDialect;
   shapes: TableRegistry<DB>;
   actorId: string;
-  partitionId?: string;
   request: SyncPushRequest;
 }): Promise<PushCommitResult> {
   const { request, dialect } = args;
   const db = args.db;
-  const partitionId = args.partitionId ?? 'default';
 
   if (!request.clientId || !request.clientCommitId) {
     return {
@@ -116,8 +83,6 @@ export async function pushCommit<DB extends SyncCoreDb>(args: {
         ],
       },
       affectedTables: [],
-      scopeKeys: [],
-      emittedChanges: [],
     };
   }
 
@@ -138,8 +103,6 @@ export async function pushCommit<DB extends SyncCoreDb>(args: {
         ],
       },
       affectedTables: [],
-      scopeKeys: [],
-      emittedChanges: [],
     };
   }
 
@@ -156,7 +119,6 @@ export async function pushCommit<DB extends SyncCoreDb>(args: {
     // 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)
@@ -164,7 +126,6 @@ export async function pushCommit<DB extends SyncCoreDb>(args: {
 
     // Insert commit row (idempotency key)
     const commitRow: Insertable<SyncCoreDb['sync_commits']> = {
-      partition_id: partitionId,
       actor_id: args.actorId,
       client_id: request.clientId,
       client_commit_id: request.clientCommitId,
@@ -176,7 +137,7 @@ export async function pushCommit<DB extends SyncCoreDb>(args: {
       .insertInto('sync_commits')
       .values(commitRow)
       .onConflict((oc) =>
-        oc.columns(['partition_id', 'client_id', 'client_commit_id']).doNothing()
+        oc.columns(['client_id', 'client_commit_id']).doNothing()
       )
       .executeTakeFirstOrThrow();
 
@@ -192,7 +153,6 @@ export async function pushCommit<DB extends SyncCoreDb>(args: {
         >
       )
         .selectAll()
-        .where('partition_id', '=', partitionId)
         .where('client_id', '=', request.clientId)
         .where('client_commit_id', '=', request.clientCommitId);
 
@@ -219,8 +179,6 @@ export async function pushCommit<DB extends SyncCoreDb>(args: {
             ],
           },
           affectedTables: [],
-          scopeKeys: [],
-          emittedChanges: [],
         };
       }
 
@@ -239,20 +197,12 @@ export async function pushCommit<DB extends SyncCoreDb>(args: {
               : await readCommitAffectedTables(
                   trx,
                   dialect,
-                  Number(existing.commit_seq),
-                  partitionId
+                  Number(existing.commit_seq)
                 ),
-          scopeKeys: [],
-          emittedChanges: [],
         };
       }
 
-      return {
-        response: base,
-        affectedTables: [],
-        scopeKeys: [],
-        emittedChanges: [],
-      };
+      return { response: base, affectedTables: [] };
     }
 
     const insertedCommit = await (
@@ -263,7 +213,6 @@ export async function pushCommit<DB extends SyncCoreDb>(args: {
       >
     )
       .selectAll()
-      .where('partition_id', '=', partitionId)
       .where('client_id', '=', request.clientId)
       .where('client_commit_id', '=', request.clientCommitId)
       .executeTakeFirstOrThrow();
@@ -343,7 +292,6 @@ export async function pushCommit<DB extends SyncCoreDb>(args: {
       if (allEmitted.length > 0) {
         const changeRows: Array<Insertable<SyncCoreDb['sync_changes']>> =
           allEmitted.map((c) => ({
-            partition_id: partitionId,
             commit_seq: commitSeq,
             table: c.table,
             row_id: c.row_id,
@@ -382,7 +330,6 @@ export async function pushCommit<DB extends SyncCoreDb>(args: {
         const tableCommits: Array<
           Insertable<SyncCoreDb['sync_table_commits']>
         > = affectedTables.map((table) => ({
-          partition_id: partitionId,
           table,
           commit_seq: commitSeq,
         }));
@@ -390,9 +337,7 @@ export async function pushCommit<DB extends SyncCoreDb>(args: {
         await syncTrx
           .insertInto('sync_table_commits')
           .values(tableCommits)
-          .onConflict((oc) =>
-            oc.columns(['partition_id', 'table', 'commit_seq']).doNothing()
-          )
+          .onConflict((oc) => oc.columns(['table', 'commit_seq']).doNothing())
           .execute();
       }
 
@@ -403,15 +348,6 @@ export async function pushCommit<DB extends SyncCoreDb>(args: {
       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,
-        })),
       };
     } catch (err) {
       // Roll back app writes but keep the commit row.
@@ -446,12 +382,7 @@ export async function pushCommit<DB extends SyncCoreDb>(args: {
         .where('commit_seq', '=', commitSeq)
         .execute();
 
-      return {
-        response: err.response,
-        affectedTables: [],
-        scopeKeys: [],
-        emittedChanges: [],
-      };
+      return { response: err.response, affectedTables: [] };
     }
   });
 }

package/src/realtime/types.ts

@@ -7,8 +7,6 @@
 export interface SyncRealtimeCommitEvent {
   type: 'commit';
   commitSeq: number;
-  /** Logical partition key (tenant / demo / workspace). */
-  partitionId?: string;
   /**
    * Optional scopes affected by the commit.
    * Broadcasters may omit this to keep payloads small (listeners can look up in DB).

package/src/schema.ts

@@ -16,8 +16,6 @@ import type { Generated } from 'kysely';
 export interface SyncCommitsTable {
   /** Monotonic commit sequence (server-assigned) */
   commit_seq: Generated<number>;
-  /** Logical partition key (tenant / demo / workspace) */
-  partition_id: string;
   /** Actor who produced the commit */
   actor_id: string;
   /** Client/device identifier */
@@ -45,8 +43,6 @@ export interface SyncCommitsTable {
 export interface SyncChangesTable {
   /** Monotonic change id */
   change_id: Generated<number>;
-  /** Logical partition key (tenant / demo / workspace) */
-  partition_id: string;
   /** Commit sequence this change belongs to */
   commit_seq: number;
   /** Table name being changed */
@@ -70,8 +66,6 @@ export interface SyncChangesTable {
  * Per-client cursor tracking (for pruning + observability).
  */
 export interface SyncClientCursorsTable {
-  /** Logical partition key (tenant / demo / workspace) */
-  partition_id: string;
   /** Client/device identifier */
   client_id: string;
   /** Actor currently associated with the client */
@@ -93,8 +87,6 @@ export interface SyncClientCursorsTable {
 export interface SyncSnapshotChunksTable {
   /** Opaque chunk id */
   chunk_id: string;
-  /** Logical partition key (tenant / demo / workspace) */
-  partition_id: string;
   /** Effective scope key this chunk belongs to */
   scope_key: string;
   /** Scope identifier */
@@ -130,8 +122,6 @@ export interface SyncSnapshotChunksTable {
  * the (much larger) change log.
  */
 export interface SyncTableCommitsTable {
-  /** Logical partition key (tenant / demo / workspace) */
-  partition_id: string;
   table: string;
   commit_seq: number;
 }

package/src/shapes/create-handler.ts

@@ -39,24 +39,6 @@ type AuthorizeResult =
   | true
   | { error: string; code: string; retriable?: boolean };
 
-function classifyConstraintViolationCode(message: string): string {
-  const normalized = message.toLowerCase();
-  if (normalized.includes('not null')) return 'NOT_NULL_CONSTRAINT';
-  if (normalized.includes('unique')) return 'UNIQUE_CONSTRAINT';
-  if (normalized.includes('foreign key')) return 'FOREIGN_KEY_CONSTRAINT';
-  return 'CONSTRAINT_VIOLATION';
-}
-
-function isConstraintViolationError(message: string): boolean {
-  const normalized = message.toLowerCase();
-  return (
-    normalized.includes('constraint') ||
-    normalized.includes('not null') ||
-    normalized.includes('foreign key') ||
-    normalized.includes('unique')
-  );
-}
-
 /**
  * Scope definition for a column - maps scope variable to column name.
  */
@@ -449,109 +431,62 @@ export function createServerHandler<
       };
     }
 
-    // If the client provided a base version, they expected this row to exist.
-    // A missing row usually indicates stale local state after a server reset.
-    if (!existing && op.base_version != null) {
-      return {
-        result: {
-          opIndex,
-          status: 'error',
-          error: 'ROW_NOT_FOUND_FOR_BASE_VERSION',
-          code: 'ROW_MISSING',
-          retriable: false,
-        },
-        emittedChanges: [],
-      };
-    }
-
     const nextVersion = existingVersion + 1;
 
-    let updated: Record<string, unknown> | undefined;
-    let constraintError: { message: string; code: string } | null = null;
-
-    try {
-      if (existing) {
-        // Update - merge payload with existing
-        const updateSet: Record<string, unknown> = {
-          ...payload,
-          [versionColumn]: nextVersion,
-        };
-        // Don't update primary key or scope columns
-        delete updateSet[primaryKey];
-        for (const col of Object.values(scopeColumns)) {
-          delete updateSet[col];
-        }
-
-        await (
-          trx.updateTable(table) as UpdateQueryBuilder<
-            ServerDB,
-            TableName,
-            TableName,
-            UpdateResult
-          >
-        )
-          .set(updateSet as UpdateSetObject)
-          .where(ref<string>(primaryKey), '=', op.row_id)
-          .execute();
-      } else {
-        // Insert
-        const insertValues: Record<string, unknown> = {
-          ...payload,
-          [primaryKey]: op.row_id,
-          [versionColumn]: 1,
-        };
-
-        await (
-          trx.insertInto(table) as InsertQueryBuilder<
-            ServerDB,
-            TableName,
-            InsertResult
-          >
-        )
-          .values(insertValues as Insertable<ServerDB[TableName]>)
-          .execute();
+    if (existing) {
+      // Update - merge payload with existing
+      const updateSet: Record<string, unknown> = {
+        ...payload,
+        [versionColumn]: nextVersion,
+      };
+      // Don't update primary key or scope columns
+      delete updateSet[primaryKey];
+      for (const col of Object.values(scopeColumns)) {
+        delete updateSet[col];
       }
 
-      // Read back the updated row
-      updated = await (
-        trx.selectFrom(table).selectAll() as SelectQueryBuilder<
+      await (
+        trx.updateTable(table) as UpdateQueryBuilder<
           ServerDB,
-          keyof ServerDB & string,
-          Record<string, unknown>
+          TableName,
+          TableName,
+          UpdateResult
         >
       )
+        .set(updateSet as UpdateSetObject)
         .where(ref<string>(primaryKey), '=', op.row_id)
-        .executeTakeFirstOrThrow();
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      if (!isConstraintViolationError(message)) {
-        throw err;
-      }
-
-      constraintError = {
-        message,
-        code: classifyConstraintViolationCode(message),
+        .execute();
+    } else {
+      // Insert
+      const insertValues: Record<string, unknown> = {
+        ...payload,
+        [primaryKey]: op.row_id,
+        [versionColumn]: 1,
       };
-    }
 
-    if (constraintError) {
-      return {
-        result: {
-          opIndex,
-          status: 'error',
-          error: constraintError.message,
-          code: constraintError.code,
-          retriable: false,
-        },
-        emittedChanges: [],
-      };
+      await (
+        trx.insertInto(table) as InsertQueryBuilder<
+          ServerDB,
+          TableName,
+          InsertResult
+        >
+      )
+        .values(insertValues as Insertable<ServerDB[TableName]>)
+        .execute();
     }
 
-    if (!updated) {
-      throw new Error('Updated row is missing after applyOperation');
-    }
+    // Read back the updated row
+    const updated = await (
+      trx.selectFrom(table).selectAll() as SelectQueryBuilder<
+        ServerDB,
+        keyof ServerDB & string,
+        Record<string, unknown>
+      >
+    )
+      .where(ref<string>(primaryKey), '=', op.row_id)
+      .executeTakeFirstOrThrow();
 
-    const updatedRow = updated;
+    const updatedRow = updated as Record<string, unknown>;
     const rowVersion = (updatedRow[versionColumn] as number) ?? 1;
 
     // Extract scopes from updated row

package/src/snapshot-chunks/db-metadata.ts

@@ -90,7 +90,6 @@ export function createDbMetadataChunkStorage(
         .insertInto('sync_snapshot_chunks')
         .values({
           chunk_id: chunkId,
-          partition_id: metaWithoutBody.partitionId,
           scope_key: metaWithoutBody.scopeKey,
           scope: metaWithoutBody.scope,
           as_of_commit_seq: metaWithoutBody.asOfCommitSeq,
@@ -107,7 +106,6 @@ export function createDbMetadataChunkStorage(
         .onConflict((oc) =>
           oc
             .columns([
-              'partition_id',
               'scope_key',
               'scope',
               'as_of_commit_seq',
@@ -170,7 +168,6 @@ export function createDbMetadataChunkStorage(
           'encoding',
           'compression',
         ])
-        .where('partition_id', '=', pageKey.partitionId)
         .where('scope_key', '=', pageKey.scopeKey)
         .where('scope', '=', pageKey.scope)
         .where('as_of_commit_seq', '=', pageKey.asOfCommitSeq)

package/src/snapshot-chunks/types.ts

@@ -11,7 +11,6 @@ import type { SyncSnapshotChunkRef } from '@syncular/core';
  * Page key for identifying a specific chunk
  */
 export interface SnapshotChunkPageKey {
-  partitionId: string;
   scopeKey: string;
   scope: string;
   asOfCommitSeq: number;
@@ -26,7 +25,6 @@ export interface SnapshotChunkPageKey {
  */
 export interface SnapshotChunkMetadata {
   chunkId: string;
-  partitionId: string;
   scopeKey: string;
   scope: string;
   asOfCommitSeq: number;

package/src/snapshot-chunks.ts

@@ -10,7 +10,6 @@ import { type Kysely, sql } from 'kysely';
 import type { SyncCoreDb } from './schema';
 
 export interface SnapshotChunkPageKey {
-  partitionId: string;
   scopeKey: string;
   scope: string;
   asOfCommitSeq: number;
@@ -22,7 +21,6 @@ export interface SnapshotChunkPageKey {
 
 export interface SnapshotChunkRow {
   chunkId: string;
-  partitionId: string;
   scopeKey: string;
   scope: string;
   asOfCommitSeq: number;
@@ -72,8 +70,7 @@ export async function readSnapshotChunkRefByPageKey<DB extends SyncCoreDb>(
     select chunk_id, sha256, byte_length, encoding, compression
     from ${sql.table('sync_snapshot_chunks')}
     where
-      partition_id = ${args.partitionId}
-      and scope_key = ${args.scopeKey}
+      scope_key = ${args.scopeKey}
       and scope = ${args.scope}
       and as_of_commit_seq = ${args.asOfCommitSeq}
       and row_cursor = ${rowCursorKey}
@@ -111,7 +108,6 @@ export async function insertSnapshotChunk<DB extends SyncCoreDb>(
   db: Kysely<DB>,
   args: {
     chunkId: string;
-    partitionId: string;
     scopeKey: string;
     scope: string;
     asOfCommitSeq: number;
@@ -133,7 +129,6 @@ export async function insertSnapshotChunk<DB extends SyncCoreDb>(
   await sql`
     insert into ${sql.table('sync_snapshot_chunks')} (
       chunk_id,
-      partition_id,
       scope_key,
       scope,
       as_of_commit_seq,
@@ -150,7 +145,6 @@ export async function insertSnapshotChunk<DB extends SyncCoreDb>(
     )
     values (
       ${args.chunkId},
-      ${args.partitionId},
       ${args.scopeKey},
       ${args.scope},
       ${args.asOfCommitSeq},
@@ -166,7 +160,6 @@ export async function insertSnapshotChunk<DB extends SyncCoreDb>(
       ${args.expiresAt}
     )
     on conflict (
-      partition_id,
       scope_key,
       scope,
       as_of_commit_seq,
@@ -181,7 +174,6 @@ export async function insertSnapshotChunk<DB extends SyncCoreDb>(
   `.execute(db);
 
   const ref = await readSnapshotChunkRefByPageKey(db, {
-    partitionId: args.partitionId,
     scopeKey: args.scopeKey,
     scope: args.scope,
     asOfCommitSeq: args.asOfCommitSeq,
@@ -208,7 +200,6 @@ export async function readSnapshotChunk<DB extends SyncCoreDb>(
 ): Promise<SnapshotChunkRow | null> {
   const rowResult = await sql<{
     chunk_id: string;
-    partition_id: string;
     scope_key: string;
     scope: string;
     as_of_commit_seq: number;
@@ -224,7 +215,6 @@ export async function readSnapshotChunk<DB extends SyncCoreDb>(
   }>`
     select
       chunk_id,
-      partition_id,
       scope_key,
       scope,
       as_of_commit_seq,
@@ -273,7 +263,6 @@ export async function readSnapshotChunk<DB extends SyncCoreDb>(
 
   return {
     chunkId: row.chunk_id,
-    partitionId: row.partition_id,
     scopeKey: row.scope_key,
     scope: row.scope,
     asOfCommitSeq: Number(row.as_of_commit_seq ?? 0),