@trypattern/sdk 0.1.8 → 0.1.9

package/dist/publishWire.d.ts

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import { appTitle } from './appTitle.ts';
 export { appTitle };
+export { ASSERTION_SECONDS, NEXT_PAGE_HEADER, TABLES_READ, assertionKey, signTablesAssertion } from './patternAccess.ts';
+export type { AssertionKey } from './patternAccess.ts';
 export declare const DASHBOARD_URL = "https://onpattern.app";
 export declare const APPS_DOMAIN = "onpattern.app";
 export declare const UPLOAD_LIMIT_BYTES: number;
@@ -116,6 +118,176 @@ export declare const connection: z.ZodObject<{
     connectedAt: z.ZodString;
 }, z.core.$strip>;
 export type Connection = z.output<typeof connection>;
+export declare const DOMAIN_ENDINGS: readonly ["com", "ca", "co", "org", "net", "app", "dev", "shop"];
+export declare const DOMAIN_PRICE_LIMIT_USD = 30;
+export declare const domainName: z.ZodString;
+export declare const domainChoice: z.ZodObject<{
+    domain: z.ZodString;
+    priceUsd: z.ZodNullable<z.ZodString>;
+    isAvailable: z.ZodBoolean;
+}, z.core.$strip>;
+export type DomainChoice = z.output<typeof domainChoice>;
+export declare const domainSteps: readonly ["register", "address", "sign-in", "reachable"];
+export declare const domainSummary: z.ZodObject<{
+    domain: z.ZodString;
+    priceUsd: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        live: "live";
+        working: "working";
+    }>;
+    step: z.ZodEnum<{
+        address: "address";
+        "sign-in": "sign-in";
+        register: "register";
+        reachable: "reachable";
+    }>;
+    error: z.ZodNullable<z.ZodString>;
+    startedAt: z.ZodString;
+    checkedAt: z.ZodNullable<z.ZodString>;
+    finishedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type DomainSummary = z.output<typeof domainSummary>;
+export declare const mailboxSummary: z.ZodObject<{
+    address: z.ZodString;
+    destination: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        ready: "ready";
+        verifying: "verifying";
+    }>;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type MailboxSummary = z.output<typeof mailboxSummary>;
+export declare const mailboxLocalPart: z.ZodString;
+export declare const DATABASE_PAGE_ROWS = 100;
+export declare const databaseTable: z.ZodObject<{
+    name: z.ZodString;
+    schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    access: z.ZodObject<{
+        read: z.ZodEnum<{
+            anyone: "anyone";
+            signedIn: "signedIn";
+            owner: "owner";
+            admin: "admin";
+            server: "server";
+        }>;
+        create: z.ZodEnum<{
+            anyone: "anyone";
+            signedIn: "signedIn";
+            owner: "owner";
+            admin: "admin";
+            server: "server";
+        }>;
+        update: z.ZodEnum<{
+            anyone: "anyone";
+            signedIn: "signedIn";
+            owner: "owner";
+            admin: "admin";
+            server: "server";
+        }>;
+        delete: z.ZodEnum<{
+            anyone: "anyone";
+            signedIn: "signedIn";
+            owner: "owner";
+            admin: "admin";
+            server: "server";
+        }>;
+    }, z.core.$strip>;
+    public: z.ZodArray<z.ZodString>;
+    rowCount: z.ZodNumber;
+    isBuiltIn: z.ZodBoolean;
+}, z.core.$strip>;
+export type DatabaseTable = z.output<typeof databaseTable>;
+export declare const appSchema: z.ZodObject<{
+    tables: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        access: z.ZodObject<{
+            read: z.ZodEnum<{
+                anyone: "anyone";
+                signedIn: "signedIn";
+                owner: "owner";
+                admin: "admin";
+                server: "server";
+            }>;
+            create: z.ZodEnum<{
+                anyone: "anyone";
+                signedIn: "signedIn";
+                owner: "owner";
+                admin: "admin";
+                server: "server";
+            }>;
+            update: z.ZodEnum<{
+                anyone: "anyone";
+                signedIn: "signedIn";
+                owner: "owner";
+                admin: "admin";
+                server: "server";
+            }>;
+            delete: z.ZodEnum<{
+                anyone: "anyone";
+                signedIn: "signedIn";
+                owner: "owner";
+                admin: "admin";
+                server: "server";
+            }>;
+        }, z.core.$strip>;
+        public: z.ZodArray<z.ZodString>;
+        rowCount: z.ZodNumber;
+        isBuiltIn: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const databaseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"ready">;
+    tables: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        access: z.ZodObject<{
+            read: z.ZodEnum<{
+                anyone: "anyone";
+                signedIn: "signedIn";
+                owner: "owner";
+                admin: "admin";
+                server: "server";
+            }>;
+            create: z.ZodEnum<{
+                anyone: "anyone";
+                signedIn: "signedIn";
+                owner: "owner";
+                admin: "admin";
+                server: "server";
+            }>;
+            update: z.ZodEnum<{
+                anyone: "anyone";
+                signedIn: "signedIn";
+                owner: "owner";
+                admin: "admin";
+                server: "server";
+            }>;
+            delete: z.ZodEnum<{
+                anyone: "anyone";
+                signedIn: "signedIn";
+                owner: "owner";
+                admin: "admin";
+                server: "server";
+            }>;
+        }, z.core.$strip>;
+        public: z.ZodArray<z.ZodString>;
+        rowCount: z.ZodNumber;
+        isBuiltIn: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"outdated">;
+}, z.core.$strip>], "status">;
+export type DatabaseSchema = z.output<typeof databaseSchema>;
+export declare const databaseRow: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type DatabaseRow = z.output<typeof databaseRow>;
+export declare const databaseRows: z.ZodObject<{
+    rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    next: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type DatabaseRows = z.output<typeof databaseRows>;
 export declare const publishServices: {
     readonly apps: {
         readonly list: NoInfer<import("./services.ts").ServiceCall<"/apps", {}, z.ZodArray<z.ZodObject<{
@@ -295,6 +467,150 @@ export declare const publishServices: {
             ok: z.ZodBoolean;
         }, z.core.$strip>>>;
     };
+    readonly domains: {
+        readonly search: NoInfer<import("./services.ts").ServiceCall<"/domains", {
+            query: z.ZodString;
+        }, z.ZodArray<z.ZodObject<{
+            domain: z.ZodString;
+            priceUsd: z.ZodNullable<z.ZodString>;
+            isAvailable: z.ZodBoolean;
+        }, z.core.$strip>>>>;
+        readonly read: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/domain", {}, z.ZodNullable<z.ZodObject<{
+            domain: z.ZodString;
+            priceUsd: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                live: "live";
+                working: "working";
+            }>;
+            step: z.ZodEnum<{
+                address: "address";
+                "sign-in": "sign-in";
+                register: "register";
+                reachable: "reachable";
+            }>;
+            error: z.ZodNullable<z.ZodString>;
+            startedAt: z.ZodString;
+            checkedAt: z.ZodNullable<z.ZodString>;
+            finishedAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>>;
+        readonly buy: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/domain", {
+            domain: z.ZodString;
+            priceUsd: z.ZodString;
+        }, z.ZodObject<{
+            domain: z.ZodString;
+            priceUsd: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                live: "live";
+                working: "working";
+            }>;
+            step: z.ZodEnum<{
+                address: "address";
+                "sign-in": "sign-in";
+                register: "register";
+                reachable: "reachable";
+            }>;
+            error: z.ZodNullable<z.ZodString>;
+            startedAt: z.ZodString;
+            checkedAt: z.ZodNullable<z.ZodString>;
+            finishedAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+        readonly retry: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/domain/retry", {}, z.ZodObject<{
+            domain: z.ZodString;
+            priceUsd: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                live: "live";
+                working: "working";
+            }>;
+            step: z.ZodEnum<{
+                address: "address";
+                "sign-in": "sign-in";
+                register: "register";
+                reachable: "reachable";
+            }>;
+            error: z.ZodNullable<z.ZodString>;
+            startedAt: z.ZodString;
+            checkedAt: z.ZodNullable<z.ZodString>;
+            finishedAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+    };
+    readonly mailboxes: {
+        readonly read: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/mailbox", {}, z.ZodNullable<z.ZodObject<{
+            address: z.ZodString;
+            destination: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                ready: "ready";
+                verifying: "verifying";
+            }>;
+            error: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>>;
+        readonly create: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/mailbox", {
+            localPart: z.ZodString;
+            destination: z.ZodEmail;
+        }, z.ZodObject<{
+            address: z.ZodString;
+            destination: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                ready: "ready";
+                verifying: "verifying";
+            }>;
+            error: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+    };
+    readonly database: {
+        readonly schema: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/database", {}, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"ready">;
+            tables: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                access: z.ZodObject<{
+                    read: z.ZodEnum<{
+                        anyone: "anyone";
+                        signedIn: "signedIn";
+                        owner: "owner";
+                        admin: "admin";
+                        server: "server";
+                    }>;
+                    create: z.ZodEnum<{
+                        anyone: "anyone";
+                        signedIn: "signedIn";
+                        owner: "owner";
+                        admin: "admin";
+                        server: "server";
+                    }>;
+                    update: z.ZodEnum<{
+                        anyone: "anyone";
+                        signedIn: "signedIn";
+                        owner: "owner";
+                        admin: "admin";
+                        server: "server";
+                    }>;
+                    delete: z.ZodEnum<{
+                        anyone: "anyone";
+                        signedIn: "signedIn";
+                        owner: "owner";
+                        admin: "admin";
+                        server: "server";
+                    }>;
+                }, z.core.$strip>;
+                public: z.ZodArray<z.ZodString>;
+                rowCount: z.ZodNumber;
+                isBuiltIn: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodLiteral<"outdated">;
+        }, z.core.$strip>], "status">>>;
+        readonly rows: NoInfer<import("./services.ts").ServiceCall<"/apps/:name/database/:table", {
+            after: z.ZodOptional<z.ZodString>;
+        }, z.ZodObject<{
+            rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            next: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+    };
     readonly logins: {
         readonly read: NoInfer<import("./services.ts").ServiceCall<"/cli/logins/:approval", {}, z.ZodObject<{
             code: z.ZodString;

package/dist/publishWire.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { appTitle } from "./appTitle.js";
 export { appTitle };
+export { ASSERTION_SECONDS, NEXT_PAGE_HEADER, TABLES_READ, assertionKey, signTablesAssertion } from "./patternAccess.js";
 import { call, defineServices } from "./services.js";
 export const DASHBOARD_URL = 'https://onpattern.app';
 export const APPS_DOMAIN = 'onpattern.app';
@@ -139,6 +140,79 @@ export const connection = z.object({
     label: z.string(),
     connectedAt: z.string()
 });
+export const DOMAIN_ENDINGS = [
+    'com',
+    'ca',
+    'co',
+    'org',
+    'net',
+    'app',
+    'dev',
+    'shop'
+];
+export const DOMAIN_PRICE_LIMIT_USD = 30;
+export const domainName = z
+    .string()
+    .trim()
+    .toLowerCase()
+    .regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$/);
+export const domainChoice = z.object({
+    domain: z.string(),
+    priceUsd: z.string().nullable(),
+    isAvailable: z.boolean()
+});
+export const domainSteps = [
+    'register',
+    'address',
+    'sign-in',
+    'reachable'
+];
+export const domainSummary = z.object({
+    domain: z.string(),
+    priceUsd: z.string(),
+    status: z.enum(['working', 'live', 'failed']),
+    step: z.enum(domainSteps),
+    error: z.string().nullable(),
+    startedAt: z.string(),
+    checkedAt: z.string().nullable(),
+    finishedAt: z.string().nullable()
+});
+export const mailboxSummary = z.object({
+    address: z.string(),
+    destination: z.string(),
+    status: z.enum(['verifying', 'ready', 'failed']),
+    error: z.string().nullable()
+});
+export const mailboxLocalPart = z
+    .string()
+    .trim()
+    .toLowerCase()
+    .regex(/^[a-z0-9]([a-z0-9._-]{0,62}[a-z0-9])?$/);
+export const DATABASE_PAGE_ROWS = 100;
+const accessLevel = z.enum(['anyone', 'signedIn', 'owner', 'admin', 'server']);
+export const databaseTable = z.object({
+    name: z.string(),
+    schema: z.record(z.string(), z.unknown()),
+    access: z.object({
+        read: accessLevel,
+        create: accessLevel,
+        update: accessLevel,
+        delete: accessLevel
+    }),
+    public: z.array(z.string()),
+    rowCount: z.number(),
+    isBuiltIn: z.boolean()
+});
+export const appSchema = z.object({ tables: z.array(databaseTable) });
+export const databaseSchema = z.discriminatedUnion('status', [
+    z.object({ status: z.literal('ready'), tables: z.array(databaseTable) }),
+    z.object({ status: z.literal('outdated') })
+]);
+export const databaseRow = z.record(z.string(), z.unknown());
+export const databaseRows = z.object({
+    rows: z.array(databaseRow),
+    next: z.string().nullable()
+});
 export const publishServices = defineServices({
     apps: {
         list: call({ get: '/apps', reply: z.array(appSummary) }),
@@ -182,6 +256,39 @@ export const publishServices = defineServices({
             reply: z.object({ ok: z.boolean() })
         })
     },
+    domains: {
+        search: call({
+            get: '/domains',
+            input: { query: z.string() },
+            reply: z.array(domainChoice)
+        }),
+        read: call({ get: '/apps/:name/domain', reply: domainSummary.nullable() }),
+        buy: call({
+            post: '/apps/:name/domain',
+            input: { domain: domainName, priceUsd: z.string() },
+            reply: domainSummary
+        }),
+        retry: call({ post: '/apps/:name/domain/retry', reply: domainSummary })
+    },
+    mailboxes: {
+        read: call({
+            get: '/apps/:name/mailbox',
+            reply: mailboxSummary.nullable()
+        }),
+        create: call({
+            post: '/apps/:name/mailbox',
+            input: { localPart: mailboxLocalPart, destination: z.email() },
+            reply: mailboxSummary
+        })
+    },
+    database: {
+        schema: call({ get: '/apps/:name/database', reply: databaseSchema }),
+        rows: call({
+            get: '/apps/:name/database/:table',
+            input: { after: z.string().optional() },
+            reply: databaseRows
+        })
+    },
     logins: {
         read: call({ get: '/cli/logins/:approval', reply: loginToApprove }),
         approve: call({

package/dist/server/createServer.d.ts

@@ -172,8 +172,90 @@ export declare function createServer<Group extends Tables, Bindings extends Serv
         };
     };
 }) | import("hono/types").MergeSchemaPath<{
+    "/schema": {
+        $get: {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 403;
+        } | {
+            input: {};
+            output: {
+                tables: {
+                    name: string;
+                    schema: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    };
+                    access: {
+                        read: "anyone" | "signedIn" | "owner" | "admin" | "server";
+                        create: "anyone" | "signedIn" | "owner" | "admin" | "server";
+                        update: "anyone" | "signedIn" | "owner" | "admin" | "server";
+                        delete: "anyone" | "signedIn" | "owner" | "admin" | "server";
+                    };
+                    public: string[];
+                    rowCount: number;
+                    isBuiltIn: boolean;
+                }[];
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/tables/users": {
+        $get: {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 403;
+        } | {
+            input: {};
+            output: readonly {
+                readonly [x: string]: import("hono/utils/types").JSONValue;
+            }[];
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        };
+    };
+}, "/api"> | import("hono/types").MergeSchemaPath<{
     "/:table": {
         $get: {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: readonly {
+                readonly [x: string]: import("hono/utils/types").JSONValue;
+            }[];
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
             input: {
                 param: {
                     table: string;
@@ -190,9 +272,11 @@ export declare function createServer<Group extends Tables, Bindings extends Serv
                     table: string;
                 };
             };
-            output: {}[];
+            output: {
+                error: string;
+            };
             outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            status: 404;
         } | {
             input: {
                 param: {
@@ -203,7 +287,7 @@ export declare function createServer<Group extends Tables, Bindings extends Serv
                 error: string;
             };
             outputFormat: "json";
-            status: 404;
+            status: 400;
         };
     };
 } & {

package/dist/server/createServer.js

@@ -3,6 +3,8 @@ import { csrf } from 'hono/csrf';
 import { adminEmails } from "../access.js";
 import { appTitle } from "../appTitle.js";
 import { auth, devSignIn } from "./auth.js";
+import { serveDatabase } from "./database.js";
+import { attachPatternViewer, bearerOf } from "./patternViewer.js";
 import { forgetSession, issuePass, needsRecheck, readPass, rememberUser } from "./session.js";
 import { renewSession } from "./sessions.js";
 import { readTitle, writeTitle } from "./settings.js";
@@ -19,6 +21,9 @@ function knowAdmins(admins) {
     };
 }
 async function attachViewer(c, next) {
+    const bearer = bearerOf(c);
+    if (bearer !== undefined)
+        return attachPatternViewer(c, next, bearer);
     if (PUBLIC_PATHS.some((path) => c.req.path.startsWith(path)))
         return next();
     const isOptional = c.req.path === APP_PATH ||
@@ -76,6 +81,7 @@ export function createServer({ tables, admins, routes }) {
         rememberUser(c, user);
         return c.json({ ...user, isAdmin: viewer?.isAdmin ?? false }, 200);
     })
+        .route('/', serveDatabase(tables))
         .route('/tables', serveTables(tables));
     const own = routes;
     return (own === undefined ? server : server.route('/', own)).notFound((c) => c.json({ error: `No route for ${c.req.path}` }, 404));

package/dist/server/database.d.ts

@@ -0,0 +1,74 @@
+import type { Tables } from '../table.ts';
+import type { ServerEnv } from './env.ts';
+export declare function serveDatabase<Group extends Tables>(tables: Group): import("hono/hono-base").HonoBase<ServerEnv, {
+    "/schema": {
+        $get: {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 403;
+        } | {
+            input: {};
+            output: {
+                tables: {
+                    name: string;
+                    schema: {
+                        [x: string]: import("hono/utils/types").JSONValue;
+                    };
+                    access: {
+                        read: "anyone" | "signedIn" | "owner" | "admin" | "server";
+                        create: "anyone" | "signedIn" | "owner" | "admin" | "server";
+                        update: "anyone" | "signedIn" | "owner" | "admin" | "server";
+                        delete: "anyone" | "signedIn" | "owner" | "admin" | "server";
+                    };
+                    public: string[];
+                    rowCount: number;
+                    isBuiltIn: boolean;
+                }[];
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/tables/users": {
+        $get: {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 403;
+        } | {
+            input: {};
+            output: readonly {
+                readonly [x: string]: import("hono/utils/types").JSONValue;
+            }[];
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        };
+    };
+}, "/", "/tables/users">;