@substrat-run/contract-tests 0.144.0 → 0.146.0

package/dist/stamps-module.d.ts

@@ -0,0 +1,462 @@
+/**
+ * The fixture behind `updatedStampsContractSuite` (#2166): an entity that declares all four stamps,
+ * written by derived and authored handlers alike, and one that declares only `createdAt`.
+ *
+ * - `sdoc` — every stamp, and archivable: a derived create, get, update and archive, plus authored
+ *   writes that stamp the updated pair right or wrong on purpose (`stamp`), an authored delete, a
+ *   write inside a `ctx.atomic` that is rolled back, and a consumer that writes the row.
+ * - `splain` — the created stamp only: an authored write that stamps nothing is never checked.
+ *
+ * Inert for every other suite: nothing else invokes a `stamps/*` operation or reads its tables.
+ */
+import { z } from 'zod';
+import { type ModuleRegistration } from '@substrat-run/kernel';
+export declare const STAMPS_MODULE_ID = "@test/stamps";
+/** A time no call is ever made at. */
+export declare const STALE_TIME = "2000-01-01T00:00:00.000Z";
+export declare const stampsEntities: {
+    readonly sdoc: {
+        readonly table: "stamped_docs";
+        readonly fields: z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            created_at: z.ZodString;
+            created_by: z.ZodString;
+            updated_at: z.ZodString;
+            updated_by: z.ZodString;
+        }, z.core.$strip>;
+        readonly archive: {
+            readonly permission: "sdoc:archive";
+        };
+        readonly stamps: {
+            readonly created_at: "createdAt";
+            readonly created_by: "createdBy";
+            readonly updated_at: "updatedAt";
+            readonly updated_by: "updatedBy";
+        };
+    };
+    readonly splain: {
+        readonly table: "stamped_plain";
+        readonly fields: z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            created_at: z.ZodString;
+        }, z.core.$strip>;
+        readonly stamps: {
+            readonly created_at: "createdAt";
+        };
+    };
+};
+/** How an authored write stamps the updated pair: right, or wrong in one particular way. */
+export declare const STAMP_MODES: readonly ['both', 'skip-at', 'skip-by', 'constant', 'other'];
+export type StampMode = (typeof STAMP_MODES)[number];
+export declare const stampsOperations: {
+    readonly 'stamps/create-doc': {
+        readonly summary: "Add a doc, every stamp written by the platform";
+        readonly derive: "create";
+        readonly permission: "sdoc:write";
+        readonly input: z.ZodObject<{
+            title: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            created_at: z.ZodString;
+            created_by: z.ZodString;
+            updated_at: z.ZodString;
+            updated_by: z.ZodString;
+        }, z.core.$strip>;
+        readonly http: {
+            readonly method: "POST";
+            readonly path: "/docs";
+        };
+        readonly emits: {
+            readonly entity: "sdoc";
+            readonly entityIdFrom: "id";
+            readonly type: "sdoc.created";
+            readonly schemaVersion: 1;
+            readonly piiClass: "none";
+            readonly payload: readonly ["id", "title"];
+        };
+    };
+    readonly 'stamps/get-doc': {
+        readonly summary: "One doc";
+        readonly derive: "get";
+        readonly permission: {
+            readonly key: "sdoc:archive" | "sdoc:read" | "sdoc:write";
+            readonly entity: 'sdoc';
+            readonly idFrom: 'docId';
+        };
+        readonly input: z.ZodObject<{
+            docId: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            created_at: z.ZodString;
+            created_by: z.ZodString;
+            updated_at: z.ZodString;
+            updated_by: z.ZodString;
+        }, z.core.$strip>;
+        readonly http: {
+            readonly method: "GET";
+            readonly path: "/docs/{docId}";
+        };
+    };
+    readonly 'stamps/update-doc': {
+        readonly summary: "Change a doc's title";
+        readonly derive: "update";
+        readonly permission: {
+            readonly key: "sdoc:archive" | "sdoc:read" | "sdoc:write";
+            readonly entity: 'sdoc';
+            readonly idFrom: 'docId';
+        };
+        readonly input: z.ZodObject<{
+            docId: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            created_at: z.ZodString;
+            created_by: z.ZodString;
+            updated_at: z.ZodString;
+            updated_by: z.ZodString;
+        }, z.core.$strip>;
+        readonly http: {
+            readonly method: "PATCH";
+            readonly path: "/docs/{docId}";
+        };
+        readonly concurrency: {
+            readonly over: "sdoc";
+            readonly idFrom: "docId";
+        };
+        readonly emits: {
+            readonly entity: "sdoc";
+            readonly entityIdFrom: "id";
+            readonly type: "sdoc.updated";
+            readonly schemaVersion: 1;
+            readonly piiClass: "none";
+            readonly payload: readonly ["id", "title"];
+        };
+    };
+    readonly 'stamps/archive-doc': {
+        readonly summary: "File a doc away — a kernel move";
+        readonly derive: "archive";
+        readonly permission: {
+            readonly key: "sdoc:archive" | "sdoc:read" | "sdoc:write";
+            readonly entity: 'sdoc';
+            readonly idFrom: 'docId';
+        };
+        readonly input: z.ZodObject<{
+            docId: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            state: z.ZodEnum<{
+                active: "active";
+                archived: "archived";
+                trashed: "trashed";
+            }>;
+        }, z.core.$strip>;
+        readonly http: {
+            readonly method: "POST";
+            readonly path: "/docs/{docId}/archive";
+        };
+    };
+    readonly 'stamps/add-doc': {
+        readonly summary: "Add a doc by hand, with or without the updated pair";
+        readonly permission: "sdoc:write";
+        readonly input: z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            stampUpdated: z.ZodBoolean;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+        readonly emits: {
+            readonly entity: "sdoc";
+            readonly entityIdFrom: "id";
+            readonly type: "sdoc.added";
+            readonly schemaVersion: 1;
+            readonly piiClass: "none";
+            readonly payload: readonly ["id"];
+        };
+    };
+    readonly 'stamps/touch-doc': {
+        readonly summary: "Change a doc's title by hand, stamping as told";
+        readonly permission: "sdoc:write";
+        readonly input: z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            stamp: z.ZodEnum<{
+                both: "both";
+                constant: "constant";
+                other: "other";
+                "skip-at": "skip-at";
+                "skip-by": "skip-by";
+            }>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+        readonly emits: {
+            readonly entity: 'sdoc';
+            readonly entityIdFrom: 'id';
+            readonly type: 'sdoc.touched';
+            readonly schemaVersion: 1;
+            readonly piiClass: 'none';
+            readonly payload: readonly ['id'];
+        };
+    };
+    readonly 'stamps/atomic-touch': {
+        readonly summary: "Write a doc without its stamps inside a ctx.atomic that is rolled back";
+        readonly permission: "sdoc:write";
+        readonly input: z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+        readonly emits: {
+            readonly entity: 'sdoc';
+            readonly entityIdFrom: 'id';
+            readonly type: 'sdoc.touched';
+            readonly schemaVersion: 1;
+            readonly piiClass: 'none';
+            readonly payload: readonly ['id'];
+        };
+    };
+    readonly 'stamps/remove-doc': {
+        readonly summary: "Delete a doc by hand";
+        readonly permission: "sdoc:write";
+        readonly input: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+        readonly emits: {
+            readonly entity: "sdoc";
+            readonly entityIdFrom: "id";
+            readonly type: "sdoc.removed";
+            readonly schemaVersion: 1;
+            readonly piiClass: "none";
+            readonly payload: readonly ["id"];
+        };
+    };
+    readonly 'stamps/poke': {
+        readonly summary: "Ask the consumer to write a doc, stamping as told — the event is about the plain row";
+        readonly permission: "sdoc:write";
+        readonly input: z.ZodObject<{
+            id: z.ZodString;
+            stamp: z.ZodEnum<{
+                both: "both";
+                constant: "constant";
+                other: "other";
+                "skip-at": "skip-at";
+                "skip-by": "skip-by";
+            }>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+        readonly emits: {
+            readonly entity: "splain";
+            readonly entityIdFrom: "id";
+            readonly type: "sdoc.poked";
+            readonly schemaVersion: 1;
+            readonly piiClass: "none";
+            readonly payload: readonly ["id"];
+        };
+    };
+    readonly 'stamps/history': {
+        readonly summary: "How many events name a doc — what a rolled-back write must leave unchanged";
+        readonly permission: "sdoc:read";
+        readonly input: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            events: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly 'stamps/touch-plain': {
+        readonly summary: "Write a plain row, which declares no updated stamp";
+        readonly permission: "sdoc:write";
+        readonly input: z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+        readonly emits: {
+            readonly entity: "splain";
+            readonly entityIdFrom: "id";
+            readonly type: "splain.touched";
+            readonly schemaVersion: 1;
+            readonly piiClass: "none";
+            readonly payload: readonly ["id"];
+        };
+    };
+};
+export declare const stampsManifest: {
+    id: string & z.$brand<"ModuleId">;
+    version: string;
+    kernelContract: string;
+    permissions: {
+        key: string & z.$brand<"PermissionKey">;
+        description: string;
+    }[];
+    events: {
+        emits: {
+            type: string;
+            schemaVersion: number;
+        }[];
+        consumes: {
+            type: string;
+            schemaVersion: number;
+            from?: string | undefined;
+        }[];
+        exports?: {
+            type: string;
+            schemaVersion: number;
+            readPermission: string & z.$brand<"PermissionKey">;
+        }[] | undefined;
+    };
+    migrations: {
+        journalDir: string;
+        compatibleFrom: string;
+    };
+    attachmentTargets: {
+        entityType: string;
+        readPermission: string & z.$brand<"PermissionKey">;
+        writePermission?: (string & z.$brand<"PermissionKey">) | undefined;
+    }[];
+    liveTargets?: {
+        entityType: string;
+        readPermission: string & z.$brand<"PermissionKey">;
+    }[] | undefined;
+    entityRelations?: {
+        entityType: string;
+        parentType: string;
+    }[] | undefined;
+    guards?: {
+        before: string;
+        predicate: string;
+        config: Record<string, unknown>;
+    }[] | undefined;
+    schedules?: {
+        operation: string;
+        cadence: {
+            everyMinutes: number;
+        };
+        input?: Record<string, unknown> | undefined;
+        permissions: (string & z.$brand<"PermissionKey">)[];
+        purge?: {
+            entityType: string;
+        } | undefined;
+    }[] | undefined;
+    peers?: {
+        vertical: string;
+        operations: string[];
+        permissions: (string & z.$brand<"PermissionKey">)[];
+    }[] | undefined;
+    freshness?: {
+        eventType: string;
+        within: {
+            hours: number;
+        };
+    }[] | undefined;
+    withdraws?: string[] | undefined;
+    entitlementKey: string;
+    envSpec?: {
+        key: string;
+        label?: string | undefined;
+        description: string;
+        placeholder?: string | undefined;
+        required: boolean;
+        secret: boolean;
+        default?: string | undefined;
+        group?: string | undefined;
+    }[] | undefined;
+    ownerGrants?: (string & z.$brand<"PermissionKey">)[] | undefined;
+    entitlements?: string[] | undefined;
+    provides?: string[] | undefined;
+    requires?: string[] | undefined;
+    api?: string | undefined;
+    searchables?: {
+        entityType: string;
+        fields: string[];
+        table?: string | undefined;
+        idColumn?: string | undefined;
+        tokenizer?: "prefix" | "substring" | undefined;
+    }[] | undefined;
+    lists?: {
+        entityType: string;
+        sortable: string[];
+        filterable?: string[] | undefined;
+        table?: string | undefined;
+        idColumn?: string | undefined;
+    }[] | undefined;
+    entityStates?: {
+        archivePermission?: (string & z.$brand<"PermissionKey">) | undefined;
+        trashPermission?: (string & z.$brand<"PermissionKey">) | undefined;
+        purgeAfterDays?: number | undefined;
+        purgeEarly?: boolean | undefined;
+        table?: string | undefined;
+        idColumn?: string | undefined;
+        entityType: string;
+    }[] | undefined;
+    erasure?: {
+        tables: string[];
+        entities: {
+            entityType: string;
+            table: string;
+            mode: "blank" | "custom" | "delete" | "unreached";
+            subjects?: string[] | undefined;
+            fields: {
+                name: string;
+                blank: "" | null;
+            }[];
+        }[];
+    } | undefined;
+    updatedStamps?: {
+        table: string;
+        idColumn: string;
+        at?: string | undefined;
+        by?: string | undefined;
+        entityType: string;
+    }[] | undefined;
+    ui?: {
+        routes?: {
+            path: string;
+            screen: string;
+            permission: string & z.$brand<"PermissionKey">;
+        }[] | undefined;
+        nav?: {
+            label: string;
+            icon?: string | undefined;
+            to: string;
+            permission: string & z.$brand<"PermissionKey">;
+        }[] | undefined;
+        entityViews?: {
+            entityType: string;
+            view: string;
+        }[] | undefined;
+        widgets?: {
+            slot: string;
+            component: string;
+            permission: string & z.$brand<"PermissionKey">;
+        }[] | undefined;
+        settingsPanels?: {
+            label: string;
+            component: string;
+            permission: string & z.$brand<"PermissionKey">;
+        }[] | undefined;
+    } | undefined;
+};
+export declare const stampsMod: ModuleRegistration;
+//# sourceMappingURL=stamps-module.d.ts.map

package/dist/stamps-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stamps-module.d.ts","sourceRoot":"","sources":["../src/stamps-module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,OAAO,EAA6C,KAAK,kBAAkB,EAAyB,MAAM,sBAAsB,CAAC;AAEjI,eAAO,MAAM,gBAAgB,iBAAiB,CAAC;AAE/C,sCAAsC;AACtC,eAAO,MAAM,UAAU,6BAA6B,CAAC;AAErD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBzB,CAAC;AAEH,4FAA4F;AAC5F,eAAO,MAAM,WAAW,YAAI,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,CAAU,CAAC;AACxF,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAOrD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAJsC,MAAM;6BAAU,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAEhE,MAAM;mCAAgB,IAAI;2BAAQ,cAAc;oCAAiB,CAAC;+BAAY,MAAM;wCAAY,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsF5H,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWzB,CAAC;AA8BH,eAAO,MAAM,SAAS,EAAE,kBAgFvB,CAAC"}