@spooky-sync/core 0.0.1-canary.33 → 0.0.1-canary.331

package/src/modules/cache/index.ts

@@ -1,241 +0,0 @@
-import { LocalDatabaseService } from '../../services/database/index';
-import {
-  StreamProcessorService,
-  StreamUpdate,
-  StreamUpdateReceiver,
-} from '../../services/stream-processor/index';
-import { Logger } from '../../services/logger/index';
-import { parseRecordIdString, encodeRecordId, surql } from '../../utils/index';
-import { CacheRecord, QueryConfig } from './types';
-import { RecordVersionArray } from '../../types';
-
-export * from './types';
-
-/**
- * CacheModule - Centralized storage and DBSP ingestion
- *
- * Single responsibility: Handle all local storage operations and DBSP ingestion.
- * This module acts as the bridge between data operations and persistence.
- */
-export class CacheModule implements StreamUpdateReceiver {
-  private logger: Logger;
-  private streamUpdateCallback: (update: StreamUpdate) => void;
-  private versionLookups: Record<string, number> = {};
-
-  constructor(
-    private local: LocalDatabaseService,
-    private streamProcessor: StreamProcessorService,
-    streamUpdateCallback: (update: StreamUpdate) => void,
-    logger: Logger
-  ) {
-    this.logger = logger.child({ service: 'CacheModule' });
-    this.streamUpdateCallback = streamUpdateCallback;
-    // Register as receiver for DBSP stream updates
-    this.streamProcessor.addReceiver(this);
-  }
-
-  /**
-   * Implements StreamUpdateReceiver interface
-   * Called directly by StreamProcessor when views change
-   */
-  onStreamUpdate(update: StreamUpdate): void {
-    this.logger.debug(
-      {
-        queryHash: update.queryHash,
-        arrayLength: update.localArray?.length,
-        Category: 'sp00ky-client::CacheModule::onStreamUpdate',
-      },
-      'Stream update received'
-    );
-    this.streamUpdateCallback(update);
-  }
-
-  public lookup(recordId: string): number {
-    return this.versionLookups[recordId] ?? 0;
-  }
-
-  /**
-   * Save a single record to local DB and ingest into DBSP
-   * Used by mutations (create/update)
-   */
-  async save(cacheRecord: CacheRecord, skipDbInsert: boolean = false): Promise<void> {
-    return this.saveBatch([cacheRecord], skipDbInsert);
-  }
-
-  /**
-   * Save multiple records in a batch
-   * More efficient than calling save() multiple times
-   * Used by sync operations
-   */
-  async saveBatch(records: CacheRecord[], skipDbInsert: boolean = false): Promise<void> {
-    if (records.length === 0) return;
-
-    this.logger.debug(
-      {
-        count: records.length,
-        Category: 'sp00ky-client::CacheModule::saveBatch',
-      },
-      'Saving record batch'
-    );
-
-    try {
-      const populatedRecords = records.map((record) => {
-        if (!record.version) throw new Error('Record version is required');
-        return {
-          ...record,
-          record: {
-            ...record.record,
-            _00_rv: record.version,
-          },
-        };
-      });
-
-      if (!skipDbInsert) {
-        const query = surql.seal<void>(
-          surql.tx(
-            populatedRecords.map((_, i) => {
-              return surql.upsert(`id${i}`, `content${i}`);
-            })
-          )
-        );
-
-        const params = populatedRecords.reduce(
-          (acc, record, i) => {
-            const { id, ...content } = record.record;
-            return {
-              ...acc,
-              [`id${i}`]: id,
-              [`content${i}`]: content,
-            };
-          },
-          {} as Record<string, any>
-        );
-
-        await this.local.execute(query, params);
-      }
-
-      // 2. Batch ingest into DBSP (use populatedRecords which has _00_rv set)
-      for (const record of populatedRecords) {
-        const recordId = encodeRecordId(record.record.id);
-        this.versionLookups[recordId] = record.version;
-        this.streamProcessor.ingest(record.table, record.op, recordId, record.record);
-      }
-
-      this.logger.debug(
-        { count: records.length, Category: 'sp00ky-client::CacheModule::saveBatch' },
-        'Batch saved successfully'
-      );
-    } catch (err) {
-      this.logger.error(
-        { err, count: records.length, Category: 'sp00ky-client::CacheModule::saveBatch' },
-        'Failed to save batch'
-      );
-      throw err;
-    }
-  }
-
-  /**
-   * Delete a record from local DB and ingest deletion into DBSP
-   */
-  async delete(table: string, id: string, skipDbDelete: boolean = false, recordData: Record<string, any> = {}): Promise<void> {
-    this.logger.debug(
-      { table, id, Category: 'sp00ky-client::CacheModule::delete' },
-      'Deleting record'
-    );
-
-    try {
-      // 1. Delete from local database
-      if (!skipDbDelete) {
-        await this.local.query('DELETE $id', { id: parseRecordIdString(id) });
-      }
-
-      // 2. Ingest deletion into DBSP (pass record data so predicates can be matched)
-      delete this.versionLookups[id];
-      this.streamProcessor.ingest(table, 'DELETE', id, recordData);
-
-      this.logger.debug(
-        { table, id, Category: 'sp00ky-client::CacheModule::delete' },
-        'Record deleted successfully'
-      );
-    } catch (err) {
-      this.logger.error(
-        { err, table, id, Category: 'sp00ky-client::CacheModule::delete' },
-        'Failed to delete record'
-      );
-      throw err;
-    }
-  }
-
-  /**
-   * Register a query with DBSP to create a materialized view
-   * Returns the initial result array
-   */
-  registerQuery(config: QueryConfig): { localArray: RecordVersionArray } {
-    this.logger.debug(
-      {
-        queryHash: config.queryHash,
-        surql: config.surql,
-        Category: 'sp00ky-client::CacheModule::registerQuery',
-      },
-      'Registering query'
-    );
-
-    try {
-      const update = this.streamProcessor.registerQueryPlan({
-        queryHash: config.queryHash,
-        surql: config.surql,
-        params: config.params,
-        ttl: config.ttl,
-        lastActiveAt: config.lastActiveAt,
-        localArray: [],
-        remoteArray: [],
-        meta: {
-          tableName: '',
-        },
-      });
-
-      if (!update) {
-        throw new Error('Failed to register query with DBSP');
-      }
-
-      this.logger.debug(
-        {
-          queryHash: config.queryHash,
-          arrayLength: update.localArray?.length,
-          Category: 'sp00ky-client::CacheModule::registerQuery',
-        },
-        'Query registered successfully'
-      );
-
-      return { localArray: update.localArray };
-    } catch (err) {
-      this.logger.error(
-        { err, queryHash: config.queryHash, Category: 'sp00ky-client::CacheModule::registerQuery' },
-        'Failed to register query'
-      );
-      throw err;
-    }
-  }
-
-  /**
-   * Unregister a query from DBSP
-   */
-  unregisterQuery(queryHash: string): void {
-    this.logger.debug(
-      { queryHash, Category: 'sp00ky-client::CacheModule::unregisterQuery' },
-      'Unregistering query'
-    );
-    try {
-      this.streamProcessor.unregisterQueryPlan(queryHash);
-      this.logger.debug(
-        { queryHash, Category: 'sp00ky-client::CacheModule::unregisterQuery' },
-        'Query unregistered successfully'
-      );
-    } catch (err) {
-      this.logger.error(
-        { err, queryHash, Category: 'sp00ky-client::CacheModule::unregisterQuery' },
-        'Failed to unregister query'
-      );
-    }
-  }
-}

package/src/modules/cache/types.ts

@@ -1,19 +0,0 @@
-import { RecordId, Duration } from 'surrealdb';
-import { QueryTimeToLive, RecordVersionArray } from '../../types';
-
-export type RecordWithId = Record<string, any> & { id: RecordId<string> };
-
-export interface QueryConfig {
-  queryHash: string;
-  surql: string;
-  params: Record<string, any>;
-  ttl: QueryTimeToLive | Duration;
-  lastActiveAt: Date;
-}
-
-export interface CacheRecord {
-  table: string;
-  op: 'CREATE' | 'UPDATE' | 'DELETE';
-  record: RecordWithId;
-  version: number;
-}

package/src/modules/data/data.test.ts

@@ -1,58 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseUpdateOptions } from './index';
-
-describe('parseUpdateOptions', () => {
-  it('returns empty options when no debounce', () => {
-    const result = parseUpdateOptions('user:1', { name: 'Alice' });
-    expect(result).toEqual({});
-  });
-
-  it('returns empty options when options is undefined', () => {
-    const result = parseUpdateOptions('user:1', { name: 'Alice' }, undefined);
-    expect(result).toEqual({});
-  });
-
-  it('returns empty options when debounced is false', () => {
-    const result = parseUpdateOptions('user:1', { name: 'Alice' }, { debounced: false });
-    expect(result).toEqual({});
-  });
-
-  it('debounced: true uses default delay (200) and key = id', () => {
-    const result = parseUpdateOptions('user:1', { name: 'Alice' }, { debounced: true });
-    expect(result).toEqual({
-      debounced: {
-        delay: 200,
-        key: 'user:1',
-      },
-    });
-  });
-
-  it('supports custom delay', () => {
-    const result = parseUpdateOptions('user:1', { name: 'Alice' }, {
-      debounced: { delay: 500 },
-    });
-    expect(result.debounced?.delay).toBe(500);
-  });
-
-  it('supports custom key type recordId', () => {
-    const result = parseUpdateOptions('user:1', { name: 'Alice', age: 30 }, {
-      debounced: { key: 'recordId' },
-    });
-    expect(result.debounced?.key).toBe('user:1');
-  });
-
-  it('key: recordId_x_fields generates composite key from id + sorted field names', () => {
-    const result = parseUpdateOptions(
-      'user:1',
-      { name: 'Alice', age: 30, email: 'a@b.com' },
-      { debounced: { key: 'recordId_x_fields' } }
-    );
-    expect(result.debounced?.key).toBe('user:1::age#email#name');
-  });
-
-  it('uses defaults when debounced is object with no key or delay', () => {
-    const result = parseUpdateOptions('user:1', { name: 'Alice' }, { debounced: {} });
-    expect(result.debounced?.delay).toBe(200);
-    expect(result.debounced?.key).toBe('user:1');
-  });
-});