@primate/core 0.3.4 → 0.4.0

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

@@ -0,0 +1,47 @@
+import FileRef from "@rcompat/fs/FileRef";
+export default function plugin_server_store(app) {
+    return {
+        name: "primate/server/store",
+        setup(build) {
+            build.onResolve({ filter: /^app:store\// }, args => {
+                const name = args.path.slice("app:store/".length).replace(/\.(js|ts)$/, "");
+                return { path: name, namespace: "primate-store-wrapper" };
+            });
+            build.onLoad({ filter: /.*/, namespace: "primate-store-wrapper" }, args => {
+                const name = args.path;
+                return {
+                    contents: `
+            import database from "app:database";
+            import wrap from "primate/database/wrap";
+            import schema from "store:${name}";
+            export default wrap("${name}", schema, database);
+          `,
+                    loader: "js",
+                    resolveDir: app.path.stores.path,
+                };
+            });
+            build.onResolve({ filter: /^store:/ }, async (args) => {
+                const name = args.path.slice("store:".length);
+                for (const ext of app.extensions) {
+                    const file = new FileRef(`${app.path.stores.path}/${name}${ext}`);
+                    if (await file.exists()) {
+                        // special namespace to bypass auto-wrap
+                        return { path: file.path, namespace: "primate-store-raw" };
+                    }
+                }
+                return null;
+            });
+            build.onLoad({ filter: /.*/, namespace: "primate-store-raw" }, async (args) => {
+                const file = new FileRef(args.path);
+                const source = await file.text();
+                return {
+                    contents: source,
+                    loader: args.path.endsWith(".ts") ? "ts" : "js",
+                    resolveDir: file.directory.path,
+                    watchFiles: [file.path],
+                };
+            });
+        },
+    };
+}
+//# sourceMappingURL=store.js.map

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

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

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

@@ -0,0 +1,25 @@
+import FileRef from "@rcompat/fs/FileRef";
+const jts_re = /\.[jt]s$/;
+export default function plugin_server_stores(app) {
+    const base = app.path.stores;
+    return {
+        name: "primate/server/stores",
+        setup(build) {
+            build.onResolve({ filter: /^app:stores$/ }, () => {
+                return { path: "stores-virtual", namespace: "primate-stores" };
+            });
+            build.onLoad({ filter: /.*/, namespace: "primate-stores" }, async () => {
+                const stores = await Promise.all((await base.collect(file => jts_re.test(file.path)))
+                    .map(async (path) => `${path}`.replace(base.toString(), _ => "")));
+                const contents = `
+        const stores = {};
+        ${stores.map(path => path.slice(1, -".js".length)).map((bare, i) => `import * as store${i} from "${FileRef.webpath(`app:store/${bare}`)}";
+           stores["${FileRef.webpath(bare)}"] = store${i}.default;`).join("\n")}
+        export default stores;
+      `;
+                return { contents, loader: "js", resolveDir: app.root.path };
+            });
+        },
+    };
+}
+//# sourceMappingURL=stores.js.map

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

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

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

@@ -0,0 +1,64 @@
+import FileRef from "@rcompat/fs/FileRef";
+export default function plugin_server_view(app) {
+    return {
+        name: "primate/server/view",
+        setup(build) {
+            build.onResolve({ filter: /.*/ }, async (args) => {
+                // only care about our wrapped route modules
+                if (args.namespace !== "primate-route")
+                    return null;
+                // avoid recursion when we call build.resolve ourselves
+                if (args.pluginData === "primate-view-inner")
+                    return null;
+                // let esbuild resolve this import as usual
+                const result = await build.resolve(args.path, {
+                    resolveDir: args.resolveDir,
+                    kind: args.kind,
+                    pluginData: "primate-view-inner",
+                });
+                // couldn't resolve, don't interfere
+                if (result.errors.length > 0 || !result.path)
+                    return null;
+                const resolved = new FileRef(result.path);
+                // must live under app.path.views (e.g. app/views/...)
+                const views_root = app.path.views.path;
+                if (!resolved.path.startsWith(views_root + "/"))
+                    return null;
+                return {
+                    path: resolved.debase(app.path.views).path.replace(/^[\\/]/, ""),
+                    namespace: "primate-view-wrapper",
+                };
+            });
+            build.onLoad({ filter: /.*/, namespace: "primate-view-wrapper" }, async (args) => {
+                const name = args.path;
+                return {
+                    contents: `export default ${JSON.stringify(name)};`,
+                    loader: "js",
+                    resolveDir: app.path.views.path,
+                };
+            });
+            build.onResolve({ filter: /^view:/ }, async (args) => {
+                const name = args.path.slice("view:".length);
+                for (const ext of app.extensions) {
+                    const file = new FileRef(`${app.path.views.path}/${name}${ext}`);
+                    if (await file.exists()) {
+                        return { path: file.path, namespace: "primate-view-original" };
+                    }
+                }
+                return null;
+            });
+            build.onLoad({ filter: /.*/, namespace: "primate-view-original" }, 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=view.js.map

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

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

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

@@ -0,0 +1,36 @@
+import FileRef from "@rcompat/fs/FileRef";
+export default function plugin_server_views(app) {
+    return {
+        name: "primate/server/views",
+        setup(build) {
+            build.onResolve({ filter: /^app:views/ }, () => {
+                return { path: "views-virtual", namespace: "primate-views" };
+            });
+            build.onLoad({ filter: /.*/, namespace: "primate-views" }, async () => {
+                const files = await app.path.views.collect();
+                const roots = Object.keys(app.roots);
+                const contents = `
+        const view = [];
+        ${files.map((file, i) => {
+                    const path = app.basename(file, app.path.views);
+                    return `
+            import * as view${i} from "${FileRef.webpath(`view:${path}`)}";
+            view.push(["${FileRef.webpath(path)}", view${i}]);`;
+                }).join("\n")}
+
+        ${roots.map((filename, i) => `
+          import * as root${i} from "app:root/${filename}";
+          view.push(["${filename}", root${i}]);
+        `).join("\n")}
+
+        export default view;`;
+                return {
+                    contents,
+                    loader: "js",
+                    resolveDir: app.root.path,
+                };
+            });
+        },
+    };
+}
+//# sourceMappingURL=views.js.map

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

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

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

@@ -0,0 +1,41 @@
+import pkg from "@rcompat/fs/project/package";
+const core_pkg = await pkg(import.meta.url);
+const core_root = core_pkg.directory;
+export default function plugin_server_virtual_pages(app) {
+    return {
+        name: "primate/server/virtual/pages",
+        setup(build) {
+            build.onResolve({ filter: /^app:pages$/ }, () => {
+                return { path: "pages-virtual", namespace: "primate-pages" };
+            });
+            build.onLoad({ filter: /.*/, namespace: "primate-pages" }, async () => {
+                const html = /^.*\.html$/ui;
+                const is_html = (file) => html.test(file.path);
+                const defaults = core_root.join("lib", "private", "defaults");
+                const pages = {};
+                for (const file of await defaults.collect(is_html))
+                    pages[file.name] = file;
+                if (await app.path.pages.exists()) {
+                    for (const file of await app.path.pages.collect(is_html))
+                        pages[file.name] = file;
+                }
+                const entries = await Promise.all(Object.entries(pages).map(async ([name, file]) => {
+                    const text = await file.text();
+                    return `"${name}": ${JSON.stringify(text)}`;
+                }));
+                const contents = `
+          const pages = {
+            ${entries.join(",\n")}
+          };
+          export default pages;
+        `;
+                return {
+                    contents,
+                    loader: "js",
+                    resolveDir: app.root.path,
+                };
+            });
+        },
+    };
+}
+//# sourceMappingURL=virtual-pages.js.map

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

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

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

@@ -0,0 +1,46 @@
+export default 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);
+    return {
+        name: "primate/server/virtual/routes",
+        setup(build) {
+            const routes_path = app.path.routes;
+            build.onResolve({ filter: /^app:routes$/ }, () => {
+                return { path: "routes-virtual", namespace: "primate-routes" };
+            });
+            build.onLoad({ filter: /.*/, namespace: "primate-routes" }, async () => {
+                const route_files = await routes_path.collect(is_route_file);
+                const watchDirs = new Set();
+                const findDirs = async (dir) => {
+                    watchDirs.add(dir.path);
+                    const entries = await dir.list();
+                    for (const entry of entries) {
+                        if (await entry.isDirectory()) {
+                            await findDirs(entry);
+                        }
+                    }
+                };
+                await findDirs(app.path.routes);
+                const contents = `
+          const route = [];
+          ${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}]);`;
+                }).join("\n")}
+          export default route;
+        `;
+                return {
+                    contents,
+                    loader: "js",
+                    resolveDir: app.root.path,
+                    watchDirs: [...watchDirs],
+                    watchFiles: route_files.map(f => f.path),
+                };
+            });
+        },
+    };
+}
+//# sourceMappingURL=virtual-routes.js.map

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

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

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

@@ -0,0 +1,36 @@
+export default function plugin_server_wasm(app) {
+    return {
+        name: "primate/server/wasm",
+        setup(build) {
+            const re = /^app:wasm\/(.+)\.wasm$/;
+            build.onResolve({ filter: re }, args => {
+                const match = re.exec(args.path);
+                if (!match)
+                    return;
+                if (app.mode === "development")
+                    return {
+                        path: match[1],
+                        namespace: "wasm-dev",
+                    };
+                else
+                    return {
+                        path: app.runpath("wasm", match[1]).path + ".wasm",
+                        namespace: "file",
+                    };
+            });
+            build.onLoad({ filter: /.*/, namespace: "wasm-dev" }, async (args) => {
+                const wasm_file = app.runpath("wasm", args.path + ".wasm");
+                return {
+                    contents: `
+            import FileRef from "primate/fs/FileRef";
+            const file = new FileRef("${wasm_file.path}");
+            export default await file.bytes();
+          `,
+                    loader: "js",
+                    resolveDir: app.root.path,
+                };
+            });
+        },
+    };
+}
+//# sourceMappingURL=wasm.js.map

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

@@ -1,9 +1,11 @@
 import type Dict from "@rcompat/type/Dict";
+import type Mode from "#Mode";
 type ClientData<T extends Dict = Dict> = {
     view: string;
     request: Dict;
     spa: boolean;
     ssr: boolean;
+    mode: Mode;
 } & T;
 export type { ClientData as default };
 //# sourceMappingURL=Data.d.ts.map

package/lib/private/client/app.js

@@ -1,5 +1,8 @@
 // @ts-expect-error esbuild vfs
-import * as frontends from "#frontends";
+import stamp from "server:stamp";
+console.log(stamp);
+// @ts-expect-error esbuild vfs
+import * as frontends from "app:frontends";
 class ClientApp {
     start() {
         const hydration = document.getElementById("hydration")?.textContent;

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

@@ -1,7 +1,5 @@
 import schema from "#config/schema";
 declare const _default: (config?: typeof schema.input) => {
-    build: Record<string, unknown> | undefined;
-    bundle: string[];
     http: {
         csp: Record<string, string[]> | undefined;
         headers: Record<string, string> | undefined;

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

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

package/lib/private/config/schema.js

@@ -1,34 +1,24 @@
 import Module from "#Module";
 import FileRef from "@rcompat/fs/FileRef";
 import p from "pema";
-import array from "pema/array";
-import boolean from "pema/boolean";
-import constructor from "pema/constructor";
-import record from "pema/record";
-import string from "pema/string";
-import uint from "pema/uint";
-import union from "pema/union";
-import unknown from "pema/unknown";
 export default p({
-    build: record(string, unknown).optional(),
-    bundle: p.array(p.string).default([]),
     http: {
-        csp: record(string, array(string)).optional(),
-        headers: record(string, string).optional(),
-        host: string.default("localhost"),
-        port: uint.port().default(6161),
+        csp: p.record(p.string, p.array(p.string)).optional(),
+        headers: p.record(p.string, p.string).optional(),
+        host: p.string.default("localhost"),
+        port: p.uint.port().default(6161),
         ssl: {
-            cert: union(FileRef, string).optional(),
-            key: union(FileRef, string).optional(),
+            cert: p.union(FileRef, p.string).optional(),
+            key: p.union(FileRef, p.string).optional(),
         },
         static: {
-            root: string.default("/"),
+            root: p.string.default("/"),
         },
     },
-    modules: array(constructor(Module)).optional(),
+    modules: p.array(p.constructor(Module)).optional(),
     request: {
         body: {
-            parse: boolean.default(true),
+            parse: p.boolean.default(true),
         },
     },
 });

package/lib/private/database/Store.d.ts

@@ -9,6 +9,7 @@ import type Id from "pema/Id";
 import type InferStore from "pema/InferStore";
 import type StoreId from "pema/StoreId";
 import type StoreSchema from "pema/StoreSchema";
+import StoreType from "pema/StoreType";
 type X<T> = {
     [K in keyof T]: T[K];
 } & {};
@@ -51,11 +52,13 @@ export default class DatabaseStore<S extends StoreSchema> implements Serializabl
     readonly Schema: Schema<S>;
     constructor(schema: S, config?: Config);
     static new<S extends StoreSchema>(schema: S, config?: Config): DatabaseStore<S>;
-    get schema(): {
+    get collection(): {
         create: () => import("@rcompat/type/MaybePromise").default<void>;
         delete: () => import("@rcompat/type/MaybePromise").default<void>;
     };
     get infer(): InferStore<S>;
+    get schema(): S;
+    get type(): StoreType<S>;
     get database(): Database;
     get types(): Types;
     get name(): string;

package/lib/private/database/Store.js

@@ -26,7 +26,7 @@ export default class DatabaseStore {
             .map(([key, value]) => [key, value.datatype]));
         this.#name = config.name;
         this.#database = config.database;
-        this.#nullables = new Set(Object.entries(this.#type.schema)
+        this.#nullables = new Set(Object.entries(this.#type.properties)
             .filter(([, v]) => v.nullable)
             .map(([k]) => k));
     }
@@ -63,7 +63,7 @@ export default class DatabaseStore {
             types: this.#types,
         };
     }
-    get schema() {
+    get collection() {
         const database = this.database;
         const name = this.name;
         const schema = this.#schema;
@@ -75,6 +75,12 @@ export default class DatabaseStore {
     get infer() {
         return undefined;
     }
+    get schema() {
+        return this.#schema;
+    }
+    get type() {
+        return this.#type;
+    }
     [wrap](name, database) {
         this.#database ??= database;
         this.#name ??= name;

package/lib/private/database/test.js

@@ -64,26 +64,26 @@ export default (database) => {
         u8: u8.optional(),
     }, { database, name: "type" });
     const bootstrap = async (tester) => {
-        await User.schema.create();
+        await User.collection.create();
         for (const user of Object.values(users)) {
             await User.insert(user);
         }
         await tester();
-        await User.schema.delete();
+        await User.collection.delete();
     };
     const typestrap = async (tester) => {
-        await Type.schema.create();
+        await Type.collection.create();
         await tester();
-        await Type.schema.delete();
+        await Type.collection.delete();
     };
     test.case("insert", async (assert) => {
-        await User.schema.create();
+        await User.collection.create();
         const donald = await User.insert({ age: 30, name: "Donald" });
         assert(await User.has(donald.id)).true();
         const ryan = await User.insert({ age: 40, name: "Ryan" });
         assert(await User.has(donald.id)).true();
         assert(await User.has(ryan.id)).true();
-        await User.schema.delete();
+        await User.collection.delete();
     });
     test.case("find - basic query", async (assert) => {
         await bootstrap(async () => {
@@ -658,7 +658,7 @@ export default (database) => {
             order: u8.optional(),
             name: string,
         }, { database, name: "select" }); // deliberately reserved-like table name
-        await Reserved.schema.create();
+        await Reserved.collection.create();
         const a = await Reserved.insert({ name: "alpha", order: 1 });
         const b = await Reserved.insert({ name: "beta", order: 2 });
         const got = await Reserved.find({ name: "alpha" });
@@ -672,7 +672,7 @@ export default (database) => {
         // and delete to complete the cycle
         const d = await Reserved.delete({ id: a.id });
         assert(d).equals(1);
-        await Reserved.schema.delete();
+        await Reserved.collection.delete();
     });
 };
 //# sourceMappingURL=test.js.map

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

@@ -1,5 +1,5 @@
 import type App from "#App";
-import type BuildApp from "#BuildApp";
+import type BuildApp from "#build/App";
 import type Render from "#frontend/Render";
 import type ServerView from "#frontend/ServerView";
 import type ViewResponse from "#frontend/ViewResponse";
@@ -7,7 +7,7 @@ import Module from "#Module";
 import type Next from "#module/Next";
 import type NextBuild from "#module/NextBuild";
 import type NextServe from "#module/NextServe";
-import type ServeApp from "#ServeApp";
+import type ServeApp from "#serve/App";
 import FileRef from "@rcompat/fs/FileRef";
 import type MaybePromise from "@rcompat/type/MaybePromise";
 export default abstract class FrontendModule<S = ServerView> extends Module {
@@ -31,7 +31,7 @@ export default abstract class FrontendModule<S = ServerView> extends Module {
     };
     conditions: string[];
     static schema: import("pema").ObjectType<{
-        fileExtensions: import("pema").OptionalType<import("pema/array").ArrayType<import("pema/string").StringType>>;
+        fileExtensions: import("pema").OptionalType<import("pema").ArrayType<import("pema/string").StringType>>;
         spa: import("pema").DefaultType<import("pema/boolean").BooleanType, true>;
         ssr: import("pema").DefaultType<import("pema/boolean").BooleanType, true>;
     }>;
@@ -56,6 +56,7 @@ export default abstract class FrontendModule<S = ServerView> extends Module {
     serve(app: ServeApp, next: NextServe): MaybePromise<ServeApp>;
     publish(app: BuildApp): void;
     init<T extends App>(app: T, next: Next<T>): MaybePromise<T>;
+    prebuild(app: BuildApp): void;
     build(app: BuildApp, next: NextBuild): Promise<BuildApp>;
 }
 //# sourceMappingURL=Module.d.ts.map