@decionis/agent-safe-pipeline 0.4.0 → 0.5.0

package/dist/profile/ApiProfile.d.ts

@@ -0,0 +1,354 @@
+import { z } from "zod";
+import type { JsonObject, JsonValue } from "../intent/JsonValue.js";
+import { type TargetPrecondition } from "../intent/TargetPrecondition.js";
+/**
+ * `agent-safe.profile.api/1`: a platform API described as data, so that every
+ * component that turns one of its calls into an intent turns it into the same
+ * one. A profile maps method + path (and, where an API overloads a path, an
+ * exact query value) to an action type, and names the facts a decision reads
+ * by JSON pointer into the call. The gateway reads it to govern an agent's
+ * call; a native executor's `prepare` reads it to describe the call it is
+ * about to make. One mapping, no code coupling between them.
+ *
+ * An operation may also say where the subject sits (the customer a call is
+ * for): in the call, and, for a read, in each item of its answer. A component
+ * that pins a session to one subject checks a read against it, and states the
+ * subject to the authority for a write. A read is an operation only for that:
+ * it is checked, never decided.
+ *
+ * A write may also name the read that states its target's version (an ETag,
+ * a row version), and where that read's answer states it: a component that
+ * binds the target's state reads it once before the authority is asked, and
+ * the version rides into the intent as its precondition.
+ */
+export declare const API_PROFILE_CONTRACT = "agent-safe.profile.api/1";
+export declare const API_PROFILE_SCHEMA_ID = "https://github.com/decionis/agent-safe-pipeline/blob/master/spec/profiles/api/v1/schema.json";
+/** The methods a profile governs: each operation of one is decided by the authority. */
+export declare const API_PROFILE_METHODS: readonly ["POST", "PUT", "PATCH", "DELETE"];
+export type ApiProfileMethod = (typeof API_PROFILE_METHODS)[number];
+/** The one read method an operation may name: checked for its subject, never decided. */
+export declare const API_PROFILE_READ_METHOD = "GET";
+/**
+ * Fact names a profile may not use. The first group is what the gateway
+ * already states in an intent's context; the second is what the Decionis
+ * authority states itself, or reads from the request rather than the context,
+ * so a fact of that name would be shadowed or refused there.
+ */
+export declare const RESERVED_FACT_NAMES: readonly string[];
+/** The most elements one `*` pointer collects; more is not a fact, it is a payload. */
+export declare const MAX_FACT_ELEMENTS = 100;
+/** The longest string a fact carries; a longer value is not stated. */
+export declare const MAX_FACT_STRING = 1000;
+/** The longest subject: an identifier, never a payload. */
+export declare const MAX_SUBJECT_LENGTH = 200;
+export declare const ApiPolicyProjectionSchema: z.ZodObject<{
+    decision_type: z.ZodString;
+    transaction_type: z.ZodNullable<z.ZodString>;
+    workflow_key: z.ZodNullable<z.ZodString>;
+    channel: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Where an operation's subject sits, and what else a call or an answer may
+ * carry around it:
+ *
+ * - `request`, a pointer into the call like a fact's, with no `*`;
+ * - `response`, a pointer into a successful answer's JSON body, where one `*`
+ *   reaches every item of a list;
+ * - `query`, for a read, the one query parameter that must state the subject,
+ *   exactly as `template` writes it with `{subject}` in place of the
+ *   session's subject (`customerNumber eq '{subject}'`);
+ * - `parameters`, for a read, every other query parameter it may carry;
+ * - `envelope`, beside a `response` pointer through `*`, the keys the object
+ *   holding the list may carry besides the list.
+ */
+export declare const ApiSubjectSchema: z.ZodObject<{
+    request: z.ZodOptional<z.ZodString>;
+    response: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        template: z.ZodString;
+    }, z.core.$strict>>;
+    parameters: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    envelope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+/**
+ * Where a write's target states its version: `read`, a read in the same
+ * profile whose path placeholders the write's path also has, so the read can
+ * be made from the write's own call; `version`, a pointer into the read's
+ * answer, `{ body, headers }`, with no `*`; and `state`, where the same answer
+ * states the target's state, when a transition rule reads one.
+ */
+export declare const ApiPreconditionSchema: z.ZodObject<{
+    read: z.ZodString;
+    version: z.ZodString;
+    state: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ApiOperationSchema: z.ZodObject<{
+    id: z.ZodString;
+    method: z.ZodEnum<{
+        POST: "POST";
+        GET: "GET";
+        PUT: "PUT";
+        PATCH: "PATCH";
+        DELETE: "DELETE";
+    }>;
+    path: z.ZodString;
+    query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    action: z.ZodString;
+    summary: z.ZodString;
+    facts: z.ZodRecord<z.ZodString, z.ZodString>;
+    policy_projection: z.ZodNullable<z.ZodObject<{
+        decision_type: z.ZodString;
+        transaction_type: z.ZodNullable<z.ZodString>;
+        workflow_key: z.ZodNullable<z.ZodString>;
+        channel: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    subject: z.ZodOptional<z.ZodObject<{
+        request: z.ZodOptional<z.ZodString>;
+        response: z.ZodOptional<z.ZodString>;
+        query: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            template: z.ZodString;
+        }, z.core.$strict>>;
+        parameters: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        envelope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    precondition: z.ZodOptional<z.ZodObject<{
+        read: z.ZodString;
+        version: z.ZodString;
+        state: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const ApiProfileDefinitionSchema: z.ZodObject<{
+    profile: z.ZodLiteral<"agent-safe.profile.api/1">;
+    id: z.ZodString;
+    platform: z.ZodString;
+    title: z.ZodString;
+    prefixes: z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>;
+    operations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        method: z.ZodEnum<{
+            POST: "POST";
+            GET: "GET";
+            PUT: "PUT";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+        }>;
+        path: z.ZodString;
+        query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        action: z.ZodString;
+        summary: z.ZodString;
+        facts: z.ZodRecord<z.ZodString, z.ZodString>;
+        policy_projection: z.ZodNullable<z.ZodObject<{
+            decision_type: z.ZodString;
+            transaction_type: z.ZodNullable<z.ZodString>;
+            workflow_key: z.ZodNullable<z.ZodString>;
+            channel: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        subject: z.ZodOptional<z.ZodObject<{
+            request: z.ZodOptional<z.ZodString>;
+            response: z.ZodOptional<z.ZodString>;
+            query: z.ZodOptional<z.ZodObject<{
+                name: z.ZodString;
+                template: z.ZodString;
+            }, z.core.$strict>>;
+            parameters: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            envelope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        precondition: z.ZodOptional<z.ZodObject<{
+            read: z.ZodString;
+            version: z.ZodString;
+            state: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ApiPolicyProjection = z.infer<typeof ApiPolicyProjectionSchema>;
+export type ApiSubject = z.infer<typeof ApiSubjectSchema>;
+export type ApiPrecondition = z.infer<typeof ApiPreconditionSchema>;
+export type ApiOperationDefinition = z.infer<typeof ApiOperationSchema>;
+export type ApiProfileDefinition = z.infer<typeof ApiProfileDefinitionSchema>;
+/** One call as a component is about to make it, or as the gateway received it. */
+export interface ApiRequest {
+    readonly method: string;
+    /** The URL path, as sent (percent-encoded); without query or fragment. */
+    readonly path: string;
+    readonly query?: {
+        readonly [key: string]: string | readonly string[];
+    };
+    /** The parsed JSON body, when there is one. */
+    readonly body?: JsonValue;
+}
+/** A read's answer, as a component that binds a precondition received it. */
+export interface ApiAnswer {
+    /** Header names in lower case. */
+    readonly headers: {
+        readonly [name: string]: string;
+    };
+    /** The parsed JSON body, when there is one. */
+    readonly body?: JsonValue;
+}
+/** What a profile says about one call. */
+export interface ApiProfileMatch {
+    readonly profile: string;
+    readonly operation: string;
+    readonly action: string;
+    /** Every fact whose pointer resolved to a statable value; the others are absent. */
+    readonly facts: JsonObject;
+    readonly policyProjection: ApiPolicyProjection | null;
+    /**
+     * The call's subject, when the operation names where it sits in the call:
+     * a string or a finite number, as a string; null when the pointer found
+     * neither. Absent when the operation names no request subject.
+     */
+    readonly subject?: string | null;
+}
+/**
+ * A subject check's answer. `MATCH` is the only one that lets a call or an
+ * answer through; every other is a refusal, and each says why without saying
+ * whose record it was.
+ */
+export type ApiSubjectCheck = "MATCH" | "SUBJECT_ABSENT" | "SUBJECT_MISMATCH" | "QUERY_PARAMETER_REFUSED" | "RESPONSE_UNREADABLE" | "RESPONSE_KEY_REFUSED" | "RESPONSE_SUBJECT_ABSENT" | "RESPONSE_SUBJECT_MISMATCH";
+export declare class ApiProfileError extends Error {
+    readonly code: "API_PROFILE_INVALID";
+    readonly detail: string;
+    constructor(code: "API_PROFILE_INVALID", detail: string);
+}
+/**
+ * One profile, validated and compiled. Matching is deterministic and total:
+ * the first operation, in profile order, whose method, path and query match
+ * is the call's operation; a call no operation matches is not described by
+ * the profile and the caller decides what that means.
+ */
+export declare class ApiProfile {
+    readonly definition: ApiProfileDefinition;
+    private readonly compiled;
+    private constructor();
+    /** Validates a definition (closed schema, unique operations, pointers, reserved names) and compiles it. */
+    static parse(value: unknown): ApiProfile;
+    get id(): string;
+    get platform(): string;
+    /**
+     * Every action type the profile's writes can produce, for a registry to be
+     * sealed over. A read's action names it in reports; it is never an intent.
+     */
+    actions(): readonly string[];
+    /** Whether an operation is a read: checked for its subject, never decided. */
+    static isRead(operation: ApiOperationDefinition): boolean;
+    /**
+     * A call against the session's subject, before it is sent: `MATCH`, or why
+     * not. A read that names the query parameters it may carry carries no
+     * other (`QUERY_PARAMETER_REFUSED`); a read that names its subject query
+     * states the session's subject there and nothing else, so a list can be
+     * asked only for the session's own records; and the subject at the
+     * operation's request pointer is the session's.
+     */
+    checkRequest(match: ApiProfileMatch, query: NonNullable<ApiRequest["query"]>, subject: string): ApiSubjectCheck;
+    /**
+     * A subject query parameter against its template: absent is
+     * `SUBJECT_ABSENT`; given twice, or anything but the template with one
+     * literal in place of `{subject}`, is `QUERY_PARAMETER_REFUSED`, which is
+     * what a second predicate beside the subject's is; a literal naming
+     * another subject is `SUBJECT_MISMATCH`. A `'` inside the literal is
+     * written doubled, as an OData string literal writes it; a single one ends
+     * the literal, so it refuses the call.
+     */
+    private static checkQuery;
+    /**
+     * A successful answer, to a read or a write, against the session's
+     * subject, before any of it is relayed: every item the operation's response
+     * pointer reaches must name the subject. One item naming another is
+     * `RESPONSE_SUBJECT_MISMATCH`, one naming none `RESPONSE_SUBJECT_ABSENT`,
+     * and an answer the pointer cannot be walked into (not JSON, or no list
+     * where the `*` stands) `RESPONSE_UNREADABLE`. Beside a list, the object
+     * that holds it may carry only the keys the operation's `envelope` names,
+     * so a count or a summary about other subjects is `RESPONSE_KEY_REFUSED`.
+     * Nothing is filtered: a partial answer would look complete. An empty list
+     * names no one and matches. Null when the operation names no response
+     * subject, so there is nothing to check.
+     */
+    checkResponse(operationId: string, body: JsonValue | undefined, subject: string): ApiSubjectCheck | null;
+    operation(id: string): ApiOperationDefinition | null;
+    /**
+     * The operation a method, path and query select, before any body is read:
+     * what the gateway needs to decide whether to govern a call.
+     */
+    operationFor(method: string, path: string, query?: ApiRequest["query"]): ApiOperationDefinition | null;
+    /**
+     * Whether a call reads like one of this method's operations without
+     * matching it exactly: its path in another letter case, or with a literal
+     * percent-encoded. An upstream that folds case or decodes before it routes
+     * would serve it as that operation, so a component that checks reads
+     * refuses it rather than let it through unchecked. A path that does not
+     * decode resembles everything.
+     */
+    resembles(method: string, path: string): boolean;
+    /**
+     * Whether a call's path goes on below one of this method's operations
+     * without being an operation itself, in any letter case: a count
+     * (`/customers/$count`), a navigation or a media stream beneath a record.
+     * What it answers is not what the operation's subject rule checks, so a
+     * component that checks reads refuses it.
+     */
+    beneath(method: string, path: string): boolean;
+    /** The operation, action type, facts and policy projection of one call; null when no operation matches. */
+    match(request: ApiRequest): ApiProfileMatch | null;
+    /**
+     * The read a write's precondition names, as the call to make: `GET`, the
+     * read's path under the prefix the write matched, each placeholder filled
+     * with the write's own text for it, exactly as the write's call wrote it.
+     * Null when the call matches no write, or its operation names no
+     * precondition. The component makes the read; the profile makes no call.
+     */
+    stateRead(request: ApiRequest): ApiRequest | null;
+    /**
+     * The precondition a write's read answered: the version at the operation's
+     * pointer, a string or a finite number as a string, within the
+     * precondition's bounds; the state beside it when the operation names
+     * where; which read said so, as `<profile>#<read>`; and when. Null when the
+     * operation names no precondition, or the answer states no usable version:
+     * a component that binds the target's state refuses then, rather than bind
+     * none. A state the answer does not state is left out.
+     */
+    precondition(operationId: string, answer: ApiAnswer, readAt: Date): TargetPrecondition | null;
+    private select;
+    /** A template as an anchored expression: placeholders take one segment's text, never a `/`. */
+    private static compile;
+    private static escape;
+    /** A placeholder's value: percent-decoded, OData quotes removed; null when it does not decode. */
+    private static decode;
+    private static queryMatches;
+    private static queryRoot;
+    /**
+     * What a definition must also be about subjects: a subject names where it
+     * sits, in the call, its query or its answer; a read names one and states
+     * no fact or policy path, since it is never decided; only a read names a
+     * subject query or the parameters it may carry; a request subject is one
+     * value, so its pointer has no `*`; a subject query's template states the
+     * subject once; an envelope stands beside a list.
+     */
+    private static subjectRules;
+    /**
+     * What a precondition must be: a write's, naming a read in the same
+     * profile, whose path placeholders the write's path all has, so the read
+     * is made from the write's own call; and pointers through no `*`, since a
+     * version is one value.
+     */
+    private static preconditionRules;
+    /** A subject as stated: a string or a finite number, as a string, within the bound; else null. */
+    private static subjectOf;
+    /** Each element's value through a `*`; null when there is no list where the `*` stands. */
+    private static walkList;
+    /** RFC 6901 reference tokens, unescaped; one `*` token at most. */
+    private static pointerSegments;
+    /**
+     * The value at a pointer, when it is statable: a string (at most 1000
+     * characters), a finite number or a boolean; or, through one `*`, an array
+     * of up to 100 of them, every element statable. Anything else is absent.
+     */
+    private static read;
+    private static walk;
+    private static statable;
+}
+/** The published JSON Schema of a profile definition, generated from the validator above. */
+export declare function apiProfileJsonSchema(): Record<string, unknown>;
+//# sourceMappingURL=ApiProfile.d.ts.map

package/dist/profile/ApiProfile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiProfile.d.ts","sourceRoot":"","sources":["../../src/profile/ApiProfile.ts"],"names":[],"mappings":"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"}