@primate/core 0.3.4 → 0.4.0

package/lib/private/{ServeApp.d.ts → serve/App.d.ts}

@@ -4,12 +4,11 @@ import type ServerView from "#frontend/ServerView";
 import type ViewOptions from "#frontend/ViewOptions";
 import type ViewResponse from "#frontend/ViewResponse";
 import type I18NConfig from "#i18n/Config";
-import type Loader from "#Loader";
 import RequestBag from "#request/RequestBag";
 import RequestBody from "#request/RequestBody";
 import type RequestFacade from "#request/RequestFacade";
 import type RouteHandler from "#route/Handler";
-import type ServeInit from "#ServeInit";
+import type ServeInit from "#serve/Init";
 import FileRouter from "@rcompat/fs/FileRouter";
 import type Actions from "@rcompat/http/Actions";
 import type Dict from "@rcompat/type/Dict";
@@ -26,20 +25,13 @@ export default class ServeApp extends App {
     #private;
     constructor(rootfile: string, init: ServeInit);
     get secure(): boolean;
-    loader<T extends Loader>(): T;
-    serve(pathname: string): Promise<Response | undefined>;
     get assets(): Asset[];
-    get modules(): import("./Module.js").default[];
+    get modules(): import("../Module.js").default[];
     get url(): string;
     get router(): FileRouter;
     get frontends(): {
         [x: string]: ViewResponse | undefined;
     };
-    get files(): {
-        routes: [string, {
-            default: any;
-        }][];
-    };
     get stores(): Dict;
     get i18n(): I18NConfig | undefined;
     loadView<T = ServerView>(name: string): T;
@@ -47,7 +39,6 @@ export default class ServeApp extends App {
         "Content-Security-Policy"?: string | undefined;
     };
     render(content: Omit<FullViewOptions, keyof ResponseInit>): string;
-    page(page?: string): string;
     body_length(body: BodyInit | null): number;
     respond(body: BodyInit | null, init?: ResponseInit): Response;
     view(options: FullViewOptions): Response;
@@ -55,6 +46,8 @@ export default class ServeApp extends App {
     publish({ code, inline, src, type }: PublishOptions): Promise<void>;
     create_csp(): void;
     register(extension: string, viewFunction: ViewResponse): void;
+    page(name?: string): string;
+    serveAsset(pathname: string): Promise<Response | undefined>;
     start(): Promise<void>;
     stop(): void;
     upgrade(request: Request, actions: Actions): null;
@@ -76,16 +69,6 @@ export default class ServeApp extends App {
             url: URL;
         };
     } | undefined>;
-    get session(): {
-        cookie: {
-            httpOnly: boolean;
-            name: string;
-            path: string;
-            sameSite: "Lax" | "None" | "Strict";
-        };
-        manager: import("./session/Manager.js").default<unknown>;
-        schema: import("@rcompat/type/Schema").default<unknown> | undefined;
-    };
 }
 export {};
-//# sourceMappingURL=ServeApp.d.ts.map
+//# sourceMappingURL=App.d.ts.map

package/lib/private/{ServeApp.js → serve/App.js}

@@ -1,6 +1,4 @@
 import App from "#App";
-import DevModule from "#builtin/DevModule";
-import HandleModule from "#builtin/HandleModule";
 import fail from "#fail";
 import hash from "#hash";
 import I18NModule from "#i18n/Module";
@@ -11,11 +9,14 @@ import parse from "#request/parse";
 import RequestBag from "#request/RequestBag";
 import RequestBody from "#request/RequestBody";
 import router from "#route/router";
+import DevModule from "#serve/module/Dev";
+import HandleModule from "#serve/module/Handle";
 import SessionModule from "#session/SessionModule";
 import tags from "#tags";
 import is from "@rcompat/assert/is";
 import FileRef from "@rcompat/fs/FileRef";
 import FileRouter from "@rcompat/fs/FileRouter";
+import resolve from "@rcompat/http/mime/extension/resolve";
 import TEXT_HTML from "@rcompat/http/mime/text/html";
 import serve from "@rcompat/http/serve";
 import Status from "@rcompat/http/Status";
@@ -58,16 +59,25 @@ export default class ServeApp extends App {
     #views;
     #csp = {};
     #assets = [];
+    #serve_assets;
+    #pages;
     #stores;
     #frontends = {};
     #router;
     #builtins;
     #i18n_config;
     constructor(rootfile, init) {
-        super(new FileRef(rootfile).directory, init.config, init.mode);
+        const dir = new FileRef(rootfile).directory;
+        super(dir, init.config, {
+            mode: init.mode,
+            target: init.target,
+            dir: dir.path,
+        });
         this.#init = init;
         this.#views = Object.fromEntries(init.views ?? []);
         this.#stores = Object.fromEntries((init.stores?.map(([k, s]) => [k, s.default])) ?? []);
+        this.#serve_assets = init.assets;
+        this.#pages = init.pages;
         const http = this.#init.config.http;
         this.#i18n_config = init.i18n_config;
         this.set(s_http, {
@@ -85,11 +95,11 @@ export default class ServeApp extends App {
                 guard: { recursive: true },
                 layout: { recursive: true },
             },
-        }, init.files.routes.map(s => s[0]));
+        }, init.routes.map(s => s[0]));
         this.#builtins = {
             dev: init.mode === "development" ? new DevModule(this) : undefined,
             handle: new HandleModule(this),
-            session: new SessionModule(this),
+            session: init.session_config ? new SessionModule(this.secure, init.session_config) : undefined,
             i18n: init.i18n_config ? new I18NModule(init.i18n_config) : undefined,
         };
     }
@@ -98,12 +108,6 @@ export default class ServeApp extends App {
         const ssl = this.config("http.ssl");
         return ssl.key !== undefined && ssl.cert !== undefined;
     }
-    loader() {
-        return this.#init.loader;
-    }
-    serve(pathname) {
-        return this.loader().serve(pathname);
-    }
     get assets() {
         return this.#assets;
     }
@@ -122,9 +126,6 @@ export default class ServeApp extends App {
     get frontends() {
         return { ...this.#frontends };
     }
-    get files() {
-        return this.#init.files;
-    }
     get stores() {
         return this.#stores;
     }
@@ -132,13 +133,17 @@ export default class ServeApp extends App {
         return this.#i18n_config;
     }
     loadView(name) {
-        const f = new FileRef(name);
-        const base = f.path.slice(0, -f.fullExtension.length);
+        const f = new FileRef(name).path;
+        const frontends = Object.keys(this.frontends);
+        const extension = frontends.find(frontend => f.endsWith(frontend));
+        const base = extension === undefined ? name : f.slice(0, -extension.length);
         const view = this.#views[base];
-        if (view === undefined) {
-            throw fail("missing view component {0}", `${location.views}/${name}`);
+        if (view === undefined)
+            throw fail("no view {0}", name);
+        if (view.default === undefined) {
+            throw fail("view {0} must export a default component", name);
         }
-        return (view.default ?? view);
+        return view.default;
     }
     ;
     headers(csp = {}) {
@@ -164,9 +169,6 @@ export default class ServeApp extends App {
             .replace("%body%", body)
             .replace("%head%", render_head(this.#assets, head));
     }
-    page(page) {
-        return this.loader().page(page);
-    }
     body_length(body) {
         return typeof body === "string" ? utf8ByteLength(body) : 0;
     }
@@ -224,15 +226,88 @@ export default class ServeApp extends App {
         this.#frontends[extension] = viewFunction;
     }
     ;
+    page(name) {
+        const page_name = name ?? location.app_html;
+        return this.#pages[page_name];
+    }
+    async #try_serve(file) {
+        if (await file.exists() && await file.isFile()) {
+            return new Response(file.stream(), {
+                headers: {
+                    "Content-Type": resolve(file.name),
+                    "Content-Length": String(await file.byteLength()),
+                },
+                status: Status.OK,
+            });
+        }
+    }
+    async serveAsset(pathname) {
+        const static_root = this.config("http.static.root");
+        if (!pathname.startsWith(static_root))
+            return undefined;
+        if (this.mode === "development") {
+            const client_asset = this.root.join(location.client, pathname);
+            const client_response = await this.#try_serve(client_asset);
+            if (client_response !== undefined)
+                return client_response;
+            const static_asset = this.root.join("..", location.static, pathname);
+            const static_response = await this.#try_serve(static_asset);
+            if (static_response !== undefined)
+                return static_response;
+            return undefined;
+        }
+        const asset = this.#serve_assets.client[pathname] ??
+            this.#serve_assets.static[pathname];
+        if (asset) {
+            const binary = atob(asset.data);
+            const bytes = new Uint8Array(binary.length);
+            for (let i = 0; i < binary.length; i++) {
+                bytes[i] = binary.charCodeAt(i);
+            }
+            return new Response(bytes, {
+                headers: {
+                    "Content-Type": asset.mime,
+                    "Content-Length": String(bytes.length),
+                },
+                status: Status.OK,
+            });
+        }
+        return undefined;
+    }
     async start() {
-        this.#assets = await Promise.all(this.#init.assets.map(async (asset) => {
-            const code = asset.code;
-            return {
-                ...asset,
-                code,
-                integrity: await hash(code),
-            };
-        }));
+        if (this.mode === "production") {
+            this.#assets = await Promise.all(Object.entries(this.#serve_assets.client)
+                .filter(([src]) => src.endsWith(".css") || src.endsWith(".js"))
+                .map(async ([src, asset]) => {
+                const type = src.endsWith(".css") ? "style" : "js";
+                const code = atob(asset.data);
+                return {
+                    code,
+                    inline: false,
+                    integrity: await hash(code),
+                    src,
+                    type,
+                };
+            }));
+        }
+        else {
+            const client_dir = this.root.join(location.client);
+            const files = await client_dir.exists()
+                ? await client_dir.collect(f => f.extension === ".js"
+                    || f.extension === ".css")
+                : [];
+            this.#assets = await Promise.all(files.map(async (file) => {
+                const type = file.extension === ".css" ? "style" : "js";
+                const code = await file.text();
+                return {
+                    code,
+                    inline: false,
+                    integrity: await hash(code),
+                    src: `/${file.name}`,
+                    type,
+                };
+            }));
+        }
         const modules = [
             this.#builtins.dev,
             ...this.modules,
@@ -306,9 +381,5 @@ export default class ServeApp extends App {
             },
         };
     }
-    get session() {
-        return this.#init.session_config;
-    }
-    ;
 }
-//# sourceMappingURL=ServeApp.js.map
+//# sourceMappingURL=App.js.map

package/lib/private/{ServeInit.d.ts → serve/Init.d.ts}

@@ -1,29 +1,33 @@
-import type Asset from "#asset/Asset";
 import type Config from "#config/Config";
 import type I18NConfig from "#i18n/Config";
-import type Loader from "#Loader";
 import type Mode from "#Mode";
 import type SessionConfig from "#session/Config";
 import type Dict from "@rcompat/type/Dict";
 type Import = {
     default: unknown;
 } & Dict;
-type BuildFiles = {
-    routes: [string, {
-        default: any;
-    }][];
-};
 type ServeInit = {
-    assets: Asset[];
+    assets: {
+        client: Dict<{
+            mime: string;
+            data: string;
+        }>;
+        static: Dict<{
+            mime: string;
+            data: string;
+        }>;
+    };
     views?: [string, Import][];
     stores?: [string, Import][];
     config: Config;
-    files: BuildFiles;
-    loader: Loader;
+    routes: [string, {
+        default: any;
+    }][];
     mode: Mode;
     target: string;
-    session_config: SessionConfig;
+    pages: Dict<string>;
+    session_config?: SessionConfig;
     i18n_config?: I18NConfig;
 };
 export type { ServeInit as default };
-//# sourceMappingURL=ServeInit.d.ts.map
+//# sourceMappingURL=Init.d.ts.map

package/lib/private/serve/Init.js

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

package/lib/private/{hook/serve.d.ts → serve/hook.d.ts}

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

package/lib/private/{hook/serve.js → serve/hook.js}

@@ -10,4 +10,4 @@ async function post(app) {
     return app;
 }
 export default async (app) => post(await reducer(app.modules, pre(app), "serve"));
-//# sourceMappingURL=serve.js.map
+//# sourceMappingURL=hook.js.map

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

@@ -0,0 +1,5 @@
+import ServeApp from "#serve/App";
+import type ServeInit from "#serve/Init";
+declare const _default: (root: string, options: ServeInit) => Promise<ServeApp>;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/private/serve/index.js

@@ -0,0 +1,6 @@
+import ServeApp from "#serve/App";
+import serve from "#serve/hook";
+export default async (root, options) => {
+    return serve(await new ServeApp(root, options).init());
+};
+//# sourceMappingURL=index.js.map

package/lib/private/{builtin/DevModule.d.ts → serve/module/Dev.d.ts}

@@ -1,11 +1,11 @@
 import Module from "#Module";
 import type NextHandle from "#module/NextHandle";
 import type RequestFacade from "#request/RequestFacade";
-import type ServeApp from "#ServeApp";
+import type ServeApp from "#serve/App";
 export default class DevModule extends Module {
     #private;
     name: string;
     constructor(app: ServeApp);
     handle(request: RequestFacade, next: NextHandle): import("@rcompat/type/MaybePromise").default<Response>;
 }
-//# sourceMappingURL=DevModule.d.ts.map
+//# sourceMappingURL=Dev.d.ts.map

package/lib/private/{builtin/DevModule.js → serve/module/Dev.js}

@@ -1,6 +1,5 @@
+import reload from "#build/client/reload";
 import Module from "#Module";
-import reload_defaults from "@rcompat/build/reload/defaults";
-import reload_path from "@rcompat/build/reload/path";
 function pass(address, request) {
     return fetch(address, {
         body: request.body,
@@ -16,9 +15,8 @@ export default class DevModule extends Module {
     constructor(app) {
         super();
         const assets = app.assets.map(asset => asset.src);
-        const http = app.config("http");
-        this.#paths = ([reload_path]).concat(assets);
-        this.#reload_url = `http://${http.host}:${reload_defaults.port}`;
+        this.#paths = ([reload.path]).concat(assets);
+        this.#reload_url = `http://${reload.host}:${reload.port}`;
     }
     handle(request, next) {
         const { pathname } = new URL(request.url);
@@ -27,4 +25,4 @@ export default class DevModule extends Module {
             : next(request);
     }
 }
-//# sourceMappingURL=DevModule.js.map
+//# sourceMappingURL=Dev.js.map

package/lib/private/{builtin/HandleModule.d.ts → serve/module/Handle.d.ts}

@@ -1,10 +1,10 @@
 import Module from "#Module";
 import type RequestFacade from "#request/RequestFacade";
-import type ServeApp from "#ServeApp";
+import type ServeApp from "#serve/App";
 export default class HandleModule extends Module {
     #private;
     name: string;
     constructor(app: ServeApp);
     handle(request: RequestFacade): Promise<Response>;
 }
-//# sourceMappingURL=HandleModule.d.ts.map
+//# sourceMappingURL=Handle.d.ts.map

package/lib/private/{builtin/HandleModule.js → serve/module/Handle.js}

@@ -8,8 +8,8 @@ export default class HandleModule extends Module {
         this.#app = app;
     }
     async handle(request) {
-        return await this.#app.serve(request.url.pathname)
+        return await this.#app.serveAsset(request.url.pathname)
             ?? route(this.#app, request);
     }
 }
-//# sourceMappingURL=HandleModule.js.map
+//# sourceMappingURL=Handle.js.map

package/lib/private/session/SessionModule.d.ts

@@ -2,11 +2,12 @@ import Module from "#Module";
 import type NextHandle from "#module/NextHandle";
 import type NextServe from "#module/NextServe";
 import type RequestFacade from "#request/RequestFacade";
-import type ServeApp from "#ServeApp";
+import type ServeApp from "#serve/App";
+import type Config from "#session/Config";
 export default class SessionModule extends Module {
     #private;
     name: string;
-    constructor(app: ServeApp);
+    constructor(secure: boolean, config: Config);
     serve(app: ServeApp, next: NextServe): Promise<ServeApp>;
     handle(request: RequestFacade, next: NextHandle): Promise<Response>;
 }

package/lib/private/session/SessionModule.js

@@ -1,7 +1,9 @@
+import fail from "#fail";
 import Module from "#Module";
 import kSerialize from "#session/k-serialize";
 import SessionHandle from "#session/SessionHandle";
 import storage from "#session/storage";
+import p from "pema";
 const cookie = (name, value, options) => {
     const parts = [`${name}=${value}`];
     parts.push(`Path=${options.path}`);
@@ -16,26 +18,47 @@ const cookie = (name, value, options) => {
 };
 export default class SessionModule extends Module {
     name = "builtin/session";
-    #app;
-    #manager;
+    #store;
     #secure;
-    constructor(app) {
+    #config;
+    constructor(secure, config) {
         super();
-        this.#app = app;
-        this.#secure = app.secure;
-        this.#manager = app.session.manager;
+        this.#secure = secure;
+        this.#config = config;
+        this.#store = config.store;
+        const props = this.#store.type.properties;
+        if (!("session_id" in props)) {
+            throw fail("Session store must have a session_id field");
+        }
+        try {
+            props.session_id.parse(crypto.randomUUID());
+        }
+        catch {
+            throw fail("Session store session_id must be a string type");
+        }
     }
     async serve(app, next) {
-        // initialize the session manager
-        await this.#manager.init?.();
+        await this.#store.collection.create();
         return next(app);
     }
     async handle(request, next) {
-        const { name, ...config } = this.#app.session.cookie;
+        const { name, ...config } = this.#config.cookie;
         const sid = request.cookies.try(name);
-        const data = sid !== undefined ? await this.#manager.load(sid) : undefined;
-        const id = data !== undefined ? sid : undefined;
-        const session = new SessionHandle(id, data, this.#app.session.schema);
+        // Look up session by session_id
+        const existing = sid !== undefined
+            ? await this.#store.find({ session_id: sid }, { limit: 1 })
+            : [];
+        const exists = existing.length > 0;
+        let data = undefined;
+        let dbId = undefined;
+        if (exists) {
+            const record = existing[0];
+            const { id: _id, session_id: _sid, ...rest } = record;
+            data = rest;
+            dbId = _id;
+        }
+        const session_type = p.omit(this.#store.type, "id", "session_id");
+        const session = new SessionHandle(sid, data, session_type);
         const response = await new Promise((resolve, reject) => {
             storage().run(session, async () => {
                 try {
@@ -56,10 +79,10 @@ export default class SessionModule extends Module {
             sameSite: config.sameSite,
             secure: this.#secure,
         };
-        // no session existed -> either create or noop (noop already returned)
-        if (id === undefined) {
+        // no session existed -> either create or noop
+        if (!exists) {
             if (!snap.exists) {
-                // stale cookie -> clear; no cookie, noop
+                // stale cookie -> clear
                 if (sid !== undefined) {
                     response.headers.append("set-cookie", cookie(name, "", {
                         ...options, maxAge: 0,
@@ -67,32 +90,32 @@ export default class SessionModule extends Module {
                 }
                 return response;
             }
-            // safe due to fast-path
-            await this.#manager.create(snap.id, snap.data);
+            // create new session
+            await this.#store.insert({ session_id: snap.id, ...snap.data });
             response.headers.append("set-cookie", cookie(name, snap.id, options));
             return response;
         }
-        // from here: session existed (id is defined)
+        // from here: session existed (dbId is defined)
         // fast-path: session exists, same id and not dirty -> noop
-        if (snap.exists && snap.id === id && !snap.dirty)
+        if (snap.exists && snap.id === sid && !snap.dirty)
             return response;
         // current absent -> destroy + clear cookie
         if (!snap.exists) {
-            await this.#manager.destroy(id);
+            await this.#store.delete(dbId);
             response.headers.append("set-cookie", cookie(name, "", {
                 ...options, maxAge: 0,
             }));
             return response;
         }
         // session recreated in route -> destroy old, create new, set cookie
-        if (snap.id !== id) {
-            await this.#manager.destroy(id);
-            await this.#manager.create(snap.id, snap.data);
+        if (snap.id !== sid) {
+            await this.#store.delete(dbId);
+            await this.#store.insert({ session_id: snap.id, ...snap.data });
             response.headers.append("set-cookie", cookie(name, snap.id, options));
             return response;
         }
         // dirty -> replace session contents
-        await this.#manager.save(id, snap.data);
+        await this.#store.update(dbId, snap.data);
         return response;
     }
 }

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

@@ -1,13 +1,16 @@
+import type DatabaseStore from "#database/Store";
 import configSchema from "#session/schema";
 import type SessionFacade from "#session/SessionFacade";
-import type Schema from "@rcompat/type/Schema";
+import type InferStore from "pema/InferStore";
+import type StoreSchema from "pema/StoreSchema";
 type ConfigInput = typeof configSchema.input;
-type InferSchema<S> = S extends {
-    parse(input: unknown): infer T;
-} ? T : unknown;
-export default function session<S extends Schema<any>>(config: {
-    schema: S;
-} & Partial<ConfigInput>): SessionFacade<InferSchema<S>>;
-export default function session(config?: Omit<Partial<ConfigInput>, "schema">): SessionFacade<unknown>;
+type X<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type Infer<S extends StoreSchema> = X<Omit<InferStore<S>, "id" | "session_id">>;
+export default function session<S extends StoreSchema>(config: {
+    store: DatabaseStore<S>;
+} & Partial<ConfigInput>): SessionFacade<Infer<S>>;
+export default function session(Infer?: Omit<Partial<ConfigInput>, "store">): SessionFacade<unknown>;
 export {};
 //# sourceMappingURL=index.d.ts.map

package/lib/private/session/index.js

@@ -3,8 +3,8 @@ import local_storage from "#session/storage";
 import s_config from "#symbol/config";
 export default function session(config) {
     const parsed = configSchema.parse(config ?? {});
-    const schema = config?.schema;
-    // bind the ALS store to this T (unknown at runtime; fine)
+    const store = parsed.store;
+    // bind the ALS store to this T
     const storage = local_storage();
     const current = () => {
         const s = storage.getStore();
@@ -34,7 +34,9 @@ export default function session(config) {
         destroy() {
             current().destroy();
         },
-        get [s_config]() { return { ...parsed, schema }; },
+        get [s_config]() {
+            return { ...parsed, store };
+        },
     };
     return facade;
 }

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

@@ -1,5 +1,4 @@
-import SessionManager from "#session/Manager";
-import type Schema from "@rcompat/type/Schema";
+import Store from "#database/Store";
 declare const _default: import("pema").ObjectType<{
     cookie: import("pema").ObjectType<{
         httpOnly: import("pema").DefaultType<import("pema/boolean").BooleanType, true>;
@@ -7,8 +6,7 @@ declare const _default: import("pema").ObjectType<{
         path: import("pema").DefaultType<import("pema/string").StringType, "/">;
         sameSite: import("pema").DefaultType<import("pema/union").UnionType<[import("pema").LiteralType<"Strict">, import("pema").LiteralType<"Lax">, import("pema").LiteralType<"None">]>, "Lax" | "None" | "Strict">;
     }>;
-    manager: import("pema").DefaultType<import("pema/constructor").ConstructorType<typeof SessionManager>, SessionManager<unknown>>;
-    schema: import("pema").OptionalType<import("pema").PureType<Schema<unknown>, "PureType">>;
+    store: import("pema").DefaultType<import("pema").ConstructorType<typeof Store>, Store<import("pema/StoreSchema").default>>;
 }>;
 export default _default;
 //# sourceMappingURL=schema.d.ts.map