@rikalabs/akter 0.1.0-alpha.0 → 0.1.0-alpha.3

package/dist/testing/conformance.js

@@ -1,364 +0,0 @@
-import { Effect, Layer, Logger, ManagedRuntime, Option } from "effect";
-import { constVoid } from "effect/Function";
-import { Statement } from "effect/sql";
-import { User } from "../index.js";
-import { principal } from "../identity/caller.js";
-import { ContentHooks, TurnHooks, } from "../runtime/turn/hooks.js";
-import { NekiTurnSessions } from "../runtime/database/neki/session.js";
-import { ActorTest } from "./actor-test.js";
-import { accessConformance, accessSuite } from "./conformance/access.js";
-import { admissionConformance, admissionSuite } from "./conformance/admission.js";
-import { adoptionConformance } from "./conformance/adoption.js";
-import { assertionsConformance, assertionsSuite, edgeConformance, } from "./conformance/assertions.js";
-import { batchesConformance, batchesSuite } from "./conformance/batches.js";
-import { blobsConformance, blobsSuite } from "./conformance/blobs.js";
-import { capacityConformance } from "./conformance/capacity.js";
-import { clientConformance, clientSuite } from "./conformance/client.js";
-import { coldServeConformance, coldServeEdgeConformance, coldServeSuite, } from "./conformance/cold-serve.js";
-import { connectionsConformance } from "./conformance/connections.js";
-import { connectionsSuite } from "./conformance/connections/actors.js";
-import { contentConformance, contentSuite } from "./conformance/content-blobs.js";
-import { counterConformance, counterSuite } from "./conformance/counter.js";
-import { cronClusterConformance, cronConformance } from "./conformance/cron.js";
-import { drainConformance, drainSuite } from "./conformance/drain.js";
-import { effectControlClusterConformance, effectControlConformance, effectControlSuite, } from "./conformance/effect-control.js";
-import { effectsConformance, effectsSuite } from "./conformance/effects.js";
-import { eventsConformance, eventsSuite } from "./conformance/events.js";
-import { exportConformance } from "./conformance/export.js";
-import { fleetConformance, fleetSuite } from "./conformance/fleet.js";
-import { heapConformance } from "./conformance/heap.js";
-import { httpConformance, httpSuite } from "./conformance/http.js";
-import { inspectionViewsConformance, inspectionViewsSuite } from "./conformance/inspection-views.js";
-import { inspectorConformance, inspectorSuite } from "./conformance/inspector.js";
-import { mintConformance, mintSuite } from "./conformance/mint.js";
-import { multiRunnerConformance } from "./conformance/multi-runner.js";
-import { observabilityConformance } from "./conformance/observability.js";
-import { offlineConformance, offlineSuite } from "./conformance/offline.js";
-import { operatorConformance } from "./conformance/operator.js";
-import { crossShardOutboxConformance, crossShardSuite } from "./conformance/outbox-cross-shard.js";
-import { outboxConformance, outboxSuite } from "./conformance/outbox.js";
-import { payloadMigrationsConformance } from "./conformance/payload-migrations.js";
-import { pipelineConformance } from "./conformance/pipeline.js";
-import { groupsConformance } from "./conformance/groups.js";
-import { placementConformance, placementSuite } from "./conformance/placement.js";
-import { progressConformance, progressDeliveryConformance, progressSuite, } from "./conformance/progress.js";
-import { propertiesConformance, propertiesSuite } from "./conformance/properties.js";
-import { protocolsConformance, protocolsSuite } from "./conformance/protocols.js";
-import { readYourWritesConformance, readYourWritesSuite } from "./conformance/read-your-writes.js";
-import { reducerConformance, reducerSuite } from "./conformance/reducers.js";
-import { relayClusterConformance, relayConformance, relaySuite } from "./conformance/relay.js";
-import { restoreConformance, restoreSuite } from "./conformance/restore.js";
-import { retentionConformance, retentionSuite } from "./conformance/retention.js";
-import { rlsConformance } from "./conformance/rls.js";
-import { simulationConformance } from "./conformance/simulation.js";
-import { singleShardConformance } from "./conformance/single-shard.js";
-import { singletonConformance } from "./conformance/singleton.js";
-import { streamsConformance, streamsSuite } from "./conformance/streams.js";
-import { subscriptionsConformance } from "./conformance/subscriptions.js";
-import { subscriptionsSuite } from "./conformance/subscriptions/actors.js";
-import { subscriptionsClusterConformance } from "./conformance/subscriptions/cluster.js";
-import { subscriptionsRetentionConformance } from "./conformance/subscriptions/retention.js";
-import { tablesConformance, tablesSuite } from "./conformance/tables.js";
-import { transportsConformance } from "./conformance/transports.js";
-import { transportsSuite } from "./conformance/transports/actors.js";
-import { watchConformance, watchSuite } from "./conformance/watch.js";
-import { workflowVersionsConformance } from "./conformance/workflow-versions.js";
-import { workflowsConformance } from "./conformance/workflows.js";
-import { workflowsSuite } from "./conformance/workflows/actors.js";
-import { foundationConformance, foundationSuite } from "./foundation.js";
-const group = (suite, cases, requires) => ({
-    suite,
-    cases: requires === undefined ? cases : cases.map((each) => ({ ...each, ...requires })),
-});
-/** Every case of the group opens a fresh database or a snapshot. */
-const freshDatabases = { requiresFreshDatabase: true };
-/** Cases whose own actors, if any, they build into their own runtimes or clusters. */
-const standalone = {};
-/**
- * Every suite in the registry. The single-shard case checks the routing of
- * every statement the framework issues, so it needs every feature's actors
- * registered, as a deployment of all of them would.
- */
-const everySuite = {
-    get uses() {
-        return [...new Set(allGroups.map((group) => conformanceGroups[group].suite))].filter((suite) => suite !== everySuite);
-    },
-};
-/**
- * Every conformance case, grouped by the file that owns it, with the suite
- * that owns its actors. `describeConformance` runs a subset through `groups`,
- * so a group can run in its own Vitest file and worker; `conformance` is
- * their union and the order within a group is kept.
- */
-export const conformanceGroups = {
-    foundation: group(foundationSuite, foundationConformance),
-    access: group(accessSuite, accessConformance, freshDatabases),
-    admission: group(admissionSuite, admissionConformance),
-    http: group(httpSuite, httpConformance),
-    protocols: group(protocolsSuite, protocolsConformance),
-    assertions: group(assertionsSuite, assertionsConformance),
-    edge: group(assertionsSuite, edgeConformance),
-    coldServeEdge: group(coldServeSuite, coldServeEdgeConformance),
-    client: group(clientSuite, clientConformance),
-    offline: group(offlineSuite, offlineConformance),
-    capacity: group(standalone, capacityConformance, freshDatabases),
-    heap: group(standalone, heapConformance, freshDatabases),
-    events: group(eventsSuite, eventsConformance),
-    reducer: group(reducerSuite, reducerConformance),
-    outbox: group(outboxSuite, outboxConformance),
-    tables: group(tablesSuite, tablesConformance),
-    effects: group(effectsSuite, effectsConformance),
-    progress: group(progressSuite, progressConformance),
-    multiRunner: group(standalone, multiRunnerConformance, freshDatabases),
-    simulation: group(standalone, simulationConformance, freshDatabases),
-    drain: group(drainSuite, drainConformance),
-    pipeline: group(standalone, pipelineConformance, freshDatabases),
-    batches: group(batchesSuite, batchesConformance),
-    groups: group(standalone, groupsConformance, freshDatabases),
-    relay: group(relaySuite, relayConformance),
-    relayCluster: group(relaySuite, relayClusterConformance, freshDatabases),
-    effectControl: group(effectControlSuite, effectControlConformance),
-    effectControlCluster: group(effectControlSuite, effectControlClusterConformance),
-    singleton: group(standalone, singletonConformance, freshDatabases),
-    cron: group(standalone, cronConformance, freshDatabases),
-    cronCluster: group(standalone, cronClusterConformance, freshDatabases),
-    blobs: group(blobsSuite, blobsConformance),
-    inspectionViews: group(inspectionViewsSuite, inspectionViewsConformance),
-    inspector: group(inspectorSuite, inspectorConformance),
-    rls: group(standalone, rlsConformance, freshDatabases),
-    retention: group(retentionSuite, retentionConformance),
-    restore: group(restoreSuite, restoreConformance, freshDatabases),
-    workflows: group(workflowsSuite, workflowsConformance),
-    connections: group(connectionsSuite, connectionsConformance),
-    streams: group(streamsSuite, streamsConformance),
-    progressDelivery: group(progressSuite, progressDeliveryConformance),
-    transports: group(transportsSuite, transportsConformance),
-    workflowVersions: group(standalone, workflowVersionsConformance, freshDatabases),
-    payloadMigrations: group(standalone, payloadMigrationsConformance, freshDatabases),
-    subscriptions: group(subscriptionsSuite, subscriptionsConformance),
-    subscriptionsRetention: group(subscriptionsSuite, subscriptionsRetentionConformance),
-    subscriptionsCluster: group(subscriptionsSuite, subscriptionsClusterConformance, freshDatabases),
-    content: group(contentSuite, contentConformance),
-    counter: group(counterSuite, counterConformance),
-    properties: group(propertiesSuite, propertiesConformance),
-    mint: group(mintSuite, mintConformance),
-    readYourWrites: group(readYourWritesSuite, readYourWritesConformance),
-    observability: group(standalone, observabilityConformance, freshDatabases),
-    operator: group(standalone, operatorConformance, freshDatabases),
-    export: group(standalone, exportConformance, freshDatabases),
-    coldServe: group(coldServeSuite, coldServeConformance),
-    placement: group(placementSuite, placementConformance),
-    watch: group(watchSuite, watchConformance),
-    adoption: group(standalone, adoptionConformance),
-    singleShard: group(everySuite, singleShardConformance),
-    crossShardOutbox: group(crossShardSuite, crossShardOutboxConformance),
-    fleet: group(fleetSuite, fleetConformance),
-};
-const allGroups = Object.keys(conformanceGroups);
-/**
- * The shared durable-turn conformance cases. Cases flagged
- * `requiresIndependentConnections` need real Postgres: a second database
- * connection to read committed state while a turn holds its transaction open
- * or to take a competing row lock, or a database outside the JavaScript heap
- * they measure. They never run on single-connection backends such as PGlite.
- */
-export const conformance = allGroups.flatMap((name) => conformanceGroups[name].cases);
-/** The capabilities `conformanceCase` requires, in a fixed order. */
-export const requirementsOf = (conformanceCase) => [
-    ...(conformanceCase.requiresIndependentConnections === true
-        ? ["independentConnections"]
-        : []),
-    ...(conformanceCase.requiresReplica === true ? ["replica"] : []),
-    ...(conformanceCase.requiresEdge === true ? ["edge"] : []),
-    ...(conformanceCase.requiresNeki === true ? ["neki"] : []),
-    ...(conformanceCase.requiresLogicalDecoding === true ? ["logicalDecoding"] : []),
-    ...(conformanceCase.requiresFreshDatabase === true ? ["freshDatabase"] : []),
-];
-/** The capabilities `backend` provides. */
-export const capabilitiesOf = (backend) => new Set([
-    ...(backend.independentConnections ? ["independentConnections"] : []),
-    ...(backend.hasReplica === true ? ["replica"] : []),
-    ...(backend.edge === undefined ? [] : ["edge"]),
-    ...(backend.neki === true ? ["neki"] : []),
-    ...(backend.logicalDecoding === true ? ["logicalDecoding"] : []),
-    ...(backend.freshDatabases ? ["freshDatabase"] : []),
-]);
-/** `suites` and every suite they use, each once, dependencies first. */
-const withDependencies = (suites) => {
-    const ordered = [];
-    const visit = (suite) => {
-        if (ordered.includes(suite))
-            return;
-        for (const used of suite.uses ?? [])
-            visit(used);
-        ordered.push(suite);
-    };
-    for (const suite of suites)
-        visit(suite);
-    return ordered;
-};
-/**
- * Registers the named groups' cases, or every group's, against `backend`.
- * Only the selected groups' suites, and the suites they use, build their
- * actors and fixtures. The same case names run on every backend; a case
- * whose requirements the backend lacks is reported through `registrar.skip`.
- *
- * Each case runs under the registrar's abort signal: a timed-out or
- * cancelled case is interrupted, its finalizers run, and the next case waits
- * for them, then restarts a runtime the case left stopped and starts with
- * open test authorization.
- */
-export const describeConformance = (options) => registerConformance({
-    ...options,
-    selected: (options.groups ?? allGroups).map((group) => conformanceGroups[group]),
-});
-/** How long the next case waits for an interrupted case's finalizers before it starts anyway. */
-const SETTLE_TIMEOUT = "20 seconds";
-/** Registers `selected` groups; `describeConformance` passes registry groups, tests pass their own. */
-export const registerConformance = (options) => {
-    const { name, backend, registrar, selected } = options;
-    const suites = withDependencies(selected.map(({ suite }) => suite));
-    const fixtures = new Map(suites.map((suite) => [suite, suite.fixture?.()]));
-    const fixtureOf = (suite) => {
-        if (!fixtures.has(suite))
-            throw new Error("A conformance case read the fixture of a suite its own suite does not use");
-        return fixtures.get(suite);
-    };
-    const access = { allowed: true, denied: new Set(), revoked: new Set() };
-    const turnHooks = suites.flatMap((suite) => suite.turn?.(fixtureOf(suite)) ?? []);
-    const contentHooks = suites.flatMap((suite) => suite.content?.(fixtureOf(suite)) ?? []);
-    const loggers = suites.flatMap((suite) => suite.logger?.(fixtureOf(suite)) ?? []);
-    let live = Layer.empty;
-    for (const suite of suites)
-        if (suite.layer !== undefined)
-            live = Layer.merge(live, suite.layer(fixtureOf(suite)));
-    const capabilities = capabilitiesOf(backend);
-    let store;
-    let current;
-    const opened = () => {
-        if (store === undefined)
-            throw new Error("Conformance environment is not open");
-        return store;
-    };
-    const environment = {
-        run: (effect) => {
-            if (current === undefined)
-                return Promise.reject(new Error("Conformance environment is stopped"));
-            return current.runPromise(Effect.scoped(effect));
-        },
-        build: (overrides) => ManagedRuntime.make(live.pipe(Layer.provideMerge(ActorTest.layer({
-            database: overrides?.database ?? opened().database,
-            maxConnections: 6,
-            admission: overrides?.admission,
-            replica: overrides?.replica,
-            as: User.make({ subject: "alice" }),
-            authorize: (request) => Effect.sync(() => access.allowed &&
-                !access.denied.has(request.command) &&
-                Option.match(principal(request.caller), {
-                    onNone: () => true,
-                    onSome: ({ subject }) => !access.revoked.has(subject),
-                })),
-            retryWindowMs: overrides?.retryWindowMs ?? 60_000,
-            content: overrides?.content,
-        }).pipe(Layer.provide(Layer.mergeAll(Layer.succeed(TurnHooks, {
-            at: (point, request) => Effect.forEach(turnHooks, (hook) => hook(point, request), { discard: true }),
-        }), Layer.succeed(ContentHooks, {
-            at: (point) => Effect.forEach(contentHooks, (hook) => hook(point), { discard: true }),
-        }), Layer.succeed(NekiTurnSessions, backend.neki === true), overrides?.observe === undefined
-            ? Layer.empty
-            : Layer.succeed(Statement.CurrentTransformer, (statement) => Effect.sync(() => {
-                overrides.observe(statement);
-                return statement;
-            })))))), Layer.provideMerge(backend.services), Layer.provide(Logger.layer(loggers, { mergeWithExisting: true })), Layer.orDie)),
-        stop: Effect.suspend(() => {
-            const previous = current;
-            current = undefined;
-            return previous === undefined ? Effect.void : Effect.promise(() => previous.dispose());
-        }),
-        restart: Effect.suspend(() => Effect.andThen(environment.stop, () => Effect.promise(() => {
-            current = environment.build();
-            return current.runPromise(Effect.void);
-        }))),
-        freshDatabase: Effect.suspend(() => opened().freshDatabase),
-        snapshot: Effect.suspend(() => {
-            if (current !== undefined)
-                return Effect.die(new Error("A snapshot needs the conformance runtime stopped"));
-            return opened().copy(opened().database);
-        }),
-        get connect() {
-            return store?.connect;
-        },
-        get replica() {
-            return store?.replica;
-        },
-        httpServer: backend.httpServer,
-        get edge() {
-            return backend.edge;
-        },
-    };
-    /** The environment one case sees: its runs end with its signal, and only a declared case opens databases. */
-    const environmentFor = (conformanceCase, signal) => {
-        const undeclared = Effect.die(new Error(`Conformance case "${conformanceCase.name}" opens a fresh database or snapshot without declaring requiresFreshDatabase`));
-        return {
-            run: (effect) => {
-                if (current === undefined)
-                    return Promise.reject(new Error("Conformance environment is stopped"));
-                return current.runPromise(Effect.scoped(effect), { signal });
-            },
-            build: environment.build,
-            stop: environment.stop,
-            restart: environment.restart,
-            freshDatabase: conformanceCase.requiresFreshDatabase === true ? environment.freshDatabase : undeclared,
-            snapshot: conformanceCase.requiresFreshDatabase === true ? environment.snapshot : undeclared,
-            get connect() {
-                return environment.connect;
-            },
-            get replica() {
-                return environment.replica;
-            },
-            httpServer: environment.httpServer,
-            get edge() {
-                return environment.edge;
-            },
-        };
-    };
-    let previousCase = Promise.resolve();
-    registrar.describe(name, () => {
-        registrar.beforeAll(() => Effect.runPromise(Effect.gen(function* () {
-            store = yield* Effect.promise(() => backend.open());
-            yield* environment.restart;
-        })), 30_000);
-        registrar.afterAll(() => previousCase.then(constVoid, constVoid).then(() => Effect.runPromise(Effect.gen(function* () {
-            yield* environment.stop;
-            if (store !== undefined)
-                yield* store.close;
-            store = undefined;
-        }))));
-        for (const { suite, cases } of selected)
-            for (const conformanceCase of cases) {
-                if (requirementsOf(conformanceCase).some((required) => !capabilities.has(required))) {
-                    registrar.skip(conformanceCase.name);
-                    continue;
-                }
-                registrar.it(conformanceCase.name, ({ signal }) => {
-                    const settled = Effect.runPromise(Effect.promise(() => previousCase.then(constVoid, constVoid)).pipe(Effect.timeoutOption(SETTLE_TIMEOUT)));
-                    const running = settled
-                        .then(() => {
-                        access.allowed = true;
-                        access.denied.clear();
-                        access.revoked.clear();
-                        return Effect.runPromise(Effect.suspend(() => (current === undefined ? environment.restart : Effect.void)));
-                    })
-                        .then(() => conformanceCase.run({
-                        expect: registrar.expect,
-                        environment: environmentFor(conformanceCase, signal),
-                        fixture: fixtureOf(suite),
-                        access,
-                        fixtureOf,
-                    }));
-                    previousCase = running;
-                    return running;
-                }, conformanceCase.timeoutMs);
-            }
-    });
-};

package/dist/testing/foundation.d.ts

@@ -1,41 +0,0 @@
-import { Effect, Layer, Logger } from "effect";
-import type { ConformanceCase } from "./conformance.ts";
-import type { ConformanceSuite } from "./conformance.ts";
-export interface RecordedDefect {
-    readonly actor: string;
-    readonly id: string;
-    readonly command: string;
-    readonly cause: string;
-}
-/** The annotations of a `Delivery timed out` warning. */
-export interface RecordedTimeout {
-    readonly actor: unknown;
-    readonly id: unknown;
-    readonly commandId: unknown;
-    readonly activation: unknown;
-    readonly turnSessions: unknown;
-    readonly restarting: unknown;
-}
-export interface FoundationFixture {
-    creates: number;
-    privateRuns: number;
-    slowIds: Array<string>;
-    slowFirst: Effect.Effect<void>;
-    deliveryRuns: number;
-    deliveryHold: Effect.Effect<void>;
-    defects: Array<RecordedDefect>;
-    /** Each `Delivery timed out` warning the runtime logged. */
-    timeouts: Array<RecordedTimeout>;
-}
-export declare const foundationFixture: () => FoundationFixture;
-/**
- * Captures the runtime's deterministic-defect log records, which replace the
- * removed defect hook, and the diagnostics of each delivery that timed out.
- */
-export declare const defectRecorder: (fixture: FoundationFixture) => Logger.Logger<unknown, void>;
-/** Handlers for the foundation actors; `fixture` supplies the observable state cases assert on. */
-export declare const foundationLayer: (fixture: FoundationFixture) => Layer.Layer<never, never, import("./index.ts").InternalActors>;
-/** Identity, admission, receipts, state migration, and blob cases every backend must pass. A receipt retry may wait for PGlite's busy connection, so its delivery deadline covers that wait as well as the RPC reply. */
-export declare const foundationConformance: ReadonlyArray<ConformanceCase<FoundationFixture>>;
-/** Foundation actors; its logger records deterministic defects and delivery timeouts for the cases to read. */
-export declare const foundationSuite: ConformanceSuite<FoundationFixture>;