@trypattern/sdk 0.0.0-stage → 0.1.0

package/dist/server/signInWire.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+export declare const verifiedIdentity: z.ZodObject<{
+    email: z.ZodEmail;
+    name: z.ZodNullable<z.ZodString>;
+    avatarUrl: z.ZodNullable<z.ZodString>;
+    via: z.ZodEnum<{
+        email: "email";
+        google: "google";
+    }>;
+}, z.core.$strip>;
+export type VerifiedIdentity = z.infer<typeof verifiedIdentity>;
+export declare const exchangeRequest: z.ZodObject<{
+    code: z.ZodString;
+}, z.core.$strip>;
+export declare const exchangeReply: z.ZodObject<{
+    hostname: z.ZodString;
+    identity: z.ZodObject<{
+        email: z.ZodEmail;
+        name: z.ZodNullable<z.ZodString>;
+        avatarUrl: z.ZodNullable<z.ZodString>;
+        via: z.ZodEnum<{
+            email: "email";
+            google: "google";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const sendCodeRequest: z.ZodObject<{
+    email: z.ZodEmail;
+    hostname: z.ZodString;
+}, z.core.$strip>;
+export declare const sendCodeReply: z.ZodObject<{
+    challenge: z.ZodString;
+}, z.core.$strip>;
+export declare const verifyCodeRequest: z.ZodObject<{
+    challenge: z.ZodString;
+    code: z.ZodString;
+}, z.core.$strip>;
+export declare const verifyCodeReply: z.ZodObject<{
+    identity: z.ZodObject<{
+        email: z.ZodEmail;
+        name: z.ZodNullable<z.ZodString>;
+        avatarUrl: z.ZodNullable<z.ZodString>;
+        via: z.ZodEnum<{
+            email: "email";
+            google: "google";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ExchangeReply = z.infer<typeof exchangeReply>;
+export type SendCodeRequest = z.infer<typeof sendCodeRequest>;
+export type SendCodeReply = z.infer<typeof sendCodeReply>;
+export type VerifyCodeRequest = z.infer<typeof verifyCodeRequest>;

package/dist/server/signInWire.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export const verifiedIdentity = z.object({
+    email: z.email(),
+    name: z.string().nullable(),
+    avatarUrl: z.string().nullable(),
+    via: z.enum(['google', 'email'])
+});
+export const exchangeRequest = z.object({ code: z.string() });
+export const exchangeReply = z.object({
+    hostname: z.string(),
+    identity: verifiedIdentity
+});
+export const sendCodeRequest = z.object({
+    email: z.email(),
+    hostname: z.string()
+});
+export const sendCodeReply = z.object({ challenge: z.string() });
+export const verifyCodeRequest = z.object({
+    challenge: z.string(),
+    code: z.string()
+});
+export const verifyCodeReply = z.object({ identity: verifiedIdentity });

package/dist/server/tables.d.ts

@@ -0,0 +1,242 @@
+import type { SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core';
+import type { ServerEnv } from './env.ts';
+import type { Seed, Table, Tables } from '../table.ts';
+type SqlTable = SQLiteTableWithColumns<{
+    name: string;
+    schema: undefined;
+    dialect: 'sqlite';
+    columns: Record<string, never>;
+}>;
+export declare function sqlTable(table: Table): SqlTable;
+export declare function sqlTables<Group extends Tables>(tables: Group): Record<keyof Group, SqlTable>;
+export declare function seedSql<Group extends Tables>(tables: Group, seed: Seed<Group>): string;
+export declare function serveTables<Group extends Tables>(tables: Group): import("hono/hono-base").HonoBase<ServerEnv, {
+    "/:table": {
+        $get: {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {
+                error: "forbidden" | "Signed out" | "No such row";
+            };
+            outputFormat: "json";
+            status: 401 | 403 | 404;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {}[];
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        };
+    };
+} & {
+    "/:table/public": {
+        $get: {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {}[];
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        };
+    };
+} & {
+    "/:table": {
+        $post: {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {
+                error: "forbidden" | "Signed out" | "No such row";
+            };
+            outputFormat: "json";
+            status: 401 | 403 | 404;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {};
+            outputFormat: "json";
+            status: 201;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                };
+            };
+            output: {
+                error: string;
+                unique: readonly (readonly string[])[];
+            };
+            outputFormat: "json";
+            status: 409;
+        };
+    };
+} & {
+    "/:table/:id": {
+        $put: {
+            input: {
+                param: {
+                    table: string;
+                } & {
+                    id: string;
+                };
+            };
+            output: {
+                error: "forbidden" | "Signed out" | "No such row";
+            };
+            outputFormat: "json";
+            status: 401 | 403 | 404;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                } & {
+                    id: string;
+                };
+            };
+            output: {};
+            outputFormat: "json";
+            status: 200;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                } & {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+                unique: readonly (readonly string[])[];
+            };
+            outputFormat: "json";
+            status: 409;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                } & {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                } & {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        };
+    };
+} & {
+    "/:table/:id": {
+        $delete: {
+            input: {
+                param: {
+                    table: string;
+                } & {
+                    id: string;
+                };
+            };
+            output: {
+                error: "forbidden" | "Signed out" | "No such row";
+            };
+            outputFormat: "json";
+            status: 401 | 403 | 404;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                } & {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    table: string;
+                } & {
+                    id: string;
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/:table/:id">;
+export {};

package/dist/server/tables.js

@@ -0,0 +1,246 @@
+import { asc, eq, sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/d1';
+import { integer, real, sqliteTable, text, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { Hono } from 'hono';
+import { z } from 'zod';
+import { changeRefusal, createRefusal, listRefusal, readScope } from "../access.js";
+import { ownerIdOf, seededRows, snakeCase } from "../table.js";
+function typesOf(schema) {
+    const { type } = z.toJSONSchema(schema);
+    if (typeof type === 'string')
+        return [type];
+    return Array.isArray(type) ? type : [];
+}
+function sqlColumn(key, schema) {
+    const types = typesOf(schema);
+    const name = snakeCase(key);
+    const column = types.includes('boolean')
+        ? integer(name, { mode: 'boolean' })
+        : types.includes('integer')
+            ? integer(name)
+            : types.includes('number')
+                ? real(name)
+                : text(name);
+    return types.includes('null') ? column : column.notNull();
+}
+function uniqueIndexName(table, columns) {
+    return [table.name, ...columns, 'unique'].map(snakeCase).join('_');
+}
+export function sqlTable(table) {
+    const columns = Object.fromEntries(Object.entries(table.columns).map(([key, schema]) => [
+        key,
+        sqlColumn(key, schema)
+    ]));
+    return sqliteTable(snakeCase(table.name), {
+        id: text('id').primaryKey(),
+        ...(table.owned ? { ownerId: text('owner_id').notNull() } : {}),
+        ...columns,
+        createdAt: text('created_at')
+            .notNull()
+            .default(sql `(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`)
+    }, (target) => table.unique.map((unique) => {
+        const [first, ...rest] = unique.map((key) => Reflect.get(target, key));
+        return uniqueIndex(uniqueIndexName(table, unique)).on(first, ...rest);
+    }));
+}
+export function sqlTables(tables) {
+    return Object.fromEntries(Object.entries(tables).map(([key, table]) => [key, sqlTable(table)]));
+}
+function column(target, key) {
+    const found = Reflect.get(target, key);
+    if (found === undefined)
+        throw new Error(`No column ${key}`);
+    return found;
+}
+function sqlLiteral(value) {
+    if (value === null)
+        return 'NULL';
+    if (typeof value === 'boolean')
+        return value ? '1' : '0';
+    if (typeof value === 'number')
+        return String(value);
+    return `'${value.replaceAll("'", "''")}'`;
+}
+function seedOwners(seed) {
+    const owners = Object.values(seed).flatMap((rows) => (rows ?? []).flatMap((row) => {
+        const owner = Reflect.get(row, 'owner');
+        return typeof owner === 'string' ? [owner.toLowerCase()] : [];
+    }));
+    return [...new Set(owners)];
+}
+function ownerSql(email) {
+    return `(SELECT id FROM users WHERE email = ${sqlLiteral(email)})`;
+}
+export function seedSql(tables, seed) {
+    const users = seedOwners(seed).map((email) => `INSERT OR IGNORE INTO users (id, email, name) VALUES (${sqlLiteral(ownerIdOf(email))}, ${sqlLiteral(email)}, ${sqlLiteral(email.split('@')[0] ?? email)});`);
+    const rowsSql = Object.values(tables).flatMap((table) => {
+        const rows = seededRows(seed, table.name);
+        if (rows.length === 0)
+            return [];
+        const keys = ['id', 'createdAt', ...Object.keys(table.columns)];
+        const source = Reflect.get(seed, table.name);
+        const owners = (Array.isArray(source) ? source : []).map((raw) => {
+            const owner = Reflect.get(Object(raw), 'owner');
+            return typeof owner === 'string' ? owner.toLowerCase() : '';
+        });
+        const values = rows
+            .map((row, index) => `(${[
+            ...(table.owned ? [ownerSql(owners[index] ?? '')] : []),
+            ...keys.map((key) => sqlLiteral((row[key] ?? null)))
+        ].join(', ')})`)
+            .join(',\n  ');
+        const names = [...(table.owned ? ['ownerId'] : []), ...keys];
+        return [
+            `INSERT INTO ${snakeCase(table.name)} (${names.map(snakeCase).join(', ')})`,
+            `SELECT * FROM (VALUES\n  ${values}\n)`,
+            `WHERE NOT EXISTS (SELECT 1 FROM ${snakeCase(table.name)});`
+        ];
+    });
+    return [...users, ...rowsSql].join('\n');
+}
+const REFUSAL_STATUSES = {
+    signedOut: { status: 401, error: 'Signed out' },
+    forbidden: { status: 403, error: 'forbidden' },
+    missing: { status: 404, error: 'No such row' }
+};
+function refuse(c, refusal) {
+    const { status, error } = REFUSAL_STATUSES[refusal];
+    return c.json({ error }, status);
+}
+function isUniqueViolation(failure) {
+    for (let error = failure; error instanceof Error; error = error.cause) {
+        if (error.message.includes('UNIQUE constraint failed'))
+            return true;
+    }
+    return false;
+}
+export function serveTables(tables) {
+    const known = new Map(Object.values(tables).map((table) => [
+        table.name,
+        { table, target: sqlTable(table) }
+    ]));
+    function selection(table, target) {
+        return Object.fromEntries([
+            'id',
+            'createdAt',
+            ...(table.owned ? ['ownerId'] : []),
+            ...Object.keys(table.columns)
+        ].map((key) => [key, column(target, key)]));
+    }
+    function publicSelection(table, target) {
+        return Object.fromEntries(['id', ...table.public].map((key) => [key, column(target, key)]));
+    }
+    async function findRow(c, table, target) {
+        const row = await drizzle(c.env.DB)
+            .select(selection(table, target))
+            .from(target)
+            .where(eq(column(target, 'id'), c.req.param('id') ?? ''))
+            .get();
+        return row;
+    }
+    async function saveOrConflict(c, table, save) {
+        try {
+            return { saved: await save() };
+        }
+        catch (failure) {
+            if (!isUniqueViolation(failure))
+                throw failure;
+            return {
+                conflict: c.json({ error: 'conflict', unique: table.unique }, 409)
+            };
+        }
+    }
+    return new Hono()
+        .get('/:table', async (c) => {
+        const entry = known.get(c.req.param('table'));
+        if (entry === undefined)
+            return c.json({ error: 'No such table' }, 404);
+        const { table, target } = entry;
+        const viewer = c.get('viewer');
+        const refusal = listRefusal(table, viewer);
+        if (refusal !== undefined)
+            return refuse(c, refusal);
+        const scope = readScope(table, viewer);
+        const query = drizzle(c.env.DB)
+            .select(selection(table, target))
+            .from(target);
+        const rows = await (typeof scope === 'object'
+            ? query.where(eq(column(target, 'ownerId'), scope.ownerId))
+            : query).orderBy(asc(column(target, 'createdAt')), asc(column(target, 'id')));
+        return c.json(rows);
+    })
+        .get('/:table/public', async (c) => {
+        const entry = known.get(c.req.param('table'));
+        if (entry === undefined || entry.table.public.length === 0) {
+            return c.json({ error: 'No such table' }, 404);
+        }
+        const { table, target } = entry;
+        const rows = await drizzle(c.env.DB)
+            .select(publicSelection(table, target))
+            .from(target)
+            .orderBy(asc(column(target, 'createdAt')), asc(column(target, 'id')));
+        return c.json(rows);
+    })
+        .post('/:table', async (c) => {
+        const entry = known.get(c.req.param('table'));
+        if (entry === undefined)
+            return c.json({ error: 'No such table' }, 404);
+        const { table, target } = entry;
+        const viewer = c.get('viewer');
+        const refusal = createRefusal(table, viewer);
+        if (refusal !== undefined)
+            return refuse(c, refusal);
+        const parsed = table.incoming.safeParse(await c.req.json());
+        if (!parsed.success) {
+            return c.json({ error: z.prettifyError(parsed.error) }, 400);
+        }
+        const values = table.owned && viewer !== null
+            ? { ...parsed.data, ownerId: viewer.userId }
+            : parsed.data;
+        const result = await saveOrConflict(c, table, () => drizzle(c.env.DB)
+            .insert(target)
+            .values(values)
+            .returning(selection(table, target))
+            .get());
+        return 'conflict' in result ? result.conflict : c.json(result.saved, 201);
+    })
+        .put('/:table/:id', async (c) => {
+        const entry = known.get(c.req.param('table'));
+        if (entry === undefined)
+            return c.json({ error: 'No such table' }, 404);
+        const { table, target } = entry;
+        const existing = await findRow(c, table, target);
+        const refusal = changeRefusal(table, 'update', c.get('viewer'), existing);
+        if (refusal !== undefined)
+            return refuse(c, refusal);
+        const parsed = table.incoming.safeParse(await c.req.json());
+        if (!parsed.success) {
+            return c.json({ error: z.prettifyError(parsed.error) }, 400);
+        }
+        const { id, ...changes } = parsed.data;
+        if (id !== c.req.param('id')) {
+            return c.json({ error: 'The row id does not match the URL' }, 400);
+        }
+        const result = await saveOrConflict(c, table, () => drizzle(c.env.DB)
+            .update(target)
+            .set(changes)
+            .where(eq(column(target, 'id'), id))
+            .returning(selection(table, target))
+            .get());
+        return 'conflict' in result ? result.conflict : c.json(result.saved, 200);
+    })
+        .delete('/:table/:id', async (c) => {
+        const entry = known.get(c.req.param('table'));
+        if (entry === undefined)
+            return c.json({ error: 'No such table' }, 404);
+        const { table, target } = entry;
+        const existing = await findRow(c, table, target);
+        const refusal = changeRefusal(table, 'delete', c.get('viewer'), existing);
+        if (refusal !== undefined)
+            return refuse(c, refusal);
+        await drizzle(c.env.DB)
+            .delete(target)
+            .where(eq(column(target, 'id'), c.req.param('id')));
+        return c.json({ ok: true });
+    });
+}