@primate/core 0.6.3 → 0.7.1

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

@@ -1,7 +1,6 @@
 import E from "#errors";
-import wrap from "#route/wrap";
 import fs from "@rcompat/fs";
-const contents = "export default {};";
+const empty = "export default {};";
 export default function plugin_server_route(app) {
     const path_routes = app.path.routes;
     return {
@@ -28,23 +27,17 @@ export default function plugin_server_route(app) {
                 if (!file || !extension) {
                     throw E.build_missing_route(relative, path_routes);
                 }
-                // normalise "routes/foo.ext" -> "foo" for router
-                const relative_from_routes = file.path.split("routes").pop();
-                const no_extensions = relative_from_routes
-                    .replace(/^[\\/]/, "")
-                    .slice(0, -extension.length);
-                const route_path = no_extensions.replace(/\\/g, "/");
                 const resolveDir = file.directory.path;
                 const watchFiles = [file.path];
                 const binder = app.binder(file);
                 if (!binder)
-                    return { contents, loader: "js", resolveDir, watchFiles };
+                    return { contents: empty, loader: "js", resolveDir, watchFiles };
                 const compiled = await binder(file, {
                     build: { id: app.id },
                     context: "routes",
                 });
                 return {
-                    contents: wrap(compiled, route_path, app.id),
+                    contents: compiled,
                     loader: extension === ".ts" ? "ts" : "js",
                     resolveDir,
                     watchFiles,

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

@@ -1,5 +1,5 @@
-import fs from "@rcompat/fs";
-const core_pkg = await fs.project.root(import.meta.dirname);
+import runtime from "@rcompat/runtime";
+const core = await runtime.projectRoot(import.meta.dirname);
 export default function plugin_server_virtual_pages(app) {
     return {
         name: "primate/server/virtual/pages",
@@ -9,7 +9,7 @@ export default function plugin_server_virtual_pages(app) {
             });
             build.onLoad({ filter: /.*/, namespace: "primate-pages" }, async () => {
                 const filter = /^.*\.html$/ui;
-                const defaults = core_pkg.join("lib", "private", "defaults");
+                const defaults = core.join("lib", "private", "defaults");
                 const pages = {};
                 for (const file of await defaults.files({ filter })) {
                     pages[file.name] = file;

package/lib/private/build/server/plugin/virtual-routes.d.ts

@@ -1,4 +1,5 @@
 import type BuildApp from "#build/App";
 import type { Plugin } from "esbuild";
-export default function plugin_server_virtual_routes(app: BuildApp): Plugin;
+declare function plugin_server_virtual_routes(app: BuildApp): Plugin;
+export default plugin_server_virtual_routes;
 //# sourceMappingURL=virtual-routes.d.ts.map

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

@@ -1,8 +1,15 @@
-export default function plugin_server_virtual_routes(app) {
+function is_hook_file(p) {
+    const basename = p.split("/").at(-1) ?? p;
+    return basename === "+hook" || basename.startsWith("+hook.");
+}
+function plugin_server_virtual_routes(app) {
     const extension_pattern = new RegExp(`(${app.extensions.map(e => e.replace(".", "\\.")).join("|")})$`);
-    const is_route_file = (f) => !f.name.endsWith("~") &&
-        !f.name.startsWith(".") &&
-        extension_pattern.test(f.path);
+    function is_route_file(f) {
+        return !f.name.endsWith("~") &&
+            !f.name.startsWith(".") &&
+            !f.name.startsWith("-") &&
+            extension_pattern.test(f.path);
+    }
     return {
         name: "primate/server/virtual/routes",
         setup(build) {
@@ -16,13 +23,24 @@ export default function plugin_server_virtual_routes(app) {
                     recursive: true,
                 });
                 const contents = `
-          const route = [];
+          import router from "primate/router";
+          ${route_files.map((file, i) => {
+                    const path = app.basename(file, app.path.routes);
+                    return `import route${i} from "app:route/${path}";`;
+                }).join("\n")}
+          const routes = [];
           ${route_files.map((file, i) => {
                     const path = app.basename(file, app.path.routes);
-                    return `const route${i} = (await import("app:route/${path}")).default;
-            route.push(["${path}", route${i}]);`;
+                    return is_hook_file(path)
+                        ? `router.addHook("${path}", route${i});
+               routes.push(["${path}", route${i}]);
+            `
+                        : `for (const [method, { handler, options }] of Object.entries(route${i})) {
+                   router.add("${path}", method, handler, options);
+                 }
+                 routes.push(["${path}", route${i}]);`;
                 }).join("\n")}
-          export default route;
+          export default routes;
         `;
                 const watchDirs = (await app.path.routes.dirs({
                     recursive: true,
@@ -38,4 +56,5 @@ export default function plugin_server_virtual_routes(app) {
         },
     };
 }
+export default plugin_server_virtual_routes;
 //# sourceMappingURL=virtual-routes.js.map

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

@@ -20,13 +20,14 @@ export default function plugin_server_wasm(app) {
             });
             build.onLoad({ filter: /.*/, namespace: "wasm-dev" }, async (args) => {
                 const wasm_file = app.runpath("wasm", args.path + ".wasm");
+                const fs_path = import.meta.resolve("@rcompat/fs");
                 return {
                     contents: `
-            import fs from "@rcompat/fs";
+            const { default: fs } = await import("${fs_path}");
             export default await fs.ref("${wasm_file.path}").bytes();
           `,
                     loader: "js",
-                    resolveDir: app.root.path,
+                    resolveDir: new URL(".", import.meta.url).pathname,
                 };
             });
         },

package/lib/private/build/shared/intercept.d.ts

@@ -0,0 +1,4 @@
+import type { FileRef } from "@rcompat/fs";
+import type { OnResolveArgs } from "esbuild";
+export default function intercept(args: OnResolveArgs, views: FileRef): boolean;
+//# sourceMappingURL=intercept.d.ts.map

package/lib/private/build/shared/intercept.js

@@ -0,0 +1,29 @@
+import runtime from "@rcompat/runtime";
+function is_bare(path) {
+    return /^[a-z]/.test(path);
+}
+function is_npm_package(path, resolve_dir) {
+    if (!path.startsWith("@"))
+        return false;
+    const parts = path.split("/");
+    if (parts.length < 2)
+        return false;
+    const pkg = parts[0] + "/" + parts[1];
+    try {
+        runtime.resolve(pkg, resolve_dir);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export default function intercept(args, views) {
+    if (!args.resolveDir.startsWith(views.path))
+        return true;
+    if (is_bare(args.path))
+        return true;
+    if (is_npm_package(args.path, args.resolveDir))
+        return true;
+    return false;
+}
+//# sourceMappingURL=intercept.js.map

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

@@ -4,7 +4,7 @@ import type { Dict } from "@rcompat/type";
 type ClientData<T extends Dict = Dict> = {
     view: string;
     request: RequestView;
-    spa: boolean;
+    csr: boolean;
     ssr: boolean;
     mode: Mode;
 } & T;

package/lib/private/client/boot.js

@@ -2,7 +2,7 @@ import navigate from "#client/navigate";
 import root from "#client/root";
 import storage from "#client/storage";
 import submit from "#client/submit";
-import { MIME } from "@rcompat/http";
+import http from "@rcompat/http";
 export default (u) => {
     root.set(u);
     const { location, history } = globalThis;
@@ -50,7 +50,7 @@ export default (u) => {
         const action = target.action ?? location.pathname;
         const url = new URL(action);
         const data = new FormData(target);
-        const form = enctype === MIME.MULTIPART_FORM_DATA
+        const form = enctype === http.MIME.MULTIPART_FORM_DATA
             ? data
             : new URLSearchParams(data);
         try {

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

@@ -1,6 +1,6 @@
 import type { Dict } from "@rcompat/type";
 type FormId = string;
-type FieldErrors = readonly string[];
+type FieldErrors = string[];
 type FormErrors = {
     form: FieldErrors;
     fields: Dict<FieldErrors>;
@@ -15,11 +15,21 @@ export type FormView = FormSnapshot & {
     submit: (event?: Event) => Promise<void>;
 };
 type FormSubscriber = (snapshot: FormSnapshot) => void;
+export type MethodMeta = {
+    contentType?: string;
+};
+export type ClientMethod<Values extends Dict = Dict> = MethodMeta & ((args: {
+    body: Values;
+}) => Promise<Response>);
 export type FormInit = {
     id?: string;
     method?: "POST" | "PUT" | "PATCH" | "DELETE";
     url?: string;
     headers?: Dict<string>;
+    action?: (args: {
+        body: unknown;
+    }) => Promise<Response>;
+    contentType?: string;
 };
 type FormController = {
     subscribe(fn: FormSubscriber): () => void;

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

@@ -1,5 +1,6 @@
 import extract_issues from "#client/extract-issues";
 import submit from "#client/submit";
+import is from "@rcompat/is";
 function decode_pointer_segment(segment) {
     // decode JSON Pointer: ~1 -> /, ~0 -> ~
     return segment.replace(/~1/g, "/").replace(/~0/g, "~");
@@ -21,6 +22,21 @@ function pointer_to_fieldname(path) {
     }
     return name;
 }
+function content_type_body(contentType, form_data) {
+    if (contentType === "application/json")
+        return Object.fromEntries(form_data);
+    if (contentType === "multipart/form-data")
+        return form_data;
+    // default: application/x-www-form-urlencoded
+    return new URLSearchParams(form_data);
+}
+function form_data_body(form_data) {
+    for (const value of form_data.values()) {
+        if (value instanceof File && value.size > 0)
+            return form_data;
+    }
+    return new URLSearchParams(form_data);
+}
 export default function createForm(init) {
     const id = init.id ?? `form-${crypto.randomUUID()}`;
     let snapshot = {
@@ -83,7 +99,9 @@ export default function createForm(init) {
         const form_data = new FormData(form_element);
         setSubmitting(true);
         try {
-            const response = await submit(url, form_data, method);
+            const response = await (is.defined(init.action)
+                ? init.action({ body: content_type_body(init.contentType, form_data) })
+                : submit(url, form_data_body(form_data), method));
             if (response.ok) {
                 // on success: clear errors, let the app decide what to do next
                 // (redirect/reload)
@@ -91,8 +109,8 @@ export default function createForm(init) {
                 publish();
                 return;
             }
-            const payload = await response.json();
-            const issues = extract_issues(payload); // all issues, all paths
+            // all issues, all paths
+            const issues = extract_issues(await response.json());
             setErrors(issues);
         }
         catch (error) {

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

@@ -1,4 +1,4 @@
-import type { FormInit, FormView } from "#client/create-form";
+import type { ClientMethod, FormInit, FormView, MethodMeta } from "#client/create-form";
 import createForm from "#client/create-form";
 import type Data from "#client/Data";
 import type Publish from "#client/Publish";
@@ -19,5 +19,5 @@ declare const client: {
     toValidated: typeof toValidated;
 };
 export default client;
-export type { Data, FormInit, FormView, Publish, Render, ValidateInit, ValidateUpdater, ValidationError, ViewResponse, };
+export type { ClientMethod, Data, FormInit, FormView, MethodMeta, Publish, Render, ValidateInit, ValidateUpdater, ValidationError, ViewResponse };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,6 +1,7 @@
 type Location = {
     hash: string;
     pathname: string;
+    search: string;
 };
 declare function goto(target: Location, state?: boolean, after?: () => void): Promise<void>;
 declare function go(href: string, event?: Event): Promise<void>;

package/lib/private/client/navigate.js

@@ -1,9 +1,9 @@
-import http from "#client/http";
 import root from "#client/root";
 import storage from "#client/storage";
-import { MIME } from "@rcompat/http";
+import transport from "#client/transport";
+import http from "@rcompat/http";
 const headers = {
-    Accept: MIME.APPLICATION_JSON,
+    Accept: http.MIME.APPLICATION_JSON,
 };
 const get_by_id_or_name = (name) => document.getElementById(name) ?? document.getElementsByName(name)[0];
 const scroll_hash = (hash) => {
@@ -18,13 +18,14 @@ async function goto(target, state = false, after) {
     try {
         const { scrollTop } = globalThis.document.scrollingElement;
         const { location } = globalThis;
-        const { requested, response } = await http.refetch(target.pathname, { headers });
-        if (http.is_json(response)) {
+        const path = target.pathname + target.search;
+        const { requested, response } = await transport.refetch(path, { headers });
+        if (transport.is_json(response)) {
             if (response.ok)
                 root.update(await response.json());
             if (state) {
                 storage.new({ hash: location.hash, pathname: location.pathname, scrollTop });
-                history.pushState({}, "", `${target.pathname}${target.hash}`);
+                history.pushState({}, "", `${path}${target.hash}`);
             }
             after?.();
             return;

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

@@ -1,2 +1,3 @@
-export default function submit(pathname: string, body: any, method: string): Promise<Response>;
+declare function submit(pathname: string, body: any, method: string): Promise<Response>;
+export default submit;
 //# sourceMappingURL=submit.d.ts.map

package/lib/private/client/submit.js

@@ -1,18 +1,18 @@
-import http from "#client/http";
 import root from "#client/root";
 import storage from "#client/storage";
-import { MIME } from "@rcompat/http";
+import transport from "#client/transport";
+import http from "@rcompat/http";
 const headers = {
-    Accept: MIME.APPLICATION_JSON,
+    Accept: http.MIME.APPLICATION_JSON,
 };
-export default async function submit(pathname, body, method) {
-    const { requested, response } = await http.refetch(pathname, {
+async function submit(pathname, body, method) {
+    const { requested, response } = await transport.refetch(pathname, {
         body, headers, method,
     });
     if (response.redirected) {
         const { location, document, history } = globalThis;
         const scrollTop = document.scrollingElement?.scrollTop ?? 0;
-        if (http.is_json(response))
+        if (transport.is_json(response))
             root.update(await response.json());
         storage.new({
             hash: location.hash,
@@ -23,7 +23,7 @@ export default async function submit(pathname, body, method) {
         history.pushState({}, "", url.pathname + url.search);
         return response;
     }
-    if (http.is_json(response)) {
+    if (transport.is_json(response)) {
         if (response.ok) {
             root.update(await response.json());
             history.replaceState({}, "", requested.pathname + requested.search);
@@ -38,4 +38,5 @@ export default async function submit(pathname, body, method) {
     globalThis.location.assign(target);
     return response;
 }
+export default submit;
 //# sourceMappingURL=submit.js.map

package/lib/private/client/{http.d.ts → transport.d.ts}

@@ -4,10 +4,10 @@ declare function refetch(input: string | URL, init?: RequestInit, max_hops?: num
 }>;
 declare function is_json(response: Response): boolean;
 declare function submit(pathname: string, body: any, method: string): Promise<Response>;
-declare const http: {
+declare const transport: {
     refetch: typeof refetch;
     is_json: typeof is_json;
     submit: typeof submit;
 };
-export default http;
-//# sourceMappingURL=http.d.ts.map
+export default transport;
+//# sourceMappingURL=transport.d.ts.map

package/lib/private/client/{http.js → transport.js}

@@ -1,4 +1,4 @@
-import { MIME } from "@rcompat/http";
+import http from "@rcompat/http";
 const sameorigin = (url) => url.origin === globalThis.location.origin;
 const get_location = (response, base) => {
     if (response.type === "opaqueredirect")
@@ -7,6 +7,8 @@ const get_location = (response, base) => {
     return location !== null ? new URL(location, base) : null;
 };
 async function refetch(input, init = {}, max_hops = 5) {
+    console.log("location.href", globalThis.location.href);
+    console.log("input", input.toString());
     let url = new URL(input.toString(), globalThis.location.href);
     const method = (init.method ?? "GET").toUpperCase();
     let hops = 0;
@@ -36,7 +38,7 @@ async function refetch(input, init = {}, max_hops = 5) {
 }
 function is_json(response) {
     const raw = response.headers.get("content-type") ?? "";
-    return raw.split(";")[0].trim() === MIME.APPLICATION_JSON;
+    return raw.split(";")[0].trim() === http.MIME.APPLICATION_JSON;
 }
 async function submit(pathname, body, method) {
     const { requested, response } = await refetch(pathname, { body, method });
@@ -48,10 +50,6 @@ async function submit(pathname, body, method) {
     }
     return response;
 }
-const http = {
-    refetch,
-    is_json,
-    submit,
-};
-export default http;
-//# sourceMappingURL=http.js.map
+const transport = { refetch, is_json, submit };
+export default transport;
+//# sourceMappingURL=transport.js.map

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

@@ -3,6 +3,7 @@ import type Module from "#Module";
 import type { Dict } from "@rcompat/type";
 import type { ObjectType, Parsed } from "pema";
 declare const _default: ObjectType<import("pema").NormalizeSchemaObject<{
+    readonly conditions: import("pema").DefaultType<import("pema").ArrayType<import("pema").StringType>, string[]>;
     readonly http: {
         readonly csp: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").ArrayType<import("pema").StringType>>>;
         readonly headers: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").StringType>>;
@@ -24,10 +25,10 @@ declare const _default: ObjectType<import("pema").NormalizeSchemaObject<{
     readonly db: {
         readonly migrations: import("pema").OptionalType<ObjectType<{
             table: import("pema").StringType;
-            db: import("pema").PureType<DB, "PureType">;
+            db: import("pema").PureType<DB<unknown>, "PureType">;
         }, {
             table: string;
-            db: DB;
+            db: DB<unknown>;
         }>>;
     };
     readonly env: {
@@ -39,12 +40,8 @@ declare const _default: ObjectType<import("pema").NormalizeSchemaObject<{
         name: import("pema").StringType;
         setup: import("pema").FunctionType;
     }, Module>>, Module[]>;
-    readonly request: {
-        readonly body: {
-            readonly parse: import("pema").DefaultType<import("pema").BooleanType, true>;
-        };
-    };
 }>, {
+    conditions: string[];
     http: {
         csp: Record<string, string[]> | undefined;
         headers: Record<string, string> | undefined;
@@ -66,7 +63,7 @@ declare const _default: ObjectType<import("pema").NormalizeSchemaObject<{
     db: {
         migrations: {
             table: string;
-            db: DB;
+            db: DB<unknown>;
         } | undefined;
     };
     env: {
@@ -75,11 +72,6 @@ declare const _default: ObjectType<import("pema").NormalizeSchemaObject<{
         }> | undefined;
     };
     modules: Module[];
-    request: {
-        body: {
-            parse: boolean;
-        };
-    };
 }>;
 export default _default;
 //# sourceMappingURL=schema.d.ts.map

package/lib/private/config/schema.js

@@ -1,6 +1,7 @@
 import fs from "@rcompat/fs";
 import p from "pema";
 export default p({
+    conditions: p.array(p.string).unique().default([]),
     http: {
         csp: p.dict(p.array(p.string)).optional(),
         headers: p.dict().optional(),
@@ -34,10 +35,5 @@ export default p({
     }).shape())
         .uniqueBy(member => member.name)
         .default([]),
-    request: {
-        body: {
-            parse: p.boolean.default(true),
-        },
-    },
 });
 //# sourceMappingURL=schema.js.map

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

@@ -21,9 +21,10 @@ export type Schema = {
     introspect(name: string, pk?: PK): MaybePromise<MaybeTable>;
     alter(name: string, diff: SchemaDiff): MaybePromise<void>;
 };
-export default interface DB {
+export default interface DB<Client = unknown> {
     schema: Schema;
     close(): MaybePromise<void>;
+    readonly client: Client;
     create<O extends Dict>(as: As, record: Dict): MaybePromise<O>;
     read(as: As, args: {
         count: true;
@@ -34,6 +35,7 @@ export default interface DB {
         where: Dict;
         fields?: string[];
         limit?: number;
+        offset?: number;
         sort?: Sort;
         with?: With;
     }): MaybePromise<Dict[]>;

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

@@ -4,9 +4,11 @@ import type { Schema } from "#db/DB";
 import type DataDict from "#db/DataDict";
 import type Sort from "#db/Sort";
 import type With from "#db/With";
-import type { Dict, MaybePromise } from "@rcompat/type";
-export default class MemoryDB implements DB {
+import type { Dict, MaybePromise, PartialDict } from "@rcompat/type";
+type Tables = PartialDict<Dict[]>;
+export default class MemoryDB implements DB<Tables> {
     #private;
+    get client(): Tables;
     get schema(): Schema;
     close(): void;
     create<O extends Dict>(as: As, record: Dict): MaybePromise<O>;
@@ -30,4 +32,5 @@ export default class MemoryDB implements DB {
         where: DataDict;
     }): number;
 }
+export {};
 //# sourceMappingURL=MemoryDB.d.ts.map