@spooky-sync/core 0.0.1-canary.4 → 0.0.1-canary.41

package/src/otel/index.ts

@@ -0,0 +1,127 @@
+import type { Level } from 'pino';
+import type { PinoTransmit } from '../types';
+
+// Map pino levels to OTEL severity numbers
+// https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/logs/data-model.md#severity-fields
+function mapLevelToSeverityNumber(level: string): number {
+  switch (level) {
+    case 'trace':
+      return 1;
+    case 'debug':
+      return 5;
+    case 'info':
+      return 9;
+    case 'warn':
+      return 13;
+    case 'error':
+      return 17;
+    case 'fatal':
+      return 21;
+    default:
+      return 9;
+  }
+}
+
+async function loadOtelModules(otelEndpoint: string) {
+  const [{ LoggerProvider, BatchLogRecordProcessor }, { OTLPLogExporter }, { resourceFromAttributes }, { ATTR_SERVICE_NAME }] =
+    await Promise.all([
+      import('@opentelemetry/sdk-logs'),
+      import('@opentelemetry/exporter-logs-otlp-proto'),
+      import('@opentelemetry/resources'),
+      import('@opentelemetry/semantic-conventions'),
+    ]);
+
+  const resource = resourceFromAttributes({
+    [ATTR_SERVICE_NAME]: 'sp00ky-client',
+  });
+
+  const exporter = new OTLPLogExporter({
+    url: otelEndpoint,
+  });
+
+  const loggerProvider = new LoggerProvider({
+    resource,
+    processors: [new BatchLogRecordProcessor(exporter)],
+  });
+
+  const otelLoggerCache: Record<string, ReturnType<typeof loggerProvider.getLogger>> = {};
+
+  return (category: string) => {
+    if (!otelLoggerCache[category]) {
+      otelLoggerCache[category] = loggerProvider.getLogger(category);
+    }
+    return otelLoggerCache[category];
+  };
+}
+
+/**
+ * Creates a pino browser transmit object that forwards logs to an OpenTelemetry collector.
+ *
+ * @example
+ * ```ts
+ * import { createOtelTransmit } from '@spooky-sync/core/otel';
+ *
+ * new Sp00kyClient({
+ *   // ...
+ *   otelTransmit: createOtelTransmit('http://localhost:4318/v1/logs'),
+ * });
+ * ```
+ */
+export function createOtelTransmit(endpoint: string, level: Level = 'info'): PinoTransmit {
+  // Start loading OTel modules eagerly (don't await — we're synchronous)
+  const otelReady = loadOtelModules(endpoint);
+
+  return {
+    level: level,
+    send: (levelLabel: string, logEvent: any) => {
+      // oxlint-disable-next-line promise/always-return
+      otelReady.then((getOtelLogger) => {
+        try {
+          const messages = [...logEvent.messages];
+          const severityNumber = mapLevelToSeverityNumber(levelLabel);
+
+          // Construct the message body
+          let body = '';
+          const lastMsg = messages.pop();
+
+          if (typeof lastMsg === 'string') {
+            body = lastMsg;
+          } else if (lastMsg) {
+            body = JSON.stringify(lastMsg);
+          }
+
+          let category = 'sp00ky-client::unknown';
+
+          const attributes = {};
+          for (const msg of messages) {
+            if (typeof msg === 'object') {
+              if (msg.Category) {
+                category = msg.Category;
+                delete msg.Category;
+              }
+              Object.assign(attributes, msg);
+            }
+          }
+
+          // Emit to OTEL SDK
+          getOtelLogger(category).emit({
+            severityNumber: severityNumber,
+            severityText: levelLabel.toUpperCase(),
+            body: body,
+            attributes: {
+              ...logEvent.bindings[0],
+              ...attributes,
+            },
+            timestamp: new Date(logEvent.ts),
+          });
+        } catch (e) {
+          // oxlint-disable-next-line no-console
+          console.warn('Failed to transmit log to OTEL endpoint', e);
+        }
+      }).catch((e) => {
+        // oxlint-disable-next-line no-console
+        console.warn('Failed to load OpenTelemetry modules', e);
+      });
+    },
+  };
+}

package/src/services/database/database.ts

@@ -1,11 +1,9 @@
-import { Surreal, SurrealTransaction } from 'surrealdb';
-import { createLogger, Logger } from '../logger/index';
-import {
+import type { Surreal, SurrealTransaction } from 'surrealdb';
+import type { Logger } from '../logger/index';
+import type {
   DatabaseEventSystem,
-  DatabaseEventTypes,
-  DatabaseQueryEventPayload,
-} from './events/index';
-import { SealedQuery } from '../../utils/surql';
+  DatabaseEventTypes} from './events/index';
+import type { SealedQuery } from '../../utils/surql';
 
 export abstract class AbstractDatabaseService {
   protected client: Surreal;
@@ -43,11 +41,12 @@ export abstract class AbstractDatabaseService {
   async query<T extends unknown[]>(query: string, vars?: Record<string, unknown>): Promise<T> {
     return new Promise((resolve, reject) => {
       this.queryQueue = this.queryQueue
+        // oxlint-disable-next-line promise/always-return
         .then(async () => {
           const startTime = performance.now();
           try {
             this.logger.debug(
-              { query, vars, Category: 'spooky-client::Database::query' },
+              { query, vars, Category: 'sp00ky-client::Database::query' },
               'Executing query'
             );
             const pending = this.client.query(query, vars);
@@ -67,7 +66,7 @@ export abstract class AbstractDatabaseService {
 
             resolve(result);
             this.logger.trace(
-              { query, result, Category: 'spooky-client::Database::query' },
+              { query, result, Category: 'sp00ky-client::Database::query' },
               'Query executed successfully'
             );
           } catch (err) {
@@ -84,9 +83,10 @@ export abstract class AbstractDatabaseService {
             });
 
             this.logger.error(
-              { query, vars, err, Category: 'spooky-client::Database::query' },
+              { query, vars, err, Category: 'sp00ky-client::Database::query' },
               'Query execution failed'
             );
+            // oxlint-disable-next-line no-multiple-resolved -- resolve/reject are in try/catch, mutually exclusive
             reject(err);
           }
         })
@@ -102,7 +102,7 @@ export abstract class AbstractDatabaseService {
   }
 
   async close(): Promise<void> {
-    this.logger.info({ Category: 'spooky-client::Database::close' }, 'Closing database connection');
+    this.logger.info({ Category: 'sp00ky-client::Database::close' }, 'Closing database connection');
     await this.client.close();
   }
 }

package/src/services/database/events/index.ts

@@ -1,4 +1,5 @@
-import { createEventSystem, EventDefinition, EventSystem } from '../../../events/index';
+import type { EventDefinition, EventSystem } from '../../../events/index';
+import { createEventSystem } from '../../../events/index';
 
 export const DatabaseEventTypes = {
   LocalQuery: 'DATABASE_LOCAL_QUERY',

package/src/services/database/local-migrator.ts

@@ -1,6 +1,6 @@
-import type { Surreal } from 'surrealdb';
-import { Logger, createLogger } from '../logger/index';
-import { LocalDatabaseService } from './local';
+import type { Logger} from '../logger/index';
+import { createLogger } from '../logger/index';
+import type { LocalDatabaseService } from './local';
 
 export interface SchemaRecord {
   hash: string;
@@ -23,8 +23,8 @@ export class LocalMigrator {
     logger: Logger
   ) {
     this.logger = logger.child({ service: 'LocalMigrator' });
-    logger?.child({ service: 'LocalMigrator' }) ??
-      createLogger('info').child({ service: 'LocalMigrator' });
+    void (logger?.child({ service: 'LocalMigrator' }) ??
+      createLogger('info').child({ service: 'LocalMigrator' }));
   }
 
   async provision(schemaSurql: string): Promise<void> {
@@ -34,7 +34,7 @@ export class LocalMigrator {
 
     if (await this.isSchemaUpToDate(hash)) {
       this.logger.info(
-        { Category: 'spooky-client::LocalMigrator::provision' },
+        { Category: 'sp00ky-client::LocalMigrator::provision' },
         '[Provisioning] Schema is up to date, skipping migration'
       );
       return;
@@ -43,10 +43,10 @@ export class LocalMigrator {
     await this.recreateDatabase(database);
 
     const systemSchema = `
-      DEFINE TABLE IF NOT EXISTS _spooky_stream_processor_state SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
-      DEFINE TABLE IF NOT EXISTS _spooky_query SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
-      DEFINE TABLE IF NOT EXISTS _spooky_schema SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
-      DEFINE TABLE IF NOT EXISTS _spooky_pending_mutations SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
+      DEFINE TABLE IF NOT EXISTS _00_stream_processor_state SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
+      DEFINE TABLE IF NOT EXISTS _00_query SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
+      DEFINE TABLE IF NOT EXISTS _00_schema SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
+      DEFINE TABLE IF NOT EXISTS _00_pending_mutations SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;
     `;
     const fullSchema = schemaSurql + '\n' + systemSchema;
 
@@ -60,7 +60,7 @@ export class LocalMigrator {
       // SKIP INDEXES: WASM engine hangs on DEFINE INDEX (confirmed)
       if (cleanStatement.toUpperCase().startsWith('DEFINE INDEX')) {
         this.logger.warn(
-          { Category: 'spooky-client::LocalMigrator::provision' },
+          { Category: 'sp00ky-client::LocalMigrator::provision' },
           `[Provisioning] Skipping index definition (WASM hang avoidance): ${cleanStatement.substring(0, 50)}...`
         );
         continue;
@@ -68,17 +68,17 @@ export class LocalMigrator {
 
       try {
         this.logger.info(
-          { Category: 'spooky-client::LocalMigrator::provision' },
+          { Category: 'sp00ky-client::LocalMigrator::provision' },
           `[Provisioning] (${i + 1}/${statements.length}) Executing: ${statement.substring(0, 50)}...`
         );
         await this.localDb.query(statement);
         this.logger.info(
-          { Category: 'spooky-client::LocalMigrator::provision' },
+          { Category: 'sp00ky-client::LocalMigrator::provision' },
           `[Provisioning] (${i + 1}/${statements.length}) Done`
         );
       } catch (e) {
         this.logger.error(
-          { Category: 'spooky-client::LocalMigrator::provision' },
+          { Category: 'sp00ky-client::LocalMigrator::provision' },
           `[Provisioning] (${i + 1}/${statements.length}) Error executing statement: ${statement}`
         );
         throw e;
@@ -91,27 +91,27 @@ export class LocalMigrator {
   private async isSchemaUpToDate(hash: string): Promise<boolean> {
     try {
       const [lastSchemaRecord] = await this.localDb.query<any>(
-        `SELECT hash, created_at FROM ONLY _spooky_schema ORDER BY created_at DESC LIMIT 1;`
+        `SELECT hash, created_at FROM ONLY _00_schema ORDER BY created_at DESC LIMIT 1;`
       );
       return lastSchemaRecord?.hash === hash;
-    } catch (error) {
+    } catch (_error) {
       return false;
     }
   }
 
   private async recreateDatabase(database: string) {
     try {
-      await this.localDb.query(`DEFINE DATABASE _spooky_temp;`);
-    } catch (e) {
+      await this.localDb.query(`DEFINE DATABASE _00_temp;`);
+    } catch (_e) {
       // Ignore if exists
     }
 
     try {
       await this.localDb.query(`
-        USE DB _spooky_temp;
+        USE DB _00_temp;
         REMOVE DATABASE ${database};
       `);
-    } catch (e) {
+    } catch (_e) {
       // Ignore error if database doesn't exist
     }
 
@@ -196,7 +196,7 @@ export class LocalMigrator {
 
   private async createHashRecord(hash: string) {
     await this.localDb.query(
-      `UPSERT _spooky_schema SET hash = $hash, created_at = time::now() WHERE hash = $hash;`,
+      `UPSERT _00_schema SET hash = $hash, created_at = time::now() WHERE hash = $hash;`,
       { hash }
     );
   }

package/src/services/database/local.ts

@@ -1,16 +1,17 @@
-import { applyDiagnostics, DateTime, Diagnostic, RecordId, Surreal } from 'surrealdb';
+import type { Diagnostic} from 'surrealdb';
+import { applyDiagnostics, DateTime, RecordId, Surreal } from 'surrealdb';
 import { createWasmWorkerEngines } from '@surrealdb/wasm';
-import { SpookyConfig } from '../../types';
-import { Logger } from '../logger/index';
+import type { Sp00kyConfig } from '../../types';
+import type { Logger } from '../logger/index';
 import { AbstractDatabaseService } from './database';
 import { createDatabaseEventSystem, DatabaseEventTypes } from './events/index';
-import { encodeRecordId, parseRecordIdString, surql } from '../../utils/index';
+import { encodeRecordId } from '../../utils/index';
 
 export class LocalDatabaseService extends AbstractDatabaseService {
-  private config: SpookyConfig<any>['database'];
+  private config: Sp00kyConfig<any>['database'];
   protected eventType = DatabaseEventTypes.LocalQuery;
 
-  constructor(config: SpookyConfig<any>['database'], logger: Logger) {
+  constructor(config: Sp00kyConfig<any>['database'], logger: Logger) {
     const events = createDatabaseEventSystem();
     super(
       new Surreal({
@@ -38,7 +39,7 @@ export class LocalDatabaseService extends AbstractDatabaseService {
                   type,
                   phase,
                   service: 'surrealdb:local',
-                  Category: 'spooky-client::LocalDatabaseService::diagnostics',
+                  Category: 'sp00ky-client::LocalDatabaseService::diagnostics',
                 },
                 `Local SurrealDB diagnostics captured ${type}:${phase}`
               );
@@ -52,26 +53,26 @@ export class LocalDatabaseService extends AbstractDatabaseService {
     this.config = config;
   }
 
-  getConfig(): SpookyConfig<any>['database'] {
+  getConfig(): Sp00kyConfig<any>['database'] {
     return this.config;
   }
 
   async connect(): Promise<void> {
     const { namespace, database } = this.getConfig();
     this.logger.info(
-      { namespace, database, Category: 'spooky-client::LocalDatabaseService::connect' },
+      { namespace, database, Category: 'sp00ky-client::LocalDatabaseService::connect' },
       'Connecting to local database'
     );
     try {
       const store = this.getConfig().store ?? 'memory';
-      const storeUrl = store === 'memory' ? 'mem://' : 'indxdb://spooky';
+      const storeUrl = store === 'memory' ? 'mem://' : 'indxdb://sp00ky';
       this.logger.debug(
-        { storeUrl, Category: 'spooky-client::LocalDatabaseService::connect' },
+        { storeUrl, Category: 'sp00ky-client::LocalDatabaseService::connect' },
         '[LocalDatabaseService] Calling client.connect'
       );
       await this.client.connect(storeUrl, {});
       this.logger.debug(
-        { namespace, database, Category: 'spooky-client::LocalDatabaseService::connect' },
+        { namespace, database, Category: 'sp00ky-client::LocalDatabaseService::connect' },
         '[LocalDatabaseService] client.connect returned. Calling client.use'
       );
 
@@ -80,17 +81,17 @@ export class LocalDatabaseService extends AbstractDatabaseService {
         database,
       });
       this.logger.debug(
-        { Category: 'spooky-client::LocalDatabaseService::connect' },
+        { Category: 'sp00ky-client::LocalDatabaseService::connect' },
         '[LocalDatabaseService] client.use returned'
       );
 
       this.logger.info(
-        { Category: 'spooky-client::LocalDatabaseService::connect' },
+        { Category: 'sp00ky-client::LocalDatabaseService::connect' },
         'Connected to local database'
       );
     } catch (err) {
       this.logger.error(
-        { err, Category: 'spooky-client::LocalDatabaseService::connect' },
+        { err, Category: 'sp00ky-client::LocalDatabaseService::connect' },
         'Failed to connect to local database'
       );
       throw err;

package/src/services/database/remote.ts

@@ -1,20 +1,20 @@
+import type {
+  Diagnostic} from 'surrealdb';
 import {
   applyDiagnostics,
   createRemoteEngines,
-  Diagnostic,
   Surreal,
-  SurrealTransaction,
 } from 'surrealdb';
-import { SpookyConfig } from '../../types';
-import { Logger } from '../logger/index';
+import type { Sp00kyConfig } from '../../types';
+import type { Logger } from '../logger/index';
 import { AbstractDatabaseService } from './database';
 import { createDatabaseEventSystem, DatabaseEventTypes } from './events/index';
 
 export class RemoteDatabaseService extends AbstractDatabaseService {
-  private config: SpookyConfig<any>['database'];
+  private config: Sp00kyConfig<any>['database'];
   protected eventType = DatabaseEventTypes.RemoteQuery;
 
-  constructor(config: SpookyConfig<any>['database'], logger: Logger) {
+  constructor(config: Sp00kyConfig<any>['database'], logger: Logger) {
     const events = createDatabaseEventSystem();
     super(
       new Surreal({
@@ -29,7 +29,7 @@ export class RemoteDatabaseService extends AbstractDatabaseService {
                   type,
                   phase,
                   service: 'surrealdb:remote',
-                  Category: 'spooky-client::RemoteDatabaseService::diagnostics',
+                  Category: 'sp00ky-client::RemoteDatabaseService::diagnostics',
                 },
                 `Remote SurrealDB diagnostics captured ${type}:${phase}`
               );
@@ -43,7 +43,7 @@ export class RemoteDatabaseService extends AbstractDatabaseService {
     this.config = config;
   }
 
-  getConfig(): SpookyConfig<any>['database'] {
+  getConfig(): Sp00kyConfig<any>['database'] {
     return this.config;
   }
 
@@ -55,7 +55,7 @@ export class RemoteDatabaseService extends AbstractDatabaseService {
           endpoint,
           namespace,
           database,
-          Category: 'spooky-client::RemoteDatabaseService::connect',
+          Category: 'sp00ky-client::RemoteDatabaseService::connect',
         },
         'Connecting to remote database'
       );
@@ -68,25 +68,25 @@ export class RemoteDatabaseService extends AbstractDatabaseService {
 
         if (token) {
           this.logger.debug(
-            { Category: 'spooky-client::RemoteDatabaseService::connect' },
+            { Category: 'sp00ky-client::RemoteDatabaseService::connect' },
             'Authenticating with token'
           );
           await this.client.authenticate(token);
         }
         this.logger.info(
-          { Category: 'spooky-client::RemoteDatabaseService::connect' },
+          { Category: 'sp00ky-client::RemoteDatabaseService::connect' },
           'Connected to remote database'
         );
       } catch (err) {
         this.logger.error(
-          { err, Category: 'spooky-client::RemoteDatabaseService::connect' },
+          { err, Category: 'sp00ky-client::RemoteDatabaseService::connect' },
           'Failed to connect to remote database'
         );
         throw err;
       }
     } else {
       this.logger.warn(
-        { Category: 'spooky-client::RemoteDatabaseService::connect' },
+        { Category: 'sp00ky-client::RemoteDatabaseService::connect' },
         'No endpoint configured for remote database'
       );
     }

package/src/services/logger/index.ts

@@ -1,114 +1,19 @@
-import pino, { Level, type Logger as PinoLogger, type LoggerOptions } from 'pino';
-import { LoggerProvider, BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';
-import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-proto';
-import { resourceFromAttributes } from '@opentelemetry/resources';
-import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
-import { createContextKey } from '@opentelemetry/api';
-
-const CATEGORY_KEY = createContextKey('Category');
+import pino, { type Level, type Logger as PinoLogger, type LoggerOptions } from 'pino';
+import type { PinoTransmit } from '../../types';
 
 export type Logger = PinoLogger;
 
-// Map pino levels to OTEL severity numbers
-// https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/logs/data-model.md#severity-fields
-function mapLevelToSeverityNumber(level: string): number {
-  switch (level) {
-    case 'trace':
-      return 1;
-    case 'debug':
-      return 5;
-    case 'info':
-      return 9;
-    case 'warn':
-      return 13;
-    case 'error':
-      return 17;
-    case 'fatal':
-      return 21;
-    default:
-      return 9;
-  }
-}
-
-export function createLogger(level: Level = 'info', otelEndpoint?: string): Logger {
+export function createLogger(level: Level = 'info', transmit?: PinoTransmit): Logger {
   const browserConfig: LoggerOptions['browser'] = {
     asObject: true,
     write: (o: any) => {
+      // oxlint-disable-next-line no-console
       console.log(JSON.stringify(o));
     },
   };
 
-  if (otelEndpoint) {
-    // Initialize OTEL LoggerProvider
-    const resource = resourceFromAttributes({
-      [ATTR_SERVICE_NAME]: 'spooky-client',
-    });
-
-    const exporter = new OTLPLogExporter({
-      url: otelEndpoint,
-    });
-
-    // Pass processors in constructor as this SDK version requires it
-    const loggerProvider = new LoggerProvider({
-      resource,
-      processors: [new BatchLogRecordProcessor(exporter)],
-    });
-
-    const otelLogger: Record<string, ReturnType<typeof loggerProvider.getLogger>> = {};
-
-    const getOtelLogger = (category: string) => {
-      if (!otelLogger[category]) {
-        otelLogger[category] = loggerProvider.getLogger(category);
-      }
-      return otelLogger[category];
-    };
-
-    browserConfig.transmit = {
-      level: level,
-      send: (levelLabel: string, logEvent: any) => {
-        try {
-          const messages = [...logEvent.messages];
-          const severityNumber = mapLevelToSeverityNumber(levelLabel);
-
-          // Construct the message body
-          let body = '';
-          const msg = messages.pop();
-
-          if (typeof msg === 'string') {
-            body = msg;
-          } else if (msg) {
-            body = JSON.stringify(msg);
-          }
-
-          let category = 'spooky-client::unknown';
-
-          const attributes = {};
-          for (const msg of messages) {
-            if (typeof msg === 'object') {
-              if (msg.Category) {
-                category = msg.Category;
-                delete msg.Category;
-              }
-              Object.assign(attributes, msg);
-            }
-          }
-
-          // Emit to OTEL SDK
-          getOtelLogger(category).emit({
-            severityNumber: severityNumber,
-            severityText: levelLabel.toUpperCase(),
-            body: body,
-            attributes: {
-              ...logEvent.bindings[0],
-              ...attributes,
-            },
-            timestamp: new Date(logEvent.ts),
-          });
-        } catch (e) {
-          console.warn('Failed to transmit log to OTEL endpoint', e);
-        }
-      },
-    };
+  if (transmit) {
+    browserConfig.transmit = transmit;
   }
 
   return pino({

package/src/services/persistence/localstorage.ts

@@ -1,5 +1,5 @@
-import { Logger } from 'pino';
-import { PersistenceClient } from '../../types';
+import type { Logger } from 'pino';
+import type { PersistenceClient } from '../../types';
 
 export class LocalStoragePersistenceClient implements PersistenceClient {
   private logger: Logger;

package/src/services/persistence/resilient.ts

@@ -0,0 +1,34 @@
+import type { Logger } from 'pino';
+import type { PersistenceClient } from '../../types';
+
+export class ResilientPersistenceClient implements PersistenceClient {
+  private logger: Logger;
+
+  constructor(
+    private inner: PersistenceClient,
+    logger: Logger
+  ) {
+    this.logger = logger.child({ service: 'ResilientPersistenceClient' });
+  }
+
+  set<T>(key: string, value: T): Promise<void> {
+    return this.inner.set(key, value);
+  }
+
+  async get<T>(key: string): Promise<T | null> {
+    try {
+      return await this.inner.get<T>(key);
+    } catch (e) {
+      this.logger.warn(
+        { key, error: e, Category: 'sp00ky-client::ResilientPersistenceClient::get' },
+        'Persistence read failed, dropping key'
+      );
+      await this.inner.remove(key).catch(() => {});
+      return null;
+    }
+  }
+
+  remove(key: string): Promise<void> {
+    return this.inner.remove(key);
+  }
+}