@primate/core 0.1.10 → 0.2.0

package/lib/private/App.d.ts

@@ -0,0 +1,54 @@
+import type Binder from "#Binder";
+import type Config from "#config/Config";
+import type Mode from "#Mode";
+import type Module from "#Module";
+import TargetManager from "#target/Manager";
+import type FileRef from "@rcompat/fs/FileRef";
+import get from "@rcompat/record/get";
+export default class App {
+    #private;
+    constructor(root: FileRef, config: Config, mode: Mode);
+    init(target: string): Promise<App>;
+    get location(): {
+        app_html: "app.html";
+        build: "build";
+        client: "client";
+        components: "components";
+        config: "config";
+        error_html: "error.html";
+        modules: "modules";
+        pages: "pages";
+        routes: "routes";
+        server: "server";
+        static: "static";
+        stores: "stores";
+        locales: "locales";
+    };
+    get target(): TargetManager;
+    get root(): FileRef;
+    get path(): {
+        readonly app_html: FileRef;
+        readonly build: FileRef;
+        readonly client: FileRef;
+        readonly components: FileRef;
+        readonly config: FileRef;
+        readonly error_html: FileRef;
+        readonly modules: FileRef;
+        readonly pages: FileRef;
+        readonly routes: FileRef;
+        readonly server: FileRef;
+        readonly static: FileRef;
+        readonly stores: FileRef;
+        readonly locales: FileRef;
+    };
+    get mode(): Mode;
+    get modules(): Module[];
+    get extensions(): string[];
+    binder(file: FileRef): Binder | undefined;
+    get<T>(key: symbol): T;
+    set(key: symbol, value: unknown): void;
+    config<P extends string>(path: P): ReturnType<typeof get<Config, P>>;
+    runpath(...directories: string[]): FileRef;
+    bind(extension: string, binder: Binder): void;
+}
+//# sourceMappingURL=App.d.ts.map

package/lib/private/App.js

@@ -0,0 +1,128 @@
+import fail from "#fail";
+import location from "#location";
+import reducer from "#reducer";
+import wrap from "#route/wrap";
+import TargetManager from "#target/Manager";
+import assert from "@rcompat/assert";
+import transform from "@rcompat/build/sync/transform";
+import entries from "@rcompat/record/entries";
+import get from "@rcompat/record/get";
+const ts_options = {
+    loader: "ts",
+    tsconfigRaw: {
+        compilerOptions: {
+            experimentalDecorators: true,
+        },
+    },
+};
+const compile = (code) => transform(code, ts_options).code;
+const toContextString = (array) => array
+    .map(member => member.endsWith("s") ? member.slice(0, -1) : member)
+    .join(", ");
+const BIND_CONTEXTS = [
+    "config",
+    "routes",
+    "components",
+    "stores",
+    "locales",
+    "modules",
+];
+function generate_bindings(_app) {
+    return {
+        ".js": async (file, { build, context }) => {
+            const error = `js: only ${toContextString(BIND_CONTEXTS)} are supported`;
+            assert(BIND_CONTEXTS.includes(context), error);
+            const code = context === "routes"
+                ? wrap(await file.text(), file, build)
+                : await file.text();
+            await file.append(".js").write(code);
+        },
+        ".json": () => {
+            // just copy the JSON for now
+        },
+        ".ts": async (file, { build, context }) => {
+            const error = `ts: only ${toContextString(BIND_CONTEXTS)} are supported`;
+            assert(BIND_CONTEXTS.includes(context), error);
+            const code = context === "routes"
+                ? wrap(compile(await file.text()), file, build)
+                : compile(await file.text());
+            await file.append(".js").write(code);
+        },
+    };
+}
+const doubled = (set) => set.find((part, i, array) => array.filter((_, j) => i !== j).includes(part)) ?? "";
+export default class App {
+    #path;
+    #root;
+    #config;
+    #modules;
+    #kv = new Map();
+    #mode;
+    #bindings;
+    #target;
+    constructor(root, config, mode) {
+        this.#root = root;
+        this.#config = config;
+        this.#modules = config.modules?.flat(10) ?? [];
+        this.#path = entries(location).valmap(([, path]) => root.join(path)).get();
+        this.#mode = mode;
+        this.#target = new TargetManager(this);
+        this.#bindings = Object.entries(generate_bindings(this));
+    }
+    async init(target) {
+        const names = this.#modules.map(({ name }) => name);
+        if (new Set(names).size !== this.#modules.length) {
+            throw fail("module {0} loaded twice", doubled(names));
+        }
+        const app = await reducer(this.#modules, this, "init");
+        this.#target.set(target);
+        return app;
+    }
+    get location() {
+        return { ...location };
+    }
+    get target() {
+        return this.#target;
+    }
+    get root() {
+        return this.#root;
+    }
+    get path() {
+        return this.#path;
+    }
+    get mode() {
+        return this.#mode;
+    }
+    get modules() {
+        return [...this.#modules];
+    }
+    get extensions() {
+        return this.#bindings.map(([extension]) => extension);
+    }
+    binder(file) {
+        return this.#bindings
+            .toSorted(([a], [b]) => a.length > b.length ? -1 : 1)
+            .find(([extension]) => file.path.endsWith(extension))?.[1];
+    }
+    get(key) {
+        return this.#kv.get(key);
+    }
+    set(key, value) {
+        this.#kv.set(key, value);
+    }
+    config(path) {
+        return get(this.#config, path);
+    }
+    runpath(...directories) {
+        return this.#path.build.join(...directories);
+    }
+    // this is technically not necessary for serving, but it has to be used by
+    // the init hook, which is shared between the build and serve app
+    bind(extension, binder) {
+        if (this.extensions.includes(extension)) {
+            throw new Error(`${extension} already bound`);
+        }
+        this.#bindings.push([extension, binder]);
+    }
+}
+//# sourceMappingURL=App.js.map

package/lib/private/AppError.d.ts

@@ -0,0 +1,4 @@
+export default class AppError extends Error {
+    constructor(message: string, ...params: unknown[]);
+}
+//# sourceMappingURL=AppError.d.ts.map

package/lib/private/AppError.js

@@ -0,0 +1,8 @@
+import mark from "@rcompat/cli/mark";
+export default class AppError extends Error {
+    constructor(message, ...params) {
+        super(mark(message, ...params));
+    }
+}
+;
+//# sourceMappingURL=AppError.js.map

package/lib/private/Binder.d.ts

@@ -0,0 +1,13 @@
+import type BindingContext from "#BindingContext";
+import type FileRef from "@rcompat/fs/FileRef";
+import type MaybePromise from "@rcompat/type/MaybePromise";
+type Options = {
+    build: {
+        id: string;
+        stage: FileRef;
+    };
+    context: BindingContext;
+};
+type Binder = (file: FileRef, options: Options) => MaybePromise<void>;
+export type { Binder as default };
+//# sourceMappingURL=Binder.d.ts.map

package/lib/private/Binder.js

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

package/lib/private/BindingContext.d.ts

@@ -0,0 +1,3 @@
+type BindingContext = "components" | "config" | "locales" | "modules" | "routes" | "stores";
+export type { BindingContext as default };
+//# sourceMappingURL=BindingContext.d.ts.map

package/lib/private/BindingContext.js

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

package/lib/private/BuildApp.d.ts

@@ -0,0 +1,23 @@
+import App from "#App";
+import type BindingContext from "#BindingContext";
+import Build from "@rcompat/build";
+import type FileRef from "@rcompat/fs/FileRef";
+import type MaybePromise from "@rcompat/type/MaybePromise";
+export default class BuildApp extends App {
+    #private;
+    frontends: Map<string, string>;
+    buildInit(): Promise<void>;
+    get id(): string;
+    get build(): Build;
+    get server_build(): string[];
+    addRoot(root: FileRef): void;
+    get roots(): FileRef[];
+    done(fn: () => void): void;
+    cleanup(): void;
+    export(code: string): void;
+    stage(directory: FileRef, context: BindingContext, importer: (file: FileRef) => MaybePromise<string>): Promise<void>;
+    depth(): number;
+    get i18n_active(): boolean;
+    set i18n_active(active: boolean);
+}
+//# sourceMappingURL=BuildApp.d.ts.map

package/lib/private/BuildApp.js

@@ -0,0 +1,121 @@
+import App from "#App";
+import build from "#hook/build";
+import location from "#location";
+import log from "#log";
+import s_layout_depth from "#symbol/layout-depth";
+import Build from "@rcompat/build";
+import cache from "@rcompat/kv/cache";
+const s = Symbol("primate.Build");
+export default class BuildApp extends App {
+    frontends = new Map();
+    #postbuild = [];
+    #roots = [];
+    #server_build = ["route"];
+    #id = crypto.randomUUID().slice(0, 8);
+    #i18n_active = false;
+    async buildInit() {
+        log.system("starting {0} build in {1} mode", this.target.name, this.mode);
+        await build(this);
+    }
+    get id() {
+        return this.#id;
+    }
+    get build() {
+        const extensions = [...this.frontends.values()];
+        return cache.get(s, () => new Build({
+            ...(this.config("build")),
+            outdir: this.runpath(location.client).path,
+            stdin: {
+                contents: "",
+                resolveDir: this.root.path,
+            },
+            resolveExtensions: [".ts", ".js", ...extensions],
+            tsconfigRaw: {
+                compilerOptions: {
+                    baseUrl: "${configDir}",
+                    paths: {
+                        "#component/*": [
+                            "components/*", ...extensions.map(e => `components/*${e}`),
+                        ],
+                        "#static/*": ["./static/*.js", "./static/*.ts"],
+                        "#i18n": ["config/i18n.ts", "config/i18n.js"],
+                        "#store/*": ["stores/*"],
+                        "#locale/*": ["locales/*"],
+                        "#config/*": ["config/*"],
+                        "#session": ["config/session.ts", "config/session.js"],
+                        "#database": [
+                            "config/database/index.ts",
+                            "config/database/index.js",
+                            "config/database/default.ts",
+                            "config/database/default.js",
+                        ],
+                    },
+                },
+            },
+        }, this.mode === "development" ? "development" : "production"));
+    }
+    get server_build() {
+        return this.#server_build;
+    }
+    addRoot(root) {
+        this.#roots.push(root);
+    }
+    get roots() {
+        return [...this.#roots];
+    }
+    done(fn) {
+        this.#postbuild.push(fn);
+    }
+    cleanup() {
+        this.#postbuild.forEach(fn => fn());
+    }
+    export(code) {
+        this.build.export(code);
+    }
+    async stage(directory, context, importer) {
+        if (!await directory.exists()) {
+            return;
+        }
+        if (!await this.runpath("stage").exists()) {
+            await this.runpath("stage").create();
+        }
+        const base = this.runpath("stage", context);
+        if (!await base.exists()) {
+            await base.create();
+        }
+        const build_directory = this.runpath(directory.name);
+        await build_directory.create();
+        for (const file of await directory.collect(({ path }) => /^.*$/.test(path))) {
+            const debased = file.debase(directory);
+            const target = base.join(debased);
+            if (!await target.directory.exists()) {
+                await target.directory.create({ recursive: true });
+            }
+            const binder = this.binder(file);
+            if (binder === undefined) {
+                log.info("no binder found for {0}", file.path);
+                continue;
+            }
+            // copy to build/stage/${directory}
+            await file.copy(target);
+            await binder(target, {
+                build: { id: this.id, stage: this.runpath("stage") },
+                context,
+            });
+            // actual
+            const runtime_file = build_directory.join(debased.bare(".js"));
+            await runtime_file.directory.create();
+            runtime_file.write(await importer(debased));
+        }
+    }
+    depth() {
+        return this.get(s_layout_depth);
+    }
+    get i18n_active() {
+        return this.#i18n_active;
+    }
+    set i18n_active(active) {
+        this.#i18n_active = active;
+    }
+}
+//# sourceMappingURL=BuildApp.js.map

package/lib/private/CSP.d.ts

@@ -0,0 +1,6 @@
+type CSPProperties = "script-src" | "style-src";
+type CSP = {
+    [K in CSPProperties]?: string[];
+};
+export type { CSP as default };
+//# sourceMappingURL=CSP.d.ts.map

package/lib/private/CSP.js

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

package/lib/private/Loader.d.ts

@@ -0,0 +1,17 @@
+import FileRef from "@rcompat/fs/FileRef";
+import type Dict from "@rcompat/type/Dict";
+type Init = {
+    pages: Dict<string>;
+    rootfile: string;
+    static_root: string;
+};
+export default class Loader {
+    #private;
+    constructor(init: Init);
+    get static_root(): string;
+    page(name?: string): string;
+    asset(file: FileRef): Response;
+    serve(pathname: string): Promise<Response | undefined>;
+}
+export {};
+//# sourceMappingURL=Loader.d.ts.map

package/lib/private/Loader.js

@@ -0,0 +1,46 @@
+import location from "#location";
+import FileRef from "@rcompat/fs/FileRef";
+import Status from "@rcompat/http/Status";
+import resolve from "@rcompat/http/mime/extension/resolve";
+export default class Loader {
+    #init;
+    #root;
+    constructor(init) {
+        this.#init = init;
+        this.#root = new FileRef(init.rootfile).join("..");
+    }
+    get static_root() {
+        return this.#init.static_root;
+    }
+    get #pages() {
+        return this.#init.pages;
+    }
+    page(name) {
+        if (name === undefined || !(name in this.#pages)) {
+            return this.#pages[location.app_html];
+        }
+        return this.#pages[name];
+    }
+    asset(file) {
+        return new Response(file.stream(), {
+            headers: {
+                "Content-Type": resolve(file.name),
+            },
+            status: Status.OK,
+        });
+    }
+    async serve(pathname) {
+        const client_file = this.#root.join(`client/${pathname}`);
+        if (await client_file.isFile()) {
+            return this.asset(client_file);
+        }
+        if (pathname.startsWith(this.static_root)) {
+            const assetname = pathname.slice(this.static_root.length);
+            const static_file = this.#root.join(`static/${assetname}`);
+            if (await static_file.isFile()) {
+                return this.asset(static_file);
+            }
+        }
+    }
+}
+//# sourceMappingURL=Loader.js.map

package/lib/private/Mode.d.ts

@@ -0,0 +1,3 @@
+type Mode = "development" | "production" | "testing";
+export { Mode as default };
+//# sourceMappingURL=Mode.d.ts.map

package/lib/private/Mode.js

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

package/lib/private/Module.d.ts

@@ -0,0 +1,18 @@
+import type App from "#App";
+import type BuildApp from "#BuildApp";
+import type Next from "#module/Next";
+import type NextBuild from "#module/NextBuild";
+import type NextHandle from "#module/NextHandle";
+import type NextRoute from "#module/NextRoute";
+import type NextServe from "#module/NextServe";
+import type RequestFacade from "#request/RequestFacade";
+import type ServeApp from "#ServeApp";
+export default abstract class Module {
+    abstract get name(): string;
+    init<T extends App>(app: T, next: Next<T>): import("@rcompat/type/MaybePromise").default<T>;
+    build(app: BuildApp, next: NextBuild): import("@rcompat/type/MaybePromise").default<BuildApp>;
+    serve(app: ServeApp, next: NextServe): import("@rcompat/type/MaybePromise").default<ServeApp>;
+    handle(request: RequestFacade, next: NextHandle): import("@rcompat/type/MaybePromise").default<Response>;
+    route(request: RequestFacade, next: NextRoute): import("@rcompat/type/MaybePromise").default<import("./response/ResponseLike.js").default>;
+}
+//# sourceMappingURL=Module.d.ts.map

package/lib/private/Module.js

@@ -0,0 +1,18 @@
+export default class Module {
+    init(app, next) {
+        return next(app);
+    }
+    build(app, next) {
+        return next(app);
+    }
+    serve(app, next) {
+        return next(app);
+    }
+    handle(request, next) {
+        return next(request);
+    }
+    route(request, next) {
+        return next(request);
+    }
+}
+//# sourceMappingURL=Module.js.map

package/lib/private/ServeApp.d.ts

@@ -0,0 +1,89 @@
+import App from "#App";
+import type Asset from "#asset/Asset";
+import type ServerComponent from "#frontend/ServerComponent";
+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 ServeInit from "#ServeInit";
+import FileRouter from "@rcompat/fs/FileRouter";
+import type Actions from "@rcompat/http/Actions";
+import type Dict from "@rcompat/type/Dict";
+interface FullViewOptions extends ViewOptions {
+    body: string;
+}
+interface PublishOptions {
+    code: string;
+    inline: boolean;
+    src?: string;
+    type: string;
+}
+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 url(): string;
+    get router(): FileRouter;
+    get frontends(): {
+        [x: string]: ViewResponse | undefined;
+    };
+    get files(): {
+        routes: [string, {
+            default: any;
+        }][];
+    };
+    get stores(): Dict;
+    get i18n(): I18NConfig | undefined;
+    component<T = ServerComponent>(name: string): T;
+    headers(csp?: {}): {
+        "Content-Security-Policy"?: string | undefined;
+    };
+    render(content: Omit<FullViewOptions, keyof ResponseInit>): string;
+    page(page?: string): string;
+    respond(body: BodyInit | null, init?: ResponseInit): Response;
+    view(options: FullViewOptions): Response;
+    media(content_type: string, response?: ResponseInit): ResponseInit;
+    publish({ code, inline, src, type }: PublishOptions): Promise<void>;
+    create_csp(): void;
+    register(extension: string, viewFunction: ViewResponse): void;
+    start(): Promise<void>;
+    stop(): void;
+    upgrade(request: Request, actions: Actions): null;
+    route(request: RequestFacade): Promise<{
+        errors: import("./route/Handler.js").default[];
+        guards: import("./route/Handler.js").default[];
+        handler: import("./route/Handler.js").default;
+        layouts: import("./route/Handler.js").default[];
+        request: {
+            body: RequestBody;
+            path: RequestBag;
+            context: Dict;
+            cookies: RequestBag;
+            forward(to: string, headers?: Dict<string>): Promise<Response>;
+            headers: RequestBag;
+            original: Request;
+            query: RequestBag;
+            target: string;
+            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