@primate/core 0.2.3 → 0.3.0

package/lib/private/frontend/Module.js

@@ -1,4 +1,4 @@
-import AppError from "#AppError";
+import fail from "#fail";
 import bundle from "#frontend/bundle-server";
 import inline from "#inline";
 import location from "#location";
@@ -13,12 +13,13 @@ import pema from "pema";
 import array from "pema/array";
 import boolean from "pema/boolean";
 import string from "pema/string";
+const contexts = ["views", "components"];
 async function normalize(path) {
     return `p_${await hash(path)}`;
 }
 export default class FrontendModule extends Module {
     #options;
-    render = async (component, props) => ({ body: await component(props) });
+    render = async (view, props) => ({ body: await view(props) });
     root;
     compile = {};
     css;
@@ -49,39 +50,41 @@ export default class FrontendModule extends Module {
         return this.#options.spa;
     }
     #load(name, props, app) {
-        const component = app.component(name);
-        return { component, name, props };
+        const view = app.loadView(name);
+        return { view, name, props };
     }
     ;
     async #render(server, client, app) {
         const { body, head = "", headers = {} } = this.ssr
-            ? await this.render(server.component, server.props)
+            ? await this.render(server.view, server.props)
             : { body: "", head: "" };
         if (!this.client) {
             return { body, head, headers };
         }
-        const code = "import app from \"app\"; app.start();";
-        const inlined = await inline(code, "module");
+        const app_asset = app.assets.find(asset => asset.src?.includes("app") && asset.src.endsWith(".js"));
+        if (!app_asset)
+            throw fail("Could not find app.js in assets");
+        const app_script = `<script type="module" src="${app_asset.src}" integrity="${app_asset.integrity}"></script>`;
         const json_props = JSON.stringify({ frontend: this.name, ...client });
         const hydrated = await inline(json_props, APPLICATION_JSON, "hydration");
-        const script_src = [inlined.integrity, hydrated.integrity];
+        const script_src = [hydrated.integrity, `'${app_asset.integrity}'`];
         return {
             body,
-            head: head.concat(inlined.head, hydrated.head),
+            head: head.concat(app_script, hydrated.head),
             headers: app.headers({ "script-src": script_src }),
         };
     }
     normalize(name) {
         return normalize(name);
     }
-    respond = (component, props = {}, options = {}) => async (app, { as_layout, layouts = [] } = {}, request) => {
+    respond = (view, props = {}, options = {}) => async (app, { as_layout, layouts = [] } = {}, request) => {
         if (as_layout) {
-            return this.#load(component, props, app);
+            return this.#load(view, props, app);
         }
-        const components = (await Promise.all(layouts
+        const views = (await Promise.all(layouts
             .map(layout => layout(app, { as_layout: true }, request))))
-            /* set the actual page as the last component */
-            .concat(this.#load(component, props, app));
+            /* set the actual page as the last view */
+            .concat(this.#load(view, props, app));
         const $request = {
             context: request.context,
             cookies: request.cookies.toJSON(),
@@ -92,35 +95,41 @@ export default class FrontendModule extends Module {
         };
         const $props = this.layouts
             ? {
-                components: await map(components, ({ name }) => normalize(name)),
-                props: components.map(c => c.props),
+                views: await map(views, ({ name }) => normalize(name)),
+                props: views.map(c => c.props),
                 request: $request,
             }
             : { props, request: $request };
         const client = {
-            component: this.layouts ? "root" : await normalize(component),
+            view: this.layouts ? "root" : await normalize(view),
             spa: this.spa,
             ssr: this.ssr,
             ...$props,
         };
         if (this.spa && request.headers.get("Accept") === APPLICATION_JSON) {
-            return new Response(JSON.stringify(client), {
-                headers: { ...app.headers(), "Content-Type": APPLICATION_JSON },
+            const json_body = JSON.stringify(client);
+            return new Response(json_body, {
+                headers: {
+                    ...app.headers(),
+                    "Content-Type": APPLICATION_JSON,
+                    "Content-Length": String(app.body_length(json_body)),
+                    "Cache-Control": "no-store",
+                },
                 status: options.status ?? Status.OK,
             });
         }
         try {
             const server = this.layouts
                 ? {
-                    component: app.component(`${this.rootname}.js`),
+                    view: app.loadView(`${this.rootname}.js`),
                     props: {
-                        components: components.map(c => c.component),
-                        props: components.map(c => c.props),
+                        views: views.map(c => c.view),
+                        props: views.map(c => c.props),
                         request: $request,
                     },
                 }
                 : {
-                    component: app.component(component),
+                    view: app.loadView(view),
                     props,
                     request: $request,
                 };
@@ -128,8 +137,8 @@ export default class FrontendModule extends Module {
             return app.view({ body, head, headers, ...options });
         }
         catch (error) {
-            const path = `${location.components}/${component}`;
-            throw new AppError("error in component {0}\n{1}", path, error);
+            const path = `${location.views}/${view}`;
+            throw fail("error in view{0}\n{1}", path, error);
         }
     };
     serve(app, next) {
@@ -167,19 +176,19 @@ export default class FrontendModule extends Module {
                                 : null;
                         });
                     }
-                    const components_filter = new RegExp(`^${name}:components`);
-                    build.onResolve({ filter: components_filter }, ({ path }) => {
+                    const views_filter = new RegExp(`^${name}:views`);
+                    const views_base = app.root.join(location.views);
+                    build.onResolve({ filter: views_filter }, ({ path }) => {
                         return { namespace: `${name}`, path };
                     });
-                    build.onLoad({ filter: components_filter }, async () => {
-                        const components = await app.root
-                            .join(location.components)
+                    build.onLoad({ filter: views_filter }, async () => {
+                        const views = await views_base
                             .collect(c => fileExtensions.includes(c.fullExtension));
                         let contents = "";
-                        for (const component of components) {
-                            const { path } = component.debase(component.directory, "/");
+                        for (const view of views) {
+                            const { path } = view.debase(views_base, "/");
                             contents += `export { default as ${await normalize(path)} }
-                from "#component/${path}";\n`;
+                from "#view/${path}";\n`;
                         }
                         return { contents, resolveDir: app.root.path };
                     });
@@ -206,20 +215,19 @@ export default class FrontendModule extends Module {
     init(app, next) {
         this.fileExtensions.forEach(e => {
             app.bind(e, async (file, { context }) => {
-                assert(context === "components", `${this.name}: only components supported`);
+                assert(contexts.includes(context), `${this.name}: only components supported`);
                 if (this.compile.server) {
-                    const original = file.debase(app.runpath("stage", "components"));
-                    const source = app.path.components.join(original);
-                    const code = await this.compile.server(await source.text());
+                    const code = await this.compile.server(await file.text());
                     const bundled = await bundle({
                         code,
-                        source,
+                        source: file,
                         root: app.root,
                         extensions: this.fileExtensions,
                         compile: async (s) => this.compile.server(s),
                     });
-                    await file.append(".js").write(bundled);
+                    return bundled;
                 }
+                return await file.text();
             });
         });
         return next(app);

package/lib/private/frontend/Render.d.ts

@@ -1,6 +1,6 @@
 import type Dict from "@rcompat/type/Dict";
 import type MaybePromise from "@rcompat/type/MaybePromise";
-type Render<S = unknown> = (component: S, props: Dict) => MaybePromise<{
+type Render<V = unknown> = (view: V, props: Dict) => MaybePromise<{
     body: string;
     head?: string;
     headers?: Record<string, string>;

package/lib/private/frontend/ServerData.d.ts

@@ -1,6 +1,6 @@
 import type Dict from "@rcompat/type/Dict";
-type ServerData<T> = {
-    component: T;
+type ServerData<V> = {
+    view: V;
     props: Dict;
 };
 export type { ServerData as default };

package/lib/private/frontend/ServerView.d.ts

@@ -0,0 +1,5 @@
+import type Dict from "@rcompat/type/Dict";
+import type MaybePromise from "@rcompat/type/MaybePromise";
+type ServerView = (props: Dict) => MaybePromise<string>;
+export { ServerView as default };
+//# sourceMappingURL=ServerView.d.ts.map

package/lib/private/frontend/ServerView.js

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

package/lib/private/frontend/View.d.ts

@@ -0,0 +1,8 @@
+import type Dict from "@rcompat/type/Dict";
+type View = {
+    view: unknown;
+    name: string;
+    props: Dict;
+};
+export type { View as default };
+//# sourceMappingURL=View.d.ts.map

package/lib/private/frontend/View.js

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

package/lib/private/frontend/bundle-server.js

@@ -13,12 +13,12 @@ export default async function bundleServer(init) {
                 const contents = await compile(src, file);
                 return { contents, loader: "js", resolveDir: file.directory.path };
             });
-            // externalise anything not relative nor "#component/"
+            // externalise anything not relative nor "#view/"
             build.onResolve({ filter: /.*/ }, args => {
                 const p = args.path;
                 const relative = p.startsWith("./") || p.startsWith("../");
-                const components = p.startsWith("#component/");
-                if (!relative && !components)
+                const views = p.startsWith("#view/");
+                if (!relative && !views)
                     return { path: p, external: true };
                 return null;
             });

package/lib/private/hook/build.js

@@ -1,8 +1,9 @@
-import AppError from "#AppError";
+import fail from "#fail";
 import location from "#location";
 import log from "#log";
 import reducer from "#reducer";
 import $router from "#request/router";
+import wrap from "#route/wrap";
 import s_layout_depth from "#symbol/layout-depth";
 import FileRef from "@rcompat/fs/FileRef";
 import json from "@rcompat/package/json";
@@ -12,10 +13,10 @@ const pre = async (app) => {
     // remove build directory in case exists
     await app.path.build.remove();
     await app.path.build.create();
-    await Promise.all(["server", "client", "components"]
+    await Promise.all(["server", "client", "views"]
         .map(directory => app.runpath(directory).create()));
     // this has to occur before post, so that layout depth is available for
-    // compiling root components
+    // compiling root views
     // bindings should have been registered during `init`
     const router = await $router(app.path.routes, app.extensions);
     app.set(s_layout_depth, router.depth("layout"));
@@ -27,33 +28,36 @@ const pre = async (app) => {
     app.i18n_active = has_i18n_config;
     return app;
 };
-async function indexDatabase(base) {
-    const export_from = "export { default } from";
-    const default_database = `${export_from} "#stage/config/database/index.js";`;
-    // app/config/database does not exist
+async function index_database(base) {
+    // app/config/database does not exist -> use prelayered default
     if (!await base.exists())
-        return default_database;
+        return "";
     const databases = await base.list();
     const n = databases.length;
-    // none in app/config/database -> fallback
+    // none in app/config/database -> use prelayered default
     if (n === 0)
-        return default_database;
-    // index database file found, will be overwritten in next step
-    if (databases.some(d => d.base === "index"))
         return "";
     const names = databases.map(d => d.name);
-    // app/config/database/default.ts -> use
-    const ts = names.includes("default.ts");
-    if (ts)
-        return `${export_from} "#stage/config/database/default.ts";`;
-    // app/config/database/default.js -> use
-    const js = names.includes("default.js");
-    if (js)
-        return `${export_from} "#stage/config/database/default.js";`;
-    // one in app/config/database -> default
-    if (n === 1)
-        return `${export_from} "#stage/config/database/${names[0]}";`;
-    throw new AppError("Multiple database drivers; add index or default.(ts|js). Found: {0}", names.join(", "));
+    // index database file found, will be overwritten in next step -> do nothing
+    if (names.includes("index.ts") || names.includes("index.js")) {
+        return ""; // empty string means: don't generate, user provided own
+    }
+    // app/config/default.ts -> reexport
+    if (names.includes("default.ts")) {
+        return "export { default } from \"./default.js\";";
+    }
+    // app/config/default.js -> reexport
+    if (names.includes("default.js")) {
+        return "export { default } from \"./default.js\";";
+    }
+    // exactly one in app/config/database -> reexport that
+    if (n === 1) {
+        const onlyFile = names[0];
+        const withoutExt = onlyFile.replace(/\.(ts|js)$/, ".js");
+        return `export { default } from "./${withoutExt}";`;
+    }
+    // multiple files, none is index or default -> error
+    throw fail("multiple database drivers, add index or default.(ts|js); found {0}", names.join(", "));
 }
 const js_re = /^.*.js$/;
 const write_directories = async (build_directory, app) => {
@@ -81,22 +85,22 @@ store.push(["${FileRef.webpath(bare)}", store${i}]);`).join("\n")}
 export default store;`;
     await build_directory.join("stores.js").write(stores_js);
 };
-const write_components = async (build_directory, app) => {
-    const d2 = app.runpath(location.components);
+const write_views = async (build_directory, app) => {
+    const d2 = app.runpath(location.views);
     const e = await Promise.all((await FileRef.collect(d2, file => js_re.test(file.path)))
         .map(async (path) => `${path}`.replace(d2.toString(), _ => "")));
-    const components_js = `
-const component = [];
-${e.map(path => path.slice(1, -".js".length)).map((bare, i) => `import * as component${i} from "${FileRef.webpath(`#component/${bare}`)}";
-component.push(["${FileRef.webpath(bare)}", component${i}]);`).join("\n")}
+    const views_js = `
+const view = [];
+${e.map(path => path.slice(1, -".js".length)).map((bare, i) => `import * as view${i} from "${FileRef.webpath(`#view/${bare}`)}";
+view.push(["${FileRef.webpath(bare)}", view${i}]);`).join("\n")}
 
 ${app.roots.map((root, i) => `
 import * as root${i} from "${FileRef.webpath(`../server/${root.name}`)}";
-component.push(["${root.name.slice(0, -".js".length)}", root${i}]);
+view.push(["${root.name.slice(0, -".js".length)}", root${i}]);
 `).join("\n")}
 
-export default component;`;
-    await build_directory.join("components.js").write(components_js);
+export default view;`;
+    await build_directory.join("views.js").write(views_js);
 };
 const write_bootstrap = async (app, mode, i18n_active) => {
     const build_start_script = `
@@ -104,7 +108,7 @@ import serve from "primate/serve";
 const files = {};
 ${app.server_build.map(name => `${name}s`).map(name => `import ${name} from "./${app.id}/${name}.js";
      files.${name} = ${name};`).join("\n")}
-import components from "./${app.id}/components.js";
+import views from "./${app.id}/views.js";
 import stores from "./${app.id}/stores.js";
 import target from "./target.js";
 import session from "#session";
@@ -122,7 +126,7 @@ const app = await serve(import.meta.url, {
   ...target,
   config,
   files,
-  components,
+  views,
   stores,
   mode: "${mode}",
   session_config: session[s_config],
@@ -135,35 +139,50 @@ export default app;
 };
 const post = async (app) => {
     const defaults = FileRef.join(import.meta.url, "../../defaults");
-    await app.stage(app.path.routes, "routes", file => dedent `
-    export * from "#stage/route${file}";
-  `);
-    await app.stage(app.path.stores, "stores", file => dedent `
-    import database from "#database";
-    import store from "#stage/store${file}";
-    import wrap from "primate/database/wrap";
-
-    export default await wrap("${file.base}", store, database);
-  `);
+    await app.compile(app.path.routes, "routes", {
+        loader: (source, file) => {
+            const path = app.basename(file, app.path.routes);
+            return wrap(source, path, app.id);
+        },
+    });
+    await app.compile(app.path.stores, "stores", {
+        resolver: basename => `${basename}.original`, // First pass: save original
+    });
+    if (await app.path.stores.exists()) {
+        const stores = await app.path.stores.collect(({ path }) => app.extensions.some(e => path.endsWith(e)));
+        for (const file of stores) {
+            const basename = app.basename(file, app.path.stores);
+            const wrapper = dedent `
+        import database from "#database";
+        import store from "./${basename}.original.js";
+        import wrap from "primate/database/wrap";
+        export default wrap("${basename}", store, database);
+      `;
+            const target = app.runpath("stores", `${basename}.js`);
+            await target.write(wrapper);
+        }
+    }
     const configs = FileRef.join(dirname, "../../private/config/config");
     const database_base = app.path.config.join("database");
-    await app.stage(configs, "config", async (file) => {
-        if (file.path === "/database/index.js")
-            return indexDatabase(database_base);
-        return `export { default } from "#stage/config${file}";`;
+    // prelayer config default
+    await app.compile(configs, "config", {
+        loader: async (source, file) => {
+            const relative = file.debase(configs);
+            if (relative.path === "/database/index.js") {
+                const indexContent = await index_database(database_base);
+                // if empty, user provided own index -> use the compiled source
+                return indexContent || source;
+            }
+            return source;
+        },
     });
-    await app.stage(app.path.modules, "modules", file => `export { default } from "#stage/module${file}";`);
-    // stage locales
-    await app.stage(app.path.locales, "locales", file => `export { default } from "#stage/locale${file}";`);
-    // stage app config after locales so #locale imports can be resolved
-    await app.stage(app.path.config, "config", file => `export { default } from "#stage/config${file}";`);
-    // stage components
-    await app.stage(app.path.components, "components", file => `
-    import * as component from "#stage/component${file}";
-
-    export * from "#stage/component${file}";
-    export default component?.default;
-  `);
+    await app.compile(app.path.modules, "modules");
+    await app.compile(app.path.locales, "locales");
+    await app.compile(app.path.config, "config");
+    // reusable components
+    await app.compile(app.path.components, "components");
+    // view components
+    await app.compile(app.path.views, "views");
     // copy framework pages
     await defaults.copy(app.runpath(location.server, location.pages));
     // copy pages to build
@@ -180,7 +199,7 @@ const post = async (app) => {
         const src = file.debase(app.path.static);
         app.build.export(`import "./${location.static}${src}";`);
     }));
-    app.build.export("export { default } from \"primate/client/app\";");
+    app.build.export("import \"primate/client/app\";");
     app.build.plugin({
         name: "@primate/core/frontend",
         setup(build) {
@@ -209,7 +228,7 @@ const post = async (app) => {
     const build_directory = app.path.build.join(app.id);
     // TODO: remove after rcompat automatically creates directories
     await build_directory.create();
-    await write_components(build_directory, app);
+    await write_views(build_directory, app);
     await write_stores(build_directory, app);
     await write_directories(build_directory, app);
     await write_bootstrap(app, app.mode, app.i18n_active);
@@ -223,16 +242,11 @@ const post = async (app) => {
             "#database/*": "./config/database/*.js",
             "#session": "./config/session.js",
             "#i18n": "./config/i18n.js",
+            "#view/*": "./views/*.js",
             "#component/*": "./components/*.js",
             "#locale/*": "./locales/*.js",
             "#module/*": "./modules/*.js",
             "#route/*": "./routes/*.js",
-            "#stage/component/*": "./stage/components/*.js",
-            "#stage/locale/*": "./stage/locales/*.js",
-            "#stage/config/*": "./stage/config/*.js",
-            "#stage/module/*": "./stage/modules/*.js",
-            "#stage/route/*": "./stage/routes/*.js",
-            "#stage/store/*": "./stage/stores/*.js",
             "#store/*": "./stores/*.js",
         },
     };

package/lib/private/i18n/Module.js

@@ -66,17 +66,30 @@ export default class I18NModule extends Module {
             return next(request);
         // only cookie-persistance is server-supported
         if (this.#persist !== "cookie")
-            return new Response(null, { status: Status.NO_CONTENT });
+            return new Response(null, {
+                headers: {
+                    "Content-Length": String(0),
+                },
+                status: Status.NO_CONTENT
+            });
         // only accept configured locales
         if (!this.#configured(requested))
-            return new Response(null, { status: Status.NO_CONTENT });
+            return new Response(null, {
+                headers: {
+                    "Content-Length": String(0),
+                },
+                status: Status.NO_CONTENT
+            });
         const header = cookie(COOKIE_NAME, requested, {
             secure: this.#secure,
             path: "/",
             sameSite: "Strict",
         });
         return new Response(null, {
-            headers: { "set-cookie": header },
+            headers: {
+                "Set-Cookie": header,
+                "Content-Length": String(0),
+            },
             status: Status.NO_CONTENT,
         });
     }

package/lib/private/location.d.ts

@@ -2,6 +2,7 @@ declare const _default: {
     readonly app_html: "app.html";
     readonly build: "build";
     readonly client: "client";
+    readonly lib: "lib";
     readonly components: "components";
     readonly config: "config";
     readonly error_html: "error.html";
@@ -12,6 +13,8 @@ declare const _default: {
     readonly static: "static";
     readonly stores: "stores";
     readonly locales: "locales";
+    readonly views: "views";
+    readonly hooks: "hooks";
 };
 export default _default;
 //# sourceMappingURL=location.d.ts.map

package/lib/private/location.js

@@ -5,6 +5,8 @@ export default {
     build: "build",
     // client build
     client: "client",
+    // component library
+    lib: "lib",
     // renderable components
     components: "components",
     // config
@@ -25,5 +27,9 @@ export default {
     stores: "stores",
     // locales
     locales: "locales",
+    // views
+    views: "views",
+    // hooks
+    hooks: "hooks",
 };
 //# sourceMappingURL=location.js.map

package/lib/private/request/RequestBody.d.ts

@@ -1,13 +1,13 @@
 import type Dict from "@rcompat/type/Dict";
 import type JSONValue from "@rcompat/type/JSONValue";
 import type Schema from "@rcompat/type/Schema";
-type Fields = Dict<FormDataEntryValue>;
+type Form = Dict<string>;
 type Parsed = {
     type: "binary";
     value: Blob;
 } | {
-    type: "fields";
-    value: Fields;
+    type: "form";
+    value: Dict<string>;
 } | {
     type: "json";
     value: JSONValue;
@@ -25,12 +25,13 @@ export default class RequestBody {
     #private;
     static parse(request: Request, url: URL): Promise<RequestBody>;
     static none(): RequestBody;
-    constructor(p: Parsed);
-    get type(): "binary" | "fields" | "json" | "none" | "text";
+    constructor(parsed: Parsed, files?: Dict<File>);
+    get type(): "binary" | "form" | "json" | "none" | "text";
     json(): JSONValue;
     json<S extends Schema<unknown>>(schema: S): ParseReturn<S>;
-    fields(): Fields;
-    fields<S extends Schema<unknown>>(schema: S): ParseReturn<S>;
+    form(): Form;
+    form<S extends Schema<unknown>>(schema: S): ParseReturn<S>;
+    files(): Dict<File>;
     text(): string;
     binary(): Blob;
     none(): null;