@syncular/testkit 0.1.3 → 0.2.0

package/src/runtime-process.ts

@@ -1,159 +0,0 @@
-import type { ChildProcess } from 'node:child_process';
-import {
-  type AsyncDisposableResource,
-  createAsyncDisposableResource,
-  type ResourceRunner,
-  withAsyncDisposableFactory,
-} from './disposable';
-
-export interface WaitForJsonPortOptions {
-  timeoutMs?: number;
-  processName?: string;
-}
-
-export async function waitForJsonPortFromStdout(
-  process: ChildProcess,
-  options: WaitForJsonPortOptions = {}
-): Promise<number> {
-  const timeoutMs = options.timeoutMs ?? 30_000;
-  const processName = options.processName ?? 'Child process';
-
-  return new Promise<number>((resolve, reject) => {
-    const stdout = process.stdout;
-    const stderr = process.stderr;
-
-    if (!stdout || !stderr) {
-      reject(new Error(`${processName} has no stdout/stderr pipes`));
-      return;
-    }
-
-    let stdoutBuffer = '';
-    let stderrBuffer = '';
-
-    const cleanup = () => {
-      clearTimeout(timeout);
-      stdout.off('data', onStdoutData);
-      stderr.off('data', onStderrData);
-      process.off('exit', onExit);
-    };
-
-    const resolvePort = (port: number) => {
-      cleanup();
-      resolve(port);
-    };
-
-    const rejectWith = (error: Error) => {
-      cleanup();
-      reject(error);
-    };
-
-    const onStdoutData = (chunk: Buffer | string) => {
-      stdoutBuffer += chunk.toString();
-
-      const lines = stdoutBuffer.split('\n');
-      stdoutBuffer = lines.pop() ?? '';
-
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed) {
-          continue;
-        }
-
-        try {
-          const parsed = JSON.parse(trimmed) as { port?: number };
-          if (parsed.port && parsed.port > 0) {
-            resolvePort(parsed.port);
-            return;
-          }
-        } catch {
-          // keep reading until a valid JSON line is emitted
-        }
-      }
-    };
-
-    const onStderrData = (chunk: Buffer | string) => {
-      stderrBuffer += chunk.toString();
-    };
-
-    const onExit = (code: number | null, signal: NodeJS.Signals | null) => {
-      rejectWith(
-        new Error(
-          `${processName} exited before reporting port (code=${String(code)} signal=${String(signal)})\nstderr: ${stderrBuffer}`
-        )
-      );
-    };
-
-    const timeout = setTimeout(() => {
-      rejectWith(
-        new Error(
-          `${processName} startup timed out after ${timeoutMs}ms\nstderr: ${stderrBuffer}`
-        )
-      );
-    }, timeoutMs);
-
-    stdout.on('data', onStdoutData);
-    stderr.on('data', onStderrData);
-    process.on('exit', onExit);
-  });
-}
-
-export interface StopChildProcessOptions {
-  gracePeriodMs?: number;
-}
-
-export async function stopChildProcess(
-  process: ChildProcess,
-  options: StopChildProcessOptions = {}
-): Promise<void> {
-  if (process.exitCode != null) {
-    return;
-  }
-
-  const gracePeriodMs = options.gracePeriodMs ?? 5000;
-
-  try {
-    process.kill('SIGTERM');
-  } catch {
-    return;
-  }
-
-  await new Promise<void>((resolve) => {
-    const onExit = () => {
-      clearTimeout(timeout);
-      process.off('exit', onExit);
-      resolve();
-    };
-
-    const timeout = setTimeout(() => {
-      try {
-        process.kill('SIGKILL');
-      } catch {
-        // ignore
-      }
-      process.off('exit', onExit);
-      resolve();
-    }, gracePeriodMs);
-
-    process.on('exit', onExit);
-  });
-}
-
-export function createChildProcessResource(
-  process: ChildProcess,
-  options: StopChildProcessOptions = {}
-): AsyncDisposableResource<ChildProcess> {
-  return createAsyncDisposableResource(process, () =>
-    stopChildProcess(process, options)
-  );
-}
-
-export async function withChildProcess<TResult>(
-  process: ChildProcess,
-  run: ResourceRunner<ChildProcess, TResult>,
-  options: StopChildProcessOptions = {}
-): Promise<TResult> {
-  return withAsyncDisposableFactory(
-    async () => createChildProcessResource(process, options),
-    run
-  );
-}

package/src/sync-builders.ts

@@ -1,136 +0,0 @@
-import type {
-  SyncCombinedRequest,
-  SyncOperation,
-  SyncPullRequest,
-  SyncPushBatchRequest,
-  SyncSubscriptionRequest,
-} from '@syncular/core';
-
-export interface CreateSyncUpsertOperationOptions {
-  table: string;
-  rowId: string;
-  payload: Record<string, unknown>;
-  baseVersion?: number | null;
-}
-
-export function createSyncUpsertOperation(
-  options: CreateSyncUpsertOperationOptions
-): SyncOperation {
-  return {
-    table: options.table,
-    row_id: options.rowId,
-    op: 'upsert',
-    payload: options.payload,
-    base_version: options.baseVersion ?? null,
-  };
-}
-
-export interface CreateSyncDeleteOperationOptions {
-  table: string;
-  rowId: string;
-  baseVersion?: number | null;
-}
-
-export function createSyncDeleteOperation(
-  options: CreateSyncDeleteOperationOptions
-): SyncOperation {
-  return {
-    table: options.table,
-    row_id: options.rowId,
-    op: 'delete',
-    payload: null,
-    base_version: options.baseVersion ?? null,
-  };
-}
-
-export interface CreateSyncSubscriptionOptions {
-  id: string;
-  table: string;
-  scopes: SyncSubscriptionRequest['scopes'];
-  params?: SyncSubscriptionRequest['params'];
-  cursor?: number;
-  bootstrapState?: SyncSubscriptionRequest['bootstrapState'];
-  crdtStateVectors?: SyncSubscriptionRequest['crdtStateVectors'];
-}
-
-export function createSyncSubscription(
-  options: CreateSyncSubscriptionOptions
-): SyncSubscriptionRequest {
-  return {
-    id: options.id,
-    table: options.table,
-    scopes: options.scopes,
-    ...(options.params ? { params: options.params } : {}),
-    cursor: options.cursor ?? 0,
-    bootstrapState: options.bootstrapState ?? null,
-    crdtStateVectors: options.crdtStateVectors ?? [],
-  };
-}
-
-export interface CreateSyncPushRequestOptions {
-  clientId: string;
-  clientCommitId: string;
-  operations: SyncOperation[];
-  schemaVersion?: number;
-}
-
-export function createSyncPushRequest(
-  options: CreateSyncPushRequestOptions
-): SyncPushBatchRequest {
-  return {
-    clientId: options.clientId,
-    commits: [
-      {
-        clientCommitId: options.clientCommitId,
-        operations: options.operations,
-        schemaVersion: options.schemaVersion ?? 1,
-      },
-    ],
-  };
-}
-
-export interface CreateSyncPullRequestOptions {
-  clientId: string;
-  schemaVersion?: number;
-  subscriptions: SyncSubscriptionRequest[];
-  limitCommits?: number;
-  limitSnapshotRows?: number;
-  maxSnapshotPages?: number;
-  dedupeRows?: boolean;
-}
-
-export function createSyncPullRequest(
-  options: CreateSyncPullRequestOptions
-): SyncPullRequest {
-  return {
-    clientId: options.clientId,
-    schemaVersion: options.schemaVersion ?? 1,
-    subscriptions: options.subscriptions,
-    limitCommits: options.limitCommits ?? 50,
-    ...(options.limitSnapshotRows !== undefined
-      ? { limitSnapshotRows: options.limitSnapshotRows }
-      : {}),
-    ...(options.maxSnapshotPages !== undefined
-      ? { maxSnapshotPages: options.maxSnapshotPages }
-      : {}),
-    ...(options.dedupeRows !== undefined
-      ? { dedupeRows: options.dedupeRows }
-      : {}),
-  };
-}
-
-export interface CreateSyncCombinedRequestOptions {
-  clientId: string;
-  push?: Omit<SyncPushBatchRequest, 'clientId'>;
-  pull?: Omit<SyncPullRequest, 'clientId'>;
-}
-
-export function createSyncCombinedRequest(
-  options: CreateSyncCombinedRequestOptions
-): SyncCombinedRequest {
-  return {
-    clientId: options.clientId,
-    ...(options.push ? { push: options.push } : {}),
-    ...(options.pull ? { pull: options.pull } : {}),
-  };
-}

package/src/sync-http.ts

@@ -1,117 +0,0 @@
-import type {
-  SyncCombinedRequest,
-  SyncCombinedResponse,
-  SyncPullRequest,
-  SyncPullResponse,
-  SyncPushRequest,
-  SyncPushResponse,
-} from '@syncular/core';
-import {
-  parseSyncCombinedResponse,
-  parseSyncPullResponse,
-  parseSyncPushResponse,
-} from './sync-parse';
-
-export interface JsonActorHeadersOptions {
-  actorId: string;
-  actorHeader?: string;
-  extraHeaders?: Record<string, string>;
-}
-
-export function createJsonActorHeaders(
-  options: JsonActorHeadersOptions
-): Record<string, string> {
-  return {
-    'content-type': 'application/json',
-    [options.actorHeader ?? 'x-actor-id']: options.actorId,
-    ...options.extraHeaders,
-  };
-}
-
-export interface PostJsonWithActorOptions<TBody> {
-  fetch: typeof globalThis.fetch;
-  url: string;
-  actorId: string;
-  actorHeader?: string;
-  extraHeaders?: Record<string, string>;
-  body: TBody;
-}
-
-export interface PostJsonWithActorResult<TResponse> {
-  response: Response;
-  json: TResponse;
-}
-
-export async function postJsonWithActor<TBody, TResponse>(
-  options: PostJsonWithActorOptions<TBody>
-): Promise<PostJsonWithActorResult<TResponse>> {
-  const response = await options.fetch(options.url, {
-    method: 'POST',
-    headers: createJsonActorHeaders({
-      actorId: options.actorId,
-      actorHeader: options.actorHeader,
-      extraHeaders: options.extraHeaders,
-    }),
-    body: JSON.stringify(options.body),
-  });
-
-  const json = (await response.json()) as TResponse;
-  return { response, json };
-}
-
-export interface PostSyncCombinedRequestOptions {
-  fetch: typeof globalThis.fetch;
-  url: string;
-  actorId: string;
-  actorHeader?: string;
-  extraHeaders?: Record<string, string>;
-  body: SyncCombinedRequest;
-}
-
-export async function postSyncCombinedRequest(
-  options: PostSyncCombinedRequestOptions
-): Promise<PostJsonWithActorResult<SyncCombinedResponse>> {
-  const result = await postJsonWithActor<SyncCombinedRequest, unknown>(options);
-  return {
-    response: result.response,
-    json: parseSyncCombinedResponse(result.json),
-  };
-}
-
-export interface PostSyncPushRequestOptions {
-  fetch: typeof globalThis.fetch;
-  url: string;
-  actorId: string;
-  actorHeader?: string;
-  extraHeaders?: Record<string, string>;
-  body: SyncPushRequest;
-}
-
-export async function postSyncPushRequest(
-  options: PostSyncPushRequestOptions
-): Promise<PostJsonWithActorResult<SyncPushResponse>> {
-  const result = await postJsonWithActor<SyncPushRequest, unknown>(options);
-  return {
-    response: result.response,
-    json: parseSyncPushResponse(result.json),
-  };
-}
-
-export interface PostSyncPullRequestOptions {
-  fetch: typeof globalThis.fetch;
-  url: string;
-  actorId: string;
-  actorHeader?: string;
-  extraHeaders?: Record<string, string>;
-  body: SyncPullRequest;
-}
-
-export async function postSyncPullRequest(
-  options: PostSyncPullRequestOptions
-): Promise<PostJsonWithActorResult<SyncPullResponse>> {
-  const result = await postJsonWithActor<SyncPullRequest, unknown>(options);
-  return {
-    response: result.response,
-    json: parseSyncPullResponse(result.json),
-  };
-}

package/src/sync-parse.ts

@@ -1,86 +0,0 @@
-import {
-  type SyncCombinedResponse,
-  SyncCombinedResponseSchema,
-  type SyncPullResponse,
-  SyncPullResponseSchema,
-  type SyncPushResponse,
-  SyncPushResponseSchema,
-} from '@syncular/core';
-
-interface ParseIssue {
-  path: ReadonlyArray<PropertyKey>;
-  message: string;
-}
-
-type ParseResult<T> =
-  | { success: true; data: T }
-  | { success: false; error: { issues: ReadonlyArray<ParseIssue> } };
-
-function formatIssue(issue: ParseIssue): string {
-  const path =
-    issue.path.length > 0
-      ? issue.path
-          .map((segment) =>
-            typeof segment === 'symbol' ? segment.toString() : String(segment)
-          )
-          .join('.')
-      : 'root';
-  return `${path}: ${issue.message}`;
-}
-
-function formatIssues(issues: ReadonlyArray<ParseIssue>): string {
-  return issues.map((issue) => formatIssue(issue)).join('; ');
-}
-
-function parseOrThrow<T>(
-  label: string,
-  value: unknown,
-  parse: (input: unknown) => ParseResult<T>
-): T {
-  const parsed = parse(value);
-  if (parsed.success) {
-    return parsed.data;
-  }
-
-  throw new Error(
-    `${label} validation failed: ${formatIssues(parsed.error.issues)}`
-  );
-}
-
-export function parseSyncCombinedResponse(
-  value: unknown
-): SyncCombinedResponse {
-  return parseOrThrow('SyncCombinedResponse', value, (input) =>
-    SyncCombinedResponseSchema.safeParse(input)
-  );
-}
-
-export function parseSyncPushResponse(value: unknown): SyncPushResponse {
-  return parseOrThrow('SyncPushResponse', value, (input) =>
-    SyncPushResponseSchema.safeParse(input)
-  );
-}
-
-export function parseSyncPullResponse(value: unknown): SyncPullResponse {
-  return parseOrThrow('SyncPullResponse', value, (input) =>
-    SyncPullResponseSchema.safeParse(input)
-  );
-}
-
-export async function readSyncCombinedResponse(
-  response: Response
-): Promise<SyncCombinedResponse> {
-  return parseSyncCombinedResponse(await response.json());
-}
-
-export async function readSyncPushResponse(
-  response: Response
-): Promise<SyncPushResponse> {
-  return parseSyncPushResponse(await response.json());
-}
-
-export async function readSyncPullResponse(
-  response: Response
-): Promise<SyncPullResponse> {
-  return parseSyncPullResponse(await response.json());
-}

package/src/sync-response.ts

@@ -1,43 +0,0 @@
-import {
-  isRecord,
-  type SyncChange,
-  type SyncPullResponse,
-} from '@syncular/core';
-
-export type SyncSubscriptionRecord = Pick<
-  SyncPullResponse['subscriptions'][number],
-  'id' | 'commits'
->;
-
-export function subscriptionChanges(
-  subscriptions: SyncSubscriptionRecord[] | undefined,
-  subscriptionId: string
-): SyncChange[] {
-  const subscription = subscriptions?.find(
-    (item) => item.id === subscriptionId
-  );
-  if (!subscription) {
-    return [];
-  }
-
-  return subscription.commits?.flatMap((commit) => commit.changes) ?? [];
-}
-
-export function findSubscriptionChange(
-  subscriptions: SyncSubscriptionRecord[] | undefined,
-  subscriptionId: string,
-  rowId: string
-): SyncChange | undefined {
-  const changes = subscriptionChanges(subscriptions, subscriptionId);
-  return changes.find((change) => change.row_id === rowId);
-}
-
-export function subscriptionChangeRow(
-  change: SyncChange | undefined
-): Record<string, unknown> | undefined {
-  if (!change) {
-    return undefined;
-  }
-
-  return isRecord(change.row_json) ? change.row_json : undefined;
-}