@primate/core 0.4.5 → 0.5.0

package/lib/private/build/server/plugin/virtual-routes.js

@@ -11,18 +11,10 @@ export default function plugin_server_virtual_routes(app) {
                 return { path: "routes-virtual", namespace: "primate-routes" };
             });
             build.onLoad({ filter: /.*/, namespace: "primate-routes" }, async () => {
-                const route_files = await routes_path.collect(is_route_file);
-                const watchDirs = new Set();
-                const findDirs = async (dir) => {
-                    watchDirs.add(dir.path);
-                    const entries = await dir.list();
-                    for (const entry of entries) {
-                        if (await entry.isDirectory()) {
-                            await findDirs(entry);
-                        }
-                    }
-                };
-                await findDirs(app.path.routes);
+                const route_files = await routes_path.files({
+                    filter: is_route_file,
+                    recursive: true,
+                });
                 const contents = `
           const route = [];
           ${route_files.map((file, i) => {
@@ -32,11 +24,14 @@ export default function plugin_server_virtual_routes(app) {
                 }).join("\n")}
           export default route;
         `;
+                const watchDirs = (await app.path.routes.dirs({
+                    recursive: true,
+                })).map(f => f.toString());
                 return {
                     contents,
                     loader: "js",
                     resolveDir: app.root.path,
-                    watchDirs: [...watchDirs],
+                    watchDirs,
                     watchFiles: route_files.map(f => f.path),
                 };
             });

package/lib/private/build/server/plugin/wasm.js

@@ -22,9 +22,8 @@ export default function plugin_server_wasm(app) {
                 const wasm_file = app.runpath("wasm", args.path + ".wasm");
                 return {
                     contents: `
-            import FileRef from "primate/fs/FileRef";
-            const file = new FileRef("${wasm_file.path}");
-            export default await file.bytes();
+            import fs from "@rcompat/fs";
+            export default await fs.ref("${wasm_file.path}").bytes();
           `,
                     loader: "js",
                     resolveDir: app.root.path,

package/lib/private/bye.js

@@ -1,5 +1,4 @@
-import dim from "@rcompat/cli/color/dim";
-import yellow from "@rcompat/cli/color/yellow";
+import color from "@rcompat/cli/color";
 import print from "@rcompat/cli/print";
-export default () => print(dim(yellow("~~ bye\n")));
+export default () => print(color.dim(color.yellow("~~ bye\n")));
 //# sourceMappingURL=bye.js.map

package/lib/private/client/Data.d.ts

@@ -1,4 +1,4 @@
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 import type Mode from "#Mode";
 type ClientData<T extends Dict = Dict> = {
     view: string;

package/lib/private/client/ValidateInit.d.ts

@@ -1,6 +1,4 @@
-import type Dict from "@rcompat/type/Dict";
-import type JSONPointer from "@rcompat/type/JSONPointer";
-import type JSONValue from "@rcompat/type/JSONValue";
+import type { Dict, JSONPointer, JSONValue } from "@rcompat/type";
 type ValidateInit<T> = {
     headers?: Dict<string>;
     initial: T;

package/lib/private/client/ValidationError.d.ts

@@ -1,4 +1,4 @@
-import type Issue from "pema/Issue";
+import type { Issue } from "pema";
 type ValidationError = {
     issues?: ReadonlyArray<Issue>;
 } & Error;

package/lib/private/client/app.js

@@ -1,6 +1,7 @@
 // @ts-expect-error esbuild vfs
 import stamp from "server:stamp";
-(() => stamp)();
+// @ts-expect-error esbuild vfs
+(0, () => stamp)();
 // @ts-expect-error esbuild vfs
 import * as frontends from "app:frontends";
 class ClientApp {

package/lib/private/client/create-form.d.ts

@@ -0,0 +1,31 @@
+import type { Dict } from "@rcompat/type";
+type FormId = string;
+type FieldErrors = readonly string[];
+type FormErrors = {
+    form: FieldErrors;
+    fields: Dict<FieldErrors>;
+};
+type FormSnapshot = {
+    id: FormId;
+    submitting: boolean;
+    errors: FormErrors;
+};
+export type FormView = FormSnapshot & {
+    submit: (event?: Event) => Promise<void>;
+};
+type FormSubscriber = (snapshot: FormSnapshot) => void;
+export type FormInit = {
+    id?: string;
+    method?: "POST" | "PUT" | "PATCH" | "DELETE";
+    url?: string;
+    headers?: Dict<string>;
+};
+type FormController = {
+    subscribe(fn: FormSubscriber): () => void;
+    read(): FormSnapshot;
+    submit(event?: Event): Promise<void>;
+    get id(): FormId;
+};
+export default function createForm(init: FormInit): FormController;
+export {};
+//# sourceMappingURL=create-form.d.ts.map

package/lib/private/client/create-form.js

@@ -0,0 +1,124 @@
+import extract_issues from "#client/extract-issues";
+function decode_pointer_segment(segment) {
+    // decode JSON Pointer: ~1 -> /, ~0 -> ~
+    return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function pointer_to_fieldname(path) {
+    // if server didn't send a pointer, assume it's already a field name
+    if (!path.startsWith("/"))
+        return path;
+    // root pointer "" is handled before calling this
+    // "/" is not a valid root pointer, but treat as form-level
+    if (path === "/")
+        return "";
+    const segments = path.split("/").slice(1).map(decode_pointer_segment);
+    if (segments.length === 0 || segments[0] === "")
+        return "";
+    let name = segments[0];
+    for (let i = 1; i < segments.length; i++) {
+        name += `[${segments[i]}]`;
+    }
+    return name;
+}
+export default function createForm(init) {
+    const id = init.id ?? `form-${crypto.randomUUID()}`;
+    let snapshot = {
+        id,
+        submitting: false,
+        errors: { form: [], fields: {} },
+    };
+    const subscribers = new Set();
+    function publish() {
+        for (const s of subscribers)
+            s(snapshot);
+    }
+    function setSubmitting(submitting) {
+        snapshot = { ...snapshot, submitting };
+        publish();
+    }
+    function setErrors(issues) {
+        const byField = {};
+        const formErrors = [];
+        for (const issue of issues) {
+            const path = issue.path;
+            // no path or empty string -> form-level error
+            if (!path) {
+                formErrors.push(issue.message);
+                continue;
+            }
+            const key = pointer_to_fieldname(path);
+            // if normalizes to empty (e.g. "/"), treat as form-level
+            if (!key) {
+                formErrors.push(issue.message);
+                continue;
+            }
+            (byField[key] ??= []).push(issue.message);
+        }
+        snapshot = {
+            ...snapshot,
+            errors: {
+                form: formErrors,
+                fields: byField,
+            },
+        };
+        publish();
+    }
+    async function submit(event) {
+        if (event) {
+            event.preventDefault();
+            event.stopPropagation();
+        }
+        const form_element = event?.currentTarget ??
+            document.getElementById(id);
+        // no form element
+        if (!form_element)
+            return;
+        const method = init.method
+            ?? form_element.method.toUpperCase()
+            ?? "POST";
+        const url = init.url ?? form_element.action;
+        const form_data = new FormData(form_element);
+        setSubmitting(true);
+        try {
+            const response = await fetch(url, {
+                method,
+                body: form_data,
+                headers: init.headers,
+            });
+            if (response.ok) {
+                // on success: clear errors, let the app decide what to do next
+                // (redirect/reload)
+                snapshot = { ...snapshot, errors: { form: [], fields: {} } };
+                publish();
+                return;
+            }
+            const payload = await response.json();
+            const issues = extract_issues(payload); // all issues, all paths
+            setErrors(issues);
+        }
+        catch (error) {
+            // network error
+            setErrors([{ message: error.message, path: "" }]);
+        }
+        finally {
+            setSubmitting(false);
+        }
+    }
+    function subscribe(fn) {
+        subscribers.add(fn);
+        fn(snapshot); // emit current
+        return () => subscribers.delete(fn);
+    }
+    function read() {
+        return snapshot;
+    }
+    return {
+        subscribe,
+        read,
+        submit,
+        get id() {
+            return snapshot.id;
+        },
+    };
+}
+//# sourceMappingURL=create-form.js.map

package/lib/private/client/extract-issues.d.ts

@@ -0,0 +1,4 @@
+import type { JSONPointer } from "@rcompat/type";
+import type { Issue, JSONPayload } from "pema";
+export default function extractIssues(payload: JSONPayload, defaultPath?: JSONPointer | ""): Issue[];
+//# sourceMappingURL=extract-issues.d.ts.map

package/lib/private/client/extract-issues.js

@@ -0,0 +1,20 @@
+export default function extractIssues(payload, defaultPath = "") {
+    // scalar: { message, messages }
+    if ("messages" in payload) {
+        return payload.messages.map(m => ({
+            message: m,
+            // for forms, defaultPath is "", but Issue.path expects a JSONPointer
+            // so we cast here; form-level errors are handled separately anyway
+            path: defaultPath,
+        }));
+    }
+    // keyed: { "/field": { message, messages }, ... }
+    const issues = [];
+    for (const [path, bundle] of Object.entries(payload)) {
+        for (const message of bundle.messages) {
+            issues.push({ message, path: path });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=extract-issues.js.map

package/lib/private/client/spa/index.d.ts

@@ -1,5 +1,5 @@
 import type ClientData from "#client/Data";
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 type Updater<T extends Dict> = (json: ClientData<T>, after?: () => void) => void;
 declare const _default: <T extends Dict>(updater: Updater<T>) => void;
 export default _default;

package/lib/private/client/spa/index.js

@@ -1,9 +1,8 @@
 import storage from "#client/spa/storage";
-const APPLICATION_JSON = "application/json";
-const MULTIPART_FORM_DATA = "multipart/form-data";
+import MIME from "@rcompat/http/mime";
 const { document } = globalThis;
 const headers = {
-    Accept: APPLICATION_JSON,
+    Accept: MIME.APPLICATION_JSON,
 };
 const get_by_id_or_name = (name) => document.getElementById(name) ?? document.getElementsByName(name)[0];
 const scroll = globalThis.scrollTo;
@@ -56,7 +55,7 @@ async function refetch(input, init = {}, maxHops = 5) {
 function is_json(response) {
     const raw = response.headers.get("content-type") || "";
     const mime = raw.split(";")[0].trim();
-    return mime === APPLICATION_JSON;
+    return mime === MIME.APPLICATION_JSON;
 }
 ;
 const handle = async (response, updater) => {
@@ -192,7 +191,7 @@ export default (updater) => {
         const action = target.action ?? globalThis.location.pathname;
         const url = new URL(action);
         const data = new FormData(target);
-        const form = enctype === MULTIPART_FORM_DATA
+        const form = enctype === MIME.MULTIPART_FORM_DATA
             ? data
             : new URLSearchParams(data);
         submit(url.pathname, form, target.method, updater);

package/lib/private/client/{toValidated.d.ts → to-validated.d.ts}

@@ -1,7 +1,5 @@
 import type ValidateInit from "#client/ValidateInit";
-import type Dict from "@rcompat/type/Dict";
-import type JSONPointer from "@rcompat/type/JSONPointer";
-import type JSONValue from "@rcompat/type/JSONValue";
+import type { Dict, JSONPointer, JSONValue } from "@rcompat/type";
 type Options<T> = {
     headers?: Dict<string>;
     map?: (v: T) => JSONValue;
@@ -14,4 +12,4 @@ export default function toValidated<T, R>(validateSignal: (init: ValidateInit<T>
     put: (url: string, options?: Options<T>) => R;
 };
 export {};
-//# sourceMappingURL=toValidated.d.ts.map
+//# sourceMappingURL=to-validated.d.ts.map

package/lib/private/client/{toValidated.js → to-validated.js}

@@ -18,4 +18,4 @@ export default function toValidated(validateSignal) {
         };
     };
 }
-//# sourceMappingURL=toValidated.js.map
+//# sourceMappingURL=to-validated.js.map

package/lib/private/client/validate-field.d.ts

@@ -0,0 +1,3 @@
+import type ValidateInit from "#client/ValidateInit";
+export default function validateField<T>(init: ValidateInit<T>, value: T): Promise<void>;
+//# sourceMappingURL=validate-field.d.ts.map

package/lib/private/client/validate-field.js

@@ -0,0 +1,41 @@
+import extract_issues from "#client/extract-issues";
+function focus(issues, path) {
+    if (path === undefined) {
+        return issues;
+    }
+    const focused = issues.filter(i => i.path === path);
+    return focused.length ? focused : issues;
+}
+export default async function validateField(init, value) {
+    const headers = {
+        "content-type": "application/json",
+        ...(init.headers ?? {}),
+    };
+    if (init.path !== undefined) {
+        headers["x-validate-path"] = init.path;
+    }
+    const body_value = init.map?.(value) ?? value;
+    let body;
+    try {
+        body = JSON.stringify(body_value);
+    }
+    catch {
+        const message = "Cannot serialize body. Provide a `map` that returns JSON.";
+        throw new Error(message);
+    }
+    const { method, url } = init;
+    const response = await fetch(url, { body, headers, method });
+    if (response.ok)
+        return;
+    const payload = await response.json();
+    const default_path = init.path ?? "";
+    const default_issues = [{ message: "Validation failed", path: default_path }];
+    const all_issues = extract_issues(payload, default_path);
+    const focused_issues = focus(all_issues, init.path);
+    const issues = focused_issues.length > 0 ? focused_issues : default_issues;
+    throw Object.assign(new Error(issues[0].message), {
+        issues,
+        name: "ValidationError",
+    });
+}
+//# sourceMappingURL=validate-field.js.map

package/lib/private/config/index.d.ts

@@ -1,24 +1,5 @@
+import AppFacade from "#app/Facade";
 import schema from "#config/schema";
-declare const _default: (config?: typeof schema.input) => {
-    http: {
-        csp: Record<string, string[]> | undefined;
-        headers: Record<string, string> | undefined;
-        host: string;
-        port: number;
-        ssl: {
-            cert: string | import("@rcompat/fs/FileRef").default | undefined;
-            key: string | import("@rcompat/fs/FileRef").default | undefined;
-        };
-        static: {
-            root: string;
-        };
-    };
-    modules: import("../Module.js").default[] | undefined;
-    request: {
-        body: {
-            parse: boolean;
-        };
-    };
-};
+declare const _default: (input?: typeof schema.input) => AppFacade;
 export default _default;
 //# sourceMappingURL=index.d.ts.map

package/lib/private/config/index.js

@@ -1,3 +1,5 @@
+import AppFacade from "#app/Facade";
 import schema from "#config/schema";
-export default (config = {}) => schema.parse(config);
+export default (input = {}) => new AppFacade(schema.parse(input));
+;
 //# sourceMappingURL=index.js.map

package/lib/private/config/schema.d.ts

@@ -1,23 +1,27 @@
 import Module from "#Module";
-import FileRef from "@rcompat/fs/FileRef";
 declare const _default: import("pema").ObjectType<{
     http: import("pema").ObjectType<{
-        csp: import("pema").OptionalType<import("pema/record").RecordType<import("pema/string").StringType, import("pema").ArrayType<import("pema/string").StringType>>>;
-        headers: import("pema").OptionalType<import("pema/record").RecordType<import("pema/string").StringType, import("pema/string").StringType>>;
-        host: import("pema").DefaultType<import("pema/string").StringType, "localhost">;
-        port: import("pema").DefaultType<import("pema/uint").UintType<"u32">, 6161>;
+        csp: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").ArrayType<import("pema").StringType>>>;
+        headers: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").StringType>>;
+        host: import("pema").DefaultType<import("pema").StringType, "localhost">;
+        port: import("pema").DefaultType<import("pema").UintType<"u32">, 6161>;
         ssl: import("pema").ObjectType<{
-            cert: import("pema").OptionalType<import("pema/union").UnionType<[import("pema").ConstructorType<typeof FileRef>, import("pema/string").StringType]>>;
-            key: import("pema").OptionalType<import("pema/union").UnionType<[import("pema").ConstructorType<typeof FileRef>, import("pema/string").StringType]>>;
+            cert: import("pema").OptionalType<import("pema").UnionType<[import("pema").ConstructorType<typeof import("@rcompat/fs").FileRef>, import("pema").StringType]>>;
+            key: import("pema").OptionalType<import("pema").UnionType<[import("pema").ConstructorType<typeof import("@rcompat/fs").FileRef>, import("pema").StringType]>>;
         }>;
         static: import("pema").ObjectType<{
-            root: import("pema").DefaultType<import("pema/string").StringType, "/">;
+            root: import("pema").DefaultType<import("pema").StringType, "/">;
         }>;
     }>;
+    livereload: import("pema").ObjectType<{
+        exclude: import("pema").OptionalType<import("pema").ArrayType<import("pema").StringType>>;
+        host: import("pema").OptionalType<import("pema").StringType>;
+        port: import("pema").OptionalType<import("pema").UintType<"u32">>;
+    }>;
     modules: import("pema").OptionalType<import("pema").ArrayType<import("pema").ConstructorType<typeof Module>>>;
     request: import("pema").ObjectType<{
         body: import("pema").ObjectType<{
-            parse: import("pema").DefaultType<import("pema/boolean").BooleanType, true>;
+            parse: import("pema").DefaultType<import("pema").BooleanType, true>;
         }>;
     }>;
 }>;

package/lib/private/config/schema.js

@@ -1,20 +1,25 @@
 import Module from "#Module";
-import FileRef from "@rcompat/fs/FileRef";
+import fs from "@rcompat/fs";
 import p from "pema";
 export default p({
     http: {
-        csp: p.record(p.string, p.array(p.string)).optional(),
-        headers: p.record(p.string, p.string).optional(),
+        csp: p.dict(p.array(p.string)).optional(),
+        headers: p.dict().optional(),
         host: p.string.default("localhost"),
         port: p.uint.port().default(6161),
         ssl: {
-            cert: p.union(FileRef, p.string).optional(),
-            key: p.union(FileRef, p.string).optional(),
+            cert: p.union(fs.FileRef, p.string).optional(),
+            key: p.union(fs.FileRef, p.string).optional(),
         },
         static: {
             root: p.string.default("/"),
         },
     },
+    livereload: {
+        exclude: p.array(p.string).optional(),
+        host: p.string.optional(),
+        port: p.uint.port().optional(),
+    },
     modules: p.array(p.constructor(Module)).optional(),
     request: {
         body: {

package/lib/private/cookie.d.ts

@@ -1,9 +1,9 @@
 declare const Schema: import("pema").ObjectType<{
-    httpOnly: import("pema").DefaultType<import("pema/boolean").BooleanType, true>;
-    path: import("pema").DefaultType<import("pema/string").StringType, "/">;
-    sameSite: import("pema/union").UnionType<[import("pema").LiteralType<"Lax">, import("pema").LiteralType<"None">, import("pema").LiteralType<"Strict">]>;
-    secure: import("pema/boolean").BooleanType;
-    maxAge: import("pema").OptionalType<import("pema/number").NumberType<"f64">>;
+    httpOnly: import("pema").DefaultType<import("pema").BooleanType, true>;
+    path: import("pema").DefaultType<import("pema").StringType, "/">;
+    sameSite: import("pema").UnionType<[import("pema").LiteralType<"Lax">, import("pema").LiteralType<"None">, import("pema").LiteralType<"Strict">]>;
+    secure: import("pema").BooleanType;
+    maxAge: import("pema").OptionalType<import("pema").NumberType<"f64">>;
 }>;
 type Options = typeof Schema.input;
 export default function cookie(name: string, value: string, options: Options): string;

package/lib/private/cookie.js

@@ -1,19 +1,15 @@
-import is from "@rcompat/assert/is";
-import pema from "pema";
-import boolean from "pema/boolean";
-import number from "pema/number";
-import string from "pema/string";
-import union from "pema/union";
-const Schema = pema({
-    httpOnly: boolean.default(true),
-    path: string.default("/"),
-    sameSite: union("Lax", "None", "Strict"),
-    secure: boolean,
-    maxAge: number.optional(), // seconds
+import assert from "@rcompat/assert";
+import p from "pema";
+const Schema = p({
+    httpOnly: p.boolean.default(true),
+    path: p.string.default("/"),
+    sameSite: p.union("Lax", "None", "Strict"),
+    secure: p.boolean,
+    maxAge: p.number.optional(), // seconds
 });
 export default function cookie(name, value, options) {
-    is(name).string();
-    is(value).string();
+    assert.string(name);
+    assert.string(value);
     const parsed = Schema.parse(options);
     const parts = [`${name}=${value}`];
     parts.push(`Path=${parsed.path}`);

package/lib/private/db/As.d.ts

@@ -0,0 +1,10 @@
+import type Types from "#db/Types";
+import type PK from "#db/PK";
+type As = {
+    table: string;
+    pk: PK;
+    generate_pk?: boolean;
+    types: Types;
+};
+export type { As as default };
+//# sourceMappingURL=As.d.ts.map

package/lib/private/db/DB.d.ts

@@ -0,0 +1,33 @@
+import type As from "#db/As";
+import type Sort from "#db/Sort";
+import type With from "#db/With";
+import type { Dict, MaybePromise } from "@rcompat/type";
+import type { StoreSchema } from "pema";
+export default interface DB {
+    schema: {
+        create(as: As, schema: StoreSchema): MaybePromise<void>;
+        delete(name: string): MaybePromise<void>;
+    };
+    close(): MaybePromise<void>;
+    create<O extends Dict>(as: As, record: Dict): MaybePromise<O>;
+    read(as: As, args: {
+        count: true;
+        where: Dict;
+        with?: never;
+    }): MaybePromise<number>;
+    read(as: As, args: {
+        where: Dict;
+        fields?: string[];
+        limit?: number;
+        sort?: Sort;
+        with?: With;
+    }): MaybePromise<Dict[]>;
+    update(as: As, args: {
+        set: Dict;
+        where: Dict;
+    }): MaybePromise<number>;
+    delete(as: As, args: {
+        where: Dict;
+    }): MaybePromise<number>;
+}
+//# sourceMappingURL=DB.d.ts.map

package/lib/private/db/DB.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DB.js.map

package/lib/private/db/DataDict.d.ts

@@ -0,0 +1,5 @@
+import type DataValue from "#db/DataValue";
+import type { Dict } from "@rcompat/type";
+type DataDict = Dict<DataValue>;
+export type { DataDict as default };
+//# sourceMappingURL=DataDict.d.ts.map

package/lib/private/db/DataKey.d.ts

@@ -0,0 +1,4 @@
+import type { DataType } from "pema";
+type DataKey = keyof DataType;
+export type { DataKey as default };
+//# sourceMappingURL=DataKey.d.ts.map

package/lib/private/db/DataValue.d.ts

@@ -0,0 +1,17 @@
+import type DataKey from "#db/DataKey";
+import type { DataType } from "pema";
+type Scalar = DataType[DataKey] | null;
+type OperatorObject = Partial<{
+    $like: string;
+    $ilike: string;
+    $gt: number | bigint;
+    $gte: number | bigint;
+    $lt: number | bigint;
+    $lte: number | bigint;
+    $before: Date;
+    $after: Date;
+    $ne: DataType[DataKey];
+}>;
+type DataValue = Scalar | OperatorObject;
+export type { DataValue as default };
+//# sourceMappingURL=DataValue.d.ts.map