feat(ios): nbstore swift native binding (#9211)

packages/frontend/apps/ios/src/plugins/nbstore/blob.ts

@@ -0,0 +1,33 @@
+import { type BlobRecord, BlobStorageBase, share } from '@affine/nbstore';
+
+import { NativeDBConnection } from './db';
+
+export class SqliteBlobStorage extends BlobStorageBase {
+  override connection = share(
+    new NativeDBConnection(this.peer, this.spaceType, this.spaceId)
+  );
+
+  get db() {
+    return this.connection.inner;
+  }
+
+  override async get(key: string) {
+    return this.db.getBlob(key);
+  }
+
+  override async set(blob: BlobRecord) {
+    await this.db.setBlob(blob);
+  }
+
+  override async delete(key: string, permanently: boolean) {
+    await this.db.deleteBlob(key, permanently);
+  }
+
+  override async release() {
+    await this.db.releaseBlobs();
+  }
+
+  override async list() {
+    return this.db.listBlobs();
+  }
+}

packages/frontend/apps/ios/src/plugins/nbstore/db.ts

@@ -0,0 +1,60 @@
+import type { DocStorage } from '@affine/native';
+import {
+  AutoReconnectConnection,
+  isValidSpaceType,
+  type SpaceType,
+  universalId,
+} from '@affine/nbstore';
+
+import { NativeDocStorage, NbStoreDocStorage } from './plugin';
+
+export class NativeDBConnection extends AutoReconnectConnection<DocStorage> {
+  private readonly universalId: string;
+
+  constructor(
+    private readonly peer: string,
+    private readonly type: SpaceType,
+    private readonly id: string
+  ) {
+    super();
+    if (!isValidSpaceType(type)) {
+      throw new TypeError(`Invalid space type: ${type}`);
+    }
+    this.universalId = universalId({
+      peer: peer,
+      type: type,
+      id: id,
+    });
+  }
+
+  async getDBPath() {
+    const { path } = await NbStoreDocStorage.getSpaceDBPath({
+      peer: this.peer,
+      spaceType: this.type,
+      id: this.id,
+    });
+    return path;
+  }
+
+  override get shareId(): string {
+    return `sqlite:${this.peer}:${this.type}:${this.id}`;
+  }
+
+  override async doConnect() {
+    const conn = new NativeDocStorage(this.universalId);
+    await conn.connect();
+    console.info('[nbstore] connection established', this.shareId);
+    return conn;
+  }
+
+  override doDisconnect(conn: NativeDocStorage) {
+    conn
+      .close()
+      .then(() => {
+        console.info('[nbstore] connection closed', this.shareId);
+      })
+      .catch(err => {
+        console.error('[nbstore] connection close failed', this.shareId, err);
+      });
+  }
+}

packages/frontend/apps/ios/src/plugins/nbstore/definitions.ts

@@ -0,0 +1,144 @@
+export interface Blob {
+  key: string;
+  // base64 encoded data
+  data: string;
+  mime: string;
+  size: number;
+  createdAt: number;
+}
+
+export interface SetBlob {
+  key: string;
+  // base64 encoded data
+  data: string;
+  mime: string;
+}
+
+export interface ListedBlob {
+  key: string;
+  mime: string;
+  size: number;
+  createdAt: number;
+}
+
+export interface DocClock {
+  docId: string;
+  timestamp: number;
+}
+
+export interface NbStorePlugin {
+  getSpaceDBPath: (options: {
+    peer: string;
+    spaceType: string;
+    id: string;
+  }) => Promise<{ path: string }>;
+  create: (options: { id: string; path: string }) => Promise<void>;
+  connect: (options: { id: string }) => Promise<void>;
+  close: (options: { id: string }) => Promise<void>;
+  isClosed: (options: { id: string }) => Promise<{ isClosed: boolean }>;
+  checkpoint: (options: { id: string }) => Promise<void>;
+  validate: (options: { id: string }) => Promise<{ isValidate: boolean }>;
+
+  setSpaceId: (options: { id: string; spaceId: string }) => Promise<void>;
+  pushUpdate: (options: {
+    id: string;
+    docId: string;
+    data: string;
+  }) => Promise<{ timestamp: number }>;
+  getDocSnapshot: (options: { id: string; docId: string }) => Promise<
+    | {
+        docId: string;
+        // base64 encoded data
+        data: string;
+        timestamp: number;
+      }
+    | undefined
+  >;
+  setDocSnapshot: (options: {
+    id: string;
+    docId: string;
+    data: string;
+  }) => Promise<{ success: boolean }>;
+  getDocUpdates: (options: { id: string; docId: string }) => Promise<
+    {
+      docId: string;
+      createdAt: number;
+      // base64 encoded data
+      data: string;
+    }[]
+  >;
+  markUpdatesMerged: (options: {
+    id: string;
+    docId: string;
+    timestamps: number[];
+  }) => Promise<{ count: number }>;
+  deleteDoc: (options: { id: string; docId: string }) => Promise<void>;
+  getDocClocks: (options: { id: string; after: number }) => Promise<
+    {
+      docId: string;
+      timestamp: number;
+    }[]
+  >;
+  getDocClock: (options: { id: string; docId: string }) => Promise<
+    | {
+        docId: string;
+        timestamp: number;
+      }
+    | undefined
+  >;
+  getBlob: (options: { id: string; key: string }) => Promise<Blob | null>;
+  setBlob: (options: { id: string } & SetBlob) => Promise<void>;
+  deleteBlob: (options: {
+    id: string;
+    key: string;
+    permanently: boolean;
+  }) => Promise<void>;
+  releaseBlobs: (options: { id: string }) => Promise<void>;
+  listBlobs: (options: { id: string }) => Promise<Array<ListedBlob>>;
+  getPeerRemoteClocks: (options: {
+    id: string;
+    peer: string;
+  }) => Promise<Array<DocClock>>;
+  getPeerRemoteClock: (options: {
+    id: string;
+    peer: string;
+    docId: string;
+  }) => Promise<DocClock>;
+  setPeerRemoteClock: (options: {
+    id: string;
+    peer: string;
+    docId: string;
+    clock: number;
+  }) => Promise<void>;
+  getPeerPushedClocks: (options: {
+    id: string;
+    peer: string;
+  }) => Promise<Array<DocClock>>;
+  getPeerPushedClock: (options: {
+    id: string;
+    peer: string;
+    docId: string;
+  }) => Promise<DocClock>;
+  setPeerPushedClock: (options: {
+    id: string;
+    peer: string;
+    docId: string;
+    clock: number;
+  }) => Promise<void>;
+  getPeerPulledRemoteClocks: (options: {
+    id: string;
+    peer: string;
+  }) => Promise<Array<DocClock>>;
+  getPeerPulledRemoteClock: (options: {
+    id: string;
+    peer: string;
+    docId: string;
+  }) => Promise<DocClock>;
+  setPeerPulledRemoteClock: (options: {
+    id: string;
+    peer: string;
+    docId: string;
+    clock: number;
+  }) => Promise<void>;
+  clearClocks: (options: { id: string }) => Promise<void>;
+}

packages/frontend/apps/ios/src/plugins/nbstore/doc.ts

@@ -0,0 +1,83 @@
+import {
+  type DocClocks,
+  type DocRecord,
+  DocStorageBase,
+  type DocUpdate,
+  share,
+} from '@affine/nbstore';
+
+import { NativeDBConnection } from './db';
+
+export class SqliteDocStorage extends DocStorageBase {
+  override connection = share(
+    new NativeDBConnection(this.peer, this.spaceType, this.spaceId)
+  );
+
+  get db() {
+    return this.connection.inner;
+  }
+
+  override async pushDocUpdate(update: DocUpdate) {
+    const timestamp = await this.db.pushUpdate(update.docId, update.bin);
+
+    return { docId: update.docId, timestamp };
+  }
+
+  override async deleteDoc(docId: string) {
+    await this.db.deleteDoc(docId);
+  }
+
+  override async getDocTimestamps(after?: Date) {
+    const clocks = await this.db.getDocClocks(after);
+
+    return clocks.reduce((ret, cur) => {
+      ret[cur.docId] = cur.timestamp;
+      return ret;
+    }, {} as DocClocks);
+  }
+
+  override async getDocTimestamp(docId: string) {
+    return this.db.getDocClock(docId);
+  }
+
+  protected override async getDocSnapshot(docId: string) {
+    const snapshot = await this.db.getDocSnapshot(docId);
+
+    if (!snapshot) {
+      return null;
+    }
+
+    return {
+      docId,
+      bin: snapshot.data,
+      timestamp: snapshot.timestamp,
+    };
+  }
+
+  protected override async setDocSnapshot(
+    snapshot: DocRecord
+  ): Promise<boolean> {
+    return this.db.setDocSnapshot({
+      docId: snapshot.docId,
+      data: Buffer.from(snapshot.bin),
+      timestamp: new Date(snapshot.timestamp),
+    });
+  }
+
+  protected override async getDocUpdates(docId: string) {
+    return this.db.getDocUpdates(docId).then(updates =>
+      updates.map(update => ({
+        docId,
+        bin: update.data,
+        timestamp: update.createdAt,
+      }))
+    );
+  }
+
+  protected override markUpdatesMerged(docId: string, updates: DocRecord[]) {
+    return this.db.markUpdatesMerged(
+      docId,
+      updates.map(update => update.timestamp)
+    );
+  }
+}

packages/frontend/apps/ios/src/plugins/nbstore/handlers.ts

@@ -0,0 +1,128 @@
+import {
+  type BlobRecord,
+  type DocClock,
+  type DocUpdate,
+} from '@affine/nbstore';
+
+import { ensureStorage, getStorage } from './storage';
+
+export const nbstoreHandlers = {
+  connect: async (id: string) => {
+    await ensureStorage(id);
+  },
+
+  close: async (id: string) => {
+    const store = getStorage(id);
+
+    if (store) {
+      store.disconnect();
+      // The store may be shared with other tabs, so we don't delete it from cache
+      // the underlying connection will handle the close correctly
+      // STORE_CACHE.delete(`${spaceType}:${spaceId}`);
+    }
+  },
+
+  pushDocUpdate: async (id: string, update: DocUpdate) => {
+    const store = await ensureStorage(id);
+    return store.get('doc').pushDocUpdate(update);
+  },
+
+  getDoc: async (id: string, docId: string) => {
+    const store = await ensureStorage(id);
+    return store.get('doc').getDoc(docId);
+  },
+
+  deleteDoc: async (id: string, docId: string) => {
+    const store = await ensureStorage(id);
+    return store.get('doc').deleteDoc(docId);
+  },
+
+  getDocTimestamps: async (id: string, after?: Date) => {
+    const store = await ensureStorage(id);
+    return store.get('doc').getDocTimestamps(after);
+  },
+
+  getDocTimestamp: async (id: string, docId: string) => {
+    const store = await ensureStorage(id);
+    return store.get('doc').getDocTimestamp(docId);
+  },
+
+  setBlob: async (id: string, blob: BlobRecord) => {
+    const store = await ensureStorage(id);
+    return store.get('blob').set(blob);
+  },
+
+  getBlob: async (id: string, key: string) => {
+    const store = await ensureStorage(id);
+    return store.get('blob').get(key);
+  },
+
+  deleteBlob: async (id: string, key: string, permanently: boolean) => {
+    const store = await ensureStorage(id);
+    return store.get('blob').delete(key, permanently);
+  },
+
+  listBlobs: async (id: string) => {
+    const store = await ensureStorage(id);
+    return store.get('blob').list();
+  },
+
+  releaseBlobs: async (id: string) => {
+    const store = await ensureStorage(id);
+    return store.get('blob').release();
+  },
+
+  getPeerRemoteClocks: async (id: string, peer: string) => {
+    const store = await ensureStorage(id);
+    return store.get('sync').getPeerRemoteClocks(peer);
+  },
+
+  getPeerRemoteClock: async (id: string, peer: string, docId: string) => {
+    const store = await ensureStorage(id);
+    return store.get('sync').getPeerRemoteClock(peer, docId);
+  },
+
+  setPeerRemoteClock: async (id: string, peer: string, clock: DocClock) => {
+    const store = await ensureStorage(id);
+    return store.get('sync').setPeerRemoteClock(peer, clock);
+  },
+
+  getPeerPulledRemoteClocks: async (id: string, peer: string) => {
+    const store = await ensureStorage(id);
+    return store.get('sync').getPeerPulledRemoteClocks(peer);
+  },
+
+  getPeerPulledRemoteClock: async (id: string, peer: string, docId: string) => {
+    const store = await ensureStorage(id);
+    return store.get('sync').getPeerPulledRemoteClock(peer, docId);
+  },
+
+  setPeerPulledRemoteClock: async (
+    id: string,
+    peer: string,
+    clock: DocClock
+  ) => {
+    const store = await ensureStorage(id);
+    return store.get('sync').setPeerPulledRemoteClock(peer, clock);
+  },
+
+  getPeerPushedClocks: async (id: string, peer: string) => {
+    const store = await ensureStorage(id);
+    return store.get('sync').getPeerPushedClocks(peer);
+  },
+
+  getPeerPushedClock: async (id: string, peer: string, docId: string) => {
+    const store = await ensureStorage(id);
+    return store.get('sync').getPeerPushedClock(peer, docId);
+  },
+
+  setPeerPushedClock: async (id: string, peer: string, clock: DocClock) => {
+    const store = await ensureStorage(id);
+    return store.get('sync').setPeerPushedClock(peer, clock);
+  },
+
+  clearClocks: async (id: string) => {
+    const store = await ensureStorage(id);
+    return store.get('sync').clearClocks();
+  },
+};

packages/frontend/apps/ios/src/plugins/nbstore/index.ts

@@ -0,0 +1,5 @@
+export * from './definitions';
+export { nbstoreHandlers } from './handlers';
+export { NbStoreDocStorage } from './plugin';
+export * from './storage';
+export { universalId } from '@affine/nbstore';

packages/frontend/apps/ios/src/plugins/nbstore/plugin.ts

@@ -0,0 +1,312 @@
+import {
+  base64ToUint8Array,
+  uint8ArrayToBase64,
+} from '@affine/core/modules/workspace-engine';
+import {
+  type Blob,
+  type DocClock,
+  type DocRecord,
+  type DocStorage,
+  type DocUpdate,
+  type ListedBlob,
+} from '@affine/native';
+import { registerPlugin } from '@capacitor/core';
+
+import type { NbStorePlugin } from './definitions';
+
+export const NbStoreDocStorage =
+  registerPlugin<NbStorePlugin>('NbStoreDocStorage');
+
+export interface SetBlob {
+  key: string;
+  data: Uint8Array;
+  mime: string;
+}
+
+export class NativeDocStorage implements DocStorage {
+  constructor(private readonly universalId: string) {}
+
+  /** Initialize the database and run migrations. */
+  connect(): Promise<void> {
+    return NbStoreDocStorage.connect({
+      id: this.universalId,
+    });
+  }
+
+  close(): Promise<void> {
+    return NbStoreDocStorage.close({
+      id: this.universalId,
+    });
+  }
+
+  get isClosed(): Promise<boolean> {
+    return NbStoreDocStorage.isClosed({
+      id: this.universalId,
+    }).then(result => result.isClosed);
+  }
+  /**
+   * Flush the WAL file to the database file.
+   * See https://www.sqlite.org/pragma.html#pragma_wal_checkpoint:~:text=PRAGMA%20schema.wal_checkpoint%3B
+   */
+  checkpoint(): Promise<void> {
+    return NbStoreDocStorage.checkpoint({
+      id: this.universalId,
+    });
+  }
+
+  validate(): Promise<boolean> {
+    return NbStoreDocStorage.validate({
+      id: this.universalId,
+    }).then(result => result.isValidate);
+  }
+
+  setSpaceId(spaceId: string): Promise<void> {
+    return NbStoreDocStorage.setSpaceId({
+      id: this.universalId,
+      spaceId,
+    });
+  }
+
+  async pushUpdate(docId: string, update: Uint8Array): Promise<Date> {
+    return NbStoreDocStorage.pushUpdate({
+      id: this.universalId,
+      docId,
+      data: await uint8ArrayToBase64(update),
+    }).then(result => new Date(result.timestamp));
+  }
+
+  getDocSnapshot(docId: string): Promise<DocRecord | null> {
+    return NbStoreDocStorage.getDocSnapshot({
+      id: this.universalId,
+      docId,
+    }).then(result => {
+      if (result) {
+        return {
+          ...result,
+          data: base64ToUint8Array(result.data),
+          timestamp: new Date(result.timestamp),
+        };
+      }
+      return null;
+    });
+  }
+
+  async setDocSnapshot(snapshot: DocRecord): Promise<boolean> {
+    return NbStoreDocStorage.setDocSnapshot({
+      id: this.universalId,
+      docId: snapshot.docId,
+      data: await uint8ArrayToBase64(snapshot.data),
+    }).then(result => result.success);
+  }
+
+  getDocUpdates(docId: string): Promise<Array<DocUpdate>> {
+    return NbStoreDocStorage.getDocUpdates({
+      id: this.universalId,
+      docId,
+    }).then(result =>
+      result.map(update => ({
+        ...update,
+        data: base64ToUint8Array(update.data),
+        createdAt: new Date(update.createdAt),
+      }))
+    );
+  }
+
+  markUpdatesMerged(docId: string, updates: Array<Date>): Promise<number> {
+    return NbStoreDocStorage.markUpdatesMerged({
+      id: this.universalId,
+      docId,
+      timestamps: updates.map(date => date.getTime()),
+    }).then(result => result.count);
+  }
+
+  deleteDoc(docId: string): Promise<void> {
+    return NbStoreDocStorage.deleteDoc({
+      id: this.universalId,
+      docId,
+    });
+  }
+
+  getDocClocks(after: Date): Promise<Array<DocClock>> {
+    return NbStoreDocStorage.getDocClocks({
+      id: this.universalId,
+      after: after.getTime(),
+    }).then(result =>
+      result.map(clock => ({
+        ...clock,
+        timestamp: new Date(clock.timestamp),
+      }))
+    );
+  }
+
+  getDocClock(docId: string): Promise<DocClock | null> {
+    return NbStoreDocStorage.getDocClock({
+      id: this.universalId,
+      docId,
+    }).then(result => {
+      if (result) {
+        return {
+          ...result,
+          timestamp: new Date(result.timestamp),
+        };
+      }
+      return null;
+    });
+  }
+
+  getBlob(key: string): Promise<Blob | null> {
+    return NbStoreDocStorage.getBlob({
+      id: this.universalId,
+      key,
+    }).then(result => {
+      if (result) {
+        return {
+          ...result,
+          data: base64ToUint8Array(result.data),
+          createdAt: new Date(result.createdAt),
+        };
+      }
+      return null;
+    });
+  }
+
+  async setBlob(blob: SetBlob): Promise<void> {
+    return NbStoreDocStorage.setBlob({
+      id: this.universalId,
+      key: blob.key,
+      data: await uint8ArrayToBase64(blob.data),
+      mime: blob.mime,
+    });
+  }
+
+  deleteBlob(key: string, permanently: boolean): Promise<void> {
+    return NbStoreDocStorage.deleteBlob({
+      id: this.universalId,
+      key,
+      permanently,
+    });
+  }
+
+  releaseBlobs(): Promise<void> {
+    return NbStoreDocStorage.releaseBlobs({
+      id: this.universalId,
+    });
+  }
+
+  async listBlobs(): Promise<Array<ListedBlob>> {
+    return (
+      await NbStoreDocStorage.listBlobs({
+        id: this.universalId,
+      })
+    ).map(blob => ({
+      ...blob,
+      createdAt: new Date(blob.createdAt),
+    }));
+  }
+
+  getPeerRemoteClocks(peer: string): Promise<Array<DocClock>> {
+    return NbStoreDocStorage.getPeerRemoteClocks({
+      id: this.universalId,
+      peer,
+    }).then(result =>
+      result.map(clock => ({
+        ...clock,
+        timestamp: new Date(clock.timestamp),
+      }))
+    );
+  }
+
+  getPeerRemoteClock(peer: string, docId: string): Promise<DocClock> {
+    return NbStoreDocStorage.getPeerRemoteClock({
+      id: this.universalId,
+      peer,
+      docId,
+    }).then(result => ({
+      ...result,
+      timestamp: new Date(result.timestamp),
+    }));
+  }
+
+  setPeerRemoteClock(peer: string, docId: string, clock: Date): Promise<void> {
+    return NbStoreDocStorage.setPeerRemoteClock({
+      id: this.universalId,
+      peer,
+      docId,
+      clock: clock.getTime(),
+    });
+  }
+
+  getPeerPulledRemoteClocks(peer: string): Promise<Array<DocClock>> {
+    return NbStoreDocStorage.getPeerPulledRemoteClocks({
+      id: this.universalId,
+      peer,
+    }).then(result =>
+      result.map(clock => ({
+        ...clock,
+        timestamp: new Date(clock.timestamp),
+      }))
+    );
+  }
+
+  getPeerPulledRemoteClock(peer: string, docId: string): Promise<DocClock> {
+    return NbStoreDocStorage.getPeerPulledRemoteClock({
+      id: this.universalId,
+      peer,
+      docId,
+    }).then(result => ({
+      ...result,
+      timestamp: new Date(result.timestamp),
+    }));
+  }
+
+  setPeerPulledRemoteClock(
+    peer: string,
+    docId: string,
+    clock: Date
+  ): Promise<void> {
+    return NbStoreDocStorage.setPeerPulledRemoteClock({
+      id: this.universalId,
+      peer,
+      docId,
+      clock: clock.getTime(),
+    });
+  }
+
+  getPeerPushedClocks(peer: string): Promise<Array<DocClock>> {
+    return NbStoreDocStorage.getPeerPushedClocks({
+      id: this.universalId,
+      peer,
+    }).then(result =>
+      result.map(clock => ({
+        ...clock,
+        timestamp: new Date(clock.timestamp),
+      }))
+    );
+  }
+
+  getPeerPushedClock(peer: string, docId: string): Promise<DocClock> {
+    return NbStoreDocStorage.getPeerPushedClock({
+      id: this.universalId,
+      peer,
+      docId,
+    }).then(result => ({
+      ...result,
+      timestamp: new Date(result.timestamp),
+    }));
+  }
+
+  setPeerPushedClock(peer: string, docId: string, clock: Date): Promise<void> {
+    return NbStoreDocStorage.setPeerPushedClock({
+      id: this.universalId,
+      peer,
+      docId,
+      clock: clock.getTime(),
+    });
+  }
+
+  clearClocks(): Promise<void> {
+    return NbStoreDocStorage.clearClocks({
+      id: this.universalId,
+    });
+  }
+}

packages/frontend/apps/ios/src/plugins/nbstore/storage.ts

@@ -0,0 +1,83 @@
+import { parseUniversalId, SpaceStorage } from '@affine/nbstore';
+import { applyUpdate, Doc as YDoc } from 'yjs';
+
+import { SqliteBlobStorage } from './blob';
+import { NativeDBConnection } from './db';
+import { SqliteDocStorage } from './doc';
+import { SqliteSyncStorage } from './sync';
+
+export class SqliteSpaceStorage extends SpaceStorage {
+  get connection() {
+    const docStore = this.get('doc');
+
+    if (!docStore) {
+      throw new Error('doc store not found');
+    }
+
+    const connection = docStore.connection;
+
+    if (!(connection instanceof NativeDBConnection)) {
+      throw new Error('doc store connection is not a Sqlite connection');
+    }
+
+    return connection;
+  }
+
+  async getDBPath() {
+    return this.connection.getDBPath();
+  }
+
+  async getWorkspaceName() {
+    const docStore = this.tryGet('doc');
+
+    if (!docStore) {
+      return null;
+    }
+
+    const doc = await docStore.getDoc(docStore.spaceId);
+    if (!doc) {
+      return null;
+    }
+
+    const ydoc = new YDoc();
+    applyUpdate(ydoc, doc.bin);
+    return ydoc.getMap('meta').get('name') as string;
+  }
+
+  async checkpoint() {
+    await this.connection.inner.checkpoint();
+  }
+}
+
+const STORE_CACHE = new Map<string, SqliteSpaceStorage>();
+
+export function getStorage(universalId: string) {
+  return STORE_CACHE.get(universalId);
+}
+
+export async function ensureStorage(universalId: string) {
+  const { peer, type, id } = parseUniversalId(universalId);
+  let store = STORE_CACHE.get(universalId);
+
+  if (!store) {
+    const opts = {
+      peer,
+      type,
+      id,
+    };
+
+    store = new SqliteSpaceStorage([
+      new SqliteDocStorage(opts),
+      new SqliteBlobStorage(opts),
+      new SqliteSyncStorage(opts),
+    ]);
+
+    store.connect();
+
+    await store.waitForConnected();
+
+    STORE_CACHE.set(universalId, store);
+  }
+
+  return store;
+}

packages/frontend/apps/ios/src/plugins/nbstore/sync.ts

@@ -0,0 +1,70 @@
+import {
+  BasicSyncStorage,
+  type DocClock,
+  type DocClocks,
+  share,
+} from '@affine/nbstore';
+
+import { NativeDBConnection } from './db';
+
+export class SqliteSyncStorage extends BasicSyncStorage {
+  override connection = share(
+    new NativeDBConnection(this.peer, this.spaceType, this.spaceId)
+  );
+
+  get db() {
+    return this.connection.inner;
+  }
+
+  override async getPeerRemoteClocks(peer: string) {
+    const records = await this.db.getPeerRemoteClocks(peer);
+    return records.reduce((clocks, { docId, timestamp }) => {
+      clocks[docId] = timestamp;
+      return clocks;
+    }, {} as DocClocks);
+  }
+
+  override async getPeerRemoteClock(peer: string, docId: string) {
+    return this.db.getPeerRemoteClock(peer, docId);
+  }
+
+  override async setPeerRemoteClock(peer: string, clock: DocClock) {
+    await this.db.setPeerRemoteClock(peer, clock.docId, clock.timestamp);
+  }
+
+  override async getPeerPulledRemoteClock(peer: string, docId: string) {
+    return this.db.getPeerPulledRemoteClock(peer, docId);
+  }
+
+  override async getPeerPulledRemoteClocks(peer: string) {
+    const records = await this.db.getPeerPulledRemoteClocks(peer);
+    return records.reduce((clocks, { docId, timestamp }) => {
+      clocks[docId] = timestamp;
+      return clocks;
+    }, {} as DocClocks);
+  }
+
+  override async setPeerPulledRemoteClock(peer: string, clock: DocClock) {
+    await this.db.setPeerPulledRemoteClock(peer, clock.docId, clock.timestamp);
+  }
+
+  override async getPeerPushedClocks(peer: string) {
+    const records = await this.db.getPeerPushedClocks(peer);
+    return records.reduce((clocks, { docId, timestamp }) => {
+      clocks[docId] = timestamp;
+      return clocks;
+    }, {} as DocClocks);
+  }
+
+  override async getPeerPushedClock(peer: string, docId: string) {
+    return this.db.getPeerPushedClock(peer, docId);
+  }
+
+  override async setPeerPushedClock(peer: string, clock: DocClock) {
+    await this.db.setPeerPushedClock(peer, clock.docId, clock.timestamp);
+  }
+
+  override async clearClocks() {
+    await this.db.clearClocks();
+  }
+}