@trypattern/sdk 0.1.0 → 0.1.2

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/start.js

@@ -8,12 +8,14 @@ import { browserApi } from "./api.js";
 import { Cache } from "./cache.js";
 import { setAppIcons } from "./components/icons.js";
 import { setInteractionSink } from "./components/interaction.js";
+import { manualClock, realClock } from "./clock.js";
 import { Gate } from "./gate.js";
 import { AppProvider } from "./hooks/appContext.js";
 import { routeObjects } from "./routes.js";
 import { borders, breakpoints, colors, controls, fontFeatures, fontSizes, fontWeights, fonts, iconSizes, lineHeights, radii, shadows, space, widths } from "./theme/tokens.stylex.js";
 const TEST_SEED = 'patternSeed';
 const TEST_ADMINS = 'patternAdmins';
+const TEST_WORLD = 'patternWorld';
 function testSeed() {
     const seed = Reflect.get(window, TEST_SEED);
     return typeof seed === 'object' && seed !== null ? seed : {};
@@ -32,20 +34,26 @@ export function startApp(App, { theme = [], icons = {}, onInteraction } = {}) {
     const gate = new Gate(testParams.getAll('fail'));
     for (const call of testParams.getAll('hold'))
         gate.hold(call);
-    const { tables, routes } = App.definition;
+    const { tables, routes, services, memory } = App.definition;
     const inMemory = testParams.has('memory');
+    const world = inMemory ? (Reflect.get(window, TEST_WORLD) ?? {}) : {};
     const router = createBrowserRouter(routeObjects(routes));
     const app = new App(router, {
         api: browserApi(tables, inMemory ? testSeed() : {}, gate, {
             inMemory,
-            admins: inMemory ? testAdmins() : []
+            admins: inMemory ? testAdmins() : [],
+            ...(services === undefined ? {} : { services }),
+            ...(memory === undefined ? {} : { memory }),
+            world
         }),
         cache: Cache.local(),
-        gate
+        gate,
+        clock: inMemory ? manualClock() : realClock()
     });
     if (hot)
-        exposeToDevTools(app, gate, hot);
+        exposeToDevTools(app, gate, hot, world);
     followAppearance(app);
+    followTitle(app);
     if (onInteraction !== undefined) {
         setInteractionSink((interaction) => onInteraction({
             ...interaction,
@@ -71,7 +79,17 @@ function followAppearance(app) {
     account.subscribe(apply);
     apply();
 }
-function exposeToDevTools(app, gate, hot) {
+function followTitle(app) {
+    const store = app.stores.app;
+    const apply = () => {
+        const { title } = store.currentState;
+        if (title !== '')
+            document.title = title;
+    };
+    store.subscribe(apply);
+    apply();
+}
+function exposeToDevTools(app, gate, hot, world) {
     async function snapshotWhenIdle() {
         await app.whenIdle();
         return app.getSnapshot();
@@ -89,7 +107,13 @@ function exposeToDevTools(app, gate, hot) {
             send: dispatch,
             snapshot: snapshotWhenIdle,
             hold: (call) => gate.hold(call),
-            release: (call) => gate.release(call)
+            release: (call) => gate.release(call),
+            tick: () => app.tick(),
+            world: (patch) => {
+                if (typeof world === 'object' && world !== null) {
+                    Object.assign(world, patch);
+                }
+            }
         }
     });
     if (navigator.webdriver)

package/dist/store.d.ts

@@ -26,13 +26,15 @@ export type StoreConfig<S extends StateSpec, P extends readonly (keyof S & strin
     state?: S;
     persist?: P;
 };
-export declare abstract class DeclaredStore<State extends object> extends StoreBase<State> {
+export declare abstract class DeclaredStore<State extends object, Client = Record<never, never>> extends StoreBase<State> {
+    protected readonly services: Client;
+    constructor(services: Client);
     protected initialState(): State;
 }
-export type StoreClass<S extends StateSpec, P extends readonly (keyof S & string)[]> = (abstract new (persisted: Persisted) => DeclaredStore<StateOf<S>>) & {
+export type StoreClass<S extends StateSpec, P extends readonly (keyof S & string)[], Client = Record<never, never>> = (abstract new (persisted: Persisted, services: Client) => DeclaredStore<StateOf<S>, Client>) & {
     readonly config: StoreConfig<S, P>;
 };
-export declare function Store<S extends StateSpec = Record<never, never>, const P extends readonly (keyof S & string)[] = []>(config: StoreConfig<S, P>): StoreClass<S, P>;
+export declare function defineStore<Client>(): <S extends StateSpec = Record<never, never>, const P extends readonly (keyof S & string)[] = []>(config: StoreConfig<S, P>) => StoreClass<S, P, Client>;
 export type Snapshots<Group> = {
     [Key in keyof Group]: Group[Key] extends {
         readonly state: infer State;

package/dist/store.js

@@ -163,17 +163,27 @@ export class StoreBase {
     }
 }
 export class DeclaredStore extends StoreBase {
+    services;
+    constructor(services) {
+        super();
+        this.services = services;
+    }
     initialState() {
         throw new Error(`${this.constructor.name} must extend Store({ state }) so its first state comes from the config`);
     }
 }
-export function Store(config) {
+export function defineStore() {
+    return function Store(config) {
+        return declaredStore(config);
+    };
+}
+function declaredStore(config) {
     const persist = config.persist ?? [];
     class Declared extends DeclaredStore {
         static config = config;
         #persisted;
-        constructor(persisted) {
-            super();
+        constructor(persisted, services) {
+            super(services);
             this.#persisted = persisted;
         }
         initialState() {

package/dist/table.d.ts

@@ -134,7 +134,7 @@ type CheckedColumns<C> = {
 type CheckedTable<Definition> = {
     [Key in keyof Definition]: Key extends 'columns' ? CheckedColumns<SameOnTheWire<Definition[Key] & z.ZodRawShape>> : Key extends 'access' ? CheckedAccess<Definition, Definition[Key]> : Key extends 'writes' ? HasUnique<Definition> extends true ? Definition[Key] extends 'confirmed' ? Definition[Key] : UniqueNeedsConfirmed : Definition[Key] : Key extends 'public' ? ReadOf<Definition> extends 'anyone' ? PublicNeedsPrivateRead : Definition[Key] & readonly (ColumnOf<Definition> | 'createdAt')[] : Key extends 'unique' ? Definition[Key] & readonly (readonly ColumnOf<Definition>[])[] : Definition[Key];
 } & Missing<Definition, 'access', AccessIsRequired> & Missing<Definition, 'writes', WritesIsRequired>;
-export declare function defineTables<const Definitions extends Record<string, DraftTable>>(definitions: {
+export declare function defineTables<const Definitions extends Record<string, DraftTable> = Record<never, never>>(definitions: {
     [Key in keyof Definitions]: CheckedTable<Definitions[Key]>;
 }): TablesOf<Definitions>;
 export declare function ownerIdOf(email: string): string;

package/dist/vite/localWorker.d.ts

@@ -1,4 +1,4 @@
 import type { Plugin } from 'vite';
 import type { Seed, Tables } from '../table.ts';
 export declare function resetLocalDatabase(root: string, tables: Tables, seed: Seed<Tables>): void;
-export declare function localWorker<Group extends Tables>(tables: Group, seed: Seed<Group>): Plugin;
+export declare function localWorker<Group extends Tables>(tables: Group, seed: Seed<Group>, title: string): Plugin;

package/dist/vite/localWorker.js

@@ -2,6 +2,7 @@ import { execFileSync } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
 import { appendFileSync, existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { seedTitleSql } from "../server/settings.js";
 import { seedSql } from "../server/tables.js";
 import { snakeCase } from "../table.js";
 import { toolBin } from "../cli/tools.js";
@@ -34,7 +35,7 @@ export function resetLocalDatabase(root, tables, seed) {
         ].join('\n')
     ]);
 }
-function prepareLocalDatabase(root, tables, seed) {
+function prepareLocalDatabase(root, tables, seed, title) {
     wrangler(root, ['d1', 'migrations', 'apply', 'DB', '--local']);
     wrangler(root, [
         'd1',
@@ -42,10 +43,10 @@ function prepareLocalDatabase(root, tables, seed) {
         'DB',
         '--local',
         '--command',
-        seedSql(tables, seed)
+        [seedTitleSql(title), seedSql(tables, seed)].join('\n')
     ]);
 }
-export function localWorker(tables, seed) {
+export function localWorker(tables, seed, title) {
     return {
         name: 'pattern-local-worker',
         config(config, { command }) {
@@ -53,7 +54,7 @@ export function localWorker(tables, seed) {
                 return;
             const root = config.root ?? process.cwd();
             ensureLocalSessionSecret(root);
-            prepareLocalDatabase(root, tables, seed);
+            prepareLocalDatabase(root, tables, seed, title);
         }
     };
 }

package/dist/vite/projectFile.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const PROJECT_FILE = "pattern.json";
+declare const projectFile: z.ZodObject<{
+    name: z.ZodString;
+    title: z.ZodString;
+}, z.core.$strip>;
+export type ProjectFile = z.output<typeof projectFile>;
+export declare function readProjectFile(root: string): ProjectFile;
+export {};

package/dist/vite/projectFile.js

@@ -0,0 +1,17 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { appTitle } from "../appTitle.js";
+export const PROJECT_FILE = 'pattern.json';
+const projectFile = z.object({ name: z.string().min(1), title: appTitle });
+export function readProjectFile(root) {
+    const path = join(root, PROJECT_FILE);
+    if (!existsSync(path)) {
+        throw new Error(`${PROJECT_FILE} is missing. It holds the app's address and title: { "name": "acme", "title": "Acme" }`);
+    }
+    const parsed = projectFile.safeParse(JSON.parse(readFileSync(path, 'utf8')));
+    if (!parsed.success) {
+        throw new Error(`${PROJECT_FILE} needs "name" (the address) and "title" (1 to 60 characters): ${z.prettifyError(parsed.error)}`);
+    }
+    return parsed.data;
+}

package/dist/vite/vite.d.ts

@@ -3,5 +3,6 @@ export type PatternOptions<Group extends Tables> = {
     tables: Group;
     admins: readonly string[];
     seed?: Seed<Group>;
+    world?: object;
 };
-export declare function pattern<Group extends Tables>({ tables, admins, seed }: PatternOptions<Group>): import("vite").UserConfig;
+export declare function pattern<Group extends Tables>({ tables, admins, seed, world }: PatternOptions<Group>): import("vite").UserConfig;

package/dist/vite/vite.js

@@ -8,6 +8,7 @@ import { defineConfig } from 'vitest/config';
 import { commandBridge } from "./commandBridge.js";
 import { designManifest } from "./designManifest.js";
 import { localWorker } from "./localWorker.js";
+import { readProjectFile } from "./projectFile.js";
 import { rootAlias } from "./rootAlias.js";
 const DEV_SERVER_PORT = 5173;
 const VISUAL_FLOW_TIMEOUT_MS = 30_000;
@@ -25,8 +26,9 @@ const reactCompilerSkippingUnchangedRendersAndLoggingWhereItCannot = {
     compiler: { logDiagnostics: true }
 };
 const FLOW_SETUP = fileURLToPath(new URL(`../flows/flowSetup${extname(import.meta.filename)}`, import.meta.url));
-export function pattern({ tables, admins, seed = {} }) {
+export function pattern({ tables, admins, seed = {}, world = {} }) {
     const isVitest = process.env['VITEST'] !== undefined;
+    const { title } = readProjectFile(process.cwd());
     const isVisualFlowRun = process.env['PATTERN_VISUAL_URL'] !== undefined;
     const stylexPlugin = stylex.vite({
         useCSSLayers: { before: CSS_LAYERS_BEFORE_STYLEX },
@@ -46,7 +48,7 @@ export function pattern({ tables, admins, seed = {} }) {
     ];
     const workerServingApiInDevAndBuild = isVitest
         ? []
-        : [localWorker(tables, seed), cloudflare()];
+        : [localWorker(tables, seed, title), cloudflare()];
     return defineConfig({
         plugins: [
             ...stylexBeforeReactToKeepFastRefresh,
@@ -67,7 +69,12 @@ export function pattern({ tables, admins, seed = {} }) {
         test: {
             include: ['flows/**/*.flow.ts'],
             server: { deps: { inline: ['@trypattern/sdk'] } },
-            provide: { patternSeed: seed, patternAdmins: admins },
+            provide: {
+                patternSeed: seed,
+                patternAdmins: admins,
+                patternTitle: title,
+                patternWorld: world
+            },
             ...(isVisualFlowRun && {
                 globalSetup: [FLOW_SETUP],
                 testTimeout: VISUAL_FLOW_TIMEOUT_MS

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trypattern/sdk",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "files": [
     "dist",
@@ -26,6 +26,10 @@
       "types": "./dist/server/index.d.ts",
       "default": "./dist/server/index.js"
     },
+    "./publish": {
+      "types": "./dist/publishWire.d.ts",
+      "default": "./dist/publishWire.js"
+    },
     "./flows": {
       "types": "./dist/flows/flows.d.ts",
       "default": "./dist/flows/flows.js"

package/presets/register.d.ts

@@ -4,6 +4,7 @@ import type { tables } from '@/schema.ts'
 import type { actionGroups } from '@/src/actions/index.ts'
 import type { models } from '@/src/models/index.ts'
 import type { routes } from '@/src/routes.tsx'
+import type { services } from '@/src/services/index.ts'
 import type { stores } from '@/src/stores/index.ts'
 import type { icons } from '@/src/theme/icons.ts'
 
@@ -14,6 +15,7 @@ declare module '@trypattern/sdk' {
     tables: typeof tables
     stores: typeof stores
     routes: typeof routes
+    services: typeof services
     icons: typeof icons
   }
 }