@trypattern/sdk 0.1.0 → 0.1.1

package/dist/api.d.ts

@@ -1,20 +1,30 @@
 import type { SessionApi, SessionCall } from './auth/sessionApi.ts';
+import type { AppInfoApi, AppInfoCall } from './appInfo.ts';
 import type { Gate } from './gate.ts';
+import type { Services } from './services.ts';
 import type { Seed, Tables } from './table.ts';
 import type { TableCall, TablesApi } from './tables.ts';
 export type AppApi<Group extends Tables> = {
     tables: TablesApi<Group>;
     session: SessionApi;
+    app: AppInfoApi;
+    services: object;
 };
-export type ApiCall<Group extends Tables> = TableCall<Group> | `session.${SessionCall}`;
-export declare function apiCalls<Group extends Tables>(tables: Group): readonly ApiCall<Group>[];
-export declare function httpApi<Group extends Tables>(tables: Group, gate: Gate): AppApi<Group>;
-export declare function memoryApi<Group extends Tables>(tables: Group, seed: Seed<Group>, { gate, signedInAs, admins }: {
+export type ServicesSetup = {
+    services?: Services;
+    memory?: object;
+    world?: unknown;
+};
+export type ApiCall<Group extends Tables> = TableCall<Group> | `session.${SessionCall}` | `app.${AppInfoCall}`;
+export declare function apiCalls<Group extends Tables>(tables: Group, services?: Services): readonly ApiCall<Group>[];
+export declare function httpApi<Group extends Tables>(tables: Group, gate: Gate, setup?: ServicesSetup): AppApi<Group>;
+export declare function memoryApi<Group extends Tables>(tables: Group, seed: Seed<Group>, { gate, signedInAs, admins, title, ...setup }: {
     gate: Gate;
     signedInAs: string | null;
     admins: readonly string[];
-}): AppApi<Group>;
-export declare function browserApi<Group extends Tables>(tables: Group, seed: Seed<Group>, gate: Gate, { inMemory, admins }: {
+    title: string;
+} & ServicesSetup): AppApi<Group>;
+export declare function browserApi<Group extends Tables>(tables: Group, seed: Seed<Group>, gate: Gate, { inMemory, admins, ...setup }: {
     inMemory: boolean;
     admins: readonly string[];
-}): AppApi<Group>;
+} & ServicesSetup): AppApi<Group>;

package/dist/api.js

@@ -1,34 +1,60 @@
 import { adminEmails, viewerByEmail, viewerOf } from "./access.js";
 import { HttpSessionApi, MemorySessionApi, sessionCalls } from "./auth/sessionApi.js";
+import { HttpAppInfoApi, MemoryAppInfoApi, appInfoCalls } from "./appInfo.js";
+import { httpServices, memoryServices } from "./serviceClients.js";
+import { serviceCallNames } from "./services.js";
 import { httpTables, memoryTables, tableCalls } from "./tables.js";
-export function apiCalls(tables) {
+export function apiCalls(tables, services = {}) {
     return [
+        ...serviceCallNames(services),
         ...tableCalls(tables),
-        ...sessionCalls.map((call) => `session.${call}`)
+        ...sessionCalls.map((call) => `session.${call}`),
+        ...appInfoCalls.map((call) => `app.${call}`)
     ];
 }
-export function httpApi(tables, gate) {
+function memoryClient(setup, options) {
+    if (setup.services === undefined)
+        return {};
+    if (setup.memory === undefined) {
+        throw new Error('This app declares services but no memory fake: pass defineApp({ services, memory }) so flows and ?memory can run without a server.');
+    }
+    return memoryServices(setup.services, setup.memory, setup.world ?? {}, options);
+}
+export function httpApi(tables, gate, setup = {}) {
     const session = new HttpSessionApi(gate);
     return {
         tables: httpTables(tables, gate, () => session.reportSignedOut()),
-        session
+        session,
+        app: new HttpAppInfoApi(gate),
+        services: setup.services === undefined
+            ? {}
+            : httpServices(setup.services, gate, () => session.reportSignedOut())
     };
 }
-export function memoryApi(tables, seed, { gate, signedInAs, admins }) {
+export function memoryApi(tables, seed, { gate, signedInAs, admins, title, ...setup }) {
     const options = { latencyMs: 0, gate };
     const session = new MemorySessionApi(signedInAs, admins, options);
     return {
         tables: memoryTables(tables, seed, () => viewerOf(session.rememberedUser()), options),
-        session
+        session,
+        app: new MemoryAppInfoApi(title, options),
+        services: memoryClient(setup, options)
     };
 }
-export function browserApi(tables, seed, gate, { inMemory, admins }) {
+export function browserApi(tables, seed, gate, { inMemory, admins, ...setup }) {
     const session = new HttpSessionApi(gate);
     const emails = adminEmails(admins);
+    const options = { latencyMs: 0, gate };
     return {
         tables: inMemory
             ? memoryTables(tables, seed, () => viewerByEmail(session.rememberedUser(), emails), { latencyMs: 0, gate })
             : httpTables(tables, gate, () => session.reportSignedOut()),
-        session
+        session,
+        app: new HttpAppInfoApi(gate),
+        services: inMemory
+            ? memoryClient(setup, options)
+            : setup.services === undefined
+                ? {}
+                : httpServices(setup.services, gate, () => session.reportSignedOut())
     };
 }

package/dist/app.d.ts

@@ -1,7 +1,9 @@
 import type { DataRouter } from 'react-router';
 import type { AppApi } from './api.ts';
+import { AppStore } from './appInfo.ts';
 import { SessionStore } from './auth/sessionStore.ts';
 import type { Cache } from './cache.ts';
+import type { Clock } from './clock.ts';
 import type { Gate } from './gate.ts';
 import { ActionsStore } from './actions.ts';
 import type { Action, ActionsBuilder } from './actions.ts';
@@ -12,6 +14,7 @@ import type { Snapshots } from './store.ts';
 import type { Json, Persisted } from './state.ts';
 import type { DerivedOf, Instances, MessagesOf, ModelClassLike, ModelSnapshots } from './model.ts';
 import type { PageOf, PathOf, RouteDefinition } from './routes.ts';
+import type { Services } from './services.ts';
 import type { Tables } from './table.ts';
 import { PublicTableStore, TableStore } from './tables.ts';
 type Observed = {
@@ -21,6 +24,7 @@ type Observed = {
 export type { DataRouter };
 export type ModelServicesOf<Path extends string> = {
     navigate: (to: Path) => Promise<void>;
+    every: (ms: number, run: () => void | Promise<void>) => () => void;
 };
 type StaticTypeError<Text extends string> = Text;
 type NonJsonGetters<Instance> = {
@@ -39,6 +43,7 @@ export type AppDependencies<Api> = {
     api: Api;
     cache: Cache;
     gate: Gate;
+    clock?: Clock;
 };
 export type RunningApp<Command, Snapshot extends {
     readonly path: string;
@@ -50,8 +55,9 @@ export type RunningApp<Command, Snapshot extends {
     };
     getSnapshot(): Snapshot;
     whenIdle(): Promise<void>;
+    tick(): void;
 };
-export type StoreClasses = Record<string, new (persisted: Persisted) => Observed>;
+export type StoreClasses = Record<string, new (persisted: Persisted, services: never) => Observed>;
 export type StoreInstances<Classes extends StoreClasses> = {
     [Key in keyof Classes]: InstanceType<Classes[Key]>;
 };
@@ -65,12 +71,12 @@ export type PublicStores<Group extends Tables> = {
 };
 export type StoresOf<Group extends Tables, Custom, Item extends Action = Action> = {
     session: SessionStore;
+    app: AppStore;
     actions: ActionsStore<Item>;
     toasts: Toasts;
     page: PageStore;
 } & TableStores<Group> & PublicStores<Group> & Custom;
 export type AppDefinition<Group extends Tables, Custom extends StoreClasses, Classes extends Record<string, ModelClassLike>, Routes extends readonly RouteDefinition[]> = {
-    name: string;
     tables: Group;
     stores?: Custom;
     models: {
@@ -79,12 +85,16 @@ export type AppDefinition<Group extends Tables, Custom extends StoreClasses, Cla
     routes: Routes;
     actions?: readonly ActionsBuilder<never, Action>[];
     actionGroups?: readonly string[];
+    services?: Services;
+    memory?: object;
 };
 export type AppClass<Group extends Tables, Instance> = {
     new (router: DataRouter, deps: AppDependencies<AppApi<Group>>): Instance;
     readonly definition: {
         readonly tables: Group;
         readonly routes: readonly RouteDefinition[];
+        readonly services?: Services;
+        readonly memory?: object;
     };
 };
 export type AppSnapshotShape<Models, Stores, Page> = {
@@ -96,7 +106,6 @@ export type AppSnapshotShape<Models, Stores, Page> = {
 type AppCommandOf<Classes extends Record<string, ModelClassLike>, Routes extends readonly RouteDefinition[]> = MessagesOf<Instances<BuiltInModels>> | MessagesOf<Instances<Classes>> | NavigateCommand<PathOf<Routes>> | PressKeyCommand;
 export type DefinedApp<Group extends Tables, Classes extends Record<string, ModelClassLike>, Routes extends readonly RouteDefinition[], Custom extends StoreClasses> = {
     new (router: DataRouter, dependencies: AppDependencies<AppApi<Group>>): RunningApp<AppCommandOf<Classes, Routes>, AppSnapshotShape<Instances<BuiltInModels & Classes>, StoresOf<Group, StoreInstances<Custom>>, PageOf<Routes>>> & {
-        readonly name: string;
         readonly models: Instances<BuiltInModels & Classes>;
         readonly stores: StoresOf<Group, StoreInstances<Custom>>;
         pressKey(key: string): Promise<void> | undefined;

package/dist/app.js

@@ -1,8 +1,11 @@
 import { z } from 'zod';
 import { viewerOf } from "./access.js";
+import { AppStore } from "./appInfo.js";
 import { SessionStore } from "./auth/sessionStore.js";
+import { realClock } from "./clock.js";
 import { ActionsStore } from "./actions.js";
 import { Account } from "./builtins/Account.js";
+import { AppSettings } from "./builtins/AppSettings.js";
 import { BUILT_IN_GROUPS, builtInActions } from "./builtins/actions.js";
 import { Palette } from "./builtins/Palette.js";
 import { SignIn } from "./builtins/SignIn.js";
@@ -43,7 +46,12 @@ function clashOf(groups) {
     }
     return undefined;
 }
-const builtInModels = { account: Account, palette: Palette, signIn: SignIn };
+const builtInModels = {
+    account: Account,
+    appSettings: AppSettings,
+    palette: Palette,
+    signIn: SignIn
+};
 const appPathInput = z.custom((value) => typeof value === 'string' && isRoutedPath(value), { error: 'Not a page in src/routes.tsx' });
 export function defineApp(definition) {
     const pages = new Set(pageIds(definition.routes));
@@ -58,7 +66,6 @@ export function defineApp(definition) {
     }
     return class App {
         static definition = definition;
-        name = definition.name;
         router;
         models;
         stores;
@@ -69,28 +76,35 @@ export function defineApp(definition) {
         #session;
         #data;
         #navigations = new Set();
+        #repeats = new Set();
+        #clock;
         #failures = [];
         #path;
         #user;
-        constructor(router, { api, cache, gate }) {
+        constructor(router, { api, cache, gate, clock = realClock() }) {
             this.router = router;
             this.#cache = cache;
             this.#gate = gate;
+            this.#clock = clock;
             const session = new SessionStore({ api: api.session });
+            const app = new AppStore({
+                api: api.app,
+                remembered: cache.scope('app.title', z.string())
+            });
             const data = dataStores(definition.tables, api.tables, cache, () => viewerOf(session.state.user));
             const custom = Object.fromEntries(Object.entries(definition.stores ?? {}).map(([key, Store]) => [
                 key,
-                new Store(cache.persisted(`stores.${key}`))
+                new Store(cache.persisted(`stores.${key}`), api.services)
             ]));
-            const toasts = new Toasts(cache.persisted('stores.toasts'));
+            const toasts = new Toasts(cache.persisted('stores.toasts'), {});
             const clash = clashOf([
-                ['session', 'actions', 'toasts', 'page'],
+                ['session', 'app', 'actions', 'toasts', 'page'],
                 Object.keys(data.tables),
                 Object.keys(data.publicViews),
                 Object.keys(custom)
             ]);
             if (clash !== undefined) {
-                throw new Error(`Two stores are called "${clash}". The built-in session, actions, toasts and page stores, each table, each table's public view and each store in src/stores/index.ts need their own name.`);
+                throw new Error(`Two stores are called "${clash}". The built-in session, app, actions, toasts and page stores, each table, each table's public view and each store in src/stores/index.ts need their own name.`);
             }
             const actions = new ActionsStore(this.#page, [...(definition.actions ?? []), ...builtInActions], [
                 ...(definition.actionGroups ?? []),
@@ -98,6 +112,7 @@ export function defineApp(definition) {
             ], (message) => this.#runAction(message));
             this.stores = {
                 session,
+                app,
                 actions,
                 toasts,
                 page: this.#page,
@@ -111,6 +126,10 @@ export function defineApp(definition) {
                 navigate: (to) => {
                     assertNotBuilding('navigate');
                     return this.#navigate(to);
+                },
+                every: (ms, run) => {
+                    assertNotBuilding('repeat');
+                    return this.#every(ms, run);
                 }
             };
             this.models = createModels({ ...builtInModels, ...definition.models }, this.stores, services, (model) => cache.persisted(model));
@@ -128,6 +147,7 @@ export function defineApp(definition) {
             router.subscribe(() => this.#routeChanged());
             session.subscribe(() => this.#sessionChanged());
             void session.confirm();
+            void app.load();
             for (const view of Object.values(data.publicViews))
                 void view.load();
             this.#loadReadableTables();
@@ -149,6 +169,9 @@ export function defineApp(definition) {
                 stores: snapshotsOf(this.stores)
             };
         }
+        tick() {
+            this.#clock.tick();
+        }
         async whenIdle() {
             do {
                 await Promise.allSettled(this.#navigations);
@@ -184,11 +207,29 @@ export function defineApp(definition) {
             this.#navigations.add(navigation);
             return navigation;
         }
+        #every(ms, run) {
+            const stop = this.#clock.every(ms, () => {
+                void Promise.resolve(run()).catch((failure) => {
+                    this.#failures.push(failure);
+                });
+            });
+            const remove = () => {
+                stop();
+                this.#repeats.delete(remove);
+            };
+            this.#repeats.add(remove);
+            return remove;
+        }
+        #stopRepeats() {
+            for (const stop of [...this.#repeats])
+                stop();
+        }
         #routeChanged() {
             const path = this.router.state.location.pathname;
             if (path === this.#path)
                 return;
             this.#path = path;
+            this.#stopRepeats();
             this.#page.moved(this.#currentPage(), this.#currentParams());
             this.#openCurrentModel();
         }
@@ -197,6 +238,7 @@ export function defineApp(definition) {
             if (user === this.#user)
                 return;
             this.#user = user;
+            this.#stopRepeats();
             this.#cache.clear();
             for (const store of Object.values(this.#data.tables))
                 store.forget();

package/dist/appInfo.d.ts

@@ -0,0 +1,35 @@
+import type { AppInfo } from './appTitle.ts';
+import type { Cached } from './cache.ts';
+import type { Gate } from './gate.ts';
+import type { MemoryApiOptions } from './memoryApi.ts';
+import { StoreBase } from './store.ts';
+export type AppInfoApi = {
+    read: () => Promise<AppInfo>;
+    rename: (title: string) => Promise<AppInfo>;
+};
+export type AppInfoCall = 'read' | 'rename';
+export declare const appInfoCalls: readonly AppInfoCall[];
+export declare class HttpAppInfoApi implements AppInfoApi {
+    #private;
+    constructor(gate: Gate);
+    read(): Promise<AppInfo>;
+    rename(title: string): Promise<AppInfo>;
+}
+export declare class MemoryAppInfoApi implements AppInfoApi {
+    #private;
+    constructor(title: string, options: MemoryApiOptions);
+    read(): Promise<AppInfo>;
+    rename(title: string): Promise<AppInfo>;
+}
+export type AppState = {
+    title: string;
+};
+export declare class AppStore extends StoreBase<AppState, {
+    api: AppInfoApi;
+    remembered: Cached<string>;
+}> {
+    #private;
+    protected initialState(): AppState;
+    load(): Promise<void>;
+    rename(title: string): Promise<void>;
+}

package/dist/appInfo.js

@@ -0,0 +1,67 @@
+import { appInfo } from "./appTitle.js";
+import { MemoryServer } from "./memoryApi.js";
+import { StoreBase } from "./store.js";
+export const appInfoCalls = ['read', 'rename'];
+export class HttpAppInfoApi {
+    #gate;
+    constructor(gate) {
+        this.#gate = gate;
+    }
+    read() {
+        return this.#gate.pass('app.read', async () => {
+            const response = await fetch('/api/app');
+            if (!response.ok)
+                throw new Error('app.read failed');
+            return appInfo.parse(await response.json());
+        });
+    }
+    rename(title) {
+        return this.#gate.pass('app.rename', async () => {
+            const response = await fetch('/api/app', {
+                method: 'PUT',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ title })
+            });
+            if (!response.ok)
+                throw new Error('app.rename failed');
+            return appInfo.parse(await response.json());
+        });
+    }
+}
+export class MemoryAppInfoApi {
+    #server;
+    #title;
+    constructor(title, options) {
+        this.#server = new MemoryServer('app', options);
+        this.#title = title;
+    }
+    read() {
+        return this.#server.reply('read', () => ({ title: this.#title }));
+    }
+    rename(title) {
+        return this.#server.reply('rename', () => {
+            this.#title = title;
+            return { title };
+        });
+    }
+}
+export class AppStore extends StoreBase {
+    initialState() {
+        return { title: this.deps.remembered.read() ?? '' };
+    }
+    async load() {
+        try {
+            this.#keep(await this.deps.api.read());
+        }
+        catch {
+            return;
+        }
+    }
+    async rename(title) {
+        this.#keep(await this.deps.api.rename(title));
+    }
+    #keep({ title }) {
+        this.set({ title });
+        this.deps.remembered.write(title);
+    }
+}

package/dist/appTitle.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare const appTitle: z.ZodString;
+export declare const appInfo: z.ZodObject<{
+    title: z.ZodString;
+}, z.core.$strip>;
+export type AppInfo = z.output<typeof appInfo>;

package/dist/appTitle.js

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export const appTitle = z.string().trim().min(1).max(60);
+export const appInfo = z.object({ title: z.string() });

package/dist/builtins/AppSettings.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+declare const AppSettings_base: import("../model.ts").ModelClass<import("../registered.ts").AppStores, import("../registered.ts").ModelServices, {
+    isRenaming: z.ZodDefault<z.ZodBoolean>;
+}, []>;
+export declare class AppSettings extends AppSettings_base {
+    get title(): string;
+    get canRename(): boolean;
+    rename: import("../model.ts").Command<{
+        title: z.ZodString;
+    }, Promise<void>>;
+}
+export {};

package/dist/builtins/AppSettings.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { appTitle } from "../appTitle.js";
+import { command } from "../model.js";
+import { Model } from "../registered.js";
+export class AppSettings extends Model({
+    state: { isRenaming: z.boolean().default(false) }
+}) {
+    get title() {
+        return this.stores.app.state.title;
+    }
+    get canRename() {
+        return this.stores.session.state.user?.isAdmin === true;
+    }
+    rename = command({ input: { title: appTitle } }, async ({ title }) => {
+        this.set({ isRenaming: true });
+        try {
+            await this.stores.app.rename(title);
+            this.stores.toasts.show({ tone: 'success', title: 'Name saved' });
+        }
+        catch {
+            this.stores.toasts.show({
+                tone: 'error',
+                title: 'Couldn’t save the name',
+                description: 'Check your connection and try again.'
+            });
+        }
+        finally {
+            this.set({ isRenaming: false });
+        }
+    });
+}

package/dist/builtins/Toasts.d.ts

@@ -24,7 +24,7 @@ declare const Toasts_base: import("../store.ts").StoreClass<{
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>>>;
-}, []>;
+}, [], Record<never, never>>;
 export declare class Toasts extends Toasts_base {
     show({ description, ...shown }: ToastInput): void;
     dismiss(id: string): void;

package/dist/builtins/Toasts.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
-import { Store } from "../store.js";
+import { defineStore } from "../store.js";
+const Store = defineStore();
 const toast = z.object({
     id: z.string(),
     tone: z.enum(['neutral', 'success', 'error']),