@trypattern/sdk 0.0.0-stage → 0.1.1

package/dist/table.js

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+const NAME = /^[a-z][a-zA-Z0-9]*$/;
+const RESERVED = ['id', 'createdAt', 'ownerId'];
+const RESERVED_TABLES = ['users', 'sessions', 'session'];
+const SEEDED_AT = Date.UTC(2000, 0, 1);
+function problemIn(name, definition) {
+    const { access, columns } = definition;
+    const known = Object.keys(columns);
+    if (access.create === 'owner') {
+        return `Table "${name}": create can't be 'owner', use 'signedIn'`;
+    }
+    if (definition.owned !== true && Object.values(access).includes('owner')) {
+        return `Table "${name}" uses 'owner' but is not owned: true`;
+    }
+    if (definition.owned === true && access.create === 'anyone') {
+        return `Table "${name}" is owned, so create must not be 'anyone'`;
+    }
+    const unknown = [
+        ...(definition.public ?? []).filter((column) => column !== 'createdAt'),
+        ...(definition.unique ?? []).flat()
+    ].find((column) => !known.includes(column));
+    if (unknown !== undefined) {
+        return `Table "${name}" names "${unknown}", which is not one of its columns`;
+    }
+    if ((definition.unique ?? []).length > 0 &&
+        definition.writes !== 'confirmed') {
+        return `Table "${name}" has a unique constraint, so writes must be 'confirmed'`;
+    }
+    return undefined;
+}
+function table(name, definition) {
+    const { columns } = definition;
+    for (const key of [name, ...Object.keys(columns)]) {
+        if (!NAME.test(key)) {
+            throw new Error(`"${key}" can't name a table or column: use camelCase letters and digits`);
+        }
+    }
+    if (RESERVED_TABLES.includes(name)) {
+        throw new Error(`A table can't be called "${name}": Pattern keeps its own ${name} for sign-in`);
+    }
+    const reserved = RESERVED.find((key) => key in columns);
+    if (reserved !== undefined) {
+        throw new Error(`Table "${name}" can't have a "${reserved}" column: Pattern adds it`);
+    }
+    const problem = problemIn(name, definition);
+    if (problem !== undefined)
+        throw new Error(problem);
+    const owned = definition.owned === true;
+    const publicColumns = definition.public ?? [];
+    return {
+        name,
+        columns,
+        access: definition.access,
+        writes: definition.writes,
+        owned,
+        public: publicColumns,
+        unique: definition.unique ?? [],
+        fields: z.object(columns),
+        incoming: z.object({ id: z.string(), ...columns }),
+        row: z.object({
+            id: z.string(),
+            createdAt: z.string(),
+            ...(owned ? { ownerId: z.string() } : {}),
+            ...columns
+        }),
+        publicRow: z.object({
+            id: z.string(),
+            ...Object.fromEntries(publicColumns.map((column) => [
+                column,
+                column === 'createdAt' ? z.string() : columns[column]
+            ]))
+        })
+    };
+}
+export function defineTables(definitions) {
+    return Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [name, table(name, definition)]));
+}
+export function ownerIdOf(email) {
+    return `user-${email.toLowerCase()}`;
+}
+export function seededRows(seed, name) {
+    const rows = Reflect.get(seed, name) ?? [];
+    return rows.map(({ owner, ...row }, index) => ({
+        ...row,
+        ...(typeof owner === 'string' ? { ownerId: ownerIdOf(owner) } : {}),
+        createdAt: new Date(SEEDED_AT + index * 1000).toISOString()
+    }));
+}
+export function snakeCase(name) {
+    return name.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}

package/dist/tables.d.ts

@@ -0,0 +1,77 @@
+import type { Viewer, WriteOutcome } from './access.ts';
+import type { Cache, Cached } from './cache.ts';
+import { EntityStore, entityCalls } from './entityStore.ts';
+import type { EntityApi } from './entityStore.ts';
+import type { Gate } from './gate.ts';
+import type { MemoryApiOptions } from './memoryApi.ts';
+import { StoreBase } from './store.ts';
+import type { Fields, PublicRow, Row, Seed, Table, Tables } from './table.ts';
+export type TableApi<T extends Table> = EntityApi<Row<T>> & {
+    listPublic: () => Promise<readonly PublicRow<T>[]>;
+};
+export type TablesApi<Group extends Tables> = {
+    [Key in keyof Group]: TableApi<Group[Key]>;
+};
+export type TableCall<Group extends Tables> = `${keyof Group & string}.${(typeof entityCalls)[number] | 'listPublic'}`;
+export type CurrentViewer = () => Viewer | null;
+export declare class HttpTableApi<T extends Table> implements TableApi<T> {
+    #private;
+    constructor(table: T, gate: Gate, onSignedOut: () => void, base?: string);
+    list(): Promise<readonly Row<T>[]>;
+    listPublic(): Promise<readonly PublicRow<T>[]>;
+    create(row: Row<T>): Promise<Row<T>>;
+    update(row: Row<T>): Promise<Row<T>>;
+    remove(id: string): Promise<void>;
+}
+type AnyRow = Readonly<Record<string, unknown>> & {
+    id: string;
+    ownerId?: string;
+};
+export declare class MemoryTableApi<T extends Table> implements TableApi<T> {
+    #private;
+    constructor(table: T, seed: readonly AnyRow[], viewer: CurrentViewer, options: MemoryApiOptions);
+    list(): Promise<readonly Row<T>[]>;
+    listPublic(): Promise<readonly PublicRow<T>[]>;
+    create(row: Row<T>): Promise<Row<T>>;
+    update(row: Row<T>): Promise<Row<T>>;
+    remove(id: string): Promise<void>;
+}
+export declare function httpTables<Group extends Tables>(tables: Group, gate: Gate, onSignedOut: () => void): TablesApi<Group>;
+export declare function memoryTables<Group extends Tables>(tables: Group, seed: Seed<Group>, viewer: CurrentViewer, options: MemoryApiOptions): TablesApi<Group>;
+export declare function tableCalls<Group extends Tables>(tables: Group): readonly TableCall<Group>[];
+export declare function publicStoreName(table: string): string;
+export type PublicSnapshot<Item> = {
+    status: 'idle' | 'loading' | 'ready' | 'failed';
+    items: readonly Item[];
+};
+type PublicDeps<Item> = {
+    list: () => Promise<readonly Item[]>;
+    cache: Cached<readonly Item[]>;
+};
+export declare class PublicTableStore<T extends Table> extends StoreBase<PublicSnapshot<PublicRow<T>>, PublicDeps<PublicRow<T>>> {
+    #private;
+    constructor(table: T, { api, cache }: {
+        api: TableApi<T>;
+        cache: Cache;
+    });
+    protected initialState(): PublicSnapshot<PublicRow<T>>;
+    load(): Promise<void>;
+}
+type TableDeps<T extends Table> = {
+    api: TableApi<T>;
+    cache: Cache;
+    viewer: CurrentViewer;
+    publicView?: {
+        load: () => Promise<void>;
+    };
+};
+export declare class TableStore<T extends Table> extends EntityStore<Row<T>> {
+    #private;
+    constructor(table: T, { api, cache, viewer, publicView }: TableDeps<T>);
+    get mayRead(): boolean;
+    load(): Promise<void>;
+    create(fields: Fields<T>): Promise<WriteOutcome>;
+    update(row: Row<T>): Promise<WriteOutcome>;
+    remove(id: string): Promise<WriteOutcome>;
+}
+export {};

package/dist/tables.js

@@ -0,0 +1,216 @@
+import { z } from 'zod';
+import { canSee, changeRefusal, clashesWith, createRefusal, listRefusal, refusalOutcome, publicRow, readScope } from "./access.js";
+import { EntityStore, WriteRefused, entityCalls } from "./entityStore.js";
+import { MemoryServer } from "./memoryApi.js";
+import { StoreBase } from "./store.js";
+import { seededRows } from "./table.js";
+const STATUS_OUTCOMES = { 401: 'forbidden', 403: 'forbidden', 404: 'missing', 409: 'conflict' };
+export class HttpTableApi {
+    #table;
+    #gate;
+    #url;
+    #onSignedOut;
+    constructor(table, gate, onSignedOut, base = '/api/tables') {
+        this.#table = table;
+        this.#gate = gate;
+        this.#onSignedOut = onSignedOut;
+        this.#url = `${base}/${table.name}`;
+    }
+    list() {
+        return this.#call('list', 'GET', '', undefined, z.array(this.#table.row));
+    }
+    listPublic() {
+        return this.#call('listPublic', 'GET', '/public', undefined, z.array(this.#table.publicRow));
+    }
+    create(row) {
+        return this.#call('create', 'POST', '', row, this.#table.row);
+    }
+    update(row) {
+        return this.#call('update', 'PUT', `/${row.id}`, row, this.#table.row);
+    }
+    async remove(id) {
+        await this.#call('remove', 'DELETE', `/${id}`, undefined, z.unknown());
+    }
+    #call(call, method, path, body, reply) {
+        const name = `${this.#table.name}.${call}`;
+        return this.#gate.pass(name, async () => {
+            const response = await fetch(`${this.#url}${path}`, {
+                method,
+                headers: { 'content-type': 'application/json' },
+                ...(body === undefined ? {} : { body: JSON.stringify(body) })
+            });
+            if (response.status === 401)
+                this.#onSignedOut();
+            const refused = STATUS_OUTCOMES[response.status];
+            if (refused !== undefined && method !== 'GET') {
+                throw new WriteRefused(refused);
+            }
+            if (!response.ok)
+                throw new Error(`${name}: HTTP ${response.status}`);
+            return reply.parse(await response.json());
+        });
+    }
+}
+export class MemoryTableApi {
+    #table;
+    #viewer;
+    #server;
+    #saved;
+    constructor(table, seed, viewer, options) {
+        this.#table = table;
+        this.#viewer = viewer;
+        this.#server = new MemoryServer(table.name, options);
+        this.#saved = seed;
+    }
+    list() {
+        return this.#server.reply('list', () => {
+            const viewer = this.#viewer();
+            if (listRefusal(this.#table, viewer) !== undefined) {
+                throw new Error(`${this.#table.name}.list: not allowed`);
+            }
+            return this.#saved.filter((row) => canSee(this.#table, viewer, row));
+        });
+    }
+    listPublic() {
+        return this.#server.reply('listPublic', () => this.#saved.map((row) => publicRow(this.#table, row)));
+    }
+    create(row) {
+        return this.#server.reply('create', () => {
+            const viewer = this.#viewer();
+            const refusal = createRefusal(this.#table, viewer);
+            if (refusal !== undefined)
+                throw new WriteRefused(refusalOutcome(refusal));
+            if (this.#table.owned && viewer === null) {
+                throw new WriteRefused('forbidden');
+            }
+            const saved = this.#table.owned && viewer !== null
+                ? { ...row, ownerId: viewer.userId }
+                : { ...row };
+            this.#refuseClash(saved);
+            this.#saved = [...this.#saved, saved];
+            return saved;
+        });
+    }
+    update(row) {
+        return this.#server.reply('update', () => {
+            const existing = this.#allowedChange('update', row.id);
+            const saved = existing.ownerId === undefined
+                ? { ...row }
+                : { ...row, ownerId: existing.ownerId };
+            this.#refuseClash(saved);
+            this.#saved = this.#saved.map((item) => item.id === saved.id ? saved : item);
+            return saved;
+        });
+    }
+    remove(id) {
+        return this.#server.reply('remove', () => {
+            this.#allowedChange('delete', id);
+            this.#saved = this.#saved.filter((item) => item.id !== id);
+        });
+    }
+    #allowedChange(operation, id) {
+        const existing = this.#saved.find((item) => item.id === id);
+        const refusal = changeRefusal(this.#table, operation, this.#viewer(), existing);
+        if (refusal !== undefined || existing === undefined) {
+            throw new WriteRefused(refusalOutcome(refusal ?? 'missing'));
+        }
+        return existing;
+    }
+    #refuseClash(row) {
+        if (clashesWith(this.#table, this.#saved, row)) {
+            throw new WriteRefused('conflict');
+        }
+    }
+}
+function eachTable(tables, api) {
+    return Object.fromEntries(Object.entries(tables).map(([key, table]) => [key, api(table)]));
+}
+export function httpTables(tables, gate, onSignedOut) {
+    return eachTable(tables, (table) => new HttpTableApi(table, gate, onSignedOut));
+}
+export function memoryTables(tables, seed, viewer, options) {
+    return eachTable(tables, (table) => new MemoryTableApi(table, seededRows(seed, table.name), viewer, options));
+}
+export function tableCalls(tables) {
+    return Object.values(tables).flatMap((table) => [...entityCalls, ...(table.public.length > 0 ? ['listPublic'] : [])].map((call) => `${table.name}.${call}`));
+}
+export function publicStoreName(table) {
+    return `public${table.charAt(0).toUpperCase()}${table.slice(1)}`;
+}
+export class PublicTableStore extends StoreBase {
+    #loading;
+    constructor(table, { api, cache }) {
+        super({
+            list: () => api.listPublic(),
+            cache: cache.scope(`anon:${publicStoreName(table.name)}`, z.array(table.publicRow))
+        });
+    }
+    initialState() {
+        const cached = this.deps.cache.read();
+        return {
+            status: cached === undefined ? 'idle' : 'ready',
+            items: cached ?? []
+        };
+    }
+    load() {
+        this.#loading ??= this.#fetch().finally(() => {
+            this.#loading = undefined;
+        });
+        return this.#loading;
+    }
+    async #fetch() {
+        if (this.state.status !== 'ready')
+            this.set({ status: 'loading' });
+        try {
+            const items = await this.deps.list();
+            this.deps.cache.write(items);
+            this.set({ status: 'ready', items });
+        }
+        catch {
+            if (this.state.status === 'loading')
+                this.set({ status: 'failed' });
+        }
+    }
+}
+export class TableStore extends EntityStore {
+    #table;
+    #viewer;
+    #publicView;
+    constructor(table, { api, cache, viewer, publicView }) {
+        super({
+            api,
+            writes: table.writes,
+            cache: cache.scope(() => `${viewer()?.userId ?? 'anon'}:${table.name}`, z.array(table.row))
+        });
+        this.#table = table;
+        this.#viewer = viewer;
+        this.#publicView = publicView;
+    }
+    get mayRead() {
+        return readScope(this.#table, this.#viewer()) !== 'none';
+    }
+    load() {
+        return this.mayRead ? super.load() : Promise.resolve();
+    }
+    async create(fields) {
+        const ownerId = this.#viewer()?.userId;
+        return this.#refreshPublic(await super.create({
+            ...fields,
+            id: crypto.randomUUID(),
+            createdAt: new Date().toISOString(),
+            ...(this.#table.owned && ownerId !== undefined ? { ownerId } : {})
+        }));
+    }
+    async update(row) {
+        return this.#refreshPublic(await super.update(row));
+    }
+    async remove(id) {
+        return this.#refreshPublic(await super.remove(id));
+    }
+    #refreshPublic(outcome) {
+        if (outcome === 'saved' || outcome === 'conflict') {
+            void this.#publicView?.load();
+        }
+        return outcome;
+    }
+}

package/dist/theme/reset.css

@@ -0,0 +1,84 @@
+@layer reset {
+  :root {
+    color-scheme: light dark;
+  }
+
+  *,
+  *::before,
+  *::after {
+    box-sizing: border-box;
+  }
+
+  html,
+  body,
+  #root {
+    height: 100%;
+    overflow: hidden;
+    overscroll-behavior: none;
+  }
+
+  body {
+    -webkit-user-select: none;
+    user-select: none;
+    -webkit-touch-callout: none;
+    -webkit-tap-highlight-color: transparent;
+  }
+
+  input,
+  textarea,
+  [contenteditable]:not([contenteditable='false']) {
+    -webkit-user-select: text;
+    user-select: text;
+  }
+
+  a,
+  button,
+  label,
+  select,
+  summary,
+  [role='button'],
+  [role='link'],
+  input[type='button'],
+  input[type='checkbox'],
+  input[type='color'],
+  input[type='file'],
+  input[type='radio'],
+  input[type='range'],
+  input[type='reset'],
+  input[type='submit'] {
+    cursor: default;
+  }
+
+  button {
+    padding: 0;
+    font: inherit;
+    color: inherit;
+    background: none;
+    border: 0;
+  }
+
+  h1,
+  h2,
+  h3,
+  h4,
+  h5,
+  h6 {
+    font-size: inherit;
+    font-weight: inherit;
+  }
+
+  body,
+  h1,
+  h2,
+  h3,
+  h4,
+  h5,
+  h6,
+  p,
+  figure,
+  blockquote,
+  ul,
+  ol {
+    margin: 0;
+  }
+}

package/dist/theme/scales.d.ts

@@ -0,0 +1,76 @@
+export declare const ascendingScales: {
+    readonly space: readonly ["xxs", "xs", "sm", "md", "lg", "xl", "xxl", "xxxl"];
+    readonly controlHeights: readonly ["heightXs", "heightSm", "heightMd", "heightLg", "heightXl"];
+    readonly controlPaddings: readonly ["paddingXs", "paddingSm", "paddingMd", "paddingLg", "paddingXl"];
+    readonly controlGaps: readonly ["gapXs", "gapSm", "gapMd", "gapLg", "gapXl"];
+    readonly contentWidths: readonly ["contentXs", "contentSm", "contentMd", "contentLg"];
+    readonly iconSizes: readonly ["xs", "sm", "md", "lg", "xl"];
+    readonly fontSizes: readonly ["captionXs", "captionSm", "captionBase", "captionLg", "bodySm", "bodyBase", "bodyLg", "heading6", "heading5", "heading4", "heading3", "heading2", "heading1"];
+    readonly lineHeights: readonly ["captionXs", "caption", "title", "bodySm", "body", "heading6", "heading5", "heading4", "heading3", "heading2", "heading1"];
+};
+export declare const scaleGroups: {
+    readonly space: "space";
+    readonly controlHeights: "controls";
+    readonly controlPaddings: "controls";
+    readonly controlGaps: "controls";
+    readonly contentWidths: "widths";
+    readonly iconSizes: "iconSizes";
+    readonly fontSizes: "fontSizes";
+    readonly lineHeights: "lineHeights";
+};
+export declare const textInControls: readonly [{
+    readonly size: "xs";
+    readonly height: "heightXs";
+    readonly lineHeight: "caption";
+}, {
+    readonly size: "sm";
+    readonly height: "heightSm";
+    readonly lineHeight: "bodySm";
+}, {
+    readonly size: "md";
+    readonly height: "heightMd";
+    readonly lineHeight: "bodySm";
+}, {
+    readonly size: "lg";
+    readonly height: "heightLg";
+    readonly lineHeight: "bodySm";
+}, {
+    readonly size: "xl";
+    readonly height: "heightXl";
+    readonly lineHeight: "body";
+}];
+export declare const textLines: readonly [{
+    readonly lineHeight: "captionXs";
+    readonly fontSize: "captionXs";
+}, {
+    readonly lineHeight: "caption";
+    readonly fontSize: "captionLg";
+}, {
+    readonly lineHeight: "title";
+    readonly fontSize: "bodyBase";
+}, {
+    readonly lineHeight: "bodySm";
+    readonly fontSize: "bodySm";
+}, {
+    readonly lineHeight: "body";
+    readonly fontSize: "bodyBase";
+}, {
+    readonly lineHeight: "heading6";
+    readonly fontSize: "heading6";
+}, {
+    readonly lineHeight: "heading5";
+    readonly fontSize: "heading5";
+}, {
+    readonly lineHeight: "heading4";
+    readonly fontSize: "heading4";
+}, {
+    readonly lineHeight: "heading3";
+    readonly fontSize: "heading3";
+}, {
+    readonly lineHeight: "heading2";
+    readonly fontSize: "heading2";
+}, {
+    readonly lineHeight: "heading1";
+    readonly fontSize: "heading1";
+}];
+export declare const pixelGroups: readonly ["space", "controls", "iconSizes", "fontSizes", "lineHeights", "borders", "radii", "widths"];

package/dist/theme/scales.js

@@ -0,0 +1,82 @@
+export const ascendingScales = {
+    space: ['xxs', 'xs', 'sm', 'md', 'lg', 'xl', 'xxl', 'xxxl'],
+    controlHeights: ['heightXs', 'heightSm', 'heightMd', 'heightLg', 'heightXl'],
+    controlPaddings: [
+        'paddingXs',
+        'paddingSm',
+        'paddingMd',
+        'paddingLg',
+        'paddingXl'
+    ],
+    controlGaps: ['gapXs', 'gapSm', 'gapMd', 'gapLg', 'gapXl'],
+    contentWidths: ['contentXs', 'contentSm', 'contentMd', 'contentLg'],
+    iconSizes: ['xs', 'sm', 'md', 'lg', 'xl'],
+    fontSizes: [
+        'captionXs',
+        'captionSm',
+        'captionBase',
+        'captionLg',
+        'bodySm',
+        'bodyBase',
+        'bodyLg',
+        'heading6',
+        'heading5',
+        'heading4',
+        'heading3',
+        'heading2',
+        'heading1'
+    ],
+    lineHeights: [
+        'captionXs',
+        'caption',
+        'title',
+        'bodySm',
+        'body',
+        'heading6',
+        'heading5',
+        'heading4',
+        'heading3',
+        'heading2',
+        'heading1'
+    ]
+};
+export const scaleGroups = {
+    space: 'space',
+    controlHeights: 'controls',
+    controlPaddings: 'controls',
+    controlGaps: 'controls',
+    contentWidths: 'widths',
+    iconSizes: 'iconSizes',
+    fontSizes: 'fontSizes',
+    lineHeights: 'lineHeights'
+};
+export const textInControls = [
+    { size: 'xs', height: 'heightXs', lineHeight: 'caption' },
+    { size: 'sm', height: 'heightSm', lineHeight: 'bodySm' },
+    { size: 'md', height: 'heightMd', lineHeight: 'bodySm' },
+    { size: 'lg', height: 'heightLg', lineHeight: 'bodySm' },
+    { size: 'xl', height: 'heightXl', lineHeight: 'body' }
+];
+export const textLines = [
+    { lineHeight: 'captionXs', fontSize: 'captionXs' },
+    { lineHeight: 'caption', fontSize: 'captionLg' },
+    { lineHeight: 'title', fontSize: 'bodyBase' },
+    { lineHeight: 'bodySm', fontSize: 'bodySm' },
+    { lineHeight: 'body', fontSize: 'bodyBase' },
+    { lineHeight: 'heading6', fontSize: 'heading6' },
+    { lineHeight: 'heading5', fontSize: 'heading5' },
+    { lineHeight: 'heading4', fontSize: 'heading4' },
+    { lineHeight: 'heading3', fontSize: 'heading3' },
+    { lineHeight: 'heading2', fontSize: 'heading2' },
+    { lineHeight: 'heading1', fontSize: 'heading1' }
+];
+export const pixelGroups = [
+    'space',
+    'controls',
+    'iconSizes',
+    'fontSizes',
+    'lineHeights',
+    'borders',
+    'radii',
+    'widths'
+];