@primate/core 0.3.3 → 0.4.0

package/lib/private/{build.js → build/index.js}

@@ -1,10 +1,11 @@
-import BuildApp from "#BuildApp";
+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/package/root";
+import root from "@rcompat/fs/project/root";
 import empty from "@rcompat/record/empty";
+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");
@@ -29,11 +30,12 @@ const get_config = async (project_root) => {
     }
     return default_config();
 };
-export default async (mode, target) => {
+export default async (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, mode).init(target);
+        const app = await new BuildApp(package_root, config, flags).init();
         await app.buildInit();
         return true;
     }
@@ -42,4 +44,4 @@ export default async (mode, target) => {
         bye();
     }
 };
-//# sourceMappingURL=build.js.map
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,3 @@
+import type BuildApp from "#build/App";
+export default function build_server(app: BuildApp): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,89 @@
+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_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 runtime from "@rcompat/runtime";
+import * as esbuild from "esbuild";
+const externals = {
+    node: ["node:"],
+    bun: ["node:", "bun:"],
+    deno: ["node:"],
+};
+const conditions = {
+    node: ["node"],
+    bun: ["bun", "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_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_virtual_pages(app));
+    app.plugin("server", plugin_virtual_routes(app));
+    app.plugin("server", plugin_route(app));
+    app.plugin("server", plugin_roots(app));
+    app.plugin("server", plugin_views(app));
+    app.plugin("server", plugin_assets(app));
+    app.plugin("server", plugin_stores(app));
+    app.plugin("server", plugin_native_addons(app));
+    app.plugin("server", plugin_requires(app));
+    app.plugin("server", plugin_config(app));
+    app.plugin("server", plugin_wasm(app));
+    const options = {
+        entryPoints: [app.path.build.join("serve.js").path],
+        outfile: app.path.build.join("server.js").path,
+        bundle: true,
+        platform: "node",
+        format: "esm",
+        packages: app.mode === "development" ? "external" : undefined,
+        external: [...externals[runtime]],
+        loader: {
+            ".json": "json",
+        },
+        banner: {
+            js: `
+        import { createRequire as __createRequire } from "node:module";
+        const require = __createRequire(import.meta.url);
+      `,
+        },
+        nodePaths: [app.root.join("node_modules").path],
+        resolveExtensions: app.extensions,
+        absWorkingDir: app.root.path,
+        tsconfig: app.root.join("tsconfig.json").path,
+        conditions: [
+            ...conditions[runtime],
+            "module", "import", "runtime", "default",
+            ...app.conditions
+        ],
+        plugins: app.plugins("server"),
+        write: app.mode !== "development",
+    };
+    if (app.mode === "development") {
+        const context = await esbuild.context(options);
+        await context.watch();
+    }
+    else {
+        await esbuild.build(options);
+    }
+}
+//# sourceMappingURL=index.js.map

package/lib/private/build/server/plugin/assets.d.ts

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

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

@@ -0,0 +1,67 @@
+import location from "#location";
+import resolve from "@rcompat/http/mime/extension/resolve";
+function bytes2base64(bytes) {
+    const chunk_size = 0x8000;
+    let result = "";
+    for (let i = 0; i < bytes.length; i += chunk_size) {
+        const chunk = bytes.slice(i, i + chunk_size);
+        result += String.fromCharCode(...chunk);
+    }
+    return btoa(result);
+}
+export default function plugin_server_assets(app) {
+    return {
+        name: "primate/server/assets",
+        setup(build) {
+            build.onResolve({ filter: /^app:assets$/ }, () => {
+                return { path: "assets-virtual", namespace: "primate-assets" };
+            });
+            build.onLoad({ filter: /.*/, namespace: "primate-assets" }, async () => {
+                if (app.mode === "production") {
+                    const client_files = await app.runpath(location.client).collect();
+                    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),
+                            data: base64,
+                        };
+                    }
+                    const static_dir = app.root.join(location.static);
+                    const static_files = await static_dir.exists()
+                        ? await static_dir.collect()
+                        : [];
+                    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),
+                            data: base64,
+                        };
+                    }
+                    const contents = `
+            const client_assets = ${JSON.stringify(client_assets, null, 2)};
+            const static_assets = ${JSON.stringify(static_assets, null, 2)};
+            export default {
+              client: client_assets,
+              static: static_assets,
+            };
+          `;
+                    return { contents, loader: "js", resolveDir: app.root.path };
+                }
+                const contents = `
+          export default {
+            client: {},
+            static: {},
+          };
+        `;
+                return { contents, loader: "js", resolveDir: app.root.path };
+            });
+        },
+    };
+}
+//# sourceMappingURL=assets.js.map

package/lib/private/build/server/plugin/config.d.ts

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

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

@@ -0,0 +1,43 @@
+import fail from "#fail";
+export default function plugin_server_config(app) {
+    return {
+        name: "primate/server/config",
+        setup(build) {
+            build.onResolve({ filter: /^app:config$/ }, async () => {
+                const ts = app.path.config.join("app.ts");
+                if (await ts.exists())
+                    return { path: ts.path };
+                const js = app.path.config.join("app.js");
+                if (await js.exists())
+                    return { path: js.path };
+                return {
+                    path: "app-config-default",
+                    namespace: "primate-config-default",
+                };
+            });
+            build.onLoad({ filter: /.*/, namespace: "primate-config-default" }, () => {
+                const contents = `
+          import config from "primate/config";
+          export default config();
+        `;
+                return {
+                    contents,
+                    loader: "js",
+                    resolveDir: app.root.path,
+                };
+            });
+            build.onResolve({ filter: /^app:config:(.+)$/ }, async (args) => {
+                const name = args.path.slice("app:config:".length);
+                const ts = app.path.config.join(`${name}.ts`);
+                if (await ts.exists())
+                    return { path: ts.path };
+                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`);
+            });
+        },
+    };
+}
+//# sourceMappingURL=config.js.map

package/lib/private/build/server/plugin/database-default.d.ts

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

package/lib/private/build/server/plugin/database-default.js

@@ -0,0 +1,48 @@
+import fail from "#fail";
+export default function plugin_server_database_default(app) {
+    return {
+        name: "primate/server/database-default",
+        setup(build) {
+            build.onResolve({ filter: /^app:database$/ }, () => {
+                return { path: "database-default", namespace: "primate-database" };
+            });
+            build.onLoad({ filter: /.*/, namespace: "primate-database" }, async () => {
+                const base = app.path.config.join("database");
+                const default_db = {
+                    contents: `
+            import DefaultDatabase from "primate/database/default";
+            export default new DefaultDatabase();
+          `,
+                    loader: "js",
+                    resolveDir: app.root.path,
+                };
+                if (!await base.exists())
+                    return default_db;
+                const dbs = await base.collect(f => f.name.endsWith(".ts") || f.name.endsWith(".js"));
+                const n = dbs.length;
+                if (n === 0)
+                    return default_db;
+                const by_name = {};
+                for (const d of dbs)
+                    by_name[d.name] = d;
+                const pick = (stem) => by_name[`${stem}.ts`] ?? by_name[`${stem}.js`];
+                let db = pick("index");
+                if (db === undefined)
+                    db = pick("default");
+                if (db === undefined) {
+                    if (dbs.length === 1)
+                        db = dbs[0];
+                    else
+                        throw fail("multiple database drivers, add index or default.(t|j)s; found {0}", dbs.map(f => f.name).join(", "));
+                }
+                const contents = `export { default } from ${JSON.stringify(db.path)};`;
+                return {
+                    contents,
+                    loader: "js",
+                    resolveDir: app.root.path,
+                };
+            });
+        },
+    };
+}
+//# sourceMappingURL=database-default.js.map

package/lib/private/build/server/plugin/frontend.d.ts

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

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

@@ -0,0 +1,21 @@
+import FileRef from "@rcompat/fs/FileRef";
+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) {
+            build.onLoad({ filter, namespace: "file" }, async (args) => {
+                const file = new FileRef(args.path);
+                const binder = app.binder(file);
+                if (!binder)
+                    return null;
+                const contents = await binder(file, {
+                    build: { id: app.id },
+                    context: "views",
+                });
+                return { contents, loader: "js", resolveDir: file.directory.path };
+            });
+        },
+    };
+}
+//# sourceMappingURL=frontend.js.map

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

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

package/lib/private/build/server/plugin/hot-reload.js

@@ -0,0 +1,36 @@
+import fail from "#fail";
+export default function plugin_server_hot_reload(app) {
+    let build_n = 0;
+    let serve_app;
+    return {
+        name: "primate/server/hot-reload",
+        setup(build) {
+            build.onEnd(async (result) => {
+                // don't do anything on errors
+                if (result.errors.length)
+                    return;
+                // we expect a single bundled file
+                const outFile = result.outputFiles?.[0];
+                if (!outFile)
+                    return;
+                const filename = `server.${build_n}.js`;
+                const s = app.path.build.join(filename);
+                await s.write(outFile.text);
+                try {
+                    // stop old app
+                    if (serve_app !== undefined)
+                        serve_app.stop();
+                    serve_app = (await s.import()).default;
+                    const stamp = app.runpath("client", "server-stamp.js");
+                    await stamp.write(`export default ${build_n};\n`);
+                    build_n++;
+                }
+                catch (err) {
+                    fail("[primate/server/hot-reload] failed to import {0}", filename);
+                    console.error(err);
+                }
+            });
+        },
+    };
+}
+//# sourceMappingURL=hot-reload.js.map

package/lib/private/build/server/plugin/native-addons.d.ts

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

package/lib/private/build/server/plugin/native-addons.js

@@ -0,0 +1,55 @@
+import fail from "#fail";
+import log from "#log";
+import FileRef from "@rcompat/fs/FileRef";
+import { createRequire } from "node:module";
+const requirer = createRequire(import.meta.url);
+export default function plugin_server_store(app) {
+    return {
+        name: "primate/server/native-addons",
+        setup(build) {
+            build.onResolve({ filter: /.*/ }, async (args) => {
+                // only check require calls for non-relative paths
+                if (args.kind === "require-call"
+                    && !args.path.startsWith(".")
+                    && !args.path.startsWith("/")) {
+                    try {
+                        // resolve the module from the import location
+                        const module_path = requirer.resolve(args.path, {
+                            paths: [args.resolveDir],
+                        });
+                        const module_dir = new FileRef(module_path).directory;
+                        // check if this module has .node files
+                        const node_files = await module_dir
+                            .collect(f => f.path.endsWith(".node"));
+                        if (node_files.length > 0) {
+                            const platform = process.platform;
+                            const arch = process.arch;
+                            let node_file = node_files.find(f => f.path.includes(`${platform}-${arch}`));
+                            if (!node_file) {
+                                node_file = node_files.find(f => f.path.includes(platform));
+                            }
+                            if (!node_file) {
+                                throw fail("could not find matching binary addon");
+                            }
+                            const addon_name = node_files[0].name;
+                            const dest = app.path.build.join("native", addon_name);
+                            await dest.directory.create();
+                            await node_files[0].copy(dest);
+                            log.info("copied native addon {0}", addon_name);
+                            return {
+                                path: `./native/${addon_name}`,
+                                external: true,
+                            };
+                        }
+                    }
+                    catch {
+                        // module not found or can't be resolved
+                    }
+                }
+                return null;
+            });
+        },
+    };
+}
+;
+//# sourceMappingURL=native-addons.js.map

package/lib/private/build/server/plugin/node-imports.d.ts

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

package/lib/private/build/server/plugin/node-imports.js

@@ -0,0 +1,32 @@
+import pkg from "@rcompat/fs/project/package";
+import { createRequire } from "node:module";
+const core_pkg = await pkg(import.meta.url);
+const core_root = core_pkg.directory.path;
+const requirer = createRequire(import.meta.url);
+export default function plugin_server_node_imports(_app) {
+    return {
+        name: "primate/server/node-imports",
+        setup(build) {
+            build.onResolve({ filter: /^#/ }, async (args) => {
+                // only touch imports coming from @primate/core sources
+                if (!args.importer || !args.importer.startsWith(core_root + "/")) {
+                    return null;
+                }
+                try {
+                    // anchor resolution at core_root we use our package.json "imports"
+                    const module_path = requirer.resolve(args.path, {
+                        paths: [core_root],
+                    });
+                    return {
+                        path: module_path,
+                        namespace: "file",
+                    };
+                }
+                catch { }
+                // next
+                return null;
+            });
+        },
+    };
+}
+//# sourceMappingURL=node-imports.js.map

package/lib/private/build/server/plugin/requires.d.ts

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

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

@@ -0,0 +1,30 @@
+export default function plugin_server_requires(_app) {
+    return {
+        name: "primate/server/requires",
+        setup(build) {
+            build.onResolve({ filter: /.*/ }, async (args) => {
+                // skip if we're already in our namespace (prevent recursion)
+                if (args.namespace === "ignore-failed-check")
+                    return null;
+                if (args.kind === "require-call"
+                    && !args.path.startsWith(".")
+                    && !args.path.startsWith("/")) {
+                    try {
+                        // resolve in a different namespace to avoid retriggering
+                        const result = await build.resolve(args.path, {
+                            kind: args.kind,
+                            resolveDir: args.resolveDir,
+                            namespace: "ignore-failed-check",
+                        });
+                        if (result.errors.length === 0)
+                            return null;
+                    }
+                    catch { }
+                    return { path: args.path, external: true };
+                }
+                return null;
+            });
+        },
+    };
+}
+//# sourceMappingURL=requires.js.map

package/lib/private/build/server/plugin/roots.d.ts

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

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

@@ -0,0 +1,18 @@
+export default function plugin_server_roots(app) {
+    return {
+        name: "primate/server/roots",
+        setup(build) {
+            build.onResolve({ filter: /^app:root\// }, args => {
+                const name = args.path.slice("app:root/".length);
+                return { path: name, namespace: "primate-roots" };
+            });
+            build.onLoad({ filter: /.*/, namespace: "primate-roots" }, args => {
+                const contents = app.roots[args.path];
+                if (!contents)
+                    throw new Error(`no root registered for ${args.path}`);
+                return { contents, loader: "js", resolveDir: app.root.path };
+            });
+        },
+    };
+}
+//# sourceMappingURL=roots.js.map

package/lib/private/build/server/plugin/route.d.ts

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

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

@@ -0,0 +1,56 @@
+import fail from "#fail";
+import wrap from "#route/wrap";
+import FileRef from "@rcompat/fs/FileRef";
+const contents = "export default {};";
+export default function plugin_server_route(app) {
+    const path_routes = app.path.routes;
+    return {
+        name: "primate/server/route",
+        setup(build) {
+            build.onResolve({ filter: /^app:route\// }, args => {
+                const rel = args.path.slice("app:route/".length);
+                return { path: rel, namespace: "primate-route" };
+            });
+            build.onLoad({ filter: /.*/, namespace: "primate-route" }, async (args) => {
+                const relative = args.path;
+                const base = path_routes.join(relative);
+                const extensions = app.extensions;
+                let file;
+                let extension;
+                for (const e of extensions) {
+                    const candidate = new FileRef(base.path + e);
+                    if (await candidate.exists()) {
+                        file = candidate;
+                        extension = e;
+                        break;
+                    }
+                }
+                if (!file || !extension) {
+                    throw fail(`cannot find route source for "${relative}" under ${path_routes.path}`);
+                }
+                // 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 };
+                const compiled = await binder(file, {
+                    build: { id: app.id },
+                    context: "routes",
+                });
+                return {
+                    contents: wrap(compiled, route_path, app.id),
+                    loader: extension === ".ts" ? "ts" : "js",
+                    resolveDir,
+                    watchFiles,
+                };
+            });
+        },
+    };
+}
+//# sourceMappingURL=route.js.map

package/lib/private/build/server/plugin/store-wrap.d.ts

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

package/lib/private/build/server/plugin/store-wrap.js

@@ -0,0 +1,33 @@
+import FileRef from "@rcompat/fs/FileRef";
+export default function plugin_server_store_wrap(app) {
+    return {
+        name: "primate/server/store-wrap",
+        setup(build) {
+            build.onLoad({ filter: /.*/ }, async (args) => {
+                // only touch the default namespace
+                if (args.namespace !== "file")
+                    return null;
+                // only TS/JS
+                if (!/\.([tj]s)$/.test(args.path))
+                    return null;
+                const file = new FileRef(args.path);
+                const storesRoot = app.path.stores.path;
+                // only files under app/stores
+                if (!file.path.startsWith(storesRoot + "/"))
+                    return null;
+                // compute logical name: stores/foo/bar.ts → "foo/bar"
+                const name = file
+                    .debase(app.path.stores)
+                    .path.replace(/^[\\/]/, "")
+                    .replace(/\.(ts|js)$/, "");
+                const contents = `export { default } from "app:store/${name}";`;
+                return {
+                    contents,
+                    loader: "js",
+                    resolveDir: app.root.path,
+                };
+            });
+        },
+    };
+}
+//# sourceMappingURL=store-wrap.js.map

package/lib/private/build/server/plugin/store.d.ts

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