@prestack/thread 0.1.2 → 0.1.4

package/dist/operations/http.ts

@@ -1,169 +0,0 @@
-import { payloadBytes } from './metering.ts'
-import { ValidationError } from './result.ts'
-import type { Http, HttpRequest, HttpResponse } from './seams.ts'
-
-export const HTTP_CALL_ACTION = 'http.call'
-
-export class HttpNotConfiguredError extends Error {
-  constructor() {
-    super(
-      'no outward seam is configured. `http.call` needs `seams.http`, which is the transport an app ' +
-        'wires — which hosts it may reach is declared in its tree and is not this seam\'s business.',
-    )
-    this.name = 'HttpNotConfiguredError'
-  }
-}
-
-export class OutwardTransportError extends Error {
-  constructor(
-    readonly target: string,
-    cause: unknown,
-  ) {
-    super(`outward call to "${target}" never reached it: ${cause instanceof Error ? cause.message : String(cause)}`)
-    this.name = 'OutwardTransportError'
-  }
-}
-
-export function outwardUrl(target: string, address: string, path: string): URL {
-  let base: URL
-  try {
-    base = new URL(address)
-  } catch {
-    throw new ValidationError(`the address resolved for "${target}" is not an absolute URL: ${JSON.stringify(address)}`)
-  }
-  if (base.protocol !== 'https:') {
-    throw new ValidationError(`outward calls go over https only, and "${target}" resolved to ${base.protocol.replace(':', '')}`)
-  }
-  if (base.search !== '' || base.hash !== '') {
-    throw new ValidationError(`the address for "${target}" carries a query or a fragment — those belong to the call`)
-  }
-  if (!path.startsWith('/')) {
-    throw new ValidationError(`an outward path starts with "/", and "${path}" does not`)
-  }
-  if (path.startsWith('//')) {
-    throw new ValidationError(`the path "${path}" is protocol-relative, which points at another host`)
-  }
-  const url = new URL(`${base.origin}${base.pathname.replace(/\/$/, '')}${path}`)
-  if (url.origin !== base.origin) {
-    throw new ValidationError(`the path "${path}" resolves to ${url.origin}, which is not where "${target}" is`)
-  }
-  return url
-}
-
-function requestBytes(headers: Readonly<Record<string, string>>, body: Uint8Array | undefined): number {
-  return payloadBytes(headers) + (body === undefined ? 0 : body.byteLength)
-}
-
-function wireBody(body: Uint8Array): ArrayBuffer {
-  const copy = new ArrayBuffer(body.byteLength)
-  new Uint8Array(copy).set(body)
-  return copy
-}
-
-export interface HttpSeamOptions {
-  readonly transport?: typeof fetch
-
-  readonly timeoutMs?: number
-}
-
-const DEFAULT_TIMEOUT_MS = 10_000
-
-export function httpSeam(options: HttpSeamOptions = {}): Http {
-  const send = options.transport ?? fetch
-  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS
-
-  return {
-    async call(request: HttpRequest): Promise<HttpResponse> {
-      const url = outwardUrl(request.target, request.address, request.path)
-
-      const headers: Record<string, string> = { ...request.headers }
-      if (request.contentType !== undefined) headers['content-type'] = request.contentType
-      if (request.idempotencyKey !== undefined) headers['idempotency-key'] = request.idempotencyKey
-
-      const bytesSent = requestBytes(headers, request.body)
-      const startedAt = Date.now()
-
-      let response: Response
-      try {
-        response = await send(url.toString(), {
-          method: request.method,
-          headers,
-          ...(request.body === undefined ? {} : { body: wireBody(request.body) }),
-          signal: AbortSignal.timeout(timeoutMs),
-        })
-      } catch (error) {
-
-        throw new OutwardTransportError(request.target, error)
-      }
-
-      const body = new Uint8Array(await response.arrayBuffer())
-      const responseHeaders = Object.fromEntries(response.headers.entries())
-
-      return {
-        status: response.status,
-        headers: responseHeaders,
-        body,
-        bytesSent,
-        bytesReceived: payloadBytes(responseHeaders) + body.byteLength,
-        durationMs: Date.now() - startedAt,
-      }
-    },
-  }
-}
-
-export interface RecordedCall {
-  readonly target: string
-  readonly method: string
-  readonly path: string
-  readonly headers: Readonly<Record<string, string>>
-  readonly body: string
-}
-
-export interface ScriptedAnswer {
-  readonly status: number
-  readonly headers?: Readonly<Record<string, string>>
-  readonly body?: string
-}
-
-const REDACTED = '(sent)'
-
-export function recordingHttp(
-  script: Readonly<Record<string, ScriptedAnswer>> = {},
-): Http & { readonly calls: readonly RecordedCall[] } {
-  const calls: RecordedCall[] = []
-  const decoder = new TextDecoder()
-
-  return {
-    calls,
-    async call(request) {
-      outwardUrl(request.target, request.address, request.path)
-
-      const body = request.body === undefined ? '' : decoder.decode(request.body)
-      calls.push({
-        target: request.target,
-        method: request.method,
-        path: request.path,
-        headers: Object.fromEntries(Object.keys(request.headers ?? {}).map((one) => [one, REDACTED])),
-        body,
-      })
-
-      const answer = script[`${request.method} ${request.path}`]
-      if (answer === undefined) {
-        throw new Error(
-          `this scenario scripts no answer for "${request.method} ${request.path}", so nothing here knows what ${request.target} would say. Add that key to the scenario's answers — a call answered by something nobody scripted proves it was made and nothing about what came back.`,
-        )
-      }
-      const answered = new TextEncoder().encode(answer.body ?? '')
-      const headers = answer.headers ?? {}
-      return {
-        status: answer.status,
-        headers,
-        body: answered,
-        bytesSent: requestBytes({ ...request.headers }, request.body),
-        bytesReceived: payloadBytes(headers) + answered.byteLength,
-
-        durationMs: 0,
-      }
-    },
-  }
-}

package/dist/operations/memory.d.ts

@@ -1,104 +0,0 @@
-import type { Actor } from '../core/actor.ts';
-import type { Store, Row, Seams, Idempotency, PlatformEvent, LogLevel, Queue, Job, EnqueueOpts, Transactional, AuditRecord, ErrorRecord, Vault, FieldList } from './seams.ts';
-export declare class UnknownColumnError extends Error {
-    constructor(entity: string, key: string);
-}
-export declare class VersionConflictError extends Error {
-    constructor(entity: string, id: string, expectedVersion: number);
-}
-export declare class MemoryStore implements Store, Transactional {
-    private data;
-    private readonly declared;
-    private readonly keys;
-    constructor(declared?: ReadonlyMap<string, ReadonlySet<string>>, keys?: ReadonlyMap<string, string>);
-    private keyOf;
-    private static readonly SYSTEM;
-    private assertDeclared;
-    private depth;
-    transaction<T>(_actor: Actor, fn: () => Promise<T>): Promise<T>;
-    insert(_actor: Actor, entity: string, row: Row): Promise<Row>;
-    get(_actor: Actor, entity: string, key: string | number, fields: FieldList): Promise<Row | null>;
-    list(_actor: Actor, entity: string, opts?: {
-        limit?: number;
-        where?: Readonly<Record<string, string | number | boolean | null>>;
-    }): Promise<Row[]>;
-    update(_actor: Actor, entity: string, key: string | number, patch: Record<string, unknown>, expectedVersion?: number): Promise<Row>;
-    remove(_actor: Actor, entity: string, key: string | number): Promise<void>;
-}
-export declare class MemoryQueue implements Queue {
-    private jobs;
-    private dead;
-    private seq;
-    enqueue<T>(actor: Actor, kind: string, payload: T, opts?: EnqueueOpts): Promise<string>;
-    poll(kinds: string[], limit: number, now: number): Promise<Job[]>;
-    ack(id: string): Promise<void>;
-    fail(id: string, error: string, now: number): Promise<void>;
-    deadLetter(id: string, error: string): Promise<void>;
-    deadLetters(): Promise<Job[]>;
-}
-export interface Sink {
-    logs: {
-        level: LogLevel;
-        action: string;
-        data: Record<string, unknown>;
-    }[];
-    events: PlatformEvent[];
-    audits: AuditRecord[];
-    errors: ErrorRecord[];
-    costs: string[];
-    indexed: {
-        entity: string;
-        row: Row;
-    }[];
-    spans: {
-        action: string;
-        status: 'ok' | 'error';
-    }[];
-    outbox: PlatformEvent[];
-    gateOrder: string[];
-    quota: {
-        reserved: number[];
-        committed: number[];
-        released: number;
-    };
-    files: {
-        action: 'put' | 'get' | 'signed' | 'remove';
-        key: string;
-        bytes: number | null;
-    }[];
-    queries: {
-        sql: string;
-        params: readonly unknown[];
-        rows: number;
-    }[];
-}
-export declare class MemoryIdempotency implements Idempotency {
-    private readonly records;
-    private readonly onCheck?;
-    constructor(opts: {
-        readonly onCheck?: () => void;
-        readonly records?: Map<string, unknown>;
-    });
-    private keyFor;
-    check(key: string | undefined, action: string): Promise<unknown | null>;
-    store(key: string | undefined, action: string, output: unknown): Promise<void>;
-}
-export interface MemorySeamOptions {
-    readonly allowRate?: boolean;
-    readonly features?: readonly string[];
-    readonly quota?: Readonly<Record<string, number>>;
-    readonly onExceed?: string;
-    readonly entities?: ReadonlyMap<string, ReadonlySet<string>>;
-    readonly keys?: ReadonlyMap<string, string>;
-    readonly secrets?: Readonly<Record<string, string>>;
-    readonly views?: Readonly<Record<string, readonly unknown[]>>;
-}
-export declare function memoryVault(seed?: Readonly<Record<string, string>>): Vault;
-export declare const arrived: () => number;
-export declare const fresh: () => string;
-export declare function inMemorySeams(opts?: MemorySeamOptions): {
-    seams: Seams;
-    sink: Sink;
-    store: MemoryStore;
-    queue: MemoryQueue;
-};

package/dist/operations/memory.js

@@ -1,365 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { backoffMs, isExhausted } from "./queue-policy.js";
-function projectRow(row, fields, key) {
-    const keep = new Set([key, 'version', ...fields]);
-    const projected = {};
-    for (const [name, value] of Object.entries(row)) {
-        if (keep.has(name))
-            projected[name] = value;
-    }
-    return projected;
-}
-export class UnknownColumnError extends Error {
-    constructor(entity, key) {
-        super(`${entity} does not declare "${key}", so writing it would be silently discarded. ` +
-            'Declare the field or relation on the entity, or stop writing the key.');
-        this.name = 'UnknownColumnError';
-    }
-}
-export class VersionConflictError extends Error {
-    constructor(entity, id, expectedVersion) {
-        super(`${entity} ${id} was not at version ${expectedVersion} — someone else changed it first. ` +
-            're-read the row and retry with its current ETag.');
-        this.name = 'VersionConflictError';
-    }
-}
-export class MemoryStore {
-    data = new Map();
-    declared;
-    keys;
-    constructor(declared, keys) {
-        this.declared = declared ?? new Map();
-        this.keys = keys ?? new Map();
-    }
-    keyOf(entity) {
-        const held = this.keys.get(entity);
-        if (held === undefined) {
-            throw new Error(`nothing told this store which value identifies a ${entity}, so it cannot find one row rather than all of ` +
-                'them. An entity states that with a `unique` invariant over one of its values, and whatever builds this ' +
-                'store passes those along with the columns each entity declares.');
-        }
-        return held;
-    }
-    static SYSTEM = new Set(['version']);
-    assertDeclared(entity, row) {
-        const allowed = this.declared.get(entity);
-        if (allowed === undefined)
-            return;
-        for (const key of Object.keys(row)) {
-            if (allowed.has(key) || MemoryStore.SYSTEM.has(key))
-                continue;
-            throw new UnknownColumnError(entity, key);
-        }
-    }
-    depth = 0;
-    async transaction(_actor, fn) {
-        if (this.depth > 0)
-            return fn();
-        const snapshot = new Map();
-        for (const [key, rows] of this.data)
-            snapshot.set(key, rows.map((r) => ({ ...r })));
-        this.depth += 1;
-        try {
-            return await fn();
-        }
-        catch (err) {
-            this.data = snapshot;
-            throw err;
-        }
-        finally {
-            this.depth -= 1;
-        }
-    }
-    async insert(_actor, entity, row) {
-        this.assertDeclared(entity, row);
-        const rows = this.data.get(entity) ?? [];
-        const rec = { ...row, version: 1 };
-        rows.push(rec);
-        this.data.set(entity, rows);
-        return { ...rec };
-    }
-    async get(_actor, entity, key, fields) {
-        const named = this.keyOf(entity);
-        const row = this.data.get(entity)?.find((r) => r[named] === key) ?? null;
-        return row === null ? null : projectRow(row, fields, named);
-    }
-    async list(_actor, entity, opts) {
-        const all = this.data.get(entity) ?? [];
-        const where = Object.entries(opts?.where ?? {});
-        for (const [field] of where)
-            this.assertDeclared(entity, { [field]: null });
-        const matched = where.length === 0 ? all : all.filter((row) => where.every(([f, v]) => (row[f] ?? null) === v));
-        return opts?.limit ? matched.slice(0, opts.limit).map((r) => ({ ...r })) : matched.map((r) => ({ ...r }));
-    }
-    async update(_actor, entity, key, patch, expectedVersion) {
-        this.assertDeclared(entity, patch);
-        const named = this.keyOf(entity);
-        const rows = this.data.get(entity) ?? [];
-        const i = rows.findIndex((r) => r[named] === key);
-        const cur = rows[i];
-        if (i < 0 || !cur)
-            throw new Error(`record ${String(key)} not found`);
-        const currentVersion = typeof cur['version'] === 'number' ? cur['version'] : 1;
-        if (expectedVersion !== undefined && expectedVersion !== currentVersion) {
-            throw new VersionConflictError(entity, String(key), expectedVersion);
-        }
-        const next = { ...cur, ...patch, [named]: key, version: currentVersion + 1 };
-        rows[i] = next;
-        return { ...next };
-    }
-    async remove(_actor, entity, key) {
-        const named = this.keyOf(entity);
-        this.data.set(entity, (this.data.get(entity) ?? []).filter((r) => r[named] !== key));
-    }
-}
-export class MemoryQueue {
-    jobs = new Map();
-    dead = [];
-    seq = 0;
-    async enqueue(actor, kind, payload, opts) {
-        if (opts?.dedupeKey) {
-            for (const [id, job] of this.jobs) {
-                if (job.dedupeKey === opts.dedupeKey)
-                    return id;
-            }
-        }
-        const id = `job_${++this.seq}`;
-        this.jobs.set(id, {
-            id,
-            kind,
-            payload,
-            attempts: 0,
-            runAt: opts?.runAt ?? 0,
-            claimed: false,
-            dedupeKey: opts?.dedupeKey,
-            actor,
-        });
-        return id;
-    }
-    async poll(kinds, limit, now) {
-        const due = [];
-        for (const job of this.jobs.values()) {
-            if (due.length >= limit)
-                break;
-            if (job.claimed || !kinds.includes(job.kind) || job.runAt > now)
-                continue;
-            job.claimed = true;
-            due.push({ ...job });
-        }
-        return due;
-    }
-    async ack(id) {
-        this.jobs.delete(id);
-    }
-    async fail(id, error, now) {
-        const job = this.jobs.get(id);
-        if (!job)
-            return;
-        job.attempts += 1;
-        job.claimed = false;
-        if (isExhausted(job.attempts)) {
-            this.dead.push({ ...job });
-            this.jobs.delete(id);
-            return;
-        }
-        job.runAt = now + backoffMs(job.attempts);
-        void error;
-    }
-    async deadLetter(id, error) {
-        const job = this.jobs.get(id);
-        if (!job)
-            return;
-        this.dead.push({ ...job });
-        this.jobs.delete(id);
-        void error;
-    }
-    async deadLetters() {
-        return this.dead.map((j) => ({ ...j }));
-    }
-}
-export class MemoryIdempotency {
-    records;
-    onCheck;
-    constructor(opts) {
-        this.records = opts.records ?? new Map();
-        this.onCheck = opts.onCheck;
-    }
-    keyFor(key, action) {
-        return `${key}:${action}`;
-    }
-    async check(key, action) {
-        this.onCheck?.();
-        if (!key)
-            return null;
-        const k = this.keyFor(key, action);
-        return this.records.has(k) ? (this.records.get(k) ?? null) : null;
-    }
-    async store(key, action, output) {
-        if (!key)
-            return;
-        const k = this.keyFor(key, action);
-        if (!this.records.has(k))
-            this.records.set(k, output);
-    }
-}
-export function memoryVault(seed = {}) {
-    return {
-        async resolve(refs) {
-            const found = {};
-            for (const ref of refs) {
-                const value = seed[ref];
-                if (value === undefined)
-                    throw new Error(`vault has no value for "${ref}"`);
-                found[ref] = value;
-            }
-            return found;
-        },
-    };
-}
-export const arrived = () => Date.now();
-export const fresh = () => randomUUID();
-export function inMemorySeams(opts) {
-    const sink = {
-        logs: [], events: [], audits: [], errors: [], costs: [], indexed: [], spans: [],
-        outbox: [], gateOrder: [], quota: { reserved: [], committed: [], released: 0 },
-        files: [], queries: [],
-    };
-    const store = new MemoryStore(opts?.entities, opts?.keys);
-    const queue = new MemoryQueue();
-    const searchIdx = new Map();
-    const telemetry = {
-        start(action) {
-            let status = 'ok';
-            return {
-                ok() { status = 'ok'; },
-                error() { status = 'error'; },
-                end() { sink.spans.push({ action, status }); },
-            };
-        },
-    };
-    const log = { write(level, action, _actor, data) { sink.logs.push({ level, action, data }); } };
-    const audit = { async append(_actor, record) { sink.audits.push(record); } };
-    const errors = { async record(_actor, record) { sink.errors.push(record); } };
-    const cost = { meter(action) { sink.costs.push(action); } };
-    const events = { async publish(e) { sink.events.push(e); } };
-    const rateLimiter = {
-        async check() {
-            sink.gateOrder.push('rate');
-            return opts?.allowRate ?? true;
-        },
-        async checkPolicy() {
-            sink.gateOrder.push('rate');
-            return opts?.allowRate ?? true;
-        },
-    };
-    const featureGate = opts?.features === undefined
-        ? undefined
-        : {
-            async check(_actor, feature) {
-                sink.gateOrder.push('feature');
-                return (opts.features ?? []).includes(feature);
-            },
-        };
-    const used = new Map();
-    const quotas = opts?.quota === undefined
-        ? undefined
-        : {
-            async reserve(_actor, meter, estimate) {
-                sink.gateOrder.push('quota');
-                sink.quota.reserved.push(estimate);
-                const allowance = opts.quota?.[meter] ?? Number.POSITIVE_INFINITY;
-                const before = used.get(meter) ?? 0;
-                if (before + estimate > allowance) {
-                    return {
-                        ok: false,
-                        behavior: opts.onExceed ?? 'block',
-                        retryAfterSeconds: 60,
-                        async commit() { },
-                        async release() { },
-                    };
-                }
-                used.set(meter, before + estimate);
-                let settled = false;
-                return {
-                    ok: true,
-                    behavior: null,
-                    retryAfterSeconds: 0,
-                    async commit(actual) {
-                        if (settled)
-                            return;
-                        settled = true;
-                        sink.quota.committed.push(actual);
-                        used.set(meter, (used.get(meter) ?? 0) - estimate + actual);
-                    },
-                    async release() {
-                        if (settled)
-                            return;
-                        settled = true;
-                        sink.quota.released += 1;
-                        used.set(meter, (used.get(meter) ?? 0) - estimate);
-                    },
-                };
-            },
-        };
-    const outbox = {
-        async emit(_actor, event) {
-            sink.outbox.push(event);
-        },
-    };
-    const idempotency = new MemoryIdempotency({
-        onCheck: () => sink.gateOrder.push('idempotency'),
-    });
-    const search = {
-        async index(_actor, entity, row) {
-            sink.indexed.push({ entity, row });
-            searchIdx.set(entity, [...(searchIdx.get(entity) ?? []), row]);
-        },
-        async query(_actor, entity, q) {
-            const needle = q.toLowerCase();
-            return (searchIdx.get(entity) ?? []).filter((r) => JSON.stringify(r).toLowerCase().includes(needle));
-        },
-    };
-    const vault = opts?.secrets === undefined ? undefined : memoryVault(opts.secrets);
-    const stored = new Map();
-    const files = {
-        async put(_actor, key, body, contentType) {
-            stored.set(key, { body, contentType });
-            sink.files.push({ action: 'put', key, bytes: body.byteLength });
-            return { size: body.byteLength };
-        },
-        async get(_actor, key) {
-            const found = stored.get(key);
-            sink.files.push({ action: 'get', key, bytes: found === undefined ? null : found.body.byteLength });
-            return found === undefined ? null : { body: found.body, contentType: found.contentType };
-        },
-        async signedUrl(_actor, key, expiresInSeconds) {
-            sink.files.push({ action: 'signed', key, bytes: null });
-            return `https://files.invalid/unsigned-in-memory/${encodeURIComponent(key)}?expires_in=${String(expiresInSeconds)}`;
-        },
-        async remove(_actor, key) {
-            stored.delete(key);
-            sink.files.push({ action: 'remove', key, bytes: null });
-        },
-    };
-    const answers = opts?.views;
-    const views = answers === undefined
-        ? undefined
-        : {
-            async query(_actor, sql, params) {
-                const found = (answers[sql] ?? []);
-                sink.queries.push({ sql, params, rows: found.length });
-                return found;
-            },
-        };
-    return {
-        seams: {
-            store, telemetry, log, audit, errors, search, cost, idempotency, events, rateLimiter, queue,
-            outbox, files, clock: { now: arrived }, random: { next: Math.random, uuid: fresh },
-            ...(featureGate ? { featureGate } : {}),
-            ...(quotas ? { quotas } : {}),
-            ...(vault ? { vault } : {}),
-            ...(views ? { views } : {}),
-        },
-        sink, store, queue,
-    };
-}