@trestleinc/replicate 1.1.0 → 1.1.2-preview.0

package/src/client/persistence/sqlite.ts

@@ -1,161 +0,0 @@
-/**
- * Universal SQLite persistence using a user-provided adapter.
- *
- * The consuming app is responsible for:
- * 1. Installing the SQLite package (sql.js, op-sqlite, etc.)
- * 2. Creating and initializing the database
- * 3. Wrapping it with the appropriate adapter
- * 4. Passing the adapter to sqlitePersistence()
- *
- * @example Browser (sql.js)
- * ```typescript
- * import initSqlJs from 'sql.js';
- * import { sqlitePersistence, SqlJsAdapter } from '@trestleinc/replicate/client';
- *
- * const SQL = await initSqlJs({ locateFile: file => `/sql-wasm/${file}` });
- * const db = new SQL.Database();
- * const adapter = new SqlJsAdapter(db, {
- *   onPersist: async (data) => {
- *     // Persist to OPFS, localStorage, etc.
- *   }
- * });
- * const persistence = await sqlitePersistence({ adapter });
- * ```
- *
- * @example React Native (op-sqlite)
- * ```typescript
- * import { open } from '@op-engineering/op-sqlite';
- * import { sqlitePersistence, OPSqliteAdapter } from '@trestleinc/replicate/client';
- *
- * const db = open({ name: 'myapp.db' });
- * const adapter = new OPSqliteAdapter(db);
- * const persistence = await sqlitePersistence({ adapter });
- * ```
- */
-import type * as Y from 'yjs';
-import { LeveldbPersistence } from 'y-leveldb';
-import { SqliteLevel, type SqliteAdapter } from './sqlite-level.js';
-import type { Persistence, PersistenceProvider, KeyValueStore } from './types.js';
-
-/**
- * SQLite-backed key-value store using sqlite-level.
- */
-class SqliteKeyValueStore implements KeyValueStore {
-  private db: SqliteLevel<string, string>;
-  private prefix = 'kv:';
-
-  constructor(db: SqliteLevel<string, string>) {
-    this.db = db;
-  }
-
-  async get<T>(key: string): Promise<T | undefined> {
-    try {
-      const value = await this.db.get(this.prefix + key);
-      if (value === undefined) {
-        return undefined;
-      }
-      return JSON.parse(value) as T;
-    } catch {
-      return undefined;
-    }
-  }
-
-  async set<T>(key: string, value: T): Promise<void> {
-    await this.db.put(this.prefix + key, JSON.stringify(value));
-  }
-
-  async del(key: string): Promise<void> {
-    await this.db.del(this.prefix + key);
-  }
-}
-
-/**
- * SQLite persistence provider using y-leveldb.
- */
-class SqlitePersistenceProvider implements PersistenceProvider {
-  private persistence: LeveldbPersistence;
-  readonly whenSynced: Promise<void>;
-
-  constructor(collection: string, _ydoc: Y.Doc, leveldb: LeveldbPersistence) {
-    this.persistence = leveldb;
-    // Load existing document state
-    this.whenSynced = this.persistence.getYDoc(collection).then((storedDoc: Y.Doc) => {
-      // Apply stored state to provided ydoc
-      const state = storedDoc.store;
-      if (state) {
-        // The stored doc and ydoc are merged via y-leveldb's internal mechanisms
-      }
-    });
-  }
-
-  destroy(): void {
-    this.persistence.destroy();
-  }
-}
-
-/**
- * Options for SQLite persistence.
- */
-export interface SqlitePersistenceOptions {
-  /**
-   * Pre-created SQLite adapter (required).
-   * Use SqlJsAdapter for browser or OPSqliteAdapter for React Native.
-   */
-  adapter: SqliteAdapter;
-
-  /**
-   * Database name for internal y-leveldb usage.
-   * @default 'replicate'
-   */
-  dbName?: string;
-}
-
-/**
- * Create a universal SQLite persistence factory.
- *
- * Requires a pre-created SqliteAdapter - the replicate package does not
- * import any SQLite packages directly, making it environment-agnostic.
- *
- * @param options - Configuration with required adapter
- *
- * @example Browser (sql.js)
- * ```typescript
- * import initSqlJs from 'sql.js';
- * import { sqlitePersistence, SqlJsAdapter } from '@trestleinc/replicate/client';
- *
- * const SQL = await initSqlJs();
- * const db = new SQL.Database();
- * const adapter = new SqlJsAdapter(db);
- * const persistence = await sqlitePersistence({ adapter });
- * ```
- *
- * @example React Native (op-sqlite)
- * ```typescript
- * import { open } from '@op-engineering/op-sqlite';
- * import { sqlitePersistence, OPSqliteAdapter } from '@trestleinc/replicate/client';
- *
- * const db = open({ name: 'myapp.db' });
- * const adapter = new OPSqliteAdapter(db);
- * const persistence = await sqlitePersistence({ adapter });
- * ```
- */
-export async function sqlitePersistence(options: SqlitePersistenceOptions): Promise<Persistence> {
-  const { adapter, dbName = 'replicate' } = options;
-
-  // Create sqlite-level database with the provided adapter
-  const db = new SqliteLevel<string, string>(dbName);
-  db.setAdapterFactory(() => Promise.resolve(adapter));
-  await db.open();
-
-  // Create y-leveldb persistence (reuses the sqlite-level database)
-  const leveldb = new LeveldbPersistence(dbName, { level: db as any });
-
-  // Create key-value store
-  const kv = new SqliteKeyValueStore(db);
-
-  return {
-    createDocPersistence: (collection: string, ydoc: Y.Doc) =>
-      new SqlitePersistenceProvider(collection, ydoc, leveldb),
-    kv,
-  };
-}

package/src/client/services/checkpoint.ts

@@ -1,86 +0,0 @@
-import { Effect, Context, Layer } from 'effect';
-import { IDBError, IDBWriteError } from '$/client/errors.js';
-import type { KeyValueStore } from '$/client/persistence/types.js';
-
-export interface CheckpointData {
-  lastModified: number;
-}
-
-export class Checkpoint extends Context.Tag('Checkpoint')<
-  Checkpoint,
-  {
-    readonly loadCheckpoint: (collection: string) => Effect.Effect<CheckpointData, IDBError>;
-    readonly saveCheckpoint: (
-      collection: string,
-      checkpoint: CheckpointData
-    ) => Effect.Effect<void, IDBWriteError>;
-    readonly clearCheckpoint: (collection: string) => Effect.Effect<void, IDBError>;
-  }
->() {}
-
-/**
- * Create a Checkpoint service layer using the provided KeyValueStore.
- */
-export function createCheckpointLayer(kv: KeyValueStore) {
-  return Layer.succeed(
-    Checkpoint,
-    Checkpoint.of({
-      loadCheckpoint: (collection) =>
-        Effect.gen(function* (_) {
-          const key = `checkpoint:${collection}`;
-          const stored = yield* _(
-            Effect.tryPromise({
-              try: () => kv.get<CheckpointData>(key),
-              catch: (cause) => new IDBError({ operation: 'get', key, cause }),
-            })
-          );
-
-          if (stored) {
-            yield* _(
-              Effect.logDebug('Loaded checkpoint from storage', {
-                collection,
-                checkpoint: stored,
-              })
-            );
-            return stored;
-          }
-
-          yield* _(
-            Effect.logDebug('No stored checkpoint, using default', {
-              collection,
-            })
-          );
-          return { lastModified: 0 };
-        }),
-
-      saveCheckpoint: (collection, checkpoint) =>
-        Effect.gen(function* (_) {
-          const key = `checkpoint:${collection}`;
-          yield* _(
-            Effect.tryPromise({
-              try: () => kv.set(key, checkpoint),
-              catch: (cause) => new IDBWriteError({ key, value: checkpoint, cause }),
-            })
-          );
-          yield* _(
-            Effect.logDebug('Checkpoint saved', {
-              collection,
-              checkpoint,
-            })
-          );
-        }),
-
-      clearCheckpoint: (collection) =>
-        Effect.gen(function* (_) {
-          const key = `checkpoint:${collection}`;
-          yield* _(
-            Effect.tryPromise({
-              try: () => kv.del(key),
-              catch: (cause) => new IDBError({ operation: 'delete', key, cause }),
-            })
-          );
-          yield* _(Effect.logDebug('Checkpoint cleared', { collection }));
-        }),
-    })
-  );
-}

package/src/client/services/reconciliation.ts

@@ -1,108 +0,0 @@
-import { Effect, Context, Layer } from 'effect';
-import * as Y from 'yjs';
-import { yjsTransact, serializeYMap } from '$/client/merge.js';
-import { ReconciliationError as ReconciliationErrorImport } from '$/client/errors.js';
-
-/**
- * Reconciliation handles removal of phantom documents -
- * documents that exist locally but have been deleted on the server.
- */
-export class Reconciliation extends Context.Tag('Reconciliation')<
-  Reconciliation,
-  {
-    /**
-     * Reconciles local Yjs state with server state by removing phantom documents.
-     * Uses an existing Yjs document and map instead of creating new ones.
-     *
-     * @param ydoc - Existing Yjs document
-     * @param ymap - Existing Yjs map within the document
-     * @param collection - Collection name for logging
-     * @param serverDocs - Documents from server
-     * @param getKey - Function to extract key from document
-     */
-    readonly reconcile: <T>(
-      ydoc: Y.Doc,
-      ymap: Y.Map<unknown>,
-      collection: string,
-      serverDocs: readonly T[],
-      getKey: (doc: T) => string
-    ) => Effect.Effect<T[], ReconciliationErrorImport>;
-  }
->() {}
-
-export const ReconciliationLive = Layer.succeed(
-  Reconciliation,
-  Reconciliation.of({
-    reconcile: <T>(
-      ydoc: Y.Doc,
-      ymap: Y.Map<unknown>,
-      collection: string,
-      serverDocs: readonly T[],
-      getKey: (doc: T) => string
-    ) =>
-      Effect.gen(function* (_) {
-        const serverDocIds = new Set(serverDocs.map(getKey));
-        const toDelete: string[] = [];
-
-        // Find phantom documents (exist locally but not on server)
-        ymap.forEach((_, key) => {
-          if (!serverDocIds.has(key)) {
-            toDelete.push(key);
-          }
-        });
-
-        if (toDelete.length === 0) {
-          yield* _(Effect.logDebug('No phantom documents found', { collection }));
-          return [];
-        }
-
-        yield* _(
-          Effect.logWarning(`Found ${toDelete.length} phantom documents`, {
-            collection,
-            phantomDocs: toDelete.slice(0, 10), // Log first 10
-          })
-        );
-
-        // Extract items before deletion for TanStack DB sync
-        // Use serializeYMap for consistent ProseMirror JSON (not XML string from toJSON)
-        const removedItems: T[] = [];
-        for (const key of toDelete) {
-          const itemYMap = ymap.get(key);
-          if (itemYMap instanceof Y.Map) {
-            removedItems.push(serializeYMap(itemYMap) as T);
-          }
-        }
-
-        // Remove from Yjs using plain function
-        yjsTransact(
-          ydoc,
-          () => {
-            for (const key of toDelete) {
-              ymap.delete(key);
-            }
-          },
-          'reconciliation'
-        );
-
-        yield* _(
-          Effect.logInfo('Reconciliation completed', {
-            collection,
-            deletedCount: removedItems.length,
-          })
-        );
-
-        // Return removed items for TanStack DB sync
-        return removedItems;
-      }).pipe(
-        Effect.catchAll((cause) =>
-          Effect.fail(
-            new ReconciliationErrorImport({
-              collection,
-              reason: 'Reconciliation failed',
-              cause,
-            })
-          )
-        )
-      ),
-  })
-);