@syncular/testkit 0.1.3 → 0.2.1

package/src/deterministic.ts

@@ -1,121 +0,0 @@
-export interface CreateIdFactoryOptions {
-  prefix?: string;
-  separator?: string;
-  startAt?: number;
-  step?: number;
-  padLength?: number;
-}
-
-export interface IdFactory {
-  next: () => string;
-  peek: () => string;
-  current: () => number;
-  reset: (startAt?: number) => void;
-}
-
-function normalizeCounter(value: number, label: string): number {
-  if (!Number.isFinite(value)) {
-    throw new Error(`${label} must be a finite number`);
-  }
-
-  return Math.trunc(value);
-}
-
-function formatCounter(value: number, padLength: number): string {
-  const text = String(value);
-  return padLength > text.length ? text.padStart(padLength, '0') : text;
-}
-
-export function createIdFactory(
-  options: CreateIdFactoryOptions = {}
-): IdFactory {
-  const prefix = options.prefix ?? '';
-  const separator = options.separator ?? '-';
-  const step = normalizeCounter(options.step ?? 1, 'step');
-  const padLength = Math.max(
-    0,
-    normalizeCounter(options.padLength ?? 0, 'padLength')
-  );
-
-  if (step === 0) {
-    throw new Error('step must not be 0');
-  }
-
-  let counter = normalizeCounter(options.startAt ?? 1, 'startAt');
-
-  const format = (value: number): string => {
-    const token = formatCounter(value, padLength);
-    if (prefix.length === 0) {
-      return token;
-    }
-
-    return `${prefix}${separator}${token}`;
-  };
-
-  return {
-    next: () => {
-      const value = format(counter);
-      counter += step;
-      return value;
-    },
-    peek: () => format(counter),
-    current: () => counter,
-    reset: (nextStartAt = options.startAt ?? 1) => {
-      counter = normalizeCounter(nextStartAt, 'startAt');
-    },
-  };
-}
-
-export interface CreateCommitIdFactoryOptions
-  extends Omit<CreateIdFactoryOptions, 'prefix'> {
-  prefix?: string;
-}
-
-export function createCommitIdFactory(
-  options: CreateCommitIdFactoryOptions = {}
-): IdFactory {
-  return createIdFactory({
-    prefix: options.prefix ?? 'commit',
-    separator: options.separator,
-    startAt: options.startAt,
-    step: options.step,
-    padLength: options.padLength,
-  });
-}
-
-export interface CreateFakeClockOptions {
-  startMs?: number;
-  tickMs?: number;
-}
-
-export interface FakeClock {
-  now: () => number;
-  iso: () => string;
-  set: (nextMs: number) => number;
-  advance: (deltaMs: number) => number;
-  tick: (stepMs?: number) => number;
-}
-
-export function createFakeClock(
-  options: CreateFakeClockOptions = {}
-): FakeClock {
-  const defaultTickMs = normalizeCounter(options.tickMs ?? 1, 'tickMs');
-  let nowMs = normalizeCounter(options.startMs ?? Date.now(), 'startMs');
-
-  return {
-    now: () => nowMs,
-    iso: () => new Date(nowMs).toISOString(),
-    set: (nextMs: number) => {
-      nowMs = normalizeCounter(nextMs, 'nextMs');
-      return nowMs;
-    },
-    advance: (deltaMs: number) => {
-      nowMs += normalizeCounter(deltaMs, 'deltaMs');
-      return nowMs;
-    },
-    tick: (stepMs = defaultTickMs) => {
-      nowMs += normalizeCounter(stepMs, 'stepMs');
-      return nowMs;
-    },
-  };
-}

package/src/disposable.ts

@@ -1,50 +0,0 @@
-export interface AsyncDisposableResource<T> {
-  value: T;
-  dispose: () => Promise<void>;
-  [Symbol.asyncDispose]: () => Promise<void>;
-}
-
-export type ResourceRunner<T, TResult> =
-  | ((value: T) => Promise<TResult>)
-  | ((value: T) => TResult);
-
-export function createAsyncDisposableResource<T>(
-  value: T,
-  dispose: () => Promise<void> | void
-): AsyncDisposableResource<T> {
-  let disposed = false;
-
-  const disposeOnce = async () => {
-    if (disposed) {
-      return;
-    }
-
-    disposed = true;
-    await dispose();
-  };
-
-  return {
-    value,
-    dispose: disposeOnce,
-    [Symbol.asyncDispose]: disposeOnce,
-  };
-}
-
-export async function withAsyncDisposableResource<T, TResult>(
-  resource: AsyncDisposableResource<T>,
-  run: ResourceRunner<T, TResult>
-): Promise<TResult> {
-  try {
-    return await run(resource.value);
-  } finally {
-    await resource.dispose();
-  }
-}
-
-export async function withAsyncDisposableFactory<T, TResult>(
-  create: () => Promise<AsyncDisposableResource<T>>,
-  run: ResourceRunner<T, TResult>
-): Promise<TResult> {
-  const resource = await create();
-  return withAsyncDisposableResource(resource, run);
-}

package/src/hono-node-server.ts

@@ -1,144 +0,0 @@
-import { createServer, type Server as NodeServer } from 'node:http';
-import type { Hono } from 'hono';
-import {
-  type AsyncDisposableResource,
-  createAsyncDisposableResource,
-  type ResourceRunner,
-  withAsyncDisposableFactory,
-} from './disposable';
-
-export interface NodeHonoServerOptions {
-  cors?: boolean;
-  corsAllowMethods?: string;
-  corsAllowHeaders?: string;
-  corsMaxAgeSeconds?: number;
-}
-
-export interface CreateNodeHonoServerResourceOptions
-  extends NodeHonoServerOptions {
-  listen?: boolean;
-  host?: string;
-  port?: number;
-}
-
-export function createNodeHonoServer(
-  app: Hono,
-  options?: NodeHonoServerOptions
-): NodeServer {
-  const corsEnabled = options?.cors ?? true;
-  const corsAllowMethods =
-    options?.corsAllowMethods ?? 'GET, POST, PUT, DELETE, OPTIONS';
-  const corsAllowHeaders =
-    options?.corsAllowHeaders ??
-    'authorization, content-type, x-actor-id, x-partition-id, x-syncular-schema-version, x-syncular-snapshot-scopes, x-syncular-transport-path, x-upload-token, x-user-id';
-  const corsMaxAgeSeconds = options?.corsMaxAgeSeconds ?? 86400;
-
-  return createServer(async (req, res) => {
-    const url = `http://localhost${req.url ?? '/'}`;
-
-    const headers = new Headers();
-    for (const [key, value] of Object.entries(req.headers)) {
-      if (!value) {
-        continue;
-      }
-
-      headers.set(key, Array.isArray(value) ? value.join(', ') : value);
-    }
-
-    if (corsEnabled && req.method === 'OPTIONS') {
-      res.writeHead(204, {
-        'access-control-allow-origin': '*',
-        'access-control-allow-methods': corsAllowMethods,
-        'access-control-allow-headers': corsAllowHeaders,
-        'access-control-max-age': String(corsMaxAgeSeconds),
-      });
-      res.end();
-      return;
-    }
-
-    const hasBody = req.method !== 'GET' && req.method !== 'HEAD';
-    const body = hasBody
-      ? await new Promise<Uint8Array>((resolve) => {
-          const chunks: Uint8Array[] = [];
-          req.on('data', (chunk: Uint8Array) => chunks.push(chunk));
-          req.on('end', () => {
-            const total = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-            const merged = new Uint8Array(total);
-            let offset = 0;
-            for (const chunk of chunks) {
-              merged.set(chunk, offset);
-              offset += chunk.length;
-            }
-            resolve(merged);
-          });
-        })
-      : undefined;
-
-    const requestBody = body ? Uint8Array.from(body) : undefined;
-
-    const request = new Request(url, {
-      method: req.method,
-      headers,
-      body: requestBody,
-    });
-
-    const response = await app.fetch(request);
-    const responseHeaders: Record<string, string> = {};
-    response.headers.forEach((value, key) => {
-      responseHeaders[key] = value;
-    });
-
-    if (corsEnabled) {
-      responseHeaders['access-control-allow-origin'] = '*';
-    }
-
-    res.writeHead(response.status, responseHeaders);
-    const bytes = Buffer.from(await response.arrayBuffer());
-    res.end(bytes);
-  });
-}
-
-export async function closeNodeServer(server: NodeServer): Promise<void> {
-  await new Promise<void>((resolve, reject) => {
-    server.close((error) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-
-      resolve();
-    });
-  });
-}
-
-export function createNodeServerResource(
-  server: NodeServer
-): AsyncDisposableResource<NodeServer> {
-  return createAsyncDisposableResource(server, () => closeNodeServer(server));
-}
-
-export async function createNodeHonoServerResource(
-  app: Hono,
-  options: CreateNodeHonoServerResourceOptions = {}
-): Promise<AsyncDisposableResource<NodeServer>> {
-  const server = createNodeHonoServer(app, options);
-
-  if (options.listen ?? true) {
-    await new Promise<void>((resolve) => {
-      server.listen(options.port ?? 0, options.host ?? '127.0.0.1', resolve);
-    });
-  }
-
-  return createNodeServerResource(server);
-}
-
-export async function withNodeHonoServer<TResult>(
-  app: Hono,
-  run: ResourceRunner<NodeServer, TResult>,
-  options: CreateNodeHonoServerResourceOptions = {}
-): Promise<TResult> {
-  return withAsyncDisposableFactory(
-    () => createNodeHonoServerResource(app, options),
-    run
-  );
-}

package/src/http-fixtures.ts

@@ -1,187 +0,0 @@
-import { createDatabase } from '@syncular/core';
-import {
-  ensureSyncSchema,
-  type ServerSyncDialect,
-  type ServerTableHandler,
-  type SyncCoreDb,
-} from '@syncular/server';
-import { createBunSqliteDialect } from '@syncular/server/bun-sqlite';
-import {
-  type CreateSyncRoutesOptions,
-  createSyncRoutes,
-} from '@syncular/server/hono';
-import { createPgliteDialect } from '@syncular/server/pglite';
-import { createPostgresServerDialect } from '@syncular/server/postgres';
-import { createSqliteServerDialect } from '@syncular/server/sqlite';
-import { Hono } from 'hono';
-import type { Kysely } from 'kysely';
-import { createNodeHonoServer } from './hono-node-server';
-
-export type HttpServerDialect = 'sqlite' | 'pglite';
-
-export interface HttpServerFixture<DB extends SyncCoreDb> {
-  db: Kysely<DB>;
-  dialect: ServerSyncDialect;
-  app: Hono;
-  httpServer: ReturnType<typeof createNodeHonoServer>;
-  baseUrl: string;
-  destroy: () => Promise<void>;
-}
-
-export interface CreateHttpServerFixtureOptions<DB extends SyncCoreDb> {
-  serverDialect: HttpServerDialect;
-  createTables: (db: Kysely<DB>) => Promise<void>;
-  handlers: ServerTableHandler<DB>[];
-  authenticate: CreateSyncRoutesOptions<
-    DB,
-    { actorId: string }
-  >['authenticate'];
-  sync?: CreateSyncRoutesOptions<DB, { actorId: string }>['sync'];
-  routePath?: string;
-  cors?: boolean;
-  corsAllowMethods?: string;
-  corsAllowHeaders?: string;
-  corsMaxAgeSeconds?: number;
-}
-
-const PGLITE_INIT_ATTEMPTS = 3;
-
-function isTransientPgliteInitError(error: Error): boolean {
-  return (
-    error.message.includes('access to a null reference') ||
-    error.message.includes('_pgl_initdb')
-  );
-}
-
-function isServerNotRunningError(error: Error | null): boolean {
-  return (
-    error !== null && 'code' in error && error.code === 'ERR_SERVER_NOT_RUNNING'
-  );
-}
-
-async function delay(ms: number): Promise<void> {
-  await new Promise<void>((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-
-async function withPgliteInitRetry<T>(
-  useRetries: boolean,
-  create: () => Promise<T>
-): Promise<T> {
-  const maxAttempts = useRetries ? PGLITE_INIT_ATTEMPTS : 1;
-  let lastError: Error | null = null;
-
-  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-    try {
-      return await create();
-    } catch (error) {
-      const candidate =
-        error instanceof Error ? error : new Error(String(error));
-      lastError = candidate;
-
-      const isRetryable =
-        useRetries &&
-        attempt < maxAttempts &&
-        isTransientPgliteInitError(candidate);
-      if (!isRetryable) {
-        throw candidate;
-      }
-
-      await delay(25 * attempt);
-    }
-  }
-
-  throw lastError ?? new Error('PGLite initialization failed');
-}
-
-export async function createHttpServerFixture<DB extends SyncCoreDb>(
-  options: CreateHttpServerFixtureOptions<DB>
-): Promise<HttpServerFixture<DB>> {
-  const dialect =
-    options.serverDialect === 'pglite'
-      ? createPostgresServerDialect()
-      : createSqliteServerDialect();
-
-  const db = await withPgliteInitRetry(
-    options.serverDialect === 'pglite',
-    async () => {
-      const candidateDb =
-        options.serverDialect === 'pglite'
-          ? createDatabase<DB>({
-              dialect: createPgliteDialect(),
-              family: 'postgres',
-            })
-          : createDatabase<DB>({
-              dialect: createBunSqliteDialect({ path: ':memory:' }),
-              family: 'sqlite',
-            });
-
-      try {
-        await ensureSyncSchema(candidateDb, dialect);
-        if (dialect.ensureConsoleSchema) {
-          await dialect.ensureConsoleSchema(candidateDb);
-        }
-        await options.createTables(candidateDb);
-        return candidateDb;
-      } catch (error) {
-        await candidateDb.destroy();
-        throw error;
-      }
-    }
-  );
-
-  const app = new Hono();
-  const routePath = options.routePath ?? '/sync';
-
-  const syncRoutes = createSyncRoutes<DB>({
-    db,
-    dialect,
-    handlers: options.handlers,
-    authenticate: options.authenticate,
-    sync: options.sync,
-  });
-
-  app.route(routePath, syncRoutes);
-
-  const httpServer = createNodeHonoServer(app, {
-    cors: options.cors,
-    corsAllowMethods: options.corsAllowMethods,
-    corsAllowHeaders: options.corsAllowHeaders,
-    corsMaxAgeSeconds: options.corsMaxAgeSeconds,
-  });
-
-  await new Promise<void>((resolve) => {
-    httpServer.listen(0, resolve);
-  });
-
-  const address = httpServer.address();
-  const port = typeof address === 'object' && address ? address.port : 0;
-
-  let destroyed = false;
-
-  return {
-    db,
-    dialect,
-    app,
-    httpServer,
-    baseUrl: `http://localhost:${port}`,
-    destroy: async () => {
-      if (destroyed) {
-        return;
-      }
-      destroyed = true;
-
-      await new Promise<void>((resolve, reject) => {
-        httpServer.close((err) => {
-          if (err && !isServerNotRunningError(err)) {
-            reject(err);
-            return;
-          }
-          resolve();
-        });
-      });
-      await db.destroy();
-    },
-  };
-}