@trypattern/sdk 0.1.33 → 0.1.34

package/dist/components/icons.js

@@ -102,8 +102,7 @@ const builtInIcons = {
     ],
     arrowDown: 'M12 5v14M6 13l6 6 6-6',
     logOut: [
-        'M14 4.5H7.5a2 2 0 0 0-2 2v11a2 2 0 0 0 2 2H14',
-        'M19.5 12H10M16 8.5l3.5 3.5-3.5 3.5'
+        'M20.25 12L9 12M20.25 12L15.75 16.5M20.25 12L15.75 7.5M11.25 20.25H5.75C4.64543 20.25 3.75 19.3546 3.75 18.25L3.75 5.75C3.75 4.64543 4.64543 3.75 5.75 3.75L11.25 3.75'
     ],
     today: 'M11.998 3.291V1.768M5.84 18.159L4.763 19.236M11.998 22.233V20.709M19.233 4.765L18.156 5.842M20.707 12H22.23M18.156 18.159L19.233 19.236M1.766 12H3.289M4.763 4.765L5.84 5.842M15.71 8.288C17.761 10.338 17.761 13.662 15.71 15.712C13.66 17.763 10.336 17.763 8.286 15.712C6.235 13.662 6.235 10.338 8.286 8.288C10.336 6.238 13.66 6.238 15.71 8.288Z',
     checklist: 'M11.75 16.25H20.25M11.75 7.75H20.25M3.75 8.625L5.417 9.75L8.75 5.25M3.75 17.625L5.417 18.75L8.75 14.25',

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export { defineApp } from './app.ts';
 export { Bookings, bookings } from './bookingsStore.ts';
 export type { BookingsWorld } from './bookingsMemory.ts';
+export { Inquiries, inquiries } from './inquiriesStore.ts';
+export type { InquiriesWorld } from './inquiriesStore.ts';
 export type { AppBlock } from './blocks.ts';
 export { ActionsStore, bindActions, rankActions } from './actions.ts';
 export type { Action, ActionsBuilder } from './actions.ts';

package/dist/index.js

@@ -1,5 +1,6 @@
 export { defineApp } from "./app.js";
 export { Bookings, bookings } from "./bookingsStore.js";
+export { Inquiries, inquiries } from "./inquiriesStore.js";
 export { ActionsStore, bindActions, rankActions } from "./actions.js";
 export { startApp } from "./start.js";
 export { appearance } from "./appearance.js";

package/dist/inquiriesStore.d.ts

@@ -0,0 +1,134 @@
+import { z } from 'zod';
+import type { WriteOutcome } from './access.ts';
+import { inquiryValue } from './requests.ts';
+import type { ServiceClient, ServiceMemory } from './services.ts';
+type Fields = Readonly<Record<string, z.output<typeof inquiryValue>>>;
+export type InquiriesWorld = {
+    sent?: {
+        source: string;
+        id: string;
+        fields: Fields;
+    }[];
+    sources?: string[];
+};
+declare const Inquiries_base: import("./store.ts").StoreClass<{
+    sent: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        source: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>>>;
+    isSending: z.ZodDefault<z.ZodBoolean>;
+}, [], ServiceClient<{
+    readonly inquiries: {
+        readonly send: NoInfer<import("./services.ts").ServiceCall<"/requests/:source", {
+            fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        }, z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>, false>>;
+    };
+}>>;
+export declare class Inquiries extends Inquiries_base {
+    send(source: string, fields: Fields): Promise<WriteOutcome>;
+}
+export declare const inquiries: {
+    readonly name: "inquiries";
+    readonly tables: {
+        requestStates: import("./table.ts").TableOf<"requestStates", {
+            readonly columns: {
+                readonly source: z.ZodString;
+                readonly requestId: z.ZodString;
+                readonly state: z.ZodEnum<{
+                    done: "done";
+                    open: "open";
+                }>;
+                readonly revision: z.ZodNumber;
+                readonly sequence: z.ZodNumber;
+                readonly updatedAt: z.ZodString;
+            };
+            readonly access: {
+                readonly read: "server";
+                readonly create: "server";
+                readonly update: "server";
+                readonly delete: "server";
+            };
+            readonly writes: "confirmed";
+        }>;
+        requestEvents: import("./table.ts").TableOf<"requestEvents", {
+            readonly columns: {
+                readonly source: z.ZodString;
+                readonly requestId: z.ZodString;
+                readonly kind: z.ZodEnum<{
+                    done: "done";
+                    accepted: "accepted";
+                    declined: "declined";
+                    replied: "replied";
+                    received: "received";
+                }>;
+            };
+            readonly access: {
+                readonly read: "server";
+                readonly create: "server";
+                readonly update: "server";
+                readonly delete: "server";
+            };
+            readonly writes: "confirmed";
+        }>;
+        requestOutbox: import("./table.ts").TableOf<"requestOutbox", {
+            readonly columns: {
+                readonly source: z.ZodString;
+                readonly requestId: z.ZodString;
+                readonly subject: z.ZodString;
+                readonly text: z.ZodString;
+                readonly replyTo: z.ZodString;
+                readonly status: z.ZodEnum<{
+                    failed: "failed";
+                    pending: "pending";
+                    sent: "sent";
+                    sending: "sending";
+                }>;
+                readonly attempts: z.ZodNumber;
+                readonly nextAt: z.ZodNullable<z.ZodString>;
+                readonly sentAt: z.ZodNullable<z.ZodString>;
+                readonly claimedAt: z.ZodNullable<z.ZodString>;
+            };
+            readonly access: {
+                readonly read: "server";
+                readonly create: "server";
+                readonly update: "server";
+                readonly delete: "server";
+            };
+            readonly writes: "confirmed";
+        }>;
+        requestOperations: import("./table.ts").TableOf<"requestOperations", {
+            readonly columns: {
+                readonly result: z.ZodString;
+            };
+            readonly access: {
+                readonly read: "server";
+                readonly create: "server";
+                readonly update: "server";
+                readonly delete: "server";
+            };
+            readonly writes: "confirmed";
+        }>;
+    };
+    readonly services: {
+        readonly inquiries: {
+            readonly send: NoInfer<import("./services.ts").ServiceCall<"/requests/:source", {
+                fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+            }, z.ZodObject<{
+                id: z.ZodString;
+            }, z.core.$strip>, false>>;
+        };
+    };
+    readonly memory: ServiceMemory<{
+        readonly inquiries: {
+            readonly send: NoInfer<import("./services.ts").ServiceCall<"/requests/:source", {
+                fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+            }, z.ZodObject<{
+                id: z.ZodString;
+            }, z.core.$strip>, false>>;
+        };
+    }, unknown>;
+    readonly Store: typeof Inquiries;
+};
+export {};

package/dist/inquiriesStore.js

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { inquiryServices, inquiryValue, requestTables } from "./requests.js";
+import { ServiceRefused, refused } from "./services.js";
+import { defineStore } from "./store.js";
+const Store = defineStore();
+function worldOf(world) {
+    const found = Reflect.get(Object(world), 'inquiries');
+    return typeof found === 'object' && found !== null ? found : {};
+}
+const inquiryMemory = {
+    inquiries: {
+        send: (world, { source, fields }) => {
+            const current = worldOf(world);
+            if (current.sources !== undefined && !current.sources.includes(source)) {
+                throw refused(404, 'No such form');
+            }
+            const sent = current.sent ?? [];
+            const id = `${source}-${sent.length + 1}`;
+            Reflect.set(Object(world), 'inquiries', {
+                ...current,
+                sent: [...sent, { source, id, fields }]
+            });
+            return { id };
+        }
+    }
+};
+function outcomeOf(error) {
+    if (!(error instanceof ServiceRefused))
+        return 'failed';
+    if (error.status === 400 || error.status === 404)
+        return 'forbidden';
+    return error.status === 409 ? 'conflict' : 'failed';
+}
+export class Inquiries extends Store({
+    state: {
+        sent: z
+            .object({ source: z.string(), id: z.string() })
+            .nullable()
+            .default(null),
+        isSending: z.boolean().default(false)
+    }
+}) {
+    async send(source, fields) {
+        this.set({ isSending: true });
+        try {
+            const { id } = await this.services.inquiries.send({ source, fields });
+            this.set({ sent: { source, id } });
+            return 'saved';
+        }
+        catch (error) {
+            return outcomeOf(error);
+        }
+        finally {
+            this.set({ isSending: false });
+        }
+    }
+}
+export const inquiries = {
+    name: 'inquiries',
+    tables: requestTables,
+    services: inquiryServices,
+    memory: inquiryMemory,
+    Store: Inquiries
+};

package/dist/patternAccess.d.ts

@@ -2,6 +2,8 @@ import { z } from 'zod';
 export declare const TABLES_READ = "tables:read";
 export declare const MEDIA_WRITE = "media:write";
 export declare const TABLES_WRITE = "tables:write";
+export declare const REQUESTS_READ = "requests:read";
+export declare const REQUESTS_ACT = "requests:act";
 export declare const ASSERTION_SECONDS = 60;
 export declare const NEXT_PAGE_HEADER = "x-pattern-next";
 export declare const assertionKey: z.ZodObject<{
@@ -16,17 +18,21 @@ declare const assertionScope: z.ZodEnum<{
     "tables:read": "tables:read";
     "media:write": "media:write";
     "tables:write": "tables:write";
+    "requests:read": "requests:read";
+    "requests:act": "requests:act";
 }>;
 export type AssertionScope = z.output<typeof assertionScope>;
-export declare function signAssertion(key: AssertionKey, { sub, aud, scope }: {
+export declare function signAssertion(key: AssertionKey, { sub, aud, scope, bound }: {
     sub: string;
     aud: string;
     scope: AssertionScope;
+    bound?: string;
 }, now: number): Promise<string>;
-export declare function verifiedAssertion(token: string, { hostname, keys, now, scope }: {
+export declare function verifiedAssertion(token: string, { hostname, keys, now, scope, bound }: {
     hostname: string;
     keys: Readonly<Record<string, string>>;
     now: number;
     scope: AssertionScope;
+    bound?: string;
 }): Promise<string | undefined>;
 export {};

package/dist/patternAccess.js

@@ -2,6 +2,8 @@ import { z } from 'zod';
 export const TABLES_READ = 'tables:read';
 export const MEDIA_WRITE = 'media:write';
 export const TABLES_WRITE = 'tables:write';
+export const REQUESTS_READ = 'requests:read';
+export const REQUESTS_ACT = 'requests:act';
 export const ASSERTION_SECONDS = 60;
 export const NEXT_PAGE_HEADER = 'x-pattern-next';
 const CLOCK_SKEW_SECONDS = 30;
@@ -13,7 +15,13 @@ export const assertionKey = z.object({
     x: z.string(),
     d: z.string()
 });
-const assertionScope = z.enum([TABLES_READ, TABLES_WRITE, MEDIA_WRITE]);
+const assertionScope = z.enum([
+    TABLES_READ,
+    TABLES_WRITE,
+    MEDIA_WRITE,
+    REQUESTS_READ,
+    REQUESTS_ACT
+]);
 const assertionHeader = z.object({
     alg: z.literal('EdDSA'),
     typ: z.literal('JWT'),
@@ -24,7 +32,8 @@ const assertionClaims = z.object({
     aud: z.string(),
     scope: assertionScope,
     iat: z.int(),
-    exp: z.int()
+    exp: z.int(),
+    bnd: z.string().optional()
 });
 const encoder = new TextEncoder();
 function base64url(bytes) {
@@ -56,14 +65,15 @@ function jsonOf(text) {
 function encoded(value) {
     return base64url(encoder.encode(JSON.stringify(value)));
 }
-export async function signAssertion(key, { sub, aud, scope }, now) {
+export async function signAssertion(key, { sub, aud, scope, bound }, now) {
     const privateKey = await crypto.subtle.importKey('jwk', { kty: key.kty, crv: key.crv, x: key.x, d: key.d }, ED25519, false, ['sign']);
     const signed = `${encoded({ alg: 'EdDSA', typ: 'JWT', kid: key.kid })}.${encoded({
         sub,
         aud,
         scope,
         iat: now,
-        exp: now + ASSERTION_SECONDS
+        exp: now + ASSERTION_SECONDS,
+        ...(bound === undefined ? {} : { bnd: bound })
     })}`;
     const signature = await crypto.subtle.sign(ED25519, privateKey, encoder.encode(signed));
     return `${signed}.${base64url(new Uint8Array(signature))}`;
@@ -83,7 +93,7 @@ async function isSignedBy(publicKey, signed, signature) {
         return false;
     }
 }
-export async function verifiedAssertion(token, { hostname, keys, now, scope }) {
+export async function verifiedAssertion(token, { hostname, keys, now, scope, bound }) {
     const [header, claims, signature, ...rest] = token.split('.');
     if (header === undefined ||
         claims === undefined ||
@@ -107,6 +117,8 @@ export async function verifiedAssertion(token, { hostname, keys, now, scope }) {
     const { sub, aud, iat, exp } = parsed.data;
     if (parsed.data.scope !== scope)
         return undefined;
+    if (bound !== undefined && parsed.data.bnd !== bound)
+        return undefined;
     const isFresh = exp > iat &&
         exp - iat <= ASSERTION_SECONDS &&
         iat <= now + CLOCK_SKEW_SECONDS &&