@primate/core 0.1.10 → 0.2.0

package/lib/private/route/wrap.js

@@ -0,0 +1,17 @@
+import location from "#location";
+import dedent from "@rcompat/string/dedent";
+export default function wrap(code, file, build) {
+    const router = `ROUTER_${build.id}`;
+    const debased = file.debase(build.stage.join(location.routes)).path
+        .slice(1, -file.extension.length);
+    const prelude = dedent `
+    import ${router} from "primate/router";
+    ${router}.push("${debased}");
+  `;
+    const postlude = `
+${router}.pop();
+`;
+    return `${prelude}${code}${postlude}`;
+}
+;
+//# sourceMappingURL=wrap.js.map

package/lib/private/route.d.ts

@@ -0,0 +1,9 @@
+import type Verb from "#request/Verb";
+import type RouteHandler from "#route/Handler";
+import type RouteOptions from "#route/Options";
+type Route = {
+    [key in Verb]: (handler: RouteHandler, options?: RouteOptions) => void;
+};
+declare const _default: Route;
+export default _default;
+//# sourceMappingURL=route.d.ts.map

package/lib/private/route.js

@@ -0,0 +1,6 @@
+import verbs from "#request/verbs";
+import router from "#route/router";
+export default Object.fromEntries(verbs.map(verb => [verb, (handler, options) => {
+        router.add(verb, handler, options);
+    }]));
+//# sourceMappingURL=route.js.map

package/lib/private/serve.d.ts

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

package/lib/private/serve.js

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

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

@@ -0,0 +1,4 @@
+import type schema from "#session/schema";
+type Config = typeof schema.infer;
+export type { Config as default };
+//# sourceMappingURL=Config.d.ts.map

package/lib/private/session/Config.js

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

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

@@ -0,0 +1,5 @@
+import type Dict from "@rcompat/type/Dict";
+import type JSONValue from "@rcompat/type/JSONValue";
+type Data = Dict<JSONValue>;
+export { Data as default };
+//# sourceMappingURL=Data.d.ts.map

package/lib/private/session/Data.js

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

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

@@ -0,0 +1,9 @@
+import SessionManager from "#session/Manager";
+export default class InMemorySessionManager<Data> extends SessionManager<Data> {
+    #private;
+    load(id: string): Data | undefined;
+    create(id: string, data: Data): void;
+    save(id: string, data: Data): void;
+    destroy(id: string): void;
+}
+//# sourceMappingURL=InMemoryManager.d.ts.map

package/lib/private/session/InMemoryManager.js

@@ -0,0 +1,23 @@
+import SessionManager from "#session/Manager";
+import assert from "@rcompat/assert";
+export default class InMemorySessionManager extends SessionManager {
+    // id -> JSON
+    #sessions = new Map();
+    load(id) {
+        const raw = this.#sessions.get(id);
+        return raw === undefined ? undefined : JSON.parse(raw);
+    }
+    create(id, data) {
+        assert(!this.#sessions.has(id), `session already exists: ${id}`);
+        this.#sessions.set(id, JSON.stringify(data));
+    }
+    save(id, data) {
+        assert(this.#sessions.has(id), `session not found: ${id}`);
+        this.#sessions.set(id, JSON.stringify(data));
+    }
+    // idempotent
+    destroy(id) {
+        this.#sessions.delete(id);
+    }
+}
+//# sourceMappingURL=InMemoryManager.js.map

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

@@ -0,0 +1,9 @@
+import type MaybePromise from "@rcompat/type/MaybePromise";
+export default abstract class SessionManager<Data> {
+    init?(): MaybePromise<void>;
+    abstract load(id: string): MaybePromise<Data | undefined>;
+    abstract create(id: string, data: Data): MaybePromise<void>;
+    abstract save(id: string, data: Data): MaybePromise<void>;
+    abstract destroy(id: string): MaybePromise<void>;
+}
+//# sourceMappingURL=Manager.d.ts.map

package/lib/private/session/Manager.js

@@ -0,0 +1,4 @@
+export default class SessionManager {
+    init() { }
+}
+//# sourceMappingURL=Manager.js.map

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

@@ -0,0 +1,56 @@
+/**
+ * Public session API available inside routes with
+ * import session from "#session";
+ *
+ * `T` is inferred automatically from the app's `config/session.ts` schema.
+ */
+export default interface SessionFacade<T> {
+    /**
+     * The unique session identifier for the current user, or `undefined` if no
+     * session has been created yet or if it has been destroyed.
+     *
+     * This value is typically sent back to the client in a cookie.
+     */
+    readonly id: string | undefined;
+    /**
+     * Whether a session currently exists.
+     *
+     * Equivalent to checking `id !== undefined`.
+     */
+    readonly exists: boolean;
+    /**
+     * Create a new session. Optionally accepts initial data.
+     *
+     * - If a session already exists, this is a no-op.
+     * - Data is validated through the schema if one was provided.
+     */
+    create(initial?: T): void;
+    /**
+     * Get the current session data.
+     *
+     * @throws if the session does not exist.
+     */
+    get(): Readonly<T>;
+    /**
+     * Get the current session data if it exists, otherwise return `undefined`.
+     */
+    try(): Readonly<T> | undefined;
+    /**
+     * Replace the current session data.
+     *
+     * - Accepts either a new object or a callback that maps the previous data to
+     *   the next.
+     * - Data is validated through the schema if one was provided.
+     *
+     * @throws if the session does not exist.
+     */
+    set(next: ((previous: Readonly<T>) => T) | T): void;
+    /**
+     * Destroy the current session.
+     *
+     * - If no session exists, this is a no-op.
+     * - After destruction, `id` becomes `undefined` and `exists` returns `false`.
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=SessionFacade.d.ts.map

package/lib/private/session/SessionFacade.js

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

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

@@ -0,0 +1,20 @@
+import kSerialize from "#session/k-serialize";
+import type Schema from "@rcompat/type/Schema";
+export default class SessionHandle<Data> {
+    #private;
+    [kSerialize]: () => {
+        data: Data | undefined;
+        dirty: boolean;
+        exists: boolean;
+        id: string | undefined;
+    };
+    constructor(id?: string, data?: Data, schema?: Schema<Data>);
+    get exists(): boolean;
+    get id(): string | undefined;
+    get(): Readonly<Data>;
+    try(): Readonly<Data> | undefined;
+    create(initial?: Data): void;
+    set(next: ((previous: Readonly<Data>) => Data) | Data): void;
+    destroy(): void;
+}
+//# sourceMappingURL=SessionHandle.d.ts.map

package/lib/private/session/SessionHandle.js

@@ -0,0 +1,67 @@
+import kSerialize from "#session/k-serialize";
+import assert from "@rcompat/assert";
+import maybe from "@rcompat/assert/maybe";
+export default class SessionHandle {
+    #id;
+    #data;
+    #schema;
+    #dirty = false;
+    constructor(id, data, schema) {
+        maybe(id).uuid();
+        maybe(data).record();
+        maybe(schema).object();
+        maybe(schema?.parse).function();
+        assert((id === undefined) === (data === undefined), "both `id` and `data` must be defined or undefined");
+        this.#id = id;
+        this.#data = data;
+        this.#schema = schema ?? { parse: (x) => x };
+    }
+    get exists() {
+        return this.#id !== undefined;
+    }
+    get id() {
+        return this.#id;
+    }
+    get() {
+        if (!this.exists)
+            throw new Error("session does not exist");
+        return this.#data;
+    }
+    try() {
+        return this.exists ? this.#data : undefined;
+    }
+    create(initial) {
+        // idempotent noop
+        if (this.exists)
+            return;
+        const parsed = this.#schema.parse(initial ?? {});
+        this.#id = crypto.randomUUID();
+        this.#data = parsed;
+        this.#dirty = true;
+    }
+    set(next) {
+        if (!this.exists)
+            throw new Error("cannot set() on non-existent session");
+        const previous = this.#data;
+        // @ts-expect-error TEST
+        const candidate = typeof next === "function" ? next(previous) : next;
+        this.#data = this.#schema.parse(candidate);
+        this.#dirty = true;
+    }
+    destroy() {
+        if (!this.exists)
+            return;
+        this.#id = undefined;
+        this.#data = undefined;
+        this.#dirty = true;
+    }
+    [kSerialize]() {
+        return {
+            data: this.#data,
+            dirty: this.#dirty,
+            exists: this.exists,
+            id: this.#id,
+        };
+    }
+}
+//# sourceMappingURL=SessionHandle.js.map

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

@@ -0,0 +1,13 @@
+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";
+export default class SessionModule extends Module {
+    #private;
+    name: string;
+    constructor(app: ServeApp);
+    serve(app: ServeApp, next: NextServe): Promise<ServeApp>;
+    handle(request: RequestFacade, next: NextHandle): Promise<Response>;
+}
+//# sourceMappingURL=SessionModule.d.ts.map

package/lib/private/session/SessionModule.js

@@ -0,0 +1,99 @@
+import Module from "#Module";
+import kSerialize from "#session/k-serialize";
+import SessionHandle from "#session/SessionHandle";
+import storage from "#session/storage";
+const cookie = (name, value, options) => {
+    const parts = [`${name}=${value}`];
+    parts.push(`Path=${options.path}`);
+    parts.push(`SameSite=${options.sameSite}`);
+    if (options.maxAge !== undefined)
+        parts.push(`Max-Age=${options.maxAge}`);
+    if (options.httpOnly)
+        parts.push("HttpOnly");
+    if (options.secure)
+        parts.push("Secure");
+    return parts.join("; ");
+};
+export default class SessionModule extends Module {
+    name = "builtin/session";
+    #app;
+    #manager;
+    #secure;
+    constructor(app) {
+        super();
+        this.#app = app;
+        this.#secure = app.secure;
+        this.#manager = app.session.manager;
+    }
+    async serve(app, next) {
+        // initialize the session manager
+        await this.#manager.init?.();
+        return next(app);
+    }
+    async handle(request, next) {
+        const { name, ...config } = this.#app.session.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);
+        const response = await new Promise((resolve, reject) => {
+            storage().run(session, async () => {
+                try {
+                    resolve(await next(request));
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
+        const snap = session[kSerialize]();
+        // no cookie coming in, no session created
+        if (sid === undefined && !snap.exists)
+            return response;
+        const options = {
+            httpOnly: !!config.httpOnly,
+            path: config.path,
+            sameSite: config.sameSite,
+            secure: this.#secure,
+        };
+        // no session existed -> either create or noop (noop already returned)
+        if (id === undefined) {
+            if (!snap.exists) {
+                // stale cookie -> clear; no cookie, noop
+                if (sid !== undefined) {
+                    response.headers.append("set-cookie", cookie(name, "", {
+                        ...options, maxAge: 0,
+                    }));
+                }
+                return response;
+            }
+            // safe due to fast-path
+            await this.#manager.create(snap.id, snap.data);
+            response.headers.append("set-cookie", cookie(name, snap.id, options));
+            return response;
+        }
+        // from here: session existed (id is defined)
+        // fast-path: session exists, same id and not dirty -> noop
+        if (snap.exists && snap.id === id && !snap.dirty)
+            return response;
+        // current absent -> destroy + clear cookie
+        if (!snap.exists) {
+            await this.#manager.destroy(id);
+            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);
+            response.headers.append("set-cookie", cookie(name, snap.id, options));
+            return response;
+        }
+        // dirty -> replace session contents
+        await this.#manager.save(id, snap.data);
+        return response;
+    }
+}
+//# sourceMappingURL=SessionModule.js.map

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

@@ -0,0 +1,13 @@
+import configSchema from "#session/schema";
+import type SessionFacade from "#session/SessionFacade";
+import type Schema from "@rcompat/type/Schema";
+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>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/private/session/index.js

@@ -0,0 +1,41 @@
+import configSchema from "#session/schema";
+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 storage = local_storage();
+    const current = () => {
+        const s = storage.getStore();
+        if (!s)
+            throw new Error("Session handle not available in this context");
+        return s;
+    };
+    const facade = {
+        get id() {
+            return current().id;
+        },
+        get exists() {
+            return current().exists;
+        },
+        create(initial) {
+            current().create(initial);
+        },
+        get() {
+            return current().get();
+        },
+        try() {
+            return current().try();
+        },
+        set(next) {
+            current().set(next);
+        },
+        destroy() {
+            current().destroy();
+        },
+        get [s_config]() { return { ...parsed, schema }; },
+    };
+    return facade;
+}
+//# sourceMappingURL=index.js.map

package/lib/private/session/k-serialize.d.ts

@@ -0,0 +1,3 @@
+declare const _default: symbol;
+export default _default;
+//# sourceMappingURL=k-serialize.d.ts.map

package/lib/private/session/k-serialize.js

@@ -0,0 +1,2 @@
+export default Symbol("primate.session.introspect");
+//# sourceMappingURL=k-serialize.js.map

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

@@ -0,0 +1,14 @@
+import SessionManager from "#session/Manager";
+import type Schema from "@rcompat/type/Schema";
+declare const _default: import("pema").ObjectType<{
+    cookie: import("pema").ObjectType<{
+        httpOnly: import("pema").DefaultType<import("pema/boolean").BooleanType, true>;
+        name: import("pema").DefaultType<import("pema/string").StringType, "session_id">;
+        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">>;
+}>;
+export default _default;
+//# sourceMappingURL=schema.d.ts.map

package/lib/private/session/schema.js

@@ -0,0 +1,20 @@
+import InMemorySessionManager from "#session/InMemoryManager";
+import SessionManager from "#session/Manager";
+import pema from "pema";
+import boolean from "pema/boolean";
+import constructor from "pema/constructor";
+import pure from "pema/pure";
+import string from "pema/string";
+import union from "pema/union";
+export default pema({
+    cookie: {
+        httpOnly: boolean.default(true),
+        name: string.default("session_id"),
+        path: string.startsWith("/").default("/"),
+        sameSite: union("Strict", "Lax", "None").default("Lax"),
+    },
+    manager: constructor(SessionManager)
+        .default(() => new InMemorySessionManager()),
+    schema: pure().optional(),
+});
+//# sourceMappingURL=schema.js.map

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

@@ -0,0 +1,5 @@
+import type SessionHandle from "#session/SessionHandle";
+import AsyncLocalStorage from "@rcompat/async/context";
+declare const _default: <Data>() => AsyncLocalStorage<SessionHandle<Data>>;
+export default _default;
+//# sourceMappingURL=storage.d.ts.map

package/lib/private/session/storage.js

@@ -0,0 +1,5 @@
+import AsyncLocalStorage from "@rcompat/async/context";
+import cache from "@rcompat/kv/cache";
+const s = Symbol("primate.session");
+export default () => cache.get(s, () => new AsyncLocalStorage);
+//# sourceMappingURL=storage.js.map

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

@@ -0,0 +1,3 @@
+declare const _default: symbol;
+export default _default;
+//# sourceMappingURL=config.d.ts.map

package/lib/private/symbol/config.js

@@ -0,0 +1,2 @@
+export default Symbol("@primate/core/symbol/config");
+//# sourceMappingURL=config.js.map

package/lib/private/symbol/layout-depth.d.ts

@@ -0,0 +1,3 @@
+declare const _default: symbol;
+export default _default;
+//# sourceMappingURL=layout-depth.d.ts.map

package/lib/private/symbol/layout-depth.js

@@ -0,0 +1,2 @@
+export default Symbol("@primate/core/symbol/layout-depth");
+//# sourceMappingURL=layout-depth.js.map

package/lib/private/tags.d.ts

@@ -0,0 +1,10 @@
+import type Font from "#asset/Font";
+import type Script from "#asset/Script";
+import type Style from "#asset/Style";
+declare const _default: {
+    font({ as, crossorigin, href, rel, type }: Font): string;
+    script({ code, id, inline, integrity, src, type }: Script): string;
+    style({ code, href, inline }: Style): string;
+};
+export default _default;
+//# sourceMappingURL=tags.d.ts.map

package/lib/private/tags.js

@@ -0,0 +1,29 @@
+import empty from "@rcompat/record/empty";
+const attribute = (attributes) => empty(attributes)
+    ? ""
+    : " ".concat(Object.entries(attributes)
+        .map(([key, value]) => `${key}="${value}"`).join(" "));
+const tag = (name, { attributes = {}, close = true, code = "" }) => `<${name}${attribute(attributes)}${close ? `>${code}</${name}>` : "/>"}`;
+const nctag = (name, properties) => tag(name, { ...properties, close: false });
+export default {
+    font({ as = "font", crossorigin = "true", href, rel = "preload", type }) {
+        return nctag("link", { attributes: { as, crossorigin, href, rel, type } });
+    },
+    // inline: <script type integrity>...</script>
+    // outline: <script type integrity src></script>
+    script({ code, id, inline, integrity, src, type }) {
+        return inline
+            ? id === undefined
+                ? tag("script", { attributes: { integrity, type }, code })
+                : tag("script", { attributes: { id, integrity, type }, code })
+            : tag("script", { attributes: { integrity, src, type } });
+    },
+    // inline: <style>...</style>
+    // outline: <link rel="stylesheet" href />
+    style({ code, href, inline }) {
+        return inline
+            ? tag("style", { code })
+            : nctag("link", { attributes: { href, rel: "stylesheet" } });
+    },
+};
+//# sourceMappingURL=tags.js.map

package/lib/private/target/Manager.d.ts

@@ -0,0 +1,14 @@
+import type App from "#App";
+import type Target from "#target/Target";
+export default class TargetManager {
+    #private;
+    constructor(app: App);
+    get name(): string;
+    get target(): string;
+    has(name: string): boolean;
+    get(): Target;
+    set(name: string): void;
+    add(target: Target): void;
+    run(): Promise<void>;
+}
+//# sourceMappingURL=Manager.d.ts.map

package/lib/private/target/Manager.js

@@ -0,0 +1,44 @@
+import fail from "#fail";
+import web from "#target/web";
+export default class TargetManager {
+    #name = "web";
+    #targets = [web];
+    #app;
+    constructor(app) {
+        this.#app = app;
+    }
+    get name() {
+        return this.#name;
+    }
+    get target() {
+        return this.get().target;
+    }
+    has(name) {
+        return this.#targets
+            .find(target => target.name === name) !== undefined;
+    }
+    get() {
+        return this.#targets.find(target => target.name === this.#name);
+    }
+    set(name) {
+        if (!this.has(name)) {
+            let message = "no target {0}, available targets {1}";
+            if (this.#targets.length === 1) {
+                message += "\n   - add {2} for more targets";
+            }
+            const targets = this.#targets.map(p => p.name).join(", ");
+            throw fail(message, name, targets, "@primate/native");
+        }
+        this.#name = name;
+    }
+    add(target) {
+        if (this.has(target.name)) {
+            throw fail("Cannot add target {0} twice", target.name);
+        }
+        this.#targets.push(target);
+    }
+    async run() {
+        await this.get().runner(this.#app);
+    }
+}
+//# sourceMappingURL=Manager.js.map

package/lib/private/target/Target.d.ts

@@ -0,0 +1,8 @@
+import type App from "#App";
+import type MaybePromise from "@rcompat/type/MaybePromise";
+export default interface Target {
+    name: string;
+    runner: (app: App) => MaybePromise<void>;
+    target: string;
+}
+//# sourceMappingURL=Target.d.ts.map

package/lib/private/target/Target.js

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

package/lib/private/target/web.d.ts

@@ -0,0 +1,4 @@
+import type Target from "#target/Target";
+declare const web: Target;
+export default web;
+//# sourceMappingURL=web.d.ts.map