@primate/core 0.4.6 → 0.6.0

package/lib/private/app/Facade.js

@@ -0,0 +1,56 @@
+import E from "#errors";
+import dict from "@rcompat/dict";
+import env from "@rcompat/env";
+import ParseError from "pema/ParseError";
+const s_attach = Symbol("attach");
+const s_config = Symbol("config");
+export { s_attach, s_config };
+export default class AppFacade {
+    #config;
+    #app;
+    #env;
+    constructor(config) {
+        this.#config = config;
+    }
+    [s_attach](app) {
+        this.#app = app;
+        const schema = this.#config.env.schema;
+        if (schema !== undefined) {
+            try {
+                this.#env = schema.coerce(env.toJSON());
+            }
+            catch (error) {
+                if (ParseError.is(error))
+                    throw E.env_invalid_schema(error);
+                throw error;
+            }
+        }
+    }
+    get [s_config]() {
+        return this.#config;
+    }
+    config(path) {
+        return dict.get(this.#config, path);
+    }
+    env(key) {
+        if (this.#env !== undefined) {
+            if (!(key in this.#env))
+                throw E.env_missing_key(key);
+            return this.#env[key];
+        }
+        return env.get(key);
+    }
+    get #with() {
+        if (!this.#app)
+            throw new Error("ServeApp not bound yet (used too early)");
+        return this.#app;
+    }
+    view(name) {
+        return this.#with.loadView(name);
+    }
+    ;
+    get root() {
+        return this.#with.root;
+    }
+}
+//# sourceMappingURL=Facade.js.map

package/lib/private/asset/Asset.d.ts

@@ -1,4 +1,4 @@
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 export default interface Asset {
     code: {
         imports: Dict;

package/lib/private/build/App.d.ts

@@ -1,7 +1,7 @@
 import App from "#App";
 import type Binder from "#Binder";
-import type FileRef from "@rcompat/fs/FileRef";
-import type Dict from "@rcompat/type/Dict";
+import type { FileRef } from "@rcompat/fs";
+import type { Dict } from "@rcompat/type";
 import type { Plugin } from "esbuild";
 type PluginType = "server" | "client";
 export default class BuildApp extends App {

package/lib/private/build/App.js

@@ -1,6 +1,5 @@
 import App from "#App";
 import build from "#build/hook";
-import log from "#log";
 import resolve_paths from "#paths";
 import s_layout_depth from "#symbol/layout-depth";
 export default class BuildApp extends App {
@@ -19,7 +18,6 @@ export default class BuildApp extends App {
     #plugins = [];
     #entrypoint_imports = [];
     async buildInit() {
-        log.system("starting {0} build in {1} mode", this.target.name, this.mode);
         this.#paths = await resolve_paths(this.root, this.config("paths"));
         await build(this);
     }

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

@@ -2,7 +2,8 @@ import plugin_alias from "#build/client/plugin/alias";
 import plugin_entrypoint from "#build/client/plugin/entrypoint";
 import plugin_frontend from "#build/client/plugin/frontend";
 import plugin_server_stamp from "#build/client/plugin/server-stamp";
-import reload from "#build/client/reload";
+import plugin_view from "#build/client/plugin/view";
+import plugin_app_request from "#build/shared/plugin/app-request";
 import location from "#location";
 import * as esbuild from "esbuild";
 const write_bootstrap = async (app, mode) => {
@@ -19,7 +20,7 @@ const write_bootstrap = async (app, mode) => {
     ` : `
     const session_config = undefined;
     `}
-    import config from "app:config";
+    import facade from "$:app";
 
     ${app.i18n_active ? `
     import i18n from "app:config:i18n";
@@ -30,13 +31,13 @@ const write_bootstrap = async (app, mode) => {
 
     const app = await serve(import.meta.url, {
       assets,
-      config,
+      facade,
       routes,
       views,
       pages,
       mode: "${mode}",
-      session_config,
-      i18n_config,
+      session: session_config,
+      i18n: i18n_config,
       target: "${app.target.name}",
     });
 
@@ -47,14 +48,20 @@ const write_bootstrap = async (app, mode) => {
 export default async function build_client(app) {
     app.plugin("client", plugin_frontend(app));
     app.plugin("client", plugin_alias(app));
+    app.plugin("client", plugin_view(app));
+    app.plugin("client", plugin_app_request(app));
     app.plugin("client", plugin_server_stamp(app));
     app.plugin("client", plugin_entrypoint(app));
-    const imports = await app.path.static.collect(file => /\.(?:js|ts|css)$/.test(file.path));
+    const imports = await app.path.static.files({
+        recursive: true,
+        filter: file => /\.(?:js|ts|css)$/.test(file.path),
+    });
     imports.forEach(file => {
         const src = file.debase(app.path.static);
         app.entrypoint(`import "./${location.static}${src}";`);
     });
     app.entrypoint("import \"primate/client/app\";");
+    const tsconfig = app.root.join("tsconfig.json");
     const conditions = app.conditions.values();
     const build_options = {
         plugins: app.plugins("client"),
@@ -62,15 +69,17 @@ export default async function build_client(app) {
         entryPoints: ["app:client"],
         conditions: ["style", "browser", "default", "module", ...conditions],
         resolveExtensions: [".ts", ".js", ...app.frontendExtensions],
-        tsconfig: app.root.join("tsconfig.json").path,
+        ...await tsconfig.exists() ? { tsconfig: tsconfig.path } : {},
         bundle: true,
         format: "esm",
     };
+    const NO_HR = app.config("livereload.exclude") ?? [];
     const mode_options = app.mode === "development"
         ? {
             banner: {
-                js: `new EventSource("${reload.path}").addEventListener("change",
-      () => globalThis.location.reload());`,
+                js: `const NO_HR=${JSON.stringify(NO_HR)};
+          new EventSource("/esbuild").addEventListener("change",
+          () => !NO_HR.includes(location.pathname) && location.reload());`,
             },
             entryNames: "app",
             minify: false,
@@ -86,7 +95,7 @@ export default async function build_client(app) {
         const context = await esbuild.context(options);
         await context.watch();
         await context.rebuild();
-        await context.serve({ host: reload.host, port: reload.port });
+        await context.serve(app.livereload);
     }
     else {
         await esbuild.build(options);

package/lib/private/build/client/plugin/app-request.d.ts

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

package/lib/private/build/client/plugin/app-request.js

@@ -0,0 +1,19 @@
+export default function plugin_client_request(app) {
+    return {
+        name: "primate/client/app/request",
+        setup(build) {
+            build.onResolve({ filter: /^app:request$/ }, ({ importer }) => {
+                const frontend = [...app.frontends.entries()]
+                    .find(([, exts]) => exts.some(ext => importer.endsWith(ext)));
+                return frontend !== undefined
+                    ? { namespace: "request", path: frontend[0] }
+                    : undefined;
+            });
+            build.onLoad({ filter: /.*/, namespace: "request" }, async ({ path }) => {
+                const contents = `export { default } from "@primate/${path}/request";`;
+                return { contents, resolveDir: app.root.path };
+            });
+        },
+    };
+}
+//# sourceMappingURL=app-request.js.map

package/lib/private/build/client/plugin/view.d.ts

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

package/lib/private/build/client/plugin/view.js

@@ -0,0 +1,13 @@
+import location from "#location";
+export default function plugin_client_view(app) {
+    return {
+        name: "primate/client/view",
+        setup(build) {
+            build.onResolve({ filter: /^view:/ }, args => {
+                const name = args.path.slice("view:".length);
+                return { path: app.root.join(location.views, name).path };
+            });
+        },
+    };
+}
+//# sourceMappingURL=view.js.map

package/lib/private/build/hook.d.ts

@@ -1,4 +1,3 @@
 import type BuildApp from "#build/App";
-declare const _default: (app: BuildApp) => Promise<BuildApp>;
-export default _default;
+export default function run_build_hooks(app: BuildApp): Promise<BuildApp>;
 //# sourceMappingURL=hook.d.ts.map

package/lib/private/build/hook.js

@@ -1,31 +1,25 @@
 import build_client from "#build/client/index";
 import build_server from "#build/server/index";
-import fail from "#fail";
+import E from "#errors";
 import location from "#location";
 import log from "#log";
-import reducer from "#reducer";
 import $router from "#request/router";
 import s_layout_depth from "#symbol/layout-depth";
-import pkg from "@rcompat/fs/project/package";
-const core_pkg = await pkg(import.meta.url);
+import c from "@rcompat/cli/color";
+import fs from "@rcompat/fs";
+const core_pkg = await fs.project.package(import.meta.dirname);
 const { version } = await core_pkg.json();
 async function pre(app) {
-    const dot_primate = app.path.build.join(".primate");
-    if (await app.path.build.exists() && !await dot_primate.exists()) {
-        const message = "{0} exists but does not contain a previous build";
-        throw fail(message, app.path.build.path);
+    const build_json = app.path.build.join("build.json");
+    const build_path = app.path.build;
+    if (await build_path.exists() && !await build_json.exists()) {
+        throw E.build_previous_build_exists(build_path);
     }
-    // remove build directory if exists
     await app.path.build.remove();
     await app.path.build.create();
-    // touch a .primate file to indicate this is a Primate build directory
-    await dot_primate.write(version);
     await app.runpath(location.client).create();
     const stamp = app.runpath("client", "server-stamp.js");
     await stamp.write("export default 0;\n");
-    // this has to occur before post, so that layout depth is available for
-    // 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"));
     const i18n_ts = app.path.config.join("i18n.ts");
@@ -34,16 +28,28 @@ async function pre(app) {
     const session_ts = app.path.config.join("session.ts");
     const session_js = app.path.config.join("session.js");
     app.session_active = await session_ts.exists() || await session_js.exists();
-    return app;
 }
-;
 async function post(app) {
     await build_client(app);
     await build_server(app);
-    log.system("build written to {0}", app.path.build);
+    // write build.json with version and migration_version
+    const migrations_dir = app.root.join("migrations");
+    let migration_version = 0;
+    if (await migrations_dir.exists()) {
+        const files = await migrations_dir.files({ filter: /\d+-.*\.[jt]s$/ });
+        migration_version = files.length === 0 ? 0 : Math.max(...files.map(f => parseInt(f.name.split("-")[0])));
+    }
+    await app.path.build.join("build.json").writeJSON({
+        version,
+        migration_version,
+    });
+    log.print(`✓ build path  ${c.dim(app.path.build.path)}\n`);
     app.cleanup();
     return app;
 }
-;
-export default async (app) => post(await reducer(app.modules, await pre(app), "build"));
+export default async function run_build_hooks(app) {
+    await pre(app);
+    await app.build_hooks(app);
+    return post(app);
+}
 //# sourceMappingURL=hook.js.map

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

@@ -1,4 +1,5 @@
 import Flags from "#Flags";
-declare const _default: (input: typeof Flags.input) => Promise<true | undefined>;
+import type { FileRef } from "@rcompat/fs";
+declare const _default: (root: FileRef, input: typeof Flags.input) => Promise<true | undefined>;
 export default _default;
 //# sourceMappingURL=index.d.ts.map

package/lib/private/build/index.js

@@ -1,41 +1,41 @@
+import { s_config } from "#app/Facade";
 import BuildApp from "#build/App";
 import bye from "#bye";
 import default_config from "#config/index";
-import fail from "#fail";
-import log from "#log";
-import root from "@rcompat/fs/project/root";
-import empty from "@rcompat/record/empty";
+import E from "#errors";
 import Flags from "#Flags";
-const no_config = (config) => config === undefined || empty(config);
-const find_config = async (project_root) => {
-    const ts_config = project_root.join("config/app.ts");
+import log from "#log";
+import dict from "@rcompat/dict";
+const no_config = (config) => config === undefined || dict.empty(config);
+async function find_config(root) {
+    const ts_config = root.join("config/app.ts");
     if (await ts_config.exists())
         return ts_config;
-    const js_config = project_root.join("config/app.js");
+    const js_config = root.join("config/app.js");
     if (await js_config.exists())
         return js_config;
-};
-const get_config = async (project_root) => {
-    const config = await find_config(project_root);
-    if (config !== undefined) {
-        try {
-            const imported = await config.import("default");
-            if (no_config(imported))
-                throw fail("empty config file at {0}", config);
-            return imported;
-        }
-        catch (error) {
-            throw fail("error in config file {0}", error);
-        }
+}
+;
+async function get_config(root) {
+    const config_file = await find_config(root);
+    if (config_file === undefined)
+        return default_config()[s_config];
+    try {
+        const imported = (await config_file.import("default"))[s_config];
+        if (no_config(imported))
+            throw E.config_file_empty(config_file);
+        return imported;
     }
-    return default_config();
-};
-export default async (input) => {
+    catch (error) {
+        throw E.config_file_error(config_file, error);
+    }
+}
+;
+export default async (root, input) => {
     try {
-        const package_root = await root();
         const flags = Flags.parse(input);
-        const config = await get_config(package_root);
-        const app = await new BuildApp(package_root, config, flags).init();
+        const config = await get_config(root);
+        const app = await new BuildApp(root, config, flags).init();
         await app.buildInit();
         return true;
     }

package/lib/private/build/presets.d.ts

@@ -0,0 +1,10 @@
+import type { TransformOptions } from "esbuild";
+declare const _default: {
+    readonly angular: TransformOptions;
+    readonly react: TransformOptions;
+    readonly solid: TransformOptions;
+    readonly typescript: TransformOptions;
+    readonly voby: TransformOptions;
+};
+export default _default;
+//# sourceMappingURL=presets.d.ts.map

package/lib/private/build/presets.js

@@ -0,0 +1,39 @@
+const angular = {
+    loader: "ts",
+    tsconfigRaw: {
+        compilerOptions: {
+            experimentalDecorators: true,
+        },
+    },
+};
+const react = {
+    jsx: "automatic",
+    loader: "tsx",
+};
+const solid = {
+    format: "esm",
+    jsx: "preserve",
+    loader: "tsx",
+    target: "esnext",
+};
+const typescript = {
+    loader: "ts",
+};
+const voby = {
+    jsx: "automatic",
+    loader: "tsx",
+    tsconfigRaw: {
+        compilerOptions: {
+            jsx: "react-jsx",
+            jsxImportSource: "voby",
+        },
+    },
+};
+export default {
+    angular,
+    react,
+    solid,
+    typescript,
+    voby,
+};
+//# sourceMappingURL=presets.js.map

package/lib/private/build/server/index.js

@@ -1,21 +1,19 @@
 import plugin_assets from "#build/server/plugin/assets";
 import plugin_config from "#build/server/plugin/config";
-import plugin_database_default from "#build/server/plugin/database-default";
 import plugin_frontend from "#build/server/plugin/frontend";
-import plugin_hot_reload from "#build/server/plugin/hot-reload";
+import plugin_live_reload from "#build/server/plugin/live-reload";
 import plugin_native_addons from "#build/server/plugin/native-addons";
 import plugin_node_imports from "#build/server/plugin/node-imports";
 import plugin_requires from "#build/server/plugin/requires";
 import plugin_roots from "#build/server/plugin/roots";
 import plugin_route from "#build/server/plugin/route";
-import plugin_store from "#build/server/plugin/store";
-import plugin_store_wrap from "#build/server/plugin/store-wrap";
 import plugin_stores from "#build/server/plugin/stores";
 import plugin_view from "#build/server/plugin/view";
 import plugin_views from "#build/server/plugin/views";
 import plugin_virtual_pages from "#build/server/plugin/virtual-pages";
 import plugin_virtual_routes from "#build/server/plugin/virtual-routes";
 import plugin_wasm from "#build/server/plugin/wasm";
+import plugin_app_request from "#build/shared/plugin/app-request";
 import runtime from "@rcompat/runtime";
 import * as esbuild from "esbuild";
 const externals = {
@@ -29,16 +27,11 @@ const conditions = {
     deno: ["deno", "node"],
 };
 export default async function build_server(app) {
-    const extensions = app.frontendExtensions;
     app.plugin("server", plugin_node_imports(app));
-    if (extensions.length > 0)
-        app.plugin("server", plugin_frontend(app));
+    app.plugin("server", plugin_frontend(app));
     app.plugin("server", plugin_view(app));
-    app.plugin("server", plugin_store(app));
-    app.plugin("server", plugin_store_wrap(app));
-    app.plugin("server", plugin_database_default(app));
     if (app.mode === "development")
-        app.plugin("server", plugin_hot_reload(app));
+        app.plugin("server", plugin_live_reload(app));
     app.plugin("server", plugin_virtual_pages(app));
     app.plugin("server", plugin_virtual_routes(app));
     app.plugin("server", plugin_route(app));
@@ -50,6 +43,9 @@ export default async function build_server(app) {
     app.plugin("server", plugin_requires(app));
     app.plugin("server", plugin_config(app));
     app.plugin("server", plugin_wasm(app));
+    app.plugin("server", plugin_app_request(app));
+    const runtime_name = runtime.name;
+    const tsconfig = app.root.join("tsconfig.json");
     const options = {
         entryPoints: [app.path.build.join("serve.js").path],
         outfile: app.path.build.join("server.js").path,
@@ -57,7 +53,7 @@ export default async function build_server(app) {
         platform: "node",
         format: "esm",
         packages: app.mode === "development" ? "external" : undefined,
-        external: [...externals[runtime]],
+        external: [...externals[runtime_name]],
         loader: {
             ".json": "json",
         },
@@ -70,9 +66,9 @@ export default async function build_server(app) {
         nodePaths: [app.root.join("node_modules").path],
         resolveExtensions: app.extensions,
         absWorkingDir: app.root.path,
-        tsconfig: app.root.join("tsconfig.json").path,
+        ...await tsconfig.exists() ? { tsconfig: tsconfig.path } : {},
         conditions: [
-            ...conditions[runtime],
+            ...conditions[runtime_name],
             "module", "import", "runtime", "default",
             ...app.conditions
         ],

package/lib/private/build/server/plugin/app-request.d.ts

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

package/lib/private/build/server/plugin/app-request.js

@@ -0,0 +1,19 @@
+export default function plugin_server_request(app) {
+    return {
+        name: "primate/server/app/request",
+        setup(build) {
+            build.onResolve({ filter: /^app:request$/ }, ({ importer }) => {
+                const frontend = [...app.frontends.entries()]
+                    .find(([, exts]) => exts.some(ext => importer.endsWith(ext)));
+                return frontend !== undefined
+                    ? { namespace: "request", path: frontend[0] }
+                    : undefined;
+            });
+            build.onLoad({ filter: /.*/, namespace: "request" }, async ({ path }) => {
+                const contents = `export { default } from "@primate/${path}/request";`;
+                return { contents, resolveDir: app.root.path };
+            });
+        },
+    };
+}
+//# sourceMappingURL=app-request.js.map

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

@@ -1,5 +1,5 @@
 import location from "#location";
-import resolve from "@rcompat/http/mime/extension/resolve";
+import { MIME } from "@rcompat/http";
 function bytes2base64(bytes) {
     const chunk_size = 0x8000;
     let result = "";
@@ -18,28 +18,30 @@ export default function plugin_server_assets(app) {
             });
             build.onLoad({ filter: /.*/, namespace: "primate-assets" }, async () => {
                 if (app.mode === "production") {
-                    const client_files = await app.runpath(location.client).collect();
+                    const client_files = await app.runpath(location.client).files({
+                        recursive: true,
+                    });
                     const client_assets = {};
                     for (const file of client_files) {
                         const pathname = `/${file.name}`;
                         const bytes = await file.bytes();
                         const base64 = bytes2base64(bytes);
                         client_assets[pathname] = {
-                            mime: resolve(file.name),
+                            mime: MIME.resolve(file.name),
                             data: base64,
                         };
                     }
                     const static_dir = app.root.join(location.static);
-                    const static_files = await static_dir.exists()
-                        ? await static_dir.collect()
-                        : [];
+                    const static_files = await static_dir.files({
+                        recursive: true,
+                    });
                     const static_assets = {};
                     for (const file of static_files) {
                         const pathname = file.debase(static_dir).path;
                         const bytes = await file.bytes();
                         const base64 = bytes2base64(bytes);
                         static_assets[pathname] = {
-                            mime: resolve(file.name),
+                            mime: MIME.resolve(file.name),
                             data: base64,
                         };
                     }

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

@@ -1,9 +1,8 @@
-import fail from "#fail";
 export default function plugin_server_config(app) {
     return {
         name: "primate/server/config",
         setup(build) {
-            build.onResolve({ filter: /^app:config$/ }, async () => {
+            build.onResolve({ filter: /^(\$:app)$/ }, async () => {
                 const ts = app.path.config.join("app.ts");
                 if (await ts.exists())
                     return { path: ts.path };
@@ -34,8 +33,16 @@ export default function plugin_server_config(app) {
                 const js = app.path.config.join(`${name}.js`);
                 if (await js.exists())
                     return { path: js.path };
-                // should never happen as we only import when session_active is true
-                throw fail(`missing config for ${name} in app/config`);
+                return {
+                    path: `app-config-${name}-default`,
+                    namespace: "primate-config-default",
+                };
+            });
+            build.onLoad({ filter: /^app-config-.+-default$/, namespace: "primate-config-default" }, () => {
+                return {
+                    contents: "export default null;",
+                    loader: "js",
+                };
             });
         },
     };

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

@@ -1,11 +1,13 @@
-import FileRef from "@rcompat/fs/FileRef";
+import fs from "@rcompat/fs";
 export default function plugin_server_frontend(app) {
     const filter = new RegExp(`(${app.frontendExtensions.map(e => e.replace(".", "\\.")).join("|")})$`);
     return {
         name: "primate/server/frontend",
         setup(build) {
+            if (app.frontendExtensions.length === 0)
+                return;
             build.onLoad({ filter, namespace: "file" }, async (args) => {
-                const file = new FileRef(args.path);
+                const file = fs.ref(args.path);
                 const binder = app.binder(file);
                 if (!binder)
                     return null;

package/lib/private/build/server/plugin/live-reload.d.ts

@@ -0,0 +1,4 @@
+import type BuildApp from "#build/App";
+import type { Plugin } from "esbuild";
+export default function plugin_server_live_reload(app: BuildApp): Plugin;
+//# sourceMappingURL=live-reload.d.ts.map