@rikalabs/akter 0.1.0-alpha.0

package/dist/testing/conformance/assertions.d.ts

@@ -0,0 +1,202 @@
+import { Crypto, Effect, Schema, type Scope } from "effect";
+import { InternalActors } from "../../runtime/actors.ts";
+import type { RuntimeControl } from "../../runtime/drain.ts";
+import type { AssertionKey } from "../../serve/assertion/verify.ts";
+import type { AuthProvider } from "../../serve/auth.ts";
+import type { ConformanceCase, ConformanceSuite } from "../conformance.ts";
+/**
+ * The runner half of hosted assertions: a runner serving with
+ * `Auth.assertion` admits a request only with a valid assertion bound
+ * to exactly that request. The cases sign assertions as an edge would, with
+ * their own Ed25519 keys.
+ */
+export declare const ISSUER = "https://edge.durable.test";
+export declare const DEPLOYMENT = "dep-assertions";
+export declare const REGION = "test-1";
+/** An edge signing key and the public key runners verify it with. */
+export interface EdgeKey {
+    readonly kid: string;
+    readonly privateKey: CryptoKey;
+    readonly publicKey: AssertionKey;
+}
+export declare const edgeKey: (kid: string) => Effect.Effect<{
+    kid: string;
+    privateKey: CryptoKey;
+    publicKey: {
+        kid: string;
+        kty: "OKP";
+        crv: "Ed25519";
+        x: string;
+    };
+}, never, never>;
+interface JwsHeader {
+    readonly alg: string;
+    readonly typ: string;
+    readonly kid: string;
+}
+/** A compact JWS over `claims`; the header defaults to an Ed25519 assertion under `key`. */
+export declare const signAssertion: (key: EdgeKey, claims: {
+    readonly iss: string;
+    readonly aud: string;
+    readonly region: string;
+    readonly iat: number;
+    readonly exp: number;
+    readonly tenant: string;
+    readonly caller: {
+        readonly _tag: "Anonymous";
+    } | {
+        readonly _tag: "User";
+        readonly subject: string;
+    };
+    readonly req: string;
+    readonly sid?: string | undefined;
+    readonly cexp?: number | undefined;
+    readonly actor?: string | undefined;
+    readonly id?: string | undefined;
+    readonly member?: string | undefined;
+    readonly cid?: string | undefined;
+} | {
+    readonly [claim: string]: Schema.Json;
+}, header?: Partial<JwsHeader> | undefined) => Effect.Effect<string, never, never>;
+/** A key-set refresh push for `audience`, issued now for 10 seconds, signed with `key`. */
+export declare const signRefresh: (key: EdgeKey, audience?: any) => Effect.Effect<string, never, never>;
+/** Claims for `tenant`'s `subject`, issued now for 10 seconds, bound to `req`. */
+export declare const claimsFor: (options: {
+    readonly tenant: string;
+    readonly subject: string;
+    readonly req: string;
+}) => Effect.Effect<{
+    iss: string;
+    aud: string;
+    region: string;
+    iat: number;
+    exp: number;
+    tenant: string;
+    caller: {
+        readonly _tag: "User";
+        readonly subject: string;
+    };
+    req: string;
+}, never, never>;
+interface Reply {
+    readonly status: number;
+    readonly body: Schema.Json | undefined;
+}
+/** A request as sent; an empty `body` sends none. */
+interface Sent {
+    readonly method: "GET" | "POST";
+    readonly path: string;
+    readonly key: string | undefined;
+    readonly body: string;
+    readonly headers: Readonly<Record<string, string>>;
+}
+interface AssertedServer {
+    /** The runner's base URL. */
+    readonly url: string;
+    readonly send: (request: Sent) => Effect.Effect<Reply>;
+    /** The `req` claim for `request` as the runner will receive it. */
+    readonly digest: (request: Sent) => Effect.Effect<string>;
+    /** A v1 command id issued now. */
+    readonly mint: Effect.Effect<string>;
+}
+/** A runner's assertion provider trusting exactly `keys`. */
+export declare const staticAuth: (keys: ReadonlyArray<EdgeKey>) => AuthProvider<never>;
+/** A request to `HttpRoom/<id>/<member>` with a fresh command id. */
+export declare const command: (server: AssertedServer, id: string, member: string, body?: any) => Effect.Effect<{
+    method: "POST";
+    path: string;
+    key: string;
+    body: any;
+    headers: {};
+}, never, never>;
+export declare const assertionsConformance: ReadonlyArray<ConformanceCase>;
+/**
+ * The edge half: the same served actors behind a real hosted edge, which a
+ * backend supplies as `ConformanceEdge`. The framework can't import the edge,
+ * so the edge's own tests run these cases with it.
+ */
+/** A runner the edge may forward to. */
+export interface EdgeRunner {
+    readonly region: string;
+    /** The runner's base URL, such as `http://127.0.0.1:4000`. */
+    readonly url: string;
+    /** The runner's `Actor.serve` base path, where the edge pushes key-set refreshes. */
+    readonly basePath?: string;
+}
+/** One running edge in front of one deployment, with the control plane it reads. */
+export interface HostedEdge {
+    /** The edge's base URL; requests to it are for `deployment`. */
+    readonly url: string;
+    readonly issuer: string;
+    readonly deployment: string;
+    /** The published key set runners verify the edge's assertions with. */
+    readonly keys: URL;
+    readonly addRunner: (runner: EdgeRunner) => Effect.Effect<void>;
+    /** Unregisters a runner, as its provider does before stopping it. */
+    readonly removeRunner: (url: string) => Effect.Effect<void>;
+    /**
+     * Takes the regions the edge asked a runner for since the last call, as a
+     * runner provider does: each `runner_wake` row is deleted as it is read.
+     */
+    readonly takeWakes: Effect.Effect<ReadonlyArray<string>>;
+    /** Issues a hosted API key for `tenant`'s `subject`. */
+    readonly issueApiKey: (options: {
+        readonly tenant: string;
+        readonly subject: string;
+    }) => Effect.Effect<string>;
+    readonly revokeApiKey: (key: string) => Effect.Effect<void>;
+    /** Revokes an edge signing key in the control plane, as an operator would. */
+    readonly revokeSigningKey: (kid: string) => Effect.Effect<void>;
+    /** Writes a directory row as a tenant move would, which only L.1's operators can do. */
+    readonly home: (options: {
+        readonly tenant: string;
+        readonly region: string;
+    }) => Effect.Effect<void>;
+    /** Rows in the tenant directory. */
+    readonly directoryRows: Effect.Effect<number>;
+}
+export interface ConformanceEdge {
+    /** Starts an edge for a new deployment whose primary region is `primaryRegion`. */
+    readonly start: (options: {
+        readonly primaryRegion: string;
+        /** How long each assertion lives; default 10 seconds. */
+        readonly assertionSeconds?: number;
+        /** How long a session opened with an API key lasts before it must reauthenticate. */
+        readonly apiKeySessionSeconds?: number;
+        /** The edge's signing keys; one new key when omitted. */
+        readonly signingKeys?: ReadonlyArray<EdgeKey>;
+        /** Whether the deployment may run with no runners; default false. */
+        readonly scaleToZero?: boolean;
+        /** How long a request waits for a cold start; default 30 seconds. */
+        readonly coldStartSeconds?: number;
+    }) => Effect.Effect<HostedEdge, never, Scope.Scope>;
+}
+export declare const edgeOf: (edge: ConformanceEdge | undefined) => Effect.Effect<ConformanceEdge, never, never>;
+/** Sends requests to the server at `url` for the rest of the scope. */
+export declare const clientFor: (url: string) => Effect.Effect<(request: Sent) => Effect.Effect<{
+    status: number;
+    body: Schema.Json | undefined;
+}, never, never>, never, Scope.Scope>;
+/** A runner in `region` that trusts `edge`, rereading its key set every second. */
+export declare const edgeRunner: (edge: HostedEdge, region: string) => Effect.Effect<AssertedServer, never, Crypto.Crypto | InternalActors | RuntimeControl | Scope.Scope>;
+export declare const bearerHeaders: (key: string) => {
+    authorization: string;
+};
+/**
+ * A proxy in front of a runner that holds each request for the delay its
+ * path's actor id names, and counts the requests that reached it.
+ */
+export declare const delayingProxy: (target: string) => Effect.Effect<{
+    url: string;
+    delay: (id: string, ms: number) => Effect.Effect<Map<string, number>, never, never>;
+    /** Answers the next `times` requests for `path` with 503. */
+    fail: (path: string, times: number) => Effect.Effect<Map<string, number>, never, never>;
+    arrived: Effect.Effect<number, never, never>;
+    /** The `cookie` header of each request that reached the proxy, `null` when it had none. */
+    cookies: Effect.Effect<(string | null)[], never, never>;
+}, never, Scope.Scope>;
+/** Edge cases: the edge strips client-supplied assertions, signs the caller it authenticated, honors key rotation and revocation bounds, and routes across runners and regions. */
+export declare const edgeConformance: ReadonlyArray<ConformanceCase>;
+/** Assertion and edge cases call the served HTTP actors and the socket room. */
+export declare const assertionsSuite: ConformanceSuite;
+export {};