@spooky-sync/core 0.0.1-canary.6 → 0.0.1-canary.61

package/src/modules/sync/queue/queue-up.ts

@@ -1,13 +1,14 @@
-import { RecordId } from 'surrealdb';
-import { LocalDatabaseService } from '../../../services/database/index';
+import type { RecordId } from 'surrealdb';
+import type { LocalDatabaseService } from '../../../services/database/index';
+import type {
+  SyncQueueEventSystem} from '../events/index';
 import {
   createSyncQueueEventSystem,
-  SyncQueueEventSystem,
   SyncQueueEventTypes,
 } from '../events/index';
 import { parseRecordIdString, extractTablePart, classifySyncError } from '../../../utils/index';
-import { Logger } from '../../../services/logger/index';
-import { PushEventOptions } from '../../../events/index';
+import type { Logger } from '../../../services/logger/index';
+import type { PushEventOptions } from '../../../events/index';
 
 export type CreateEvent = {
   type: 'create';
@@ -114,7 +115,7 @@ export class UpQueue {
 
         if (errorType === 'network') {
           this.logger.error(
-            { error, event, Category: 'spooky-client::UpQueue::next' },
+            { error, event, Category: 'sp00ky-client::UpQueue::next' },
             'Network error processing mutation, re-queuing'
           );
           this.queue.unshift(event);
@@ -123,14 +124,14 @@ export class UpQueue {
 
         // Application error — rollback instead of re-queuing
         this.logger.error(
-          { error, event, Category: 'spooky-client::UpQueue::next' },
+          { error, event, Category: 'sp00ky-client::UpQueue::next' },
           'Application error processing mutation, rolling back'
         );
         try {
           await this.removeEventFromDatabase(event.mutation_id);
         } catch (removeError) {
           this.logger.error(
-            { error: removeError, event, Category: 'spooky-client::UpQueue::next' },
+            { error: removeError, event, Category: 'sp00ky-client::UpQueue::next' },
             'Failed to remove rolled-back mutation from database'
           );
         }
@@ -139,7 +140,7 @@ export class UpQueue {
             await onRollback(event, error instanceof Error ? error : new Error(String(error)));
           } catch (rollbackError) {
             this.logger.error(
-              { error: rollbackError, event, Category: 'spooky-client::UpQueue::next' },
+              { error: rollbackError, event, Category: 'sp00ky-client::UpQueue::next' },
               'Rollback handler failed'
             );
           }
@@ -154,7 +155,7 @@ export class UpQueue {
         await this.removeEventFromDatabase(event.mutation_id);
       } catch (error) {
         this.logger.error(
-          { error, event, Category: 'spooky-client::UpQueue::next' },
+          { error, event, Category: 'sp00ky-client::UpQueue::next' },
           'Failed to remove mutation from database after successful processing'
         );
       }
@@ -172,7 +173,7 @@ export class UpQueue {
   async loadFromDatabase() {
     try {
       const [records] = await this.local.query<any>(
-        `SELECT * FROM _spooky_pending_mutations ORDER BY created_at ASC`
+        `SELECT * FROM _00_pending_mutations ORDER BY created_at ASC`
       );
 
       this.queue = records
@@ -205,7 +206,7 @@ export class UpQueue {
                 {
                   mutationType: r.mutationType,
                   record: r,
-                  Category: 'spooky-client::UpQueue::loadFromDatabase',
+                  Category: 'sp00ky-client::UpQueue::loadFromDatabase',
                 },
                 'Unknown mutation type'
               );
@@ -215,7 +216,7 @@ export class UpQueue {
         .filter((e: UpEvent | null): e is UpEvent => e !== null);
     } catch (error) {
       this.logger.error(
-        { error, Category: 'spooky-client::UpQueue::loadFromDatabase' },
+        { error, Category: 'sp00ky-client::UpQueue::loadFromDatabase' },
         'Failed to load pending mutations from database'
       );
     }

package/src/modules/sync/scheduler.ts

@@ -1,5 +1,5 @@
-import { Logger } from '../../services/logger/index';
-import { UpQueue, DownQueue, DownEvent, UpEvent, RollbackCallback } from './queue/index';
+import type { Logger } from '../../services/logger/index';
+import type { UpQueue, DownQueue, DownEvent, UpEvent, RollbackCallback } from './queue/index';
 import { SyncQueueEventTypes } from './events/index';
 
 /**

package/src/modules/sync/sync.ts

@@ -1,24 +1,25 @@
-import { LocalDatabaseService, RemoteDatabaseService } from '../../services/database/index';
-import { MutationEvent, RecordVersionArray } from '../../types';
+import type { LocalDatabaseService, RemoteDatabaseService } from '../../services/database/index';
+import type { RecordVersionArray } from '../../types';
 import { createSyncEventSystem, SyncEventTypes, SyncQueueEventTypes } from './events/index';
-import { Logger } from '../../services/logger/index';
-import { DownEvent, DownQueue, UpEvent, UpQueue } from './queue/index';
-import { RecordId, Uuid } from 'surrealdb';
+import type { Logger } from '../../services/logger/index';
+import type { DownEvent, UpEvent} from './queue/index';
+import { DownQueue, UpQueue } from './queue/index';
+import type { RecordId, Uuid } from 'surrealdb';
 import { ArraySyncer, createDiffFromDbOp } from './utils';
 import { SyncEngine } from './engine';
 import { SyncScheduler } from './scheduler';
-import { SchemaStructure } from '@spooky-sync/query-builder';
-import { CacheModule } from '../cache/index';
-import { DataModule } from '../data/index';
-import { encodeRecordId, extractTablePart, parseDuration, surql } from '../../utils/index';
+import type { SchemaStructure } from '@spooky-sync/query-builder';
+import type { CacheModule } from '../cache/index';
+import type { DataModule } from '../data/index';
+import { encodeRecordId, extractTablePart, surql } from '../../utils/index';
 
 /**
- * The main synchronization engine for Spooky.
+ * The main synchronization engine for Sp00ky.
  * Handles the bidirectional synchronization between the local database and the remote backend.
  * Uses a queue-based architecture with 'up' (local to remote) and 'down' (remote to local) queues.
  * @template S The schema structure type.
  */
-export class SpookySync<S extends SchemaStructure> {
+export class Sp00kySync<S extends SchemaStructure> {
   private clientId: string = '';
   private upQueue: UpQueue;
   private downQueue: DownQueue;
@@ -59,7 +60,7 @@ export class SpookySync<S extends SchemaStructure> {
     private schema: S,
     logger: Logger
   ) {
-    this.logger = logger.child({ service: 'SpookySync' });
+    this.logger = logger.child({ service: 'Sp00kySync' });
     this.upQueue = new UpQueue(this.local, this.logger);
     this.downQueue = new DownQueue(this.local, this.logger);
     this.syncEngine = new SyncEngine(this.remote, this.cache, this.schema, this.logger);
@@ -80,7 +81,7 @@ export class SpookySync<S extends SchemaStructure> {
    * @throws Error if already initialized.
    */
   public async init(clientId: string) {
-    if (this.isInit) throw new Error('SpookySync is already initialized');
+    if (this.isInit) throw new Error('Sp00kySync is already initialized');
     this.clientId = clientId;
     this.isInit = true;
     await this.scheduler.init();
@@ -92,17 +93,17 @@ export class SpookySync<S extends SchemaStructure> {
 
   private async startRefLiveQueries() {
     this.logger.debug(
-      { clientId: this.clientId, Category: 'spooky-client::SpookySync::startRefLiveQueries' },
+      { clientId: this.clientId, Category: 'sp00ky-client::Sp00kySync::startRefLiveQueries' },
       'Starting ref live queries'
     );
 
     const [queryUuid] = await this.remote.query<[Uuid]>(
-      'LIVE SELECT * FROM _spooky_list_ref'
+      'LIVE SELECT * FROM _00_list_ref'
     );
 
     (await this.remote.getClient().liveOf(queryUuid)).subscribe((message) => {
       this.logger.debug(
-        { message, Category: 'spooky-client::SpookySync::startRefLiveQueries' },
+        { message, Category: 'sp00ky-client::Sp00kySync::startRefLiveQueries' },
         'Live update received'
       );
       if (message.action === 'KILLED') return;
@@ -113,7 +114,7 @@ export class SpookySync<S extends SchemaStructure> {
         message.value.version as number
       ).catch((err) => {
         this.logger.error(
-          { err, Category: 'spooky-client::SpookySync::startRefLiveQueries' },
+          { err, Category: 'sp00ky-client::Sp00kySync::startRefLiveQueries' },
           'Error handling remote list ref change'
         );
       });
@@ -126,13 +127,25 @@ export class SpookySync<S extends SchemaStructure> {
     recordId: RecordId,
     version: number
   ) {
+    if (action === 'DELETE') {
+      this.logger.debug(
+        {
+          queryId: queryId.toString(),
+          recordId: recordId.toString(),
+          Category: 'sp00ky-client::Sp00kySync::handleRemoteListRefChange',
+        },
+        'Ignoring DELETE on list_ref — should not happen'
+      );
+      return;
+    }
+
     const existing = this.dataModule.getQueryById(queryId);
 
     if (!existing) {
       this.logger.warn(
         {
           queryId: queryId.toString(),
-          Category: 'spooky-client::SpookySync::handleRemoteListRefChange',
+          Category: 'sp00ky-client::Sp00kySync::handleRemoteListRefChange',
         },
         'Received remote update for unknown local query'
       );
@@ -148,7 +161,7 @@ export class SpookySync<S extends SchemaStructure> {
         recordId,
         version,
         localArray,
-        Category: 'spooky-client::SpookySync::handleRemoteListRefChange',
+        Category: 'sp00ky-client::Sp00kySync::handleRemoteListRefChange',
       },
       'Live update is being processed'
     );
@@ -166,12 +179,11 @@ export class SpookySync<S extends SchemaStructure> {
 
   private async processUpEvent(event: UpEvent) {
     this.logger.debug(
-      { event, Category: 'spooky-client::SpookySync::processUpEvent' },
+      { event, Category: 'sp00ky-client::Sp00kySync::processUpEvent' },
       'Processing up event'
     );
-    console.log('xx1', event);
     switch (event.type) {
-      case 'create':
+      case 'create': {
         const dataKeys = Object.keys(event.data).map((key) => ({ key, variable: `data_${key}` }));
         const prefixedParams = Object.fromEntries(
           dataKeys.map(({ key, variable }) => [variable, event.data[key]])
@@ -182,6 +194,7 @@ export class SpookySync<S extends SchemaStructure> {
           ...prefixedParams,
         });
         break;
+      }
       case 'update':
         await this.remote.query(`UPDATE $id MERGE $data`, {
           id: event.record_id,
@@ -195,7 +208,7 @@ export class SpookySync<S extends SchemaStructure> {
         break;
       default:
         this.logger.error(
-          { event, Category: 'spooky-client::SpookySync::processUpEvent' },
+          { event, Category: 'sp00ky-client::Sp00kySync::processUpEvent' },
           'processUpEvent unknown event type'
         );
         return;
@@ -215,7 +228,7 @@ export class SpookySync<S extends SchemaStructure> {
         recordId,
         tableName,
         error: error.message,
-        Category: 'spooky-client::SpookySync::handleRollback',
+        Category: 'sp00ky-client::Sp00kySync::handleRollback',
       },
       'Rolling back failed mutation'
     );
@@ -231,7 +244,7 @@ export class SpookySync<S extends SchemaStructure> {
           this.logger.warn(
             {
               recordId,
-              Category: 'spooky-client::SpookySync::handleRollback',
+              Category: 'sp00ky-client::Sp00kySync::handleRollback',
             },
             'Cannot rollback update: no beforeRecord available. Down-sync will reconcile.'
           );
@@ -241,7 +254,7 @@ export class SpookySync<S extends SchemaStructure> {
         this.logger.warn(
           {
             recordId,
-            Category: 'spooky-client::SpookySync::handleRollback',
+            Category: 'sp00ky-client::Sp00kySync::handleRollback',
           },
           'Delete rollback not implemented. Down-sync will reconcile.'
         );
@@ -257,7 +270,7 @@ export class SpookySync<S extends SchemaStructure> {
 
   private async processDownEvent(event: DownEvent) {
     this.logger.debug(
-      { event, Category: 'spooky-client::SpookySync::processDownEvent' },
+      { event, Category: 'sp00ky-client::Sp00kySync::processDownEvent' },
       'Processing down event'
     );
     switch (event.type) {
@@ -281,7 +294,7 @@ export class SpookySync<S extends SchemaStructure> {
     const queryState = this.dataModule.getQueryByHash(hash);
     if (!queryState) {
       this.logger.warn(
-        { hash, Category: 'spooky-client::SpookySync::syncQuery' },
+        { hash, Category: 'sp00ky-client::Sp00kySync::syncQuery' },
         'Query not found'
       );
       return;
@@ -309,7 +322,7 @@ export class SpookySync<S extends SchemaStructure> {
   private async registerQuery(queryHash: string) {
     try {
       this.logger.debug(
-        { queryHash, Category: 'spooky-client::SpookySync::registerQuery' },
+        { queryHash, Category: 'sp00ky-client::Sp00kySync::registerQuery' },
         'Register Query state'
       );
       await this.createRemoteQuery(queryHash);
@@ -319,7 +332,7 @@ export class SpookySync<S extends SchemaStructure> {
       await this.dataModule.notifyQuerySynced(queryHash);
     } catch (e) {
       this.logger.error(
-        { err: e, Category: 'spooky-client::SpookySync::registerQuery' },
+        { err: e, Category: 'sp00ky-client::Sp00kySync::registerQuery' },
         'registerQuery error'
       );
       throw e;
@@ -331,7 +344,7 @@ export class SpookySync<S extends SchemaStructure> {
 
     if (!queryState) {
       this.logger.warn(
-        { queryHash, Category: 'spooky-client::SpookySync::createRemoteQuery' },
+        { queryHash, Category: 'sp00ky-client::Sp00kySync::createRemoteQuery' },
         'Query to register not found'
       );
       throw new Error('Query to register not found');
@@ -348,7 +361,7 @@ export class SpookySync<S extends SchemaStructure> {
     });
 
     const [items] = await this.remote.query<[{ out: RecordId<string>; version: number }[]]>(
-      surql.selectByFieldsAnd('_spooky_list_ref', ['in'], ['out', 'version']),
+      surql.selectByFieldsAnd('_00_list_ref', ['in'], ['out', 'version']),
       {
         in: queryState.config.id,
       }
@@ -358,7 +371,7 @@ export class SpookySync<S extends SchemaStructure> {
       {
         queryId: encodeRecordId(queryState.config.id),
         items,
-        Category: 'spooky-client::SpookySync::createRemoteQuery',
+        Category: 'sp00ky-client::Sp00kySync::createRemoteQuery',
       },
       'Got query record version array from remote'
     );
@@ -369,7 +382,7 @@ export class SpookySync<S extends SchemaStructure> {
       {
         queryId: encodeRecordId(queryState.config.id),
         array,
-        Category: 'spooky-client::SpookySync::createRemoteQuery',
+        Category: 'sp00ky-client::Sp00kySync::createRemoteQuery',
       },
       'createdRemoteQuery'
     );
@@ -384,7 +397,7 @@ export class SpookySync<S extends SchemaStructure> {
     const queryState = this.dataModule.getQueryByHash(queryHash);
     if (!queryState) {
       this.logger.warn(
-        { queryHash, Category: 'spooky-client::SpookySync::heartbeatQuery' },
+        { queryHash, Category: 'sp00ky-client::Sp00kySync::heartbeatQuery' },
         'Query to register not found'
       );
       throw new Error('Query to register not found');
@@ -398,7 +411,7 @@ export class SpookySync<S extends SchemaStructure> {
     const queryState = this.dataModule.getQueryByHash(queryHash);
     if (!queryState) {
       this.logger.warn(
-        { queryHash, Category: 'spooky-client::SpookySync::cleanupQuery' },
+        { queryHash, Category: 'sp00ky-client::Sp00kySync::cleanupQuery' },
         'Query to register not found'
       );
       throw new Error('Query to register not found');

package/src/modules/sync/utils.test.ts

@@ -6,7 +6,7 @@ import {
   createDiffFromDbOp,
   ArraySyncer,
 } from './utils';
-import { RecordVersionArray, RecordVersionDiff } from '../../types';
+import type { RecordVersionArray, RecordVersionDiff } from '../../types';
 import { encodeRecordId } from '../../utils/index';
 
 function rid(table: string, id: string): RecordId<string> {
@@ -305,7 +305,7 @@ describe('ArraySyncer', () => {
     expect(diff!.removed).toHaveLength(3);
     // Check they come in sorted order
     const removedIds = diff!.removed.map((r) => encodeRecordId(r));
-    const sorted = [...removedIds].sort();
+    const sorted = [...removedIds].toSorted();
     expect(removedIds).toEqual(sorted);
   });
 });

package/src/modules/sync/utils.ts

@@ -1,5 +1,5 @@
-import { RecordId } from 'surrealdb';
-import { RecordVersionArray, RecordVersionDiff } from '../../types';
+import type { RecordId } from 'surrealdb';
+import type { RecordVersionArray, RecordVersionDiff } from '../../types';
 import { parseRecordIdString, encodeRecordId } from '../../utils/index';
 
 export class ArraySyncer {
@@ -8,8 +8,8 @@ export class ArraySyncer {
   private needsSort = false;
 
   constructor(localArray: RecordVersionArray, remoteArray: RecordVersionArray) {
-    this.remoteArray = remoteArray.sort((a, b) => a[0].localeCompare(b[0]));
-    this.localArray = localArray.sort((a, b) => a[0].localeCompare(b[0]));
+    this.remoteArray = remoteArray.toSorted((a, b) => a[0].localeCompare(b[0]));
+    this.localArray = localArray.toSorted((a, b) => a[0].localeCompare(b[0]));
   }
 
   /**
@@ -49,7 +49,6 @@ export class ArraySyncer {
       this.localArray.sort((a, b) => a[0].localeCompare(b[0]));
       this.needsSort = false;
     }
-    console.log('xxxx555', this.localArray, this.remoteArray);
     const diff = diffRecordVersionArray(this.localArray, this.remoteArray);
     return diff;
   }
@@ -93,10 +92,12 @@ export function diffRecordVersionArray(
   return {
     added: added.map((id) => ({
       id: parseRecordIdString(id),
+      // oxlint-disable-next-line no-non-null-assertion
       version: remoteMap.get(id)!,
     })),
     updated: updated.map((id) => ({
       id: parseRecordIdString(id),
+      // oxlint-disable-next-line no-non-null-assertion
       version: remoteMap.get(id)!,
     })),
     removed: removed.map(parseRecordIdString),
@@ -127,7 +128,7 @@ export function applyRecordVersionDiff(
     currentMap.set(encodeRecordId(item.id), item.version);
   }
 
-  return Array.from(currentMap).sort((a, b) => a[0].localeCompare(b[0]));
+  return Array.from(currentMap).toSorted((a, b) => a[0].localeCompare(b[0]));
 }
 
 export function createDiffFromDbOp(
@@ -136,17 +137,14 @@ export function createDiffFromDbOp(
   version: number,
   versions?: RecordVersionArray
 ): RecordVersionDiff {
-  // Version guard: skip stale CREATE/UPDATE, but always process DELETE
-  if (op !== 'DELETE') {
-    const old = versions?.find((record) => record[0] === encodeRecordId(recordId));
-
-    if (old && old[1] >= version) {
-      return {
-        added: [],
-        updated: [],
-        removed: [],
-      };
-    }
+  const old = versions?.find((record) => record[0] === encodeRecordId(recordId));
+
+  if (old && old[1] >= version) {
+    return {
+      added: [],
+      updated: [],
+      removed: [],
+    };
   }
 
   if (op === 'CREATE') {

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',