@primate/core 0.5.0 → 0.6.0

package/lib/private/backend/Module.js

@@ -1,19 +0,0 @@
-import Module from "#Module";
-import p from "pema";
-export default class BackendModule extends Module {
-    #options;
-    static schema = p({ fileExtension: p.string.optional() });
-    static options = BackendModule.schema.infer;
-    static input = BackendModule.schema.input;
-    constructor(options) {
-        super();
-        this.#options = BackendModule.schema.parse(options);
-    }
-    get fileExtension() {
-        return this.#options.fileExtension ?? this.defaultExtension;
-    }
-    get package() {
-        return `@primate/${this.name}`;
-    }
-}
-//# sourceMappingURL=Module.js.map

package/lib/private/backend/TAG.d.ts

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

package/lib/private/backend/TAG.js

@@ -1,2 +0,0 @@
-export default "0.4";
-//# sourceMappingURL=TAG.js.map

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

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

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

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

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

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

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

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

package/lib/private/client/spa/index.d.ts

@@ -1,6 +0,0 @@
-import type ClientData from "#client/Data";
-import type { Dict } from "@rcompat/type";
-type Updater<T extends Dict> = (json: ClientData<T>, after?: () => void) => void;
-declare const _default: <T extends Dict>(updater: Updater<T>) => void;
-export default _default;
-//# sourceMappingURL=index.d.ts.map

package/lib/private/client/spa/index.js

@@ -1,200 +0,0 @@
-import storage from "#client/spa/storage";
-import MIME from "@rcompat/http/mime";
-const { document } = globalThis;
-const headers = {
-    Accept: MIME.APPLICATION_JSON,
-};
-const get_by_id_or_name = (name) => document.getElementById(name) ?? document.getElementsByName(name)[0];
-const scroll = globalThis.scrollTo;
-const scroll_hash = (hash) => {
-    if (hash === "") {
-        scroll(0, 0);
-    }
-    else {
-        // https://html.spec.whatwg.org/browsing-the-web.html#scroll-to-fragid
-        // first try id, then name
-        get_by_id_or_name(hash.slice(1)).scrollIntoView();
-    }
-};
-const sameorigin = (url) => url.origin === globalThis.location.origin;
-const getLocation = (response, base) => {
-    // only readable when not opaqueredirect
-    if (response.type === "opaqueredirect")
-        return null;
-    const location = response.headers.get("Location");
-    return location ? new URL(location, base) : null;
-};
-// Follows same-origin redirects in "manual" mode up to a small limit
-async function refetch(input, init = {}, maxHops = 5) {
-    let url = new URL(input.toString(), globalThis.location.href);
-    let hops = 0;
-    while (hops < maxHops) {
-        const response = await fetch(url.pathname + url.search, {
-            ...init, redirect: "manual",
-        });
-        // cross-origin redirect -> bail
-        if (response.type === "opaqueredirect") {
-            return { requested: url, response: response };
-        }
-        // same-origin redirect we can see?
-        const location = getLocation(response, url.toString());
-        if (location && (response.status >= 300 && response.status < 400)) {
-            // would go cross-origin -> bail
-            if (!sameorigin(location))
-                return { requested: url, response: response };
-            // follow internally without touching history
-            url = location;
-            hops++;
-            continue;
-        }
-        // not a redirect -> return it
-        return { requested: url, response };
-    }
-    throw new Error("Too many redirects");
-}
-function is_json(response) {
-    const raw = response.headers.get("content-type") || "";
-    const mime = raw.split(";")[0].trim();
-    return mime === MIME.APPLICATION_JSON;
-}
-;
-const handle = async (response, updater) => {
-    // if it's JSON, process SPA update and keep history under our control
-    if (is_json(response)) {
-        updater(await response.json());
-        return true; // handled in SPA
-    }
-    // not JSON ⇒ we will hard-navigate outside the SPA
-    return false;
-};
-const goto = async ({ hash, pathname }, updater, state = false) => {
-    try {
-        // save before loading next
-        const { scrollTop } = globalThis.document.scrollingElement;
-        const { hash: currentHash, pathname: currentPathname } = globalThis.location;
-        const { requested, response } = await refetch(pathname, { headers });
-        if (await handle(response, updater)) {
-            if (state) {
-                storage.new({ hash: currentHash, pathname: currentPathname, scrollTop });
-                const url = response.redirected ? response.url : `${pathname}${hash}`;
-                history.pushState({}, "", url);
-            }
-            return;
-        }
-        const target = (response.type !== "opaqueredirect")
-            ? requested.toString() + hash
-            : new URL(pathname + hash, globalThis.location.href).toString();
-        globalThis.location.assign(target);
-    }
-    catch (error) {
-        console.warn(error);
-    }
-};
-const submit = async (pathname, body, method, updater) => {
-    try {
-        const { requested, response } = await refetch(pathname, { body, headers, method });
-        if (await handle(response, updater)) {
-            history.replaceState({}, "", requested.pathname + requested.search);
-            return;
-        }
-        const target = (response.type !== "opaqueredirect")
-            ? requested.toString()
-            : new URL(pathname, globalThis.location.href).toString();
-        globalThis.location.assign(target);
-    }
-    catch (error) {
-        console.warn(error);
-    }
-};
-const go = async (href, updater, event) => {
-    const url = new URL(href);
-    const { hash, pathname } = url;
-    const current = globalThis.location.pathname;
-    // hosts must match
-    if (url.host === globalThis.location.host) {
-        // prevent event
-        event?.preventDefault();
-        // pathname differs
-        if (current !== pathname) {
-            await goto(url, props => updater(props, () => {
-                scroll_hash(hash);
-                globalThis.dispatchEvent(new Event("updated"));
-            }), true);
-        }
-        // different hash on same page, jump to hash
-        if (hash !== globalThis.location.hash) {
-            const { scrollTop } = globalThis.document.scrollingElement;
-            storage.new({
-                hash: globalThis.location.hash,
-                pathname: current,
-                scrollTop,
-                stop: true,
-            });
-            history.pushState(null, "", `${current}${hash}`);
-            scroll_hash(hash);
-        }
-    }
-    // external redirect
-};
-export default (updater) => {
-    if (document.contentType === "application/json") {
-        location.reload();
-        return;
-    }
-    globalThis.addEventListener("pageshow", event => {
-        if (event.persisted) {
-            globalThis.location.reload();
-        }
-    });
-    globalThis.addEventListener("load", _ => {
-        history.scrollRestoration = "manual";
-        if (globalThis.location.hash !== "") {
-            scroll_hash(globalThis.location.hash);
-        }
-    });
-    globalThis.addEventListener("beforeunload", _ => {
-        history.scrollRestoration = "auto";
-    });
-    globalThis.addEventListener("popstate", _ => {
-        const state = storage.peek() ?? { scrollTop: 0 };
-        const { pathname } = globalThis.location;
-        let { scrollTop } = state;
-        if (state.stop) {
-            storage.back();
-            if (state.hash) {
-                scroll_hash(state.hash);
-            }
-            else {
-                scroll(0, state.scrollTop);
-            }
-            return;
-        }
-        const back = state.pathname === pathname;
-        if (back) {
-            storage.back();
-        }
-        else {
-            scrollTop = storage.forward().scrollTop;
-        }
-        goto(globalThis.location, props => updater(props, () => scroll(0, scrollTop ?? 0)));
-    });
-    globalThis.addEventListener("click", event => {
-        const target = event.target.closest("a");
-        if (target?.tagName === "A" && target.href !== "") {
-            go(target.href, updater, event);
-        }
-    });
-    globalThis.addEventListener("submit", (event) => {
-        event.preventDefault();
-        const target = event.target;
-        const { enctype } = target;
-        const action = target.action ?? globalThis.location.pathname;
-        const url = new URL(action);
-        const data = new FormData(target);
-        const form = enctype === MIME.MULTIPART_FORM_DATA
-            ? data
-            : new URLSearchParams(data);
-        submit(url.pathname, form, target.method, updater);
-    });
-};
-//# sourceMappingURL=index.js.map

package/lib/private/db/error.d.ts

@@ -1,81 +0,0 @@
-declare function db_missing(): import("../AppError.js").default;
-declare function store_name_required(): import("../AppError.js").default;
-declare function unregistered_schema(): import("../AppError.js").default;
-declare function record_not_found(field: string, value: string | number | bigint): import("../AppError.js").default;
-declare function key_duplicate(key: string): import("../AppError.js").default;
-declare function pk_undefined(store: string): import("../AppError.js").default;
-declare function pk_immutable(pk: string): import("../AppError.js").default;
-declare function pk_duplicate(pk: string): import("../AppError.js").default;
-declare function pk_invalid(pk: unknown): import("../AppError.js").default;
-declare function pk_required(table: string): import("../AppError.js").default;
-type Context = "select" | "where" | "sort" | "insert" | "set";
-declare function field_unknown(field: string, context: Context): import("../AppError.js").default;
-declare function field_duplicate(field: string, context: Context): import("../AppError.js").default;
-declare function field_required(operator: string): import("../AppError.js").default;
-declare function field_undefined(field: string, context: Context): import("../AppError.js").default;
-declare function fields_unknown(fields: string[]): import("../AppError.js").default;
-declare function null_not_allowed(field: string): import("../AppError.js").default;
-declare function wrong_type(type: "string" | "number" | "bigint" | "boolean" | "url" | "date" | "blob", field: string, got: unknown, op?: string): import("../AppError.js").default;
-declare function operator_unknown(field: string, operator: string): import("../AppError.js").default;
-declare function operator_empty(field: string): import("../AppError.js").default;
-declare function operator_scalar(field: string): import("../AppError.js").default;
-declare function sort_empty(): import("../AppError.js").default;
-declare function sort_invalid(): import("../AppError.js").default;
-declare function sort_invalid_value(field: string, value: unknown): import("../AppError.js").default;
-declare function select_empty(): import("../AppError.js").default;
-declare function select_invalid(): import("../AppError.js").default;
-declare function limit_invalid(): import("../AppError.js").default;
-declare function select_invalid_value(index: number, x: unknown): import("../AppError.js").default;
-declare function where_required(): import("../AppError.js").default;
-declare function where_invalid(): import("../AppError.js").default;
-declare function where_invalid_value(field: string, value: unknown): import("../AppError.js").default;
-declare function set_empty(): import("../AppError.js").default;
-declare function relation_unknown(relation: string): import("../AppError.js").default;
-declare function relation_requires_pk(type: "target" | "parent"): import("../AppError.js").default;
-declare function option_unknown(option: string): import("../AppError.js").default;
-declare function identifier_invalid(identifier: string): import("../AppError.js").default;
-declare function count_with_invalid(): import("../AppError.js").default;
-declare function count_overflow(table: string, count: unknown): import("../AppError.js").default;
-declare const errors: {
-    option_unknown: typeof option_unknown;
-    identifier_invalid: typeof identifier_invalid;
-    count_with_invalid: typeof count_with_invalid;
-    count_overflow: typeof count_overflow;
-    relation_unknown: typeof relation_unknown;
-    relation_requires_pk: typeof relation_requires_pk;
-    sort_empty: typeof sort_empty;
-    sort_invalid: typeof sort_invalid;
-    sort_invalid_value: typeof sort_invalid_value;
-    select_empty: typeof select_empty;
-    select_invalid: typeof select_invalid;
-    select_invalid_value: typeof select_invalid_value;
-    where_required: typeof where_required;
-    where_invalid: typeof where_invalid;
-    where_invalid_value: typeof where_invalid_value;
-    set_empty: typeof set_empty;
-    limit_invalid: typeof limit_invalid;
-    operator_unknown: typeof operator_unknown;
-    operator_empty: typeof operator_empty;
-    wrong_type: typeof wrong_type;
-    operator_scalar: typeof operator_scalar;
-    null_not_allowed: typeof null_not_allowed;
-    field_unknown: typeof field_unknown;
-    field_duplicate: typeof field_duplicate;
-    field_required: typeof field_required;
-    field_undefined: typeof field_undefined;
-    fields_unknown: typeof fields_unknown;
-    pk_undefined: typeof pk_undefined;
-    pk_immutable: typeof pk_immutable;
-    pk_duplicate: typeof pk_duplicate;
-    pk_invalid: typeof pk_invalid;
-    pk_required: typeof pk_required;
-    db_missing: typeof db_missing;
-    store_name_required: typeof store_name_required;
-    unregistered_schema: typeof unregistered_schema;
-    record_not_found: typeof record_not_found;
-    key_duplicate: typeof key_duplicate;
-};
-export type Code = keyof typeof errors;
-export declare const Code: { [K in Code]: K; };
-export default errors;
-//# sourceMappingURL=error.d.ts.map

package/lib/private/db/error.js

@@ -1,199 +0,0 @@
-import fail from "#fail";
-function coded(fns) {
-    return Object.fromEntries(Object.entries(fns).map(([key, fn]) => [
-        key,
-        (...args) => {
-            const err = fn(...args);
-            err.code = key;
-            return err;
-        },
-    ]));
-}
-function db_missing() {
-    return fail("database missing");
-}
-function store_name_required() {
-    return fail("store name required");
-}
-function unregistered_schema() {
-    return fail("no store registered for schema");
-}
-function record_not_found(field, value) {
-    return fail("no record with {0} = {1}", field, value);
-}
-function key_duplicate(key) {
-    return fail("key {0} already exists", key);
-}
-const STORE = coded({
-    db_missing,
-    store_name_required,
-    unregistered_schema,
-    record_not_found,
-    key_duplicate,
-});
-function pk_undefined(store) {
-    return fail("{0}: store has no primary key", store);
-}
-function pk_immutable(pk) {
-    return fail("primary key {0} cannot be updated", pk);
-}
-function pk_duplicate(pk) {
-    return fail("primary key {0} already exists", pk);
-}
-function pk_invalid(pk) {
-    return fail("pk must be string, number or bigint, got {0}", kind_of(pk));
-}
-function pk_required(table) {
-    return fail("pk is required but has generate={0} in table {1}", false, table);
-}
-const PK = coded({
-    pk_undefined,
-    pk_immutable,
-    pk_duplicate,
-    pk_invalid,
-    pk_required,
-});
-function field_unknown(field, context) {
-    return fail("{0}: unknown field on {1}", field, context);
-}
-function field_duplicate(field, context) {
-    return fail("{0}: duplicate field on {1}", field, context);
-}
-function field_required(operator) {
-    return fail("{0}: at least one field required", operator);
-}
-function field_undefined(field, context) {
-    return fail("{0}: undefined value on {1}", field, context);
-}
-function fields_unknown(fields) {
-    return fail("unknown fields {0}", fields.join(", "));
-}
-const FIELD = coded({
-    field_unknown,
-    field_duplicate,
-    field_required,
-    field_undefined,
-    fields_unknown,
-});
-function null_not_allowed(field) {
-    return fail("{0}: null not allowed", field);
-}
-const NULL = coded({
-    null_not_allowed,
-});
-function kind_of(x) {
-    if (x === null)
-        return "null";
-    if (x instanceof Date)
-        return "Date";
-    if (x instanceof URL)
-        return "URL";
-    if (x instanceof Blob)
-        return "Blob";
-    return typeof x;
-}
-function wrong_type(type, field, got, op = "value") {
-    return fail("{0}: {1} requires {2}, got {3}", field, op, type, kind_of(got));
-}
-function operator_unknown(field, operator) {
-    return fail("{0}: unknown operator {1}", field, operator);
-}
-function operator_empty(field) {
-    return fail("{0}: empty operator", field);
-}
-function operator_scalar(field) {
-    return fail("{0}: operator requires scalar value", field);
-}
-const OPERATOR = coded({
-    operator_unknown,
-    operator_empty,
-    wrong_type,
-    operator_scalar,
-});
-function sort_empty() {
-    return fail("empty sort");
-}
-function sort_invalid() {
-    return fail("sort invalid");
-}
-function sort_invalid_value(field, value) {
-    return fail("{0}: invalid sort value, received {1}", field, kind_of(value));
-}
-function select_empty() {
-    return fail("empty select");
-}
-function select_invalid() {
-    return fail("invalid select");
-}
-function limit_invalid() {
-    return fail("invalid limit");
-}
-function select_invalid_value(index, x) {
-    return fail("select[{0}]: must be string, received {1}", index, kind_of(x));
-}
-function where_required() {
-    return fail("where required");
-}
-function where_invalid() {
-    return fail("where invalid");
-}
-function where_invalid_value(field, value) {
-    return fail("{0}: invalid where value, received {1}", field, kind_of(value));
-}
-function set_empty() {
-    return fail("empty set on update");
-}
-const QUERY = coded({
-    sort_empty,
-    sort_invalid,
-    sort_invalid_value,
-    select_empty,
-    select_invalid,
-    select_invalid_value,
-    where_required,
-    where_invalid,
-    where_invalid_value,
-    set_empty,
-    limit_invalid,
-});
-function relation_unknown(relation) {
-    return fail("unknown relation {0}", relation);
-}
-function relation_requires_pk(type) {
-    return fail("relation loading requires {0} primary key", type);
-}
-const RELATION = coded({
-    relation_unknown,
-    relation_requires_pk,
-});
-function option_unknown(option) {
-    return fail("unknown option {0}", option);
-}
-function identifier_invalid(identifier) {
-    return fail("invalid identifier {0}", identifier);
-}
-function count_with_invalid() {
-    return fail("count and with are mutually exclusive");
-}
-function count_overflow(table, count) {
-    return fail("{0}: count overflow, received {1} (max {2})", table, count, Number.MAX_SAFE_INTEGER);
-}
-const MISC = coded({
-    option_unknown,
-    identifier_invalid,
-    count_with_invalid,
-    count_overflow,
-});
-const errors = {
-    ...STORE,
-    ...PK,
-    ...FIELD,
-    ...NULL,
-    ...OPERATOR,
-    ...QUERY,
-    ...RELATION,
-    ...MISC,
-};
-export const Code = Object.fromEntries(Object.keys(errors).map(k => [k, k]));
-export default errors;
-//# sourceMappingURL=error.js.map

package/lib/private/db/symbol/wrap.d.ts

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

package/lib/private/db/symbol/wrap.js

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

package/lib/private/fail.d.ts

@@ -1,3 +0,0 @@
-import AppError from "#AppError";
-export default function fail(message: string, ...params: unknown[]): AppError;
-//# sourceMappingURL=fail.d.ts.map

package/lib/private/fail.js

@@ -1,5 +0,0 @@
-import AppError from "#AppError";
-export default function fail(message, ...params) {
-    return new AppError(message, ...params);
-}
-//# sourceMappingURL=fail.js.map