@trypattern/sdk 0.0.0-stage → 0.1.1

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 });
+    });
+}

package/dist/server/users.d.ts

@@ -0,0 +1,189 @@
+import type { D1Database } from '@cloudflare/workers-types';
+import type { StoredUser } from '../auth/user.ts';
+export declare const users: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "users";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "users";
+            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;
+        }>;
+        email: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "email";
+            tableName: "users";
+            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;
+        }>;
+        name: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "name";
+            tableName: "users";
+            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;
+        }>;
+        avatarUrl: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "avatar_url";
+            tableName: "users";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            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: "users";
+            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 const userColumns: {
+    id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "id";
+        tableName: "users";
+        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;
+    }>;
+    email: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "email";
+        tableName: "users";
+        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;
+    }>;
+    name: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "name";
+        tableName: "users";
+        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;
+    }>;
+    avatarUrl: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "avatar_url";
+        tableName: "users";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: number | undefined;
+    }>;
+};
+export declare function findUser(d1: D1Database, id: string): Promise<StoredUser | undefined>;
+export type SignedInPerson = {
+    email: string;
+    name: string | null;
+    avatarUrl: string | null;
+};
+export declare function saveUser(d1: D1Database, person: SignedInPerson): Promise<StoredUser>;

package/dist/server/users.js

@@ -0,0 +1,49 @@
+import { eq, sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/d1';
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+export const users = sqliteTable('users', {
+    id: text('id').primaryKey(),
+    email: text('email').notNull().unique(),
+    name: text('name').notNull(),
+    avatarUrl: text('avatar_url'),
+    createdAt: text('created_at')
+        .notNull()
+        .default(sql `(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`)
+});
+export const userColumns = {
+    id: users.id,
+    email: users.email,
+    name: users.name,
+    avatarUrl: users.avatarUrl
+};
+export async function findUser(d1, id) {
+    return drizzle(d1)
+        .select(userColumns)
+        .from(users)
+        .where(eq(users.id, id))
+        .get();
+}
+function nameFromEmail(email) {
+    const local = email.split('@')[0] ?? email;
+    return local.charAt(0).toUpperCase() + local.slice(1);
+}
+export async function saveUser(d1, person) {
+    const email = person.email.toLowerCase();
+    return drizzle(d1)
+        .insert(users)
+        .values({
+        id: crypto.randomUUID(),
+        email,
+        name: person.name ?? nameFromEmail(email),
+        avatarUrl: person.avatarUrl
+    })
+        .onConflictDoUpdate({
+        target: users.email,
+        set: {
+            name: person.name === null ? sql `${users.name}` : sql `excluded.name`,
+            avatarUrl: sql `coalesce(excluded.avatar_url, ${users.avatarUrl})`
+        }
+    })
+        .returning(userColumns)
+        .get();
+}

package/dist/serviceClients.d.ts

@@ -0,0 +1,5 @@
+import type { Gate } from './gate.ts';
+import type { MemoryApiOptions } from './memoryApi.ts';
+import type { ServiceClient, ServiceMemory, Services } from './services.ts';
+export declare function httpServices<Group extends Services>(services: Group, gate: Gate, onSignedOut: () => void): ServiceClient<Group>;
+export declare function memoryServices<Group extends Services, World>(services: Group, memory: ServiceMemory<Group, World>, world: World, options: MemoryApiOptions): ServiceClient<Group>;

package/dist/serviceClients.js

@@ -0,0 +1,70 @@
+import { MemoryServer } from "./memoryApi.js";
+import { ServiceRefused, paramNamesOf } from "./services.js";
+function buildClient(services, make) {
+    return Object.fromEntries(Object.entries(services).map(([group, calls]) => [
+        group,
+        Object.fromEntries(Object.entries(calls).map(([name, call]) => [
+            name,
+            make(group, name, call)
+        ]))
+    ]));
+}
+function splitInput(call, input) {
+    const params = paramNamesOf(call.path);
+    const path = call.path.replaceAll(/:(\w+)/g, (_match, key) => encodeURIComponent(String(input[key] ?? '')));
+    const rest = Object.fromEntries(Object.entries(input).filter(([key]) => !params.includes(key)));
+    return { path, rest };
+}
+function errorOf(body, status) {
+    const error = typeof body === 'object' && body !== null
+        ? Reflect.get(body, 'error')
+        : undefined;
+    return typeof error === 'string' ? error : `HTTP ${status}`;
+}
+export function httpServices(services, gate, onSignedOut) {
+    return buildClient(services, (group, name, call) => (input = {}) => gate.pass(`${group}.${name}`, async () => {
+        const { path, rest } = splitInput(call, input);
+        const sent = call.input.parse(rest);
+        const query = call.method === 'get' && Object.keys(sent).length > 0
+            ? `?${new URLSearchParams(Object.entries(sent).map(([key, value]) => [
+                key,
+                String(value)
+            ])).toString()}`
+            : '';
+        const response = await fetch(`/api${path}${query}`, {
+            method: call.method.toUpperCase(),
+            ...(call.method === 'post'
+                ? {
+                    headers: { 'content-type': 'application/json' },
+                    body: JSON.stringify(sent)
+                }
+                : {})
+        });
+        const body = await response.json().catch(() => null);
+        if (response.status === 401)
+            onSignedOut();
+        if (!response.ok) {
+            throw new ServiceRefused(response.status, errorOf(body, response.status));
+        }
+        return call.reply.parse(body);
+    }));
+}
+export function memoryServices(services, memory, world, options) {
+    const servers = new Map();
+    return buildClient(services, (group, name, call) => (input = {}) => {
+        const server = servers.get(group) ?? new MemoryServer(group, options);
+        servers.set(group, server);
+        return server.reply(name, () => {
+            const handlers = Reflect.get(memory, group);
+            const handler = typeof handlers === 'object' && handlers !== null
+                ? Reflect.get(handlers, name)
+                : undefined;
+            if (typeof handler !== 'function') {
+                throw new Error(`The memory fake has no ${group}.${name}`);
+            }
+            const { rest } = splitInput(call, input);
+            const params = Object.fromEntries(paramNamesOf(call.path).map((key) => [key, String(input[key] ?? '')]));
+            return call.reply.parse(handler(world, { ...params, ...call.input.parse(rest) }));
+        });
+    });
+}

package/dist/services.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import type { SameOnTheWire } from './wire.ts';
+type Shape = z.ZodRawShape;
+type NoShape = Record<never, never>;
+type ParamNames<Path extends string> = Path extends `${string}:${infer Param}/${infer Rest}` ? Param | ParamNames<`/${Rest}`> : Path extends `${string}:${infer Param}` ? Param : never;
+export type ParamsOf<Path extends string> = {
+    readonly [Name in ParamNames<Path>]: string;
+};
+export type ServiceCall<Path extends string = string, S extends Shape = Shape, Reply extends z.ZodType = z.ZodType> = {
+    readonly method: 'get' | 'post';
+    readonly path: Path;
+    readonly input: z.ZodObject<S>;
+    readonly reply: Reply;
+};
+type StaticTypeError<Message extends string> = Message;
+type NotText = StaticTypeError<'A get call sends its input in the address, where everything is text: use z.string() or z.enum() here, or make it a post call'>;
+type TextOnly<S> = {
+    [Key in keyof S]: S[Key] extends z.ZodType ? z.output<S[Key]> extends string | undefined ? S[Key] : NotText : S[Key];
+};
+type CallOptions<Path extends string, S extends Shape, Reply extends z.ZodType> = {
+    get: Path;
+    input?: TextOnly<S> & SameOnTheWire<S>;
+    reply: Reply;
+} | {
+    post: Path;
+    input?: SameOnTheWire<S>;
+    reply: Reply;
+};
+export declare function call<Path extends string, Reply extends z.ZodType, S extends Shape = NoShape>(options: CallOptions<Path, S, Reply>): NoInfer<ServiceCall<Path, S, Reply>>;
+export type Services = Readonly<Record<string, Readonly<Record<string, ServiceCall>>>>;
+export declare function defineServices<const Group extends Services>(services: Group): Group;
+export type CallInput<Call> = Call extends ServiceCall<infer Path, infer S, z.ZodType> ? ParamsOf<Path> & (keyof S extends never ? NoShape : z.output<z.ZodObject<S>>) : never;
+export type CallReply<Call> = Call extends ServiceCall<string, Shape, infer Reply> ? z.output<Reply> : never;
+type ClientCall<Call> = keyof CallInput<Call> extends never ? (input?: CallInput<Call>) => Promise<CallReply<Call>> : (input: CallInput<Call>) => Promise<CallReply<Call>>;
+export type ServiceClient<Group extends Services> = {
+    readonly [Name in keyof Group]: {
+        readonly [Call in keyof Group[Name]]: ClientCall<Group[Name][Call]>;
+    };
+};
+export type MemoryHandler<Call, World> = (world: World, input: CallInput<Call>) => CallReply<Call>;
+export type ServiceMemory<Group extends Services, World> = {
+    readonly [Name in keyof Group]: {
+        readonly [Call in keyof Group[Name]]: MemoryHandler<Group[Name][Call], World>;
+    };
+};
+export declare class ServiceRefused extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+export declare function refused(status: number, message: string): ServiceRefused;
+export declare function paramNamesOf(path: string): readonly string[];
+export declare function serviceCallNames(services: Services): readonly string[];
+export {};

package/dist/services.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export function call(options) {
+    const method = 'get' in options ? 'get' : 'post';
+    const path = 'get' in options ? options.get : options.post;
+    return {
+        method,
+        path,
+        input: z.object((options.input ?? {})),
+        reply: options.reply
+    };
+}
+export function defineServices(services) {
+    return services;
+}
+export class ServiceRefused extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+export function refused(status, message) {
+    return new ServiceRefused(status, message);
+}
+export function paramNamesOf(path) {
+    return [...path.matchAll(/:(\w+)/g)].map((match) => match[1] ?? '');
+}
+export function serviceCallNames(services) {
+    return Object.entries(services).flatMap(([group, calls]) => Object.keys(calls).map((name) => `${group}.${name}`));
+}

package/dist/shortcuts.d.ts

@@ -0,0 +1,3 @@
+type PressKey = (key: string) => Promise<void> | undefined;
+export declare function useShortcuts(pressKey: PressKey): void;
+export {};