@syncular/server 0.1.3 → 0.2.1

package/src/sqlite3.ts

@@ -1,137 +0,0 @@
-/**
- * @syncular/server/sqlite3 - node-sqlite3 dialect for sync
- *
- * Provides a Kysely dialect for the callback-based `sqlite3` npm package.
- * SQLite-compatible — use with @syncular/server/sqlite.
- */
-
-import type {
-  CompiledQuery,
-  DatabaseConnection,
-  Dialect,
-  QueryResult,
-} from 'kysely';
-import { BaseSqliteDialect, BaseSqliteDriver } from 'kysely-generic-sqlite';
-import sqlite3 from 'sqlite3';
-
-export interface Sqlite3PathOptions {
-  /** Path to SQLite database file, or ':memory:' for in-memory */
-  path: string;
-}
-
-export interface Sqlite3InstanceOptions {
-  /** An existing sqlite3.Database instance */
-  database: sqlite3.Database;
-}
-
-export type Sqlite3Options = Sqlite3PathOptions | Sqlite3InstanceOptions;
-
-/**
- * Create the sqlite3 dialect directly.
- */
-export function createSqlite3Dialect(options: Sqlite3Options): Dialect {
-  return new BaseSqliteDialect(() => new Sqlite3Driver(options));
-}
-
-class Sqlite3Driver extends BaseSqliteDriver {
-  #db: sqlite3.Database | undefined;
-
-  constructor(options: Sqlite3Options) {
-    super(async () => {
-      this.#db = await resolveSqlite3Database(options);
-      this.conn = new Sqlite3Connection(this.#db);
-    });
-  }
-
-  async destroy(): Promise<void> {
-    const db = this.#db;
-    this.#db = undefined;
-    if (!db) return;
-
-    await new Promise<void>((resolve, reject) => {
-      db.close((err) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve();
-      });
-    });
-  }
-}
-
-async function resolveSqlite3Database(
-  options: Sqlite3Options
-): Promise<sqlite3.Database> {
-  if ('database' in options) {
-    return options.database;
-  }
-
-  return new Promise<sqlite3.Database>((resolve, reject) => {
-    const db = new sqlite3.Database(options.path, (err) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      resolve(db);
-    });
-  });
-}
-
-class Sqlite3Connection implements DatabaseConnection {
-  readonly #db: sqlite3.Database;
-
-  constructor(db: sqlite3.Database) {
-    this.#db = db;
-  }
-
-  async executeQuery<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>> {
-    const { sql, parameters } = compiledQuery;
-    const params = [...parameters];
-
-    const hasReturning = /\breturning\b/i.test(sql);
-    const isSelectLike = /^\s*(select|pragma|explain|with)\b/i.test(sql);
-    const isInsert = /^\s*(insert|replace)\b/i.test(sql);
-
-    if (isSelectLike || hasReturning) {
-      return new Promise<QueryResult<R>>((resolve, reject) => {
-        this.#db.all(sql, params, (err: Error | null, rows: R[]) => {
-          if (err) {
-            reject(err);
-            return;
-          }
-
-          const normalizedRows = rows ?? [];
-          resolve({
-            rows: normalizedRows,
-            ...(hasReturning
-              ? { numAffectedRows: BigInt(normalizedRows.length) }
-              : {}),
-          });
-        });
-      });
-    }
-
-    return new Promise<QueryResult<R>>((resolve, reject) => {
-      this.#db.run(sql, params, function onRun(err: Error | null) {
-        if (err) {
-          reject(err);
-          return;
-        }
-
-        resolve({
-          rows: [],
-          numAffectedRows: BigInt(this.changes),
-          ...(isInsert ? { insertId: BigInt(this.lastID) } : {}),
-        });
-      });
-    });
-  }
-
-  streamQuery<R>(
-    _compiledQuery: CompiledQuery,
-    _chunkSize?: number
-  ): AsyncIterableIterator<QueryResult<R>> {
-    throw new Error('sqlite3 driver does not support streaming');
-  }
-}

package/src/stats.ts

@@ -1,180 +0,0 @@
-/**
- * @syncular/server - Observability helpers
- */
-
-import type { Kysely, SelectQueryBuilder, SqlBool } from 'kysely';
-import { sql } from 'kysely';
-import { coerceNumber } from './dialect/helpers';
-import type { SyncCoreDb } from './schema';
-
-// biome-ignore lint/complexity/noBannedTypes: Kysely uses `{}` as the initial "no selected columns yet" marker.
-type EmptySelection = {};
-
-export interface SyncStats {
-  commitCount: number;
-  changeCount: number;
-  minCommitSeq: number;
-  maxCommitSeq: number;
-  clientCount: number;
-  activeClientCount: number;
-  minActiveClientCursor: number | null;
-  maxActiveClientCursor: number | null;
-  snapshotChunkCount: number;
-  snapshotChunkBytes: number;
-  expiredSnapshotChunkCount: number;
-  expiredSnapshotChunkBytes: number;
-  snapshotArtifactCount: number;
-  snapshotArtifactBytes: number;
-  expiredSnapshotArtifactCount: number;
-  expiredSnapshotArtifactBytes: number;
-}
-
-interface CachePressureRow {
-  total_count: unknown;
-  total_bytes: unknown;
-  expired_count: unknown;
-  expired_bytes: unknown;
-}
-
-function mapCachePressure(row: CachePressureRow | undefined): {
-  count: number;
-  bytes: number;
-  expiredCount: number;
-  expiredBytes: number;
-} {
-  return {
-    count: coerceNumber(row?.total_count) ?? 0,
-    bytes: coerceNumber(row?.total_bytes) ?? 0,
-    expiredCount: coerceNumber(row?.expired_count) ?? 0,
-    expiredBytes: coerceNumber(row?.expired_bytes) ?? 0,
-  };
-}
-
-export async function readSyncStats<DB extends SyncCoreDb>(
-  db: Kysely<DB>,
-  options: { activeWindowMs?: number; partitionId?: string } = {}
-): Promise<SyncStats> {
-  type SyncDb = Pick<Kysely<SyncCoreDb>, 'selectFrom'>;
-  const syncDb = db as SyncDb;
-
-  const activeWindowMs = options.activeWindowMs ?? 14 * 24 * 60 * 60 * 1000;
-  const cutoffIso = new Date(Date.now() - activeWindowMs).toISOString();
-  const nowIso = new Date().toISOString();
-  const partitionId = options.partitionId;
-
-  let commitQuery = (
-    syncDb.selectFrom('sync_commits') as SelectQueryBuilder<
-      SyncCoreDb,
-      'sync_commits',
-      EmptySelection
-    >
-  ).select(({ fn }) => [
-    fn.countAll().as('commitCount'),
-    fn.min('commit_seq').as('minCommitSeq'),
-    fn.max('commit_seq').as('maxCommitSeq'),
-  ]);
-
-  let changeQuery = (
-    syncDb.selectFrom('sync_changes') as SelectQueryBuilder<
-      SyncCoreDb,
-      'sync_changes',
-      EmptySelection
-    >
-  ).select(({ fn }) => [fn.countAll().as('changeCount')]);
-
-  let clientQuery = (
-    syncDb.selectFrom('sync_client_cursors') as SelectQueryBuilder<
-      SyncCoreDb,
-      'sync_client_cursors',
-      EmptySelection
-    >
-  ).select(({ fn }) => [fn.countAll().as('clientCount')]);
-
-  let activeClientQuery = (
-    syncDb.selectFrom('sync_client_cursors') as SelectQueryBuilder<
-      SyncCoreDb,
-      'sync_client_cursors',
-      EmptySelection
-    >
-  )
-    .where(sql<SqlBool>`updated_at >= ${cutoffIso}`)
-    .where(sql<SqlBool>`cursor >= ${0}`)
-    .select(({ fn }) => [
-      fn.countAll().as('activeClientCount'),
-      fn.min('cursor').as('minActiveClientCursor'),
-      fn.max('cursor').as('maxActiveClientCursor'),
-    ]);
-
-  if (partitionId) {
-    commitQuery = commitQuery.where('partition_id', '=', partitionId);
-    changeQuery = changeQuery.where('partition_id', '=', partitionId);
-    clientQuery = clientQuery.where('partition_id', '=', partitionId);
-    activeClientQuery = activeClientQuery.where(
-      'partition_id',
-      '=',
-      partitionId
-    );
-  }
-
-  const partitionFilter = partitionId
-    ? sql`where partition_id = ${partitionId}`
-    : sql``;
-
-  const [
-    commitRow,
-    changeRow,
-    clientRow,
-    activeClientRow,
-    chunkPressureRow,
-    artifactPressureRow,
-  ] = await Promise.all([
-    commitQuery.executeTakeFirst(),
-    changeQuery.executeTakeFirst(),
-    clientQuery.executeTakeFirst(),
-    activeClientQuery.executeTakeFirst(),
-    sql<CachePressureRow>`
-      select
-        count(*) as total_count,
-        coalesce(sum(byte_length), 0) as total_bytes,
-        coalesce(sum(case when expires_at <= ${nowIso} then 1 else 0 end), 0) as expired_count,
-        coalesce(sum(case when expires_at <= ${nowIso} then byte_length else 0 end), 0) as expired_bytes
-      from ${sql.table('sync_snapshot_chunks')}
-      ${partitionFilter}
-    `
-      .execute(db)
-      .then((result) => result.rows[0]),
-    sql<CachePressureRow>`
-      select
-        count(*) as total_count,
-        coalesce(sum(byte_length), 0) as total_bytes,
-        coalesce(sum(case when expires_at <= ${nowIso} then 1 else 0 end), 0) as expired_count,
-        coalesce(sum(case when expires_at <= ${nowIso} then byte_length else 0 end), 0) as expired_bytes
-      from ${sql.table('sync_snapshot_artifacts')}
-      ${partitionFilter}
-    `
-      .execute(db)
-      .then((result) => result.rows[0]),
-  ]);
-
-  const chunkPressure = mapCachePressure(chunkPressureRow);
-  const artifactPressure = mapCachePressure(artifactPressureRow);
-
-  return {
-    commitCount: coerceNumber(commitRow?.commitCount) ?? 0,
-    changeCount: coerceNumber(changeRow?.changeCount) ?? 0,
-    minCommitSeq: coerceNumber(commitRow?.minCommitSeq) ?? 0,
-    maxCommitSeq: coerceNumber(commitRow?.maxCommitSeq) ?? 0,
-    clientCount: coerceNumber(clientRow?.clientCount) ?? 0,
-    activeClientCount: coerceNumber(activeClientRow?.activeClientCount) ?? 0,
-    minActiveClientCursor: coerceNumber(activeClientRow?.minActiveClientCursor),
-    maxActiveClientCursor: coerceNumber(activeClientRow?.maxActiveClientCursor),
-    snapshotChunkCount: chunkPressure.count,
-    snapshotChunkBytes: chunkPressure.bytes,
-    expiredSnapshotChunkCount: chunkPressure.expiredCount,
-    expiredSnapshotChunkBytes: chunkPressure.expiredBytes,
-    snapshotArtifactCount: artifactPressure.count,
-    snapshotArtifactBytes: artifactPressure.bytes,
-    expiredSnapshotArtifactCount: artifactPressure.expiredCount,
-    expiredSnapshotArtifactBytes: artifactPressure.expiredBytes,
-  };
-}

package/src/subscriptions/cache.ts

@@ -1,376 +0,0 @@
-import type { ScopeValues } from '@syncular/core';
-import { type Kysely, sql } from 'kysely';
-import type { SyncServerAuth } from '../handlers/types';
-import type { SyncCoreDb } from '../schema';
-
-const DEFAULT_SCOPE_CACHE_PARTITION_ID = 'default';
-const DEFAULT_MEMORY_SCOPE_CACHE_TTL_MS = 30_000;
-const DEFAULT_MEMORY_SCOPE_CACHE_MAX_ENTRIES = 5_000;
-const DEFAULT_DATABASE_SCOPE_CACHE_TTL_MS = 60_000;
-const DEFAULT_DATABASE_SCOPE_CACHE_TABLE = 'sync_scope_cache';
-
-export interface ScopeCacheContext<
-  DB extends SyncCoreDb = SyncCoreDb,
-  Auth extends SyncServerAuth = SyncServerAuth,
-> {
-  db: Kysely<DB>;
-  auth: Auth;
-  table: string;
-  cacheKey: string;
-}
-
-export interface ScopeCacheSetContext<
-  DB extends SyncCoreDb = SyncCoreDb,
-  Auth extends SyncServerAuth = SyncServerAuth,
-> extends ScopeCacheContext<DB, Auth> {
-  scopes: ScopeValues;
-}
-
-/**
- * Shared cache contract for scope resolution results.
- *
- * Pull requests always apply request-local memoization first.
- * This cache is used to share results across pulls.
- */
-export interface ScopeCacheBackend {
-  name: string;
-  get<DB extends SyncCoreDb, Auth extends SyncServerAuth>(
-    args: ScopeCacheContext<DB, Auth>
-  ): Promise<ScopeValues | null>;
-  getOrResolve?<DB extends SyncCoreDb, Auth extends SyncServerAuth>(
-    args: ScopeCacheContext<DB, Auth> & {
-      load: () => Promise<ScopeValues | null>;
-    }
-  ): Promise<ScopeValues | null>;
-  set<DB extends SyncCoreDb, Auth extends SyncServerAuth>(
-    args: ScopeCacheSetContext<DB, Auth>
-  ): Promise<void>;
-  delete?<DB extends SyncCoreDb, Auth extends SyncServerAuth>(
-    args: ScopeCacheContext<DB, Auth>
-  ): Promise<void>;
-}
-
-export function createDefaultScopeCacheKey(args: {
-  table: string;
-  auth: SyncServerAuth;
-}): string {
-  const partitionId = args.auth.partitionId ?? DEFAULT_SCOPE_CACHE_PARTITION_ID;
-  return `${partitionId}\u0000${args.auth.actorId}\u0000${args.table}`;
-}
-
-function cloneScopeValues(scopes: ScopeValues): ScopeValues {
-  const cloned: ScopeValues = {};
-  for (const [key, value] of Object.entries(scopes)) {
-    if (typeof value === 'string') {
-      cloned[key] = value;
-      continue;
-    }
-    cloned[key] = [...value];
-  }
-  return cloned;
-}
-
-function parseScopeValues(value: string): ScopeValues | null {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(value);
-  } catch {
-    return null;
-  }
-
-  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-    return null;
-  }
-
-  const out: ScopeValues = {};
-  for (const [scopeKey, scopeValue] of Object.entries(parsed)) {
-    if (typeof scopeValue === 'string') {
-      out[scopeKey] = scopeValue;
-      continue;
-    }
-
-    if (
-      Array.isArray(scopeValue) &&
-      scopeValue.every((item) => typeof item === 'string')
-    ) {
-      out[scopeKey] = [...scopeValue];
-      continue;
-    }
-
-    return null;
-  }
-
-  return out;
-}
-
-interface MemoryScopeCacheEntry {
-  scopes: ScopeValues;
-  expiresAt: number;
-}
-
-export interface MemoryScopeCacheOptions {
-  ttlMs?: number;
-  maxEntries?: number;
-  now?: () => number;
-}
-
-export function createMemoryScopeCache(
-  options?: MemoryScopeCacheOptions
-): ScopeCacheBackend {
-  const ttlMs = options?.ttlMs ?? DEFAULT_MEMORY_SCOPE_CACHE_TTL_MS;
-  const maxEntries =
-    options?.maxEntries ?? DEFAULT_MEMORY_SCOPE_CACHE_MAX_ENTRIES;
-  const now = options?.now ?? Date.now;
-  const buckets = new WeakMap<object, Map<string, MemoryScopeCacheEntry>>();
-  const inflightByDb = new WeakMap<
-    object,
-    Map<string, Promise<ScopeValues | null>>
-  >();
-
-  function getBucket(db: object): Map<string, MemoryScopeCacheEntry> {
-    const existing = buckets.get(db);
-    if (existing) {
-      return existing;
-    }
-    const created = new Map<string, MemoryScopeCacheEntry>();
-    buckets.set(db, created);
-    return created;
-  }
-
-  function getInflightBucket(
-    db: object
-  ): Map<string, Promise<ScopeValues | null>> {
-    const existing = inflightByDb.get(db);
-    if (existing) {
-      return existing;
-    }
-    const created = new Map<string, Promise<ScopeValues | null>>();
-    inflightByDb.set(db, created);
-    return created;
-  }
-
-  function evictOldest(bucket: Map<string, MemoryScopeCacheEntry>): void {
-    while (bucket.size > maxEntries) {
-      const oldestKey = bucket.keys().next().value;
-      if (!oldestKey) {
-        return;
-      }
-      bucket.delete(oldestKey);
-    }
-  }
-
-  return {
-    name: 'memory',
-    async get(args) {
-      const bucket = getBucket(args.db);
-      const entry = bucket.get(args.cacheKey);
-      if (!entry) {
-        return null;
-      }
-
-      const nowMs = now();
-      if (entry.expiresAt <= nowMs) {
-        bucket.delete(args.cacheKey);
-        return null;
-      }
-
-      return cloneScopeValues(entry.scopes);
-    },
-    async getOrResolve(args) {
-      const cached = await this.get(args);
-      if (cached !== null) {
-        return cached;
-      }
-
-      const inflightBucket = getInflightBucket(args.db);
-      const inflight = inflightBucket.get(args.cacheKey);
-      if (inflight) {
-        const resolved = await inflight;
-        return resolved ? cloneScopeValues(resolved) : null;
-      }
-
-      const pending = args
-        .load()
-        .then(async (resolved) => {
-          if (resolved !== null && ttlMs > 0) {
-            const bucket = getBucket(args.db);
-            if (bucket.has(args.cacheKey)) {
-              bucket.delete(args.cacheKey);
-            }
-            bucket.set(args.cacheKey, {
-              scopes: cloneScopeValues(resolved),
-              expiresAt: now() + ttlMs,
-            });
-            evictOldest(bucket);
-          }
-          return resolved;
-        })
-        .finally(() => {
-          inflightBucket.delete(args.cacheKey);
-        });
-
-      inflightBucket.set(args.cacheKey, pending);
-      const resolved = await pending;
-      return resolved ? cloneScopeValues(resolved) : null;
-    },
-    async set(args) {
-      const bucket = getBucket(args.db);
-      if (ttlMs <= 0) {
-        bucket.delete(args.cacheKey);
-        return;
-      }
-
-      if (bucket.has(args.cacheKey)) {
-        bucket.delete(args.cacheKey);
-      }
-      bucket.set(args.cacheKey, {
-        scopes: cloneScopeValues(args.scopes),
-        expiresAt: now() + ttlMs,
-      });
-      evictOldest(bucket);
-    },
-    async delete(args) {
-      const bucket = getBucket(args.db);
-      bucket.delete(args.cacheKey);
-    },
-  };
-}
-
-export interface DatabaseScopeCacheOptions {
-  /**
-   * Scope cache table name.
-   * Default: `sync_scope_cache`
-   */
-  tableName?: string;
-  /**
-   * TTL for cache entries (milliseconds).
-   * Default: 60000
-   */
-  ttlMs?: number;
-  /**
-   * Automatically creates the cache table.
-   * Default: true
-   */
-  autoCreateTable?: boolean;
-  now?: () => Date;
-}
-
-export function createDatabaseScopeCache(
-  options?: DatabaseScopeCacheOptions
-): ScopeCacheBackend {
-  const tableName = options?.tableName ?? DEFAULT_DATABASE_SCOPE_CACHE_TABLE;
-  const ttlMs = options?.ttlMs ?? DEFAULT_DATABASE_SCOPE_CACHE_TTL_MS;
-  const autoCreateTable = options?.autoCreateTable ?? true;
-  const now = options?.now ?? (() => new Date());
-  const schemaReady = new WeakMap<object, Promise<void>>();
-
-  async function ensureTable<DB extends SyncCoreDb>(db: Kysely<DB>) {
-    if (!autoCreateTable) {
-      return;
-    }
-
-    const existing = schemaReady.get(db);
-    if (existing) {
-      await existing;
-      return;
-    }
-
-    const pending = sql`
-      CREATE TABLE IF NOT EXISTS ${sql.table(tableName)} (
-        cache_key TEXT PRIMARY KEY,
-        scope_values TEXT NOT NULL,
-        expires_at TEXT NOT NULL,
-        created_at TEXT NOT NULL
-      )
-    `
-      .execute(db)
-      .then(() => undefined);
-    schemaReady.set(db, pending);
-
-    try {
-      await pending;
-    } catch (error) {
-      schemaReady.delete(db);
-      throw error;
-    }
-  }
-
-  async function removeCacheRow<DB extends SyncCoreDb>(args: {
-    db: Kysely<DB>;
-    cacheKey: string;
-  }): Promise<void> {
-    await sql`
-      DELETE FROM ${sql.table(tableName)}
-      WHERE cache_key = ${args.cacheKey}
-    `.execute(args.db);
-  }
-
-  return {
-    name: 'database',
-    async get(args) {
-      await ensureTable(args.db);
-
-      const rows = await sql<{
-        scope_values: string;
-        expires_at: string;
-      }>`
-        SELECT scope_values, expires_at
-        FROM ${sql.table(tableName)}
-        WHERE cache_key = ${args.cacheKey}
-        LIMIT 1
-      `.execute(args.db);
-
-      const row = rows.rows[0];
-      if (!row) {
-        return null;
-      }
-
-      const nowIso = now().toISOString();
-      if (row.expires_at <= nowIso) {
-        await removeCacheRow({ db: args.db, cacheKey: args.cacheKey });
-        return null;
-      }
-
-      const parsed = parseScopeValues(row.scope_values);
-      if (!parsed) {
-        await removeCacheRow({ db: args.db, cacheKey: args.cacheKey });
-        return null;
-      }
-
-      return parsed;
-    },
-    async set(args) {
-      await ensureTable(args.db);
-
-      if (ttlMs <= 0) {
-        await removeCacheRow({ db: args.db, cacheKey: args.cacheKey });
-        return;
-      }
-
-      const createdAt = now();
-      const expiresAt = new Date(createdAt.getTime() + ttlMs);
-      await sql`
-        INSERT INTO ${sql.table(tableName)} (
-          cache_key,
-          scope_values,
-          expires_at,
-          created_at
-        )
-        VALUES (
-          ${args.cacheKey},
-          ${JSON.stringify(cloneScopeValues(args.scopes))},
-          ${expiresAt.toISOString()},
-          ${createdAt.toISOString()}
-        )
-        ON CONFLICT (cache_key) DO UPDATE SET
-          scope_values = EXCLUDED.scope_values,
-          expires_at = EXCLUDED.expires_at,
-          created_at = EXCLUDED.created_at
-      `.execute(args.db);
-    },
-    async delete(args) {
-      await ensureTable(args.db);
-      await removeCacheRow({ db: args.db, cacheKey: args.cacheKey });
-    },
-  };
-}

package/src/subscriptions/index.ts

@@ -1,2 +0,0 @@
-export * from './cache';
-export * from './resolve';