@primate/core 0.5.0 → 0.6.0

package/lib/private/serve/dev-module.js

@@ -0,0 +1,34 @@
+import log from "#log";
+import create from "#module/create";
+import c from "@rcompat/cli/color";
+function pass(address, request) {
+    return fetch(address, {
+        body: request.body,
+        duplex: "half",
+        headers: request.headers,
+        method: request.method,
+    });
+}
+export default function dev() {
+    let paths;
+    let reload;
+    return create({
+        name: "builtin/dev",
+        setup({ onServe, onHandle }) {
+            onServe(app => {
+                const { host, port } = app.livereload;
+                const assets = app.assets.map(asset => asset.src);
+                reload = `http://${host}:${port}`;
+                paths = ["/esbuild"].concat(assets);
+                log.print(`↻ live reload ${c.dim(reload)}\n`);
+            });
+            onHandle((request, next) => {
+                const { pathname } = new URL(request.url);
+                return paths.includes(pathname)
+                    ? pass(`${reload}${pathname}`, request.original)
+                    : next(request);
+            });
+        },
+    });
+}
+//# sourceMappingURL=dev-module.js.map

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

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

package/lib/private/serve/hook.js

@@ -1,7 +1,6 @@
-import reducer from "#reducer";
-async function post(app) {
+export default async function run_serve_hooks(app) {
+    await app.serve_hooks(app);
     await app.start();
     return app;
 }
-export default async (app) => post(await reducer(app.modules, app, "serve"));
 //# sourceMappingURL=hook.js.map

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

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

package/lib/private/serve/index.js

@@ -1,10 +1,40 @@
-import { s_attach } from "#app/Facade";
+import { s_attach, s_config } from "#app/Facade";
+import E from "#db/errors";
+import log from "#log";
+import key from "#orm/key";
+import store from "#orm/store";
 import ServeApp from "#serve/App";
 import serve_hook from "#serve/hook";
+import p from "pema";
 export default async (root, options) => {
     const facade = options.facade;
     const app = await new ServeApp(root, options).init();
     facade[s_attach](app);
-    return serve_hook(app);
+    const config = facade[s_config];
+    const migrations = config.db.migrations;
+    try {
+        if (migrations !== undefined) {
+            const { table, db } = migrations;
+            const Migration = store({
+                name: table,
+                db,
+                schema: {
+                    id: key.primary(p.u16, { generate: false }),
+                    applied: p.date,
+                },
+            });
+            await Migration.table.create();
+            const last = await Migration.find({ limit: 1, sort: { id: "desc" } });
+            const last_id = last.length === 0 ? 0 : last[0].id;
+            const build_json = app.root.join("build.json");
+            const { migration_version } = await build_json.json();
+            if (last_id < migration_version)
+                throw E.unapplied_migrations();
+        }
+        return serve_hook(app);
+    }
+    catch (cause) {
+        log.error(cause);
+    }
 };
 //# sourceMappingURL=index.js.map

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

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

package/lib/private/server/TAG.js

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

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

@@ -0,0 +1,5 @@
+declare const server: {
+    TAG: string;
+};
+export default server;
+//# sourceMappingURL=index.d.ts.map

package/lib/private/server/index.js

@@ -0,0 +1,6 @@
+import TAG from "#server/TAG";
+const server = {
+    TAG,
+};
+export default server;
+//# sourceMappingURL=index.js.map

package/lib/private/session/SessionHandle.js

@@ -1,3 +1,4 @@
+import E from "#errors";
 import kSerialize from "#session/k-serialize";
 import assert from "@rcompat/assert";
 import is from "@rcompat/is";
@@ -11,7 +12,7 @@ export default class SessionHandle {
         assert.maybe.dict(data);
         assert.maybe.object(schema);
         assert.maybe.function(schema?.parse);
-        assert.true((id === undefined) === (data === undefined), "both `id` and `data` must be defined or undefined");
+        assert.true((id === undefined) === (data === undefined), E.session_id_data());
         this.#id = id;
         this.#data = data;
         this.#schema = schema?.parse

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

@@ -1,4 +1,4 @@
-import type Store from "#orm/Store";
+import type { Store } from "#orm/store";
 import configSchema from "#session/schema";
 import type SessionFacade from "#session/SessionFacade";
 import type { InferStore, StoreSchema } from "pema";

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

@@ -0,0 +1,3 @@
+import type Config from "#session/Config";
+export default function session_module(config: Config): import("#module/create").Created;
+//# sourceMappingURL=module.d.ts.map

package/lib/private/session/module.js

@@ -0,0 +1,114 @@
+import E from "#errors";
+import create from "#module/create";
+import kSerialize from "#session/k-serialize";
+import SessionHandle from "#session/SessionHandle";
+import storage from "#session/storage";
+import p from "pema";
+function 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 function session_module(config) {
+    let secure;
+    const store = config.store;
+    const props = store.type.properties;
+    if (!("session_id" in props))
+        throw E.session_missing_id();
+    try {
+        props.session_id.parse(crypto.randomUUID());
+    }
+    catch {
+        throw E.session_id_string();
+    }
+    return create({
+        name: "builtin/session",
+        setup({ onServe, onHandle }) {
+            onServe(async (app) => {
+                secure = app.secure;
+                await store.table.create();
+            });
+            onHandle(async (request, next) => {
+                const { name, ...cookie_config } = config.cookie;
+                const sid = request.cookies.try(name);
+                // Look up session by session_id
+                const existing = sid !== undefined
+                    ? await store.find({ where: { session_id: sid }, limit: 1 })
+                    : [];
+                const exists = existing.length > 0;
+                let data = undefined;
+                let db_id = undefined;
+                if (exists) {
+                    const record = existing[0];
+                    const { id: _id, session_id: _sid, ...rest } = record;
+                    data = rest;
+                    db_id = _id;
+                }
+                const session_type = p.omit(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 {
+                            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 = { ...cookie_config, secure };
+                // no session existed -> either create or noop
+                if (!exists) {
+                    if (!snap.exists) {
+                        // stale cookie -> clear
+                        if (sid !== undefined) {
+                            response.headers.append("set-cookie", cookie(name, "", {
+                                ...options, maxAge: 0,
+                            }));
+                        }
+                        return response;
+                    }
+                    // create new session
+                    await store.insert({ session_id: snap.id, ...snap.data });
+                    response.headers.append("set-cookie", cookie(name, snap.id, options));
+                    return response;
+                }
+                // from here: session existed (db_id is defined)
+                // fast-path: session exists, same id and not dirty -> noop
+                if (snap.exists && snap.id === sid && !snap.dirty)
+                    return response;
+                // current absent -> destroy + clear cookie
+                if (!snap.exists) {
+                    await store.delete(db_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 !== sid) {
+                    await store.delete(db_id);
+                    await 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 store.update(db_id, { set: snap.data });
+                return response;
+            });
+        },
+    });
+}
+//# sourceMappingURL=module.js.map

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

@@ -1,12 +1,20 @@
-import Store from "#orm/Store";
-declare const _default: import("pema").ObjectType<{
-    cookie: import("pema").ObjectType<{
-        httpOnly: import("pema").DefaultType<import("pema").BooleanType, true>;
-        name: import("pema").DefaultType<import("pema").StringType, "session_id">;
-        path: import("pema").DefaultType<import("pema").StringType, "/">;
-        sameSite: import("pema").DefaultType<import("pema").UnionType<[import("pema").LiteralType<"Strict">, import("pema").LiteralType<"Lax">, import("pema").LiteralType<"None">]>, "Lax" | "None" | "Strict">;
-    }>;
-    store: import("pema").DefaultType<import("pema").ConstructorType<typeof Store>, Store<import("../orm/types.js").StoreInput, import("@rcompat/type").Dict<import("../orm/relation.js").Relation>>>;
+import { Store } from "#orm/store";
+declare const _default: import("pema").ObjectType<import("pema").NormalizeSchemaObject<{
+    readonly cookie: {
+        readonly httpOnly: import("pema").DefaultType<import("pema").BooleanType, true>;
+        readonly name: import("pema").DefaultType<import("pema").StringType, "session_id">;
+        readonly path: import("pema").DefaultType<import("pema").StringType, "/">;
+        readonly sameSite: import("pema").DefaultType<import("pema").UnionType<[import("pema").LiteralType<"Strict">, import("pema").LiteralType<"Lax">, import("pema").LiteralType<"None">]>, "Lax" | "None" | "Strict">;
+    };
+    readonly store: import("pema").DefaultType<import("pema").ConstructorType<typeof Store>, Store<import("../orm/StoreInput.js").default, import("@rcompat/type").Dict<import("../orm/relation.js").Relation>>>;
+}>, {
+    cookie: {
+        httpOnly: boolean;
+        name: string;
+        path: string;
+        sameSite: "Lax" | "None" | "Strict";
+    };
+    store: Store<import("../orm/StoreInput.js").default, import("@rcompat/type").Dict<import("../orm/relation.js").Relation>>;
 }>;
 export default _default;
 //# sourceMappingURL=schema.d.ts.map

package/lib/private/session/schema.js

@@ -1,6 +1,6 @@
 import MemoryDB from "#db/MemoryDB";
 import key from "#orm/key";
-import Store from "#orm/Store";
+import store, { Store } from "#orm/store";
 import p from "pema";
 export default p({
     cookie: {
@@ -10,10 +10,14 @@ export default p({
         sameSite: p.union("Strict", "Lax", "None").default("Lax"),
     },
     store: p.constructor(Store).default(() => {
-        return new Store({
-            id: key.primary(p.string),
-            session_id: p.string.uuid(),
-        }, { db: new MemoryDB(), name: "session" });
+        return store({
+            schema: {
+                id: key.primary(p.uuid),
+                session_id: p.uuid,
+            },
+            db: new MemoryDB(),
+            name: "session",
+        });
     }),
 });
 //# sourceMappingURL=schema.js.map

package/lib/private/target/Manager.js

@@ -1,4 +1,4 @@
-import fail from "#fail";
+import E from "#errors";
 const web = {
     name: "web",
     runner: () => { },
@@ -25,20 +25,14 @@ export default class TargetManager {
         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");
-        }
+        const targets = this.#targets;
+        if (!this.has(name))
+            throw E.target_missing(name, targets.map(p => p.name));
         this.#name = name;
     }
     add(target) {
-        if (this.has(target.name)) {
-            throw fail("cannot add target {0} twice", target.name);
-        }
+        if (this.has(target.name))
+            throw E.target_duplicate(target.name);
         this.#targets.push(target);
     }
     async run() {

package/lib/public/client.d.ts

@@ -1,14 +1,3 @@
-import createForm, { type FormInit, type FormView } from "#client/create-form";
-import toValidated from "#client/to-validated";
-import validateField from "#client/validate-field";
-import type ValidateInit from "#client/ValidateInit";
-import type ValidateUpdater from "#client/ValidateUpdater";
-import type ValidationError from "#client/ValidationError";
-declare const client: {
-    createForm: typeof createForm;
-    validateField: typeof validateField;
-    toValidated: typeof toValidated;
-};
-export default client;
-export type { FormInit, FormView, ValidateInit, ValidateUpdater, ValidationError, };
+export type * from "#client/index";
+export { default } from "#client/index";
 //# sourceMappingURL=client.d.ts.map

package/lib/public/client.js

@@ -1,10 +1,2 @@
-import createForm from "#client/create-form";
-import toValidated from "#client/to-validated";
-import validateField from "#client/validate-field";
-const client = {
-    createForm, // headless form controller
-    validateField, // low-level single-value transport
-    toValidated, // adapter to create field stores/hooks
-};
-export default client;
+export { default } from "#client/index";
 //# sourceMappingURL=client.js.map

package/lib/public/db/errors.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#db/errors";
+//# sourceMappingURL=errors.d.ts.map

package/lib/public/db/errors.js

@@ -0,0 +1,2 @@
+export { default } from "#db/errors";
+//# sourceMappingURL=errors.js.map

package/lib/public/db/migrate.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#db/migrate/index";
+//# sourceMappingURL=migrate.d.ts.map

package/lib/public/db/migrate.js

@@ -0,0 +1,2 @@
+export { default } from "#db/migrate/index";
+//# sourceMappingURL=migrate.js.map

package/lib/public/db.d.ts

@@ -1,12 +1,12 @@
 export type { default as As } from "#db/As";
 export type { default as DataDict } from "#db/DataDict";
-export type { default as DB } from "#db/DB";
+export type { default as DB, Schema } from "#db/DB";
 export type { default as PK } from "#db/PK";
+export type { default as ReadArgs } from "#db/ReadArgs";
+export type { default as ReadRelationsArgs } from "#db/ReadRelationsArgs";
 export type { default as Sort } from "#db/Sort";
 export type { default as TypeMap } from "#db/TypeMap";
 export type { default as Types } from "#db/Types";
 export type { default as With } from "#db/With";
-export type { default as ReadArgs } from "#db/ReadArgs";
-export type { default as ReadRelationsArgs } from "#db/ReadRelationsArgs";
 export { default } from "#db/common";
 //# sourceMappingURL=db.d.ts.map

package/lib/public/frontend.d.ts

@@ -0,0 +1,3 @@
+export { default } from "#frontend";
+export type * from "#frontend";
+//# sourceMappingURL=frontend.d.ts.map

package/lib/public/frontend.js

@@ -0,0 +1,2 @@
+export { default } from "#frontend";
+//# sourceMappingURL=frontend.js.map

package/lib/public/index.d.ts

@@ -0,0 +1,2 @@
+export type * from "#index";
+//# sourceMappingURL=index.d.ts.map

package/lib/public/index.js

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

package/lib/public/orm/store.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#orm/store";
+//# sourceMappingURL=store.d.ts.map

package/lib/public/orm/store.js

@@ -0,0 +1,2 @@
+export { default } from "#orm/store";
+//# sourceMappingURL=store.js.map

package/lib/public/request/server.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    get(): import("../index.js").RequestView | undefined;
+};
+export default _default;
+//# sourceMappingURL=server.d.ts.map

package/lib/public/request/server.js

@@ -0,0 +1,7 @@
+import storage from "#request/storage";
+export default {
+    get() {
+        return storage().getStore()?.toJSON();
+    },
+};
+//# sourceMappingURL=server.js.map

package/lib/public/response.d.ts

@@ -6,17 +6,17 @@ export type { default as ResponseLike } from "#response/ResponseLike";
 declare const _default: {
     binary: typeof binary;
     error: typeof error;
-    json: (body: unknown, init?: ResponseInit) => (app: import("./ServeApp.js").default) => import("@rcompat/type").MaybePromise<Response>;
+    json: (body: unknown, init?: ResponseInit) => (app: import("./index.js").ServeApp) => import("@rcompat/type").MaybePromise<Response>;
     redirect: (location: string, status?: 302 | 301 | 300 | 304 | 308 | 303 | 307) => import("#response/ResponseFunction").default;
     sse: (body: {
         close?(): undefined;
         open(events: {
             send(name: string, data: unknown): undefined;
         }): undefined;
-    }, init?: ResponseInit) => (app: import("./ServeApp.js").default) => import("@rcompat/type").MaybePromise<Response>;
-    text: (body: string, init?: ResponseInit) => (app: import("./ServeApp.js").default) => import("@rcompat/type").MaybePromise<Response>;
+    }, init?: ResponseInit) => (app: import("./index.js").ServeApp) => import("@rcompat/type").MaybePromise<Response>;
+    text: (body: string, init?: ResponseInit) => (app: import("./index.js").ServeApp) => import("@rcompat/type").MaybePromise<Response>;
     view: typeof view;
-    ws: (actions: import("@rcompat/http/Actions").default) => import("#response/ResponseFunction").default;
+    ws: (actions: import("@rcompat/http").Actions) => import("#response/ResponseFunction").default;
 };
 export default _default;
 //# sourceMappingURL=response.d.ts.map

package/lib/public/server.d.ts

@@ -0,0 +1,3 @@
+export type * from "#server/index";
+export { default } from "#server/index";
+//# sourceMappingURL=server.d.ts.map

package/lib/public/server.js

@@ -0,0 +1,2 @@
+export { default } from "#server/index";
+//# sourceMappingURL=server.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primate/core",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "The universal web framework",
   "homepage": "https://primate.run",
   "bugs": "https://github.com/primate-run/primate/issues",
@@ -18,49 +18,54 @@
     "!/**/*.spec.*"
   ],
   "dependencies": {
-    "@rcompat/args": "^0.11.0",
-    "@rcompat/assert": "^0.6.0",
-    "@rcompat/cli": "^0.14.0",
-    "@rcompat/crypto": "^0.14.0",
-    "@rcompat/dict": "^0.3.1",
-    "@rcompat/fn": "^0.3.0",
-    "@rcompat/fs": "^0.25.2",
-    "@rcompat/http": "^0.21.0",
-    "@rcompat/io": "^0.3.0",
-    "@rcompat/is": "^0.4.2",
-    "@rcompat/kv": "^0.6.0",
-    "@rcompat/runtime": "^0.9.0",
-    "@rcompat/string": "^0.13.0",
-    "@rcompat/type": "^0.9.0",
-    "esbuild": "^0.27.3",
-    "pema": "^0.5.0"
+    "@rcompat/assert": "^0.8.1",
+    "@rcompat/cli": "^0.18.1",
+    "@rcompat/crypto": "^0.16.1",
+    "@rcompat/dict": "^0.5.1",
+    "@rcompat/env": "^0.17.2",
+    "@rcompat/error": "^0.3.1",
+    "@rcompat/fn": "^0.5.1",
+    "@rcompat/fs": "^0.28.1",
+    "@rcompat/http": "^0.25.1",
+    "@rcompat/io": "^0.5.1",
+    "@rcompat/is": "^0.6.1",
+    "@rcompat/kv": "^0.8.1",
+    "@rcompat/runtime": "^0.11.1",
+    "@rcompat/string": "^0.16.1",
+    "@rcompat/type": "^0.11.1",
+    "esbuild": "^0.28.0",
+    "pema": "^0.6.0"
   },
   "imports": {
     "#i18n/index": {
-      "apekit": "./src/private/i18n/index/client.ts",
+      "@primate/source": "./src/private/i18n/index/client.ts",
       "browser": "./lib/private/i18n/index/client.js",
       "default": "./lib/private/i18n/index/server.js"
     },
     "#*": {
-      "apekit": "./src/private/*.ts",
+      "@primate/source": "./src/private/*.ts",
       "default": "./lib/private/*.js"
     }
   },
   "exports": {
-    "./error": "./lib/error/index.js",
-    "./dispatch": "./lib/dispatch/index.js",
-    "./frontend": {
-      "apekit": "./src/public/Frontend.ts"
+    "./AppFacade": {
+      "@primate/source": "./src/public/AppFacade.ts",
+      "browser": "./lib/private/app/Facade.browser.js",
+      "default": "./lib/public/AppFacade.js"
     },
     "./*": {
-      "apekit": "./src/public/*.ts",
+      "@primate/source": "./src/public/*.ts",
       "default": "./lib/public/*.js"
+    },
+    ".": {
+      "@primate/source": "./src/public/index.ts",
+      "default": "./lib/public/index.js"
     }
   },
   "scripts": {
     "build": "npm run clean && tsc && cp -a src/private/defaults lib/private",
     "clean": "rm -rf ./lib",
     "lint": "eslint .",
-    "test": "npm run build && npx proby"
+    "test": "npx proby"
   }
 }

package/lib/private/AppError.d.ts

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

package/lib/private/AppError.js

@@ -1,8 +0,0 @@
-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/backend/Module.d.ts

@@ -1,18 +0,0 @@
-import Module from "#Module";
-export default abstract class BackendModule extends Module {
-    #private;
-    abstract defaultExtension: string;
-    static schema: import("pema").ObjectType<{
-        fileExtension: import("pema").OptionalType<import("pema").StringType>;
-    }>;
-    static options: {
-        fileExtension: string | undefined;
-    };
-    static input: {
-        fileExtension?: string | undefined;
-    } | undefined;
-    constructor(options?: typeof BackendModule.schema.input);
-    get fileExtension(): string;
-    get package(): string;
-}
-//# sourceMappingURL=Module.d.ts.map