@syncular/server 0.0.6-96 → 0.1.1

package/src/relay/client-role/pull-engine.ts

@@ -0,0 +1,329 @@
+/**
+ * @syncular/server/relay - Pull Engine
+ *
+ * Pulls changes from the main server and stores them locally
+ * on the relay for local clients to access.
+ */
+
+import type {
+  ScopeValues,
+  SyncCommit,
+  SyncPullResponse,
+  SyncSubscriptionRequest,
+  SyncTransport,
+} from '@syncular/core';
+import type {
+  ServerHandlerCollection,
+  ServerSyncDialect,
+  SyncServerAuth,
+} from '@syncular/server';
+import { pushCommit } from '@syncular/server';
+import { type Kysely, sql } from 'kysely';
+import type { RelayRealtime } from '../realtime';
+import type { RelayDatabase } from '../schema';
+import type { SequenceMapper } from './sequence-mapper';
+
+type RelayAuth = SyncServerAuth;
+
+/**
+ * Pull engine options.
+ */
+export interface PullEngineOptions<DB extends RelayDatabase = RelayDatabase> {
+  db: Kysely<DB>;
+  dialect: ServerSyncDialect;
+  transport: SyncTransport;
+  clientId: string;
+  /** Tables to subscribe to */
+  tables: string[];
+  /** Scope values for subscriptions */
+  scopes: ScopeValues;
+  handlers: ServerHandlerCollection<DB, RelayAuth>;
+  sequenceMapper: SequenceMapper<DB>;
+  realtime: RelayRealtime;
+  intervalMs?: number;
+  onError?: (error: Error) => void;
+  onPullComplete?: () => Promise<void>;
+}
+
+/**
+ * Pull engine for receiving changes from the main server.
+ */
+export class PullEngine<DB extends RelayDatabase = RelayDatabase> {
+  private readonly db: Kysely<DB>;
+  private readonly dialect: ServerSyncDialect;
+  private readonly transport: SyncTransport;
+  private readonly clientId: string;
+  private readonly tables: string[];
+  private readonly scopes: ScopeValues;
+  private readonly handlers: ServerHandlerCollection<DB, RelayAuth>;
+  private readonly sequenceMapper: SequenceMapper<DB>;
+  private readonly realtime: RelayRealtime;
+  private readonly intervalMs: number;
+  private readonly onError?: (error: Error) => void;
+  private readonly onPullComplete?: () => Promise<void>;
+
+  private running = false;
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private cursors = new Map<string, number>();
+
+  constructor(options: PullEngineOptions<DB>) {
+    this.db = options.db;
+    this.dialect = options.dialect;
+    this.transport = options.transport;
+    this.clientId = options.clientId;
+    this.tables = options.tables;
+    this.scopes = options.scopes;
+    this.handlers = options.handlers;
+    this.sequenceMapper = options.sequenceMapper;
+    this.realtime = options.realtime;
+    this.intervalMs = options.intervalMs ?? 10000;
+    this.onError = options.onError;
+    this.onPullComplete = options.onPullComplete;
+  }
+
+  /**
+   * Start the pull engine loop.
+   */
+  start(): void {
+    if (this.running) return;
+    this.running = true;
+    void this.loadCursors()
+      .catch((error) => {
+        this.onError?.(
+          error instanceof Error ? error : new Error(String(error))
+        );
+      })
+      .finally(() => {
+        if (this.running) {
+          this.scheduleNext(0);
+        }
+      });
+  }
+
+  /**
+   * Stop the pull engine.
+   */
+  stop(): void {
+    this.running = false;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+
+  /**
+   * Pull once (for manual/testing use).
+   */
+  async pullOnce(): Promise<boolean> {
+    return this.processOne();
+  }
+
+  private async loadCursors(): Promise<void> {
+    try {
+      // Load cursors from config
+      const rowResult = await sql<{ value_json: string }>`
+        select value_json
+        from ${sql.table('relay_config')}
+        where key = 'main_cursors'
+        limit 1
+      `.execute(this.db);
+      const row = rowResult.rows[0];
+
+      if (row?.value_json) {
+        const parsed = JSON.parse(row.value_json);
+        if (typeof parsed === 'object' && parsed !== null) {
+          for (const [key, value] of Object.entries(parsed)) {
+            if (typeof value === 'number') {
+              this.cursors.set(key, value);
+            }
+          }
+        }
+      }
+    } catch {
+      // Ignore - start from scratch
+    }
+  }
+
+  private async saveCursors(): Promise<void> {
+    const cursorObj: Record<string, number> = {};
+    for (const [key, value] of this.cursors) {
+      cursorObj[key] = value;
+    }
+
+    const valueJson = JSON.stringify(cursorObj);
+    await sql`
+      insert into ${sql.table('relay_config')} (key, value_json)
+      values ('main_cursors', ${valueJson})
+      on conflict (key)
+      do update set value_json = ${valueJson}
+    `.execute(this.db);
+  }
+
+  private scheduleNext(delayMs: number): void {
+    if (!this.running) return;
+    if (this.timer) return;
+
+    this.timer = setTimeout(async () => {
+      this.timer = null;
+
+      try {
+        const pulled = await this.processOne();
+        // If we pulled something, immediately try again
+        const nextDelay = pulled ? 0 : this.intervalMs;
+        this.scheduleNext(nextDelay);
+      } catch (err) {
+        this.onError?.(err instanceof Error ? err : new Error(String(err)));
+        this.scheduleNext(this.intervalMs);
+      }
+    }, delayMs);
+  }
+
+  private async processOne(): Promise<boolean> {
+    // Build subscriptions for each table
+    const subscriptionRequests: SyncSubscriptionRequest[] = this.tables.map(
+      (table) => ({
+        id: table,
+        table,
+        scopes: this.scopes,
+        cursor: this.cursors.get(table) ?? -1,
+        crdtStateVectors: [],
+      })
+    );
+
+    let response: SyncPullResponse;
+    try {
+      const combined = await this.transport.sync({
+        clientId: this.clientId,
+        pull: {
+          schemaVersion: 1,
+          subscriptions: subscriptionRequests,
+          limitCommits: 100,
+        },
+      });
+      if (!combined.pull) {
+        return false;
+      }
+      response = combined.pull;
+    } catch {
+      // Network error - will retry
+      return false;
+    }
+
+    if (!response.ok) {
+      return false;
+    }
+
+    let hasChanges = false;
+    const affectedTables = new Set<string>();
+
+    for (const sub of response.subscriptions) {
+      if (sub.status !== 'active') continue;
+
+      const table = sub.id;
+
+      // Process commits
+      let canAdvanceCursor = true;
+      for (const commit of sub.commits) {
+        const outcome = await this.applyCommitLocally(commit, table);
+        if (outcome === 'applied') {
+          hasChanges = true;
+          affectedTables.add(table);
+        }
+        if (outcome === 'rejected') {
+          canAdvanceCursor = false;
+          break;
+        }
+      }
+
+      // Update cursor
+      if (
+        canAdvanceCursor &&
+        sub.nextCursor > (this.cursors.get(table) ?? -1)
+      ) {
+        this.cursors.set(table, sub.nextCursor);
+      }
+    }
+
+    // Save updated cursors
+    await this.saveCursors();
+
+    // Notify local clients if we have changes
+    if (hasChanges && affectedTables.size > 0) {
+      const maxCursor = await this.dialect.readMaxCommitSeq(this.db);
+      this.realtime.notifyScopeKeys(Array.from(affectedTables), maxCursor);
+    }
+
+    // Trigger rate-limited prune after successful pull
+    await this.onPullComplete?.();
+
+    return hasChanges;
+  }
+
+  /**
+   * Apply a commit from main server locally.
+   *
+   * This re-applies the commit through the local table handlers
+   * to ensure proper indexing and scope assignment.
+   */
+  private async applyCommitLocally(
+    commit: SyncCommit,
+    table: string
+  ): Promise<'applied' | 'cached' | 'rejected'> {
+    if (commit.changes.length === 0) return 'cached';
+
+    // Convert changes to operations
+    const operations = commit.changes.map((change) => ({
+      table: change.table,
+      row_id: change.row_id,
+      op: change.op,
+      payload: change.row_json as Record<string, unknown> | null,
+    }));
+
+    // Generate a unique commit ID for this relay instance
+    const relayCommitId = `main:${commit.commitSeq}:${table}`;
+
+    // Push through local handler
+    const result = await pushCommit({
+      db: this.db,
+      dialect: this.dialect,
+      handlers: this.handlers,
+      auth: { actorId: commit.actorId },
+      request: {
+        clientId: `relay:${this.clientId}`,
+        clientCommitId: relayCommitId,
+        operations,
+        schemaVersion: 1,
+      },
+    });
+
+    if (
+      result.response.ok === true &&
+      result.response.status === 'applied' &&
+      typeof result.response.commitSeq === 'number'
+    ) {
+      // Record sequence mapping
+      await this.sequenceMapper.createConfirmedMapping(
+        result.response.commitSeq,
+        commit.commitSeq
+      );
+      return 'applied';
+    }
+
+    // Already applied (cached) - that's fine
+    if (result.response.status === 'cached') {
+      return 'cached';
+    }
+
+    // Rejected - this shouldn't happen for pulls from main
+    // Do not advance cursor; signal error so caller can react.
+    const error = new Error(
+      `Relay: Failed to apply commit ${commit.commitSeq} locally (status=${result.response.status})`
+    );
+    console.warn(
+      `Relay: Failed to apply commit ${commit.commitSeq} locally:`,
+      result.response
+    );
+    this.onError?.(error);
+    return 'rejected';
+  }
+}

package/src/relay/client-role/sequence-mapper.ts

@@ -0,0 +1,201 @@
+/**
+ * @syncular/server/relay - Sequence Mapper
+ *
+ * Tracks the mapping between relay's local commit_seq
+ * and the main server's global commit_seq.
+ */
+
+import { type Kysely, sql } from 'kysely';
+import type { RelayDatabase, RelaySequenceMapStatus } from '../schema';
+
+/**
+ * Sequence mapping entry.
+ */
+export interface SequenceMapping {
+  localCommitSeq: number;
+  mainCommitSeq: number | null;
+  status: RelaySequenceMapStatus;
+}
+
+/**
+ * Sequence mapper for tracking local to main commit sequence mappings.
+ */
+export class SequenceMapper<DB extends RelayDatabase = RelayDatabase> {
+  private readonly db: Kysely<DB>;
+
+  constructor(options: { db: Kysely<DB> }) {
+    this.db = options.db;
+  }
+
+  /**
+   * Create a pending mapping for a local commit that will be forwarded.
+   */
+  async createPendingMapping(localCommitSeq: number): Promise<void> {
+    const now = Date.now();
+    await sql`
+      insert into ${sql.table('relay_sequence_map')} (
+        local_commit_seq,
+        main_commit_seq,
+        status,
+        created_at,
+        updated_at
+      )
+      values (${localCommitSeq}, ${null}, 'pending', ${now}, ${now})
+      on conflict (local_commit_seq) do nothing
+    `.execute(this.db);
+  }
+
+  /**
+   * Mark a mapping as forwarded with the main server's commit_seq.
+   */
+  async markForwarded(
+    localCommitSeq: number,
+    mainCommitSeq: number
+  ): Promise<void> {
+    const now = Date.now();
+    await sql`
+      update ${sql.table('relay_sequence_map')}
+      set
+        main_commit_seq = ${mainCommitSeq},
+        status = 'forwarded',
+        updated_at = ${now}
+      where local_commit_seq = ${localCommitSeq}
+    `.execute(this.db);
+  }
+
+  /**
+   * Mark a mapping as confirmed (main server acknowledged).
+   */
+  async markConfirmed(localCommitSeq: number): Promise<void> {
+    const now = Date.now();
+    await sql`
+      update ${sql.table('relay_sequence_map')}
+      set status = 'confirmed', updated_at = ${now}
+      where local_commit_seq = ${localCommitSeq}
+    `.execute(this.db);
+  }
+
+  /**
+   * Get the mapping for a local commit sequence.
+   */
+  async getMapping(localCommitSeq: number): Promise<SequenceMapping | null> {
+    const rowResult = await sql<{
+      local_commit_seq: number;
+      main_commit_seq: number | null;
+      status: RelaySequenceMapStatus;
+    }>`
+      select local_commit_seq, main_commit_seq, status
+      from ${sql.table('relay_sequence_map')}
+      where local_commit_seq = ${localCommitSeq}
+      limit 1
+    `.execute(this.db);
+    const row = rowResult.rows[0];
+
+    if (!row) return null;
+
+    return {
+      localCommitSeq: row.local_commit_seq,
+      mainCommitSeq: row.main_commit_seq,
+      status: row.status,
+    };
+  }
+
+  /**
+   * Get the local commit sequence for a main server commit sequence.
+   */
+  async getLocalCommitSeq(mainCommitSeq: number): Promise<number | null> {
+    const rowResult = await sql<{ local_commit_seq: number }>`
+      select local_commit_seq
+      from ${sql.table('relay_sequence_map')}
+      where main_commit_seq = ${mainCommitSeq}
+      limit 1
+    `.execute(this.db);
+
+    return rowResult.rows[0]?.local_commit_seq ?? null;
+  }
+
+  /**
+   * Get all pending mappings (commits not yet forwarded).
+   */
+  async getPendingMappings(): Promise<SequenceMapping[]> {
+    const rowsResult = await sql<{
+      local_commit_seq: number;
+      main_commit_seq: number | null;
+      status: RelaySequenceMapStatus;
+    }>`
+      select local_commit_seq, main_commit_seq, status
+      from ${sql.table('relay_sequence_map')}
+      where status = 'pending'
+      order by local_commit_seq asc
+    `.execute(this.db);
+    const rows = rowsResult.rows;
+
+    return rows.map((row) => ({
+      localCommitSeq: row.local_commit_seq,
+      mainCommitSeq: row.main_commit_seq,
+      status: row.status,
+    }));
+  }
+
+  /**
+   * Create a mapping for commits pulled from main (assigned new local commit_seq).
+   *
+   * These mappings go directly to 'confirmed' status since they came from main.
+   */
+  async createConfirmedMapping(
+    localCommitSeq: number,
+    mainCommitSeq: number
+  ): Promise<void> {
+    const now = Date.now();
+    await sql`
+      insert into ${sql.table('relay_sequence_map')} (
+        local_commit_seq,
+        main_commit_seq,
+        status,
+        created_at,
+        updated_at
+      )
+      values (
+        ${localCommitSeq},
+        ${mainCommitSeq},
+        'confirmed',
+        ${now},
+        ${now}
+      )
+      on conflict (local_commit_seq)
+      do update set
+        main_commit_seq = ${mainCommitSeq},
+        status = 'confirmed',
+        updated_at = ${now}
+    `.execute(this.db);
+  }
+
+  /**
+   * Delete confirmed/forwarded sequence mappings older than the given age.
+   * Keeps pending mappings (they haven't been forwarded yet).
+   */
+  async pruneOldMappings(maxAgeMs: number): Promise<number> {
+    const threshold = Date.now() - maxAgeMs;
+    const result = await sql`
+      delete from ${sql.table('relay_sequence_map')}
+      where status in ('confirmed', 'forwarded')
+      and updated_at < ${threshold}
+    `.execute(this.db);
+
+    return Number(result.numAffectedRows ?? 0);
+  }
+
+  /**
+   * Get the highest main_commit_seq we've seen (for tracking pull cursor).
+   */
+  async getHighestMainCommitSeq(): Promise<number> {
+    const rowResult = await sql<{ max_seq: number | null }>`
+      select max(main_commit_seq) as max_seq
+      from ${sql.table('relay_sequence_map')}
+      where main_commit_seq is not null
+      limit 1
+    `.execute(this.db);
+
+    return rowResult.rows[0]?.max_seq ?? 0;
+  }
+}