@syncular/server 0.0.1 → 0.0.2-126

package/src/realtime/types.ts

@@ -7,6 +7,8 @@
 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,6 +16,8 @@ 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 */
@@ -43,6 +45,8 @@ 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 */
@@ -66,6 +70,8 @@ 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 */
@@ -87,6 +93,8 @@ 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 */
@@ -97,7 +105,7 @@ export interface SyncSnapshotChunksTable {
   row_cursor: string;
   /** Snapshot row limit used to produce this chunk */
   row_limit: number;
-  /** Row encoding (e.g. 'ndjson') */
+  /** Row encoding (e.g. 'json-row-frame-v1') */
   encoding: string;
   /** Compression algorithm (e.g. 'gzip') */
   compression: string;
@@ -122,6 +130,8 @@ 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/snapshot-chunks/db-metadata.test.ts

@@ -0,0 +1,169 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import type { BlobStorageAdapter } from '@syncular/core';
+import { type Kysely, sql } from 'kysely';
+import { createBunSqliteDb } from '../../../dialect-bun-sqlite/src';
+import { createSqliteServerDialect } from '../../../server-dialect-sqlite/src';
+import { ensureSyncSchema } from '../migrate';
+import type { SyncCoreDb } from '../schema';
+import { createDbMetadataChunkStorage } from './db-metadata';
+
+interface TestDb extends SyncCoreDb {}
+
+function createInMemoryBlobAdapter(): BlobStorageAdapter {
+  const store = new Map<string, Uint8Array>();
+
+  return {
+    name: 'memory',
+    async signUpload() {
+      return { url: 'https://example.test/upload', method: 'PUT' };
+    },
+    async signDownload() {
+      return 'https://example.test/download';
+    },
+    async exists(hash) {
+      return store.has(hash);
+    },
+    async delete(hash) {
+      store.delete(hash);
+    },
+    async put(hash, data) {
+      store.set(hash, new Uint8Array(data));
+    },
+    async get(hash) {
+      const value = store.get(hash);
+      return value ? new Uint8Array(value) : null;
+    },
+  };
+}
+
+function createBodyStream(
+  chunks: readonly Uint8Array[]
+): ReadableStream<Uint8Array> {
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      for (const chunk of chunks) {
+        controller.enqueue(chunk);
+      }
+      controller.close();
+    },
+  });
+}
+
+describe('createDbMetadataChunkStorage', () => {
+  let db: Kysely<TestDb>;
+
+  beforeEach(async () => {
+    db = createBunSqliteDb<TestDb>({ path: ':memory:' });
+    await ensureSyncSchema(db, createSqliteServerDialect());
+  });
+
+  afterEach(async () => {
+    await db.destroy();
+  });
+
+  it('returns the persisted chunk id on page-key conflicts', async () => {
+    const storage = createDbMetadataChunkStorage({
+      db,
+      blobAdapter: createInMemoryBlobAdapter(),
+    });
+
+    const body = new Uint8Array([1, 2, 3, 4]);
+    const expiresAt = new Date(Date.now() + 60_000).toISOString();
+
+    const first = await storage.storeChunk({
+      partitionId: 'p1',
+      scopeKey: 'scope-key',
+      scope: 'tasks',
+      asOfCommitSeq: 1,
+      rowCursor: null,
+      rowLimit: 100,
+      encoding: 'json-row-frame-v1',
+      compression: 'gzip',
+      sha256: 'chunk-sha',
+      expiresAt,
+      body,
+    });
+
+    const second = await storage.storeChunk({
+      partitionId: 'p1',
+      scopeKey: 'scope-key',
+      scope: 'tasks',
+      asOfCommitSeq: 1,
+      rowCursor: null,
+      rowLimit: 100,
+      encoding: 'json-row-frame-v1',
+      compression: 'gzip',
+      sha256: 'chunk-sha',
+      expiresAt: new Date(Date.now() + 120_000).toISOString(),
+      body,
+    });
+
+    expect(second.id).toBe(first.id);
+
+    const chunkBody = await storage.readChunk(second.id);
+    expect(chunkBody).toEqual(body);
+
+    const countResult = await sql<{ count: number }>`
+      select count(*) as count
+      from ${sql.table('sync_snapshot_chunks')}
+    `.execute(db);
+
+    expect(Number(countResult.rows[0]?.count ?? 0)).toBe(1);
+  });
+
+  it('disables blob checksums for chunk stream writes', async () => {
+    const putStreamMetadata: Array<Record<string, unknown> | undefined> = [];
+    const blobAdapter: BlobStorageAdapter = {
+      name: 'memory-stream',
+      async signUpload() {
+        return { url: 'https://example.test/upload', method: 'PUT' };
+      },
+      async signDownload() {
+        return 'https://example.test/download';
+      },
+      async exists() {
+        return false;
+      },
+      async delete() {},
+      async put() {},
+      async get() {
+        return null;
+      },
+      async putStream(_hash, stream, metadata) {
+        putStreamMetadata.push(metadata);
+        const reader = stream.getReader();
+        try {
+          while (true) {
+            const { done } = await reader.read();
+            if (done) break;
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      },
+    };
+
+    const storage = createDbMetadataChunkStorage({
+      db,
+      blobAdapter,
+    });
+
+    await storage.storeChunkStream({
+      partitionId: 'p1',
+      scopeKey: 'scope-key',
+      scope: 'tasks',
+      asOfCommitSeq: 1,
+      rowCursor: null,
+      rowLimit: 100,
+      encoding: 'json-row-frame-v1',
+      compression: 'gzip',
+      sha256: 'chunk-sha',
+      expiresAt: new Date(Date.now() + 60_000).toISOString(),
+      byteLength: 4,
+      bodyStream: createBodyStream([new Uint8Array([1, 2, 3, 4])]),
+    });
+
+    expect(putStreamMetadata).toHaveLength(1);
+    expect(putStreamMetadata[0]?.disableChecksum).toBe(true);
+  });
+});