@trypattern/sdk 0.1.33 → 0.1.34

package/dist/publishWire.js

@@ -2,6 +2,9 @@ import { z } from 'zod';
 import { appTitle } from "./appTitle.js";
 export { appTitle };
 export { ASSERTION_SECONDS, MEDIA_WRITE, NEXT_PAGE_HEADER, TABLES_READ, TABLES_WRITE, assertionKey, signAssertion } from "./patternAccess.js";
+export { REQUESTS_ACT, REQUESTS_READ } from "./patternAccess.js";
+export { REQUESTS_PATH, REQUEST_SYNC_PAGE, requestBound, requestCard, requestSync } from "./requests.js";
+import { requestCard } from "./requests.js";
 import { call, defineServices } from "./services.js";
 export const DASHBOARD_URL = 'https://onpattern.app';
 export const APPS_DOMAIN = 'onpattern.app';
@@ -302,6 +305,34 @@ export const changeSet = z.object({
     changes: z.array(dataChange),
     outcomes: z.array(changeOutcome).nullable()
 });
+export const REPLY_LIMIT = 5000;
+export const requestMessage = z.object({
+    id: z.string(),
+    kind: z.enum(['reply', 'accepted', 'declined']),
+    text: z.string(),
+    status: z.enum(['sending', 'sent', 'failed']),
+    problem: z.string().nullable(),
+    createdAt: z.string(),
+    sentAt: z.string().nullable()
+});
+export const requestDraft = z.object({
+    id: z.string(),
+    text: z.string(),
+    asked: z.string(),
+    device: z.string(),
+    createdAt: z.string()
+});
+export const requestEntry = requestCard.extend({
+    isUnread: z.boolean(),
+    messages: z.array(requestMessage),
+    draft: requestDraft.nullable()
+});
+export const requestList = z.object({
+    status: z.enum(['ready', 'outdated', 'none']),
+    requests: z.array(requestEntry),
+    syncedAt: z.string().nullable()
+});
+const operation = z.string().min(8).max(100);
 export const publishServices = defineServices({
     apps: {
         list: call({ get: '/apps', reply: z.array(appSummary) }),
@@ -411,6 +442,53 @@ export const publishServices = defineServices({
         }),
         undo: call({ post: '/apps/:name/changes/:id/undo', reply: changeSet })
     },
+    requests: {
+        list: call({ get: '/apps/:name/requests', reply: requestList }),
+        deliver: call({
+            post: '/apps/:name/requests/deliver',
+            reply: requestList
+        }),
+        open: call({
+            post: '/apps/:name/requests/:source/:id/open',
+            reply: requestEntry
+        }),
+        act: call({
+            post: '/apps/:name/requests/:source/:id/act',
+            input: {
+                action: z.enum(['accept', 'decline', 'done']),
+                revision: z.number().int(),
+                operation
+            },
+            reply: requestEntry
+        }),
+        reply: call({
+            post: '/apps/:name/requests/:source/:id/reply',
+            input: {
+                text: z.string().trim().min(1).max(REPLY_LIMIT),
+                revision: z.number().int(),
+                operation,
+                draft: z.string().optional()
+            },
+            reply: requestEntry
+        }),
+        retry: call({
+            post: '/apps/:name/requests/:source/:id/retry',
+            input: { message: z.string() },
+            reply: requestEntry
+        }),
+        draft: call({
+            post: '/apps/:name/requests/:source/:id/drafts',
+            input: {
+                text: z.string().trim().min(1).max(REPLY_LIMIT),
+                asked: z.string().trim().min(1).max(1000)
+            },
+            reply: requestDraft
+        }),
+        discard: call({
+            post: '/apps/:name/requests/:source/:id/drafts/:draft/discard',
+            reply: requestEntry
+        })
+    },
     logins: {
         read: call({ get: '/cli/logins/:approval', reply: loginToApprove }),
         approve: call({

package/dist/requests.d.ts

@@ -0,0 +1,361 @@
+import { z } from 'zod';
+import type { Table } from './table.ts';
+export declare const REQUEST_KINDS: readonly ["booking", "inquiry"];
+export declare const REQUEST_ACTIONS: readonly ["accept", "decline", "reply", "done"];
+export declare const REQUEST_STATUSES: readonly ["requested", "accepted", "declined", "cancelled", "open", "replied", "done"];
+export declare const REQUEST_EVENTS: readonly ["received", "accepted", "declined", "replied", "done"];
+export declare const NOTICE_STATUSES: readonly ["pending", "sending", "sent", "failed"];
+export declare const REQUESTS_PATH = "/api/pattern/requests";
+export declare const REQUEST_SYNC_PAGE = 200;
+export declare const 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";
+}>;
+export declare const 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";
+}>;
+export declare const 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";
+}>;
+export declare const 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";
+}>;
+export declare const requestTables: {
+    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";
+    }>;
+};
+export type RequestKind = (typeof REQUEST_KINDS)[number];
+export type RequestAction = (typeof REQUEST_ACTIONS)[number];
+export declare const requestField: z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodString;
+}, z.core.$strip>;
+export declare const requestCard: z.ZodObject<{
+    source: z.ZodString;
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        booking: "booking";
+        inquiry: "inquiry";
+    }>;
+    title: z.ZodString;
+    label: z.ZodString;
+    summary: z.ZodString;
+    name: z.ZodString;
+    email: z.ZodString;
+    when: z.ZodNullable<z.ZodString>;
+    whenDetail: z.ZodNullable<z.ZodString>;
+    fields: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    contact: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    message: z.ZodString;
+    status: z.ZodEnum<{
+        done: "done";
+        requested: "requested";
+        accepted: "accepted";
+        declined: "declined";
+        cancelled: "cancelled";
+        open: "open";
+        replied: "replied";
+    }>;
+    needsAnswer: z.ZodBoolean;
+    actions: z.ZodArray<z.ZodEnum<{
+        done: "done";
+        accept: "accept";
+        decline: "decline";
+        reply: "reply";
+    }>>;
+    revision: z.ZodNumber;
+    receivedAt: z.ZodString;
+    history: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            done: "done";
+            accepted: "accepted";
+            declined: "declined";
+            replied: "replied";
+            received: "received";
+        }>;
+        at: z.ZodString;
+    }, z.core.$strip>>;
+    notice: z.ZodNullable<z.ZodObject<{
+        status: z.ZodEnum<{
+            failed: "failed";
+            pending: "pending";
+            sent: "sent";
+            sending: "sending";
+        }>;
+        attempts: z.ZodNumber;
+        at: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RequestCard = z.output<typeof requestCard>;
+export declare const requestSync: z.ZodObject<{
+    cursor: z.ZodNumber;
+    requests: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            booking: "booking";
+            inquiry: "inquiry";
+        }>;
+        title: z.ZodString;
+        label: z.ZodString;
+        summary: z.ZodString;
+        name: z.ZodString;
+        email: z.ZodString;
+        when: z.ZodNullable<z.ZodString>;
+        whenDetail: z.ZodNullable<z.ZodString>;
+        fields: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>>;
+        contact: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>>;
+        message: z.ZodString;
+        status: z.ZodEnum<{
+            done: "done";
+            requested: "requested";
+            accepted: "accepted";
+            declined: "declined";
+            cancelled: "cancelled";
+            open: "open";
+            replied: "replied";
+        }>;
+        needsAnswer: z.ZodBoolean;
+        actions: z.ZodArray<z.ZodEnum<{
+            done: "done";
+            accept: "accept";
+            decline: "decline";
+            reply: "reply";
+        }>>;
+        revision: z.ZodNumber;
+        receivedAt: z.ZodString;
+        history: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                done: "done";
+                accepted: "accepted";
+                declined: "declined";
+                replied: "replied";
+                received: "received";
+            }>;
+            at: z.ZodString;
+        }, z.core.$strip>>;
+        notice: z.ZodNullable<z.ZodObject<{
+            status: z.ZodEnum<{
+                failed: "failed";
+                pending: "pending";
+                sent: "sent";
+                sending: "sending";
+            }>;
+            attempts: z.ZodNumber;
+            at: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RequestSync = z.output<typeof requestSync>;
+export declare const requestAct: z.ZodObject<{
+    source: z.ZodString;
+    id: z.ZodString;
+    action: z.ZodEnum<{
+        done: "done";
+        accept: "accept";
+        decline: "decline";
+        reply: "reply";
+    }>;
+    revision: z.ZodNumber;
+    operation: z.ZodString;
+}, z.core.$strip>;
+export type RequestAct = z.output<typeof requestAct>;
+export declare function requestBound(act: RequestAct): Promise<string>;
+type ColumnOf<T extends Table> = keyof T['columns'] & string;
+export type InquiryOptions<T extends Table> = {
+    source: string;
+    title: string;
+    form: string;
+    name: ColumnOf<T>;
+    email: ColumnOf<T>;
+    fields: Partial<Readonly<Record<ColumnOf<T>, string>>>;
+    summary?: ColumnOf<T>;
+    message?: ColumnOf<T>;
+    when?: {
+        field: ColumnOf<T>;
+        detail: string;
+    };
+};
+export type Inquiry = {
+    readonly source: string;
+    readonly table: Table;
+    readonly title: string;
+    readonly form: string;
+    readonly name: string;
+    readonly email: string;
+    readonly fields: readonly {
+        key: string;
+        label: string;
+    }[];
+    readonly summary: string | null;
+    readonly message: string | null;
+    readonly when: {
+        field: string;
+        detail: string;
+    } | null;
+};
+export declare function inquiry<T extends Table>(table: T, options: InquiryOptions<T>): Inquiry;
+export declare const inquiryValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+export declare const inquiryServices: {
+    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 {};

package/dist/requests.js

@@ -0,0 +1,180 @@
+import { z } from 'zod';
+import { call, defineServices } from "./services.js";
+import { patternTable } from "./table.js";
+export const REQUEST_KINDS = ['booking', 'inquiry'];
+export const REQUEST_ACTIONS = ['accept', 'decline', 'reply', 'done'];
+export const REQUEST_STATUSES = [
+    'requested',
+    'accepted',
+    'declined',
+    'cancelled',
+    'open',
+    'replied',
+    'done'
+];
+export const REQUEST_EVENTS = [
+    'received',
+    'accepted',
+    'declined',
+    'replied',
+    'done'
+];
+export const NOTICE_STATUSES = ['pending', 'sending', 'sent', 'failed'];
+export const REQUESTS_PATH = '/api/pattern/requests';
+export const REQUEST_SYNC_PAGE = 200;
+export const requestStates = patternTable('requestStates', {
+    columns: {
+        source: z.string(),
+        requestId: z.string(),
+        state: z.enum(['open', 'done']),
+        revision: z.number().int(),
+        sequence: z.number().int(),
+        updatedAt: z.string()
+    },
+    access: {
+        read: 'server',
+        create: 'server',
+        update: 'server',
+        delete: 'server'
+    },
+    writes: 'confirmed'
+});
+export const requestEvents = patternTable('requestEvents', {
+    columns: {
+        source: z.string(),
+        requestId: z.string(),
+        kind: z.enum(REQUEST_EVENTS)
+    },
+    access: {
+        read: 'server',
+        create: 'server',
+        update: 'server',
+        delete: 'server'
+    },
+    writes: 'confirmed'
+});
+export const requestOutbox = patternTable('requestOutbox', {
+    columns: {
+        source: z.string(),
+        requestId: z.string(),
+        subject: z.string(),
+        text: z.string(),
+        replyTo: z.string(),
+        status: z.enum(NOTICE_STATUSES),
+        attempts: z.number().int(),
+        nextAt: z.string().nullable(),
+        sentAt: z.string().nullable(),
+        claimedAt: z.string().nullable()
+    },
+    access: {
+        read: 'server',
+        create: 'server',
+        update: 'server',
+        delete: 'server'
+    },
+    writes: 'confirmed'
+});
+export const requestOperations = patternTable('requestOperations', {
+    columns: { result: z.string() },
+    access: {
+        read: 'server',
+        create: 'server',
+        update: 'server',
+        delete: 'server'
+    },
+    writes: 'confirmed'
+});
+export const requestTables = {
+    requestStates,
+    requestEvents,
+    requestOutbox,
+    requestOperations
+};
+export const requestField = z.object({ label: z.string(), value: z.string() });
+export const requestCard = z.object({
+    source: z.string(),
+    id: z.string(),
+    kind: z.enum(REQUEST_KINDS),
+    title: z.string(),
+    label: z.string(),
+    summary: z.string(),
+    name: z.string(),
+    email: z.string(),
+    when: z.string().nullable(),
+    whenDetail: z.string().nullable(),
+    fields: z.array(requestField),
+    contact: z.array(requestField),
+    message: z.string(),
+    status: z.enum(REQUEST_STATUSES),
+    needsAnswer: z.boolean(),
+    actions: z.array(z.enum(REQUEST_ACTIONS)),
+    revision: z.number().int(),
+    receivedAt: z.string(),
+    history: z.array(z.object({ kind: z.enum(REQUEST_EVENTS), at: z.string() })),
+    notice: z
+        .object({
+        status: z.enum(NOTICE_STATUSES),
+        attempts: z.number().int(),
+        at: z.string().nullable()
+    })
+        .nullable()
+});
+export const requestSync = z.object({
+    cursor: z.number().int(),
+    requests: z.array(requestCard)
+});
+export const requestAct = z.object({
+    source: z.string().min(1).max(60),
+    id: z.string().min(1).max(200),
+    action: z.enum(REQUEST_ACTIONS),
+    revision: z.number().int(),
+    operation: z.string().min(8).max(100)
+});
+export async function requestBound(act) {
+    const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(JSON.stringify([
+        act.source,
+        act.id,
+        act.action,
+        act.revision,
+        act.operation
+    ])));
+    return [...new Uint8Array(digest)]
+        .map((byte) => byte.toString(16).padStart(2, '0'))
+        .join('');
+}
+const SOURCE_NAME = /^[a-z][a-zA-Z0-9]{0,39}$/;
+export function inquiry(table, options) {
+    if (!SOURCE_NAME.test(options.source) || options.source === 'bookings') {
+        throw new Error(`inquiry source '${options.source}' needs a short camelCase name of its own, like 'orders'`);
+    }
+    if (table.access.create !== 'server') {
+        throw new Error(`${table.name} holds the ${options.source} inquiry, so its create access is 'server': visitors send through this.stores.inquiries.send('${options.source}', …), which also tells the owner`);
+    }
+    return {
+        source: options.source,
+        table,
+        title: options.title,
+        form: options.form,
+        name: options.name,
+        email: options.email,
+        fields: Object.entries(options.fields).flatMap(([key, label]) => typeof label === 'string' ? [{ key, label }] : []),
+        summary: options.summary ?? null,
+        message: options.message ?? null,
+        when: options.when ?? null
+    };
+}
+export const inquiryValue = z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null()
+]);
+export const inquiryServices = defineServices({
+    inquiries: {
+        send: call({
+            post: '/requests/:source',
+            input: { fields: z.record(z.string(), inquiryValue) },
+            reply: z.object({ id: z.string() })
+        })
+    }
+});

package/dist/schema.d.ts

@@ -2,6 +2,8 @@ export { call, defineServices } from './services.ts';
 export type { CallInput, CallReply, HandlerInput, ServiceCall, ServiceMemory, Services, UploadOptions } from './services.ts';
 export { media } from './media.ts';
 export { bookingTables } from './bookings.ts';
+export { inquiry, requestTables } from './requests.ts';
+export type { Inquiry, InquiryOptions } from './requests.ts';
 export type { BookingDay, BookingRequest, BookingRequestFields, BookingRules, BookingSlot, BookingStatus, BookingWindow } from './bookings.ts';
 export type { Media, MediaImage, Starter, StarterPhoto } from './media.ts';
 export { defineTables } from './table.ts';

package/dist/schema.js

@@ -1,4 +1,5 @@
 export { call, defineServices } from "./services.js";
 export { media } from "./media.js";
 export { bookingTables } from "./bookings.js";
+export { inquiry, requestTables } from "./requests.js";
 export { defineTables } from "./table.js";

package/dist/server/authService.d.ts

@@ -11,6 +11,7 @@ export type OwnerNote = {
     subject: string;
     text: string;
     replyTo?: string;
+    key?: string;
 };
 export declare function authServiceFor(env: ServerBindings): AuthService | undefined;
 export declare function notifyOwner(env: ServerBindings, note: OwnerNote): Promise<boolean>;

package/dist/server/bookings.d.ts

@@ -1,13 +1,6 @@
-import type { Context } from 'hono';
-import type { BookingRequest } from '../bookings.ts';
-import type { ServerBlock, ServerEnv } from './env.ts';
+import type { ServerBlock } from './env.ts';
 export type BookingsOptions = {
     timezone: string;
     managePath?: string;
 };
-export type BookingEmail = {
-    kind: 'requested' | 'accepted' | 'declined';
-    request: BookingRequest;
-};
-export declare function sendBookingEmail(c: Context<ServerEnv>, email: BookingEmail): Promise<void>;
-export declare function bookings({ timezone, managePath }: BookingsOptions): ServerBlock;
+export declare function bookings({ timezone }: BookingsOptions): ServerBlock;