@boxxy/auth-oauth 0.0.1 → 0.2.2

package/src/test-utils/build-stub-clock.ts

@@ -0,0 +1,65 @@
+// Copied from atc: packages/test-utils/src/build-stub-clock.ts at commit 4fe647cf.
+
+import type { AuthClock } from '../utils/types.ts';
+
+interface StubTimer {
+  readonly dueAt: number;
+  readonly callback: () => void;
+}
+
+export function buildStubClock(startMs: number) {
+  let time = startMs;
+  let nextID = 0;
+
+  const timers = new Map<number, StubTimer>();
+
+  const delays: number[] = [];
+
+  const findDue = (until: number): [number, StubTimer] | null => {
+    let due: [number, StubTimer] | null = null;
+
+    for (const entry of timers) {
+      if (entry[1].dueAt <= until && (due === null || entry[1].dueAt < due[1].dueAt)) {
+        due = entry;
+      }
+    }
+
+    return due;
+  };
+
+  const clock: AuthClock = {
+    now: () => time,
+    schedule: (callback, delayMs) => {
+      const id = nextID++;
+
+      delays.push(delayMs);
+      timers.set(id, { dueAt: time + Math.max(0, delayMs), callback });
+
+      return () => {
+        timers.delete(id);
+      };
+    },
+  };
+
+  return {
+    ...clock,
+    advance(durationMs: number): void {
+      const until = time + durationMs;
+
+      for (let due = findDue(until); due !== null; due = findDue(until)) {
+        timers.delete(due[0]);
+
+        time = due[1].dueAt;
+
+        due[1].callback();
+      }
+
+      time = until;
+    },
+    collectPending: (): number[] =>
+      [...timers.values()]
+        .map((timer) => timer.dueAt - time)
+        .toSorted((left, right) => left - right),
+    collectDelays: (): number[] => [...delays],
+  };
+}

package/src/test-utils/load-web-authn-early.ts

@@ -0,0 +1,8 @@
+// Copied from atc: packages/mcp/src/testing/load-web-authn-early.ts at commit 4fe647cf.
+
+import { loadWebAuthn } from '../auth/load-web-authn.ts';
+
+// The first passkey ceremony in a test process loads the WebAuthn library,
+// measured at about 0.26 s cold against 0.015 s warm. Loading it here keeps
+// that one-time cost out of the first test's timeout.
+await loadWebAuthn();

package/src/test-utils/register-test-cleanup.ts

@@ -0,0 +1,55 @@
+// Copied from atc: packages/test-utils/src/register-test-cleanup.ts at commit 4fe647cf.
+
+import { onTestFinished } from 'bun:test';
+
+// The releases the current test registered, in registration order; null
+// before its first registration and once its hook has started.
+let pending: (() => unknown)[] | null = null;
+
+export function registerTestCleanup<T>(release: () => T): () => T {
+  let released: { readonly value: T } | null = null;
+
+  const releaseOnce = (): T => {
+    released ??= { value: release() };
+
+    return released.value;
+  };
+
+  if (pending === null) {
+    // Bun runs this hook after every afterEach, so a release works only from the
+    // paths and handles it captured.
+    onTestFinished(releasePending);
+
+    pending = [];
+  }
+
+  pending.push(releaseOnce);
+
+  return releaseOnce;
+}
+
+async function releasePending(): Promise<void> {
+  const releases = pending ?? [];
+
+  pending = null;
+
+  const errors: unknown[] = [];
+
+  // Last registered first, so a directory made before a process that lives in it
+  // goes only once that process stops.
+  for (const release of releases.toReversed()) {
+    try {
+      await release();
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+
+  if (errors.length === 1) {
+    throw errors[0];
+  }
+
+  if (errors.length > 1) {
+    throw new AggregateError(errors, 'more than one test cleanup failed');
+  }
+}

package/src/test-utils/seed-passkey.ts

@@ -0,0 +1,32 @@
+// Copied from atc: packages/mcp/src/test-utils/seed-passkey.ts at commit 4fe647cf.
+
+import invariant from 'tiny-invariant';
+import { createEnrollmentToken } from '../auth/create-enrollment-token.ts';
+import { createPasskey } from '../auth/create-passkey.ts';
+import type { NewPasskey } from '../auth/create-passkey.ts';
+import { deriveTokenHash } from '../auth/derive-token-hash.ts';
+import { buildMockNewPasskey } from './build-mock-new-passkey.ts';
+import type { MCPAuthSeedDeps } from './types.ts';
+
+export type PasskeyInput = Partial<Omit<NewPasskey, 'tokenHash'>>;
+
+export async function seedPasskey(
+  deps: MCPAuthSeedDeps,
+  input: PasskeyInput = {},
+): Promise<NewPasskey> {
+  const now = input.now ?? deps.clock.now();
+
+  const enrollment = await createEnrollmentToken(deps.db, now);
+
+  const passkey = buildMockNewPasskey({
+    ...input,
+    now,
+    tokenHash: deriveTokenHash(enrollment.token),
+  });
+
+  const created = await createPasskey(deps.db, passkey);
+
+  invariant(created);
+
+  return passkey;
+}

package/src/test-utils/setup-temp-dir.ts

@@ -0,0 +1,24 @@
+// Copied from atc: packages/test-utils/src/setup-temp-dir.ts at commit 4fe647cf.
+
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { registerTestCleanup } from './register-test-cleanup';
+
+interface TempDir {
+  readonly path: string;
+  readonly teardown: () => void;
+}
+
+export function setupTempDir(prefix: string): TempDir {
+  const directory = mkdtempSync(join(tmpdir(), prefix));
+
+  const teardown = registerTestCleanup(() => {
+    rmSync(directory, { recursive: true, force: true });
+  });
+
+  return {
+    path: directory,
+    teardown,
+  };
+}

package/src/test-utils/start-stub-telemetry-collector.ts

@@ -0,0 +1,27 @@
+// Copied from atc: packages/test-utils/src/start-stub-telemetry-collector.ts at commit 4fe647cf.
+
+import { registerTestCleanup } from './register-test-cleanup.ts';
+
+export function startStubTelemetryCollector() {
+  const received: string[] = [];
+
+  const answerRequest = (request: Request) => {
+    received.push(request.url);
+
+    return new Response(null, { status: 204 });
+  };
+
+  const server = Bun.serve({
+    hostname: '127.0.0.1',
+    port: 0,
+    fetch: answerRequest,
+  });
+
+  const stop = registerTestCleanup(() => server.stop(true));
+
+  return {
+    url: `http://127.0.0.1:${String(server.port)}/`,
+    received,
+    stop,
+  };
+}

package/src/test-utils/types.ts

@@ -0,0 +1,11 @@
+// Copied from atc: packages/mcp/src/test-utils/types.ts at commit 4fe647cf.
+
+import type { Kysely } from 'kysely';
+import type { MCPAuthSchema } from '../auth/mcp-auth-schema.ts';
+import type { AuthClock } from '../utils/types.ts';
+
+// The handles the seeds of the authorization database take.
+export interface MCPAuthSeedDeps {
+  readonly db: Kysely<MCPAuthSchema>;
+  readonly clock: Pick<AuthClock, 'now'>;
+}

package/src/utils/is-record.ts

@@ -0,0 +1,5 @@
+// Copied from atc: packages/core/src/is-record.ts at commit 4fe647cf.
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/src/utils/parse-json-strings.ts

@@ -0,0 +1,15 @@
+// Copied from atc: packages/core/src/parse-json-strings.ts at commit 4fe647cf.
+
+export function parseJSONStrings(raw: string): string[] | null {
+  let parsed: unknown;
+
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+
+  return Array.isArray(parsed)
+    ? parsed.filter((item): item is string => typeof item === 'string')
+    : null;
+}

package/src/utils/types.ts

@@ -0,0 +1,8 @@
+// Copied from atc: packages/core/src/types.ts at commit 4fe647cf.
+
+export interface AuthClock {
+  readonly now: () => number;
+
+  // runs the callback once after the delay; the returned function cancels it
+  readonly schedule: (callback: () => void, delayMs: number) => () => void;
+}