@trypattern/sdk 0.0.0-stage → 0.1.1

package/dist/server/sessions.d.ts

@@ -0,0 +1,92 @@
+import type { D1Database } from '@cloudflare/workers-types';
+export declare const sessions: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "sessions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        userId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "user_id";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        expiresAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "expires_at";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "sessions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+export declare function createSession(d1: D1Database, userId: string): Promise<`${string}-${string}-${string}-${string}-${string}`>;
+export declare function renewSession(d1: D1Database, id: string): Promise<{
+    id: string;
+    email: string;
+    name: string;
+    avatarUrl: string | null;
+} | undefined>;
+export declare function deleteSession(d1: D1Database, id: string): Promise<void>;

package/dist/server/sessions.js

@@ -0,0 +1,47 @@
+import { and, eq, gt, lt, sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/d1';
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { userColumns, users } from "./users.js";
+export const sessions = sqliteTable('sessions', {
+    id: text('id').primaryKey(),
+    userId: text('user_id')
+        .notNull()
+        .references(() => users.id, { onDelete: 'cascade' }),
+    expiresAt: text('expires_at').notNull(),
+    createdAt: text('created_at')
+        .notNull()
+        .default(sql `(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`)
+});
+const SESSION_DAYS = 30;
+const DAY_MILLISECONDS = 86_400_000;
+const sessionEnd = () => new Date(Date.now() + SESSION_DAYS * DAY_MILLISECONDS).toISOString();
+export async function createSession(d1, userId) {
+    const db = drizzle(d1);
+    const id = crypto.randomUUID();
+    await db.batch([
+        db
+            .delete(sessions)
+            .where(and(eq(sessions.userId, userId), lt(sessions.expiresAt, new Date().toISOString()))),
+        db.insert(sessions).values({ id, userId, expiresAt: sessionEnd() })
+    ]);
+    return id;
+}
+export async function renewSession(d1, id) {
+    const db = drizzle(d1);
+    const user = await db
+        .select(userColumns)
+        .from(sessions)
+        .innerJoin(users, eq(users.id, sessions.userId))
+        .where(and(eq(sessions.id, id), gt(sessions.expiresAt, new Date().toISOString())))
+        .get();
+    if (user === undefined)
+        return undefined;
+    await db
+        .update(sessions)
+        .set({ expiresAt: sessionEnd() })
+        .where(eq(sessions.id, id));
+    return user;
+}
+export async function deleteSession(d1, id) {
+    await drizzle(d1).delete(sessions).where(eq(sessions.id, id));
+}

package/dist/server/settings.d.ts

@@ -0,0 +1,49 @@
+import type { D1Database } from '@cloudflare/workers-types';
+export declare const settings: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "settings";
+    schema: undefined;
+    columns: {
+        key: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "key";
+            tableName: "settings";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        value: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "value";
+            tableName: "settings";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+export declare function readTitle(d1: D1Database): Promise<string>;
+export declare function writeTitle(d1: D1Database, title: string): Promise<void>;
+export declare function seedTitleSql(title: string): string;

package/dist/server/settings.js

@@ -0,0 +1,25 @@
+import { eq } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/d1';
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+export const settings = sqliteTable('settings', {
+    key: text('key').primaryKey(),
+    value: text('value').notNull()
+});
+const TITLE = 'title';
+export async function readTitle(d1) {
+    const row = await drizzle(d1)
+        .select({ value: settings.value })
+        .from(settings)
+        .where(eq(settings.key, TITLE))
+        .get();
+    return row?.value ?? '';
+}
+export async function writeTitle(d1, title) {
+    await drizzle(d1)
+        .insert(settings)
+        .values({ key: TITLE, value: title })
+        .onConflictDoUpdate({ target: settings.key, set: { value: title } });
+}
+export function seedTitleSql(title) {
+    return `INSERT OR IGNORE INTO settings (key, value) VALUES ('${TITLE}', '${title.replaceAll("'", "''")}');`;
+}

package/dist/server/signInWire.d.ts

@@ -0,0 +1,53 @@
+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;
+    appName: z.ZodOptional<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,23 @@
+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(),
+    appName: z.string().min(1).max(60).optional()
+});
+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 {};