@primate/core 0.6.2 → 0.7.0

package/lib/private/build/server/plugin/route.js

@@ -1,7 +1,6 @@
 import E from "#errors";
-import wrap from "#route/wrap";
 import fs from "@rcompat/fs";
-const contents = "export default {};";
+const empty = "export default {};";
 export default function plugin_server_route(app) {
     const path_routes = app.path.routes;
     return {
@@ -28,23 +27,17 @@ export default function plugin_server_route(app) {
                 if (!file || !extension) {
                     throw E.build_missing_route(relative, path_routes);
                 }
-                // normalise "routes/foo.ext" -> "foo" for router
-                const relative_from_routes = file.path.split("routes").pop();
-                const no_extensions = relative_from_routes
-                    .replace(/^[\\/]/, "")
-                    .slice(0, -extension.length);
-                const route_path = no_extensions.replace(/\\/g, "/");
                 const resolveDir = file.directory.path;
                 const watchFiles = [file.path];
                 const binder = app.binder(file);
                 if (!binder)
-                    return { contents, loader: "js", resolveDir, watchFiles };
+                    return { contents: empty, loader: "js", resolveDir, watchFiles };
                 const compiled = await binder(file, {
                     build: { id: app.id },
                     context: "routes",
                 });
                 return {
-                    contents: wrap(compiled, route_path, app.id),
+                    contents: compiled,
                     loader: extension === ".ts" ? "ts" : "js",
                     resolveDir,
                     watchFiles,

package/lib/private/build/server/plugin/virtual-pages.js

@@ -1,5 +1,5 @@
-import fs from "@rcompat/fs";
-const core_pkg = await fs.project.root(import.meta.dirname);
+import runtime from "@rcompat/runtime";
+const core = await runtime.projectRoot(import.meta.dirname);
 export default function plugin_server_virtual_pages(app) {
     return {
         name: "primate/server/virtual/pages",
@@ -9,7 +9,7 @@ export default function plugin_server_virtual_pages(app) {
             });
             build.onLoad({ filter: /.*/, namespace: "primate-pages" }, async () => {
                 const filter = /^.*\.html$/ui;
-                const defaults = core_pkg.join("lib", "private", "defaults");
+                const defaults = core.join("lib", "private", "defaults");
                 const pages = {};
                 for (const file of await defaults.files({ filter })) {
                     pages[file.name] = file;

package/lib/private/build/server/plugin/virtual-routes.d.ts

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

package/lib/private/build/server/plugin/virtual-routes.js

@@ -1,8 +1,15 @@
-export default function plugin_server_virtual_routes(app) {
+function is_hook_file(p) {
+    const basename = p.split("/").at(-1) ?? p;
+    return basename === "+hook" || basename.startsWith("+hook.");
+}
+function plugin_server_virtual_routes(app) {
     const extension_pattern = new RegExp(`(${app.extensions.map(e => e.replace(".", "\\.")).join("|")})$`);
-    const is_route_file = (f) => !f.name.endsWith("~") &&
-        !f.name.startsWith(".") &&
-        extension_pattern.test(f.path);
+    function is_route_file(f) {
+        return !f.name.endsWith("~") &&
+            !f.name.startsWith(".") &&
+            !f.name.startsWith("-") &&
+            extension_pattern.test(f.path);
+    }
     return {
         name: "primate/server/virtual/routes",
         setup(build) {
@@ -16,13 +23,24 @@ export default function plugin_server_virtual_routes(app) {
                     recursive: true,
                 });
                 const contents = `
-          const route = [];
+          import router from "primate/router";
+          ${route_files.map((file, i) => {
+                    const path = app.basename(file, app.path.routes);
+                    return `import route${i} from "app:route/${path}";`;
+                }).join("\n")}
+          const routes = [];
           ${route_files.map((file, i) => {
                     const path = app.basename(file, app.path.routes);
-                    return `const route${i} = (await import("app:route/${path}")).default;
-            route.push(["${path}", route${i}]);`;
+                    return is_hook_file(path)
+                        ? `router.addHook("${path}", route${i});
+               routes.push(["${path}", route${i}]);
+            `
+                        : `for (const [method, { handler, options }] of Object.entries(route${i})) {
+                   router.add("${path}", method, handler, options);
+                 }
+                 routes.push(["${path}", route${i}]);`;
                 }).join("\n")}
-          export default route;
+          export default routes;
         `;
                 const watchDirs = (await app.path.routes.dirs({
                     recursive: true,
@@ -38,4 +56,5 @@ export default function plugin_server_virtual_routes(app) {
         },
     };
 }
+export default plugin_server_virtual_routes;
 //# sourceMappingURL=virtual-routes.js.map

package/lib/private/build/server/plugin/wasm.js

@@ -20,13 +20,14 @@ export default function plugin_server_wasm(app) {
             });
             build.onLoad({ filter: /.*/, namespace: "wasm-dev" }, async (args) => {
                 const wasm_file = app.runpath("wasm", args.path + ".wasm");
+                const fs_path = import.meta.resolve("@rcompat/fs");
                 return {
                     contents: `
-            import fs from "@rcompat/fs";
+            const { default: fs } = await import("${fs_path}");
             export default await fs.ref("${wasm_file.path}").bytes();
           `,
                     loader: "js",
-                    resolveDir: app.root.path,
+                    resolveDir: new URL(".", import.meta.url).pathname,
                 };
             });
         },

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

@@ -4,7 +4,7 @@ import type { Dict } from "@rcompat/type";
 type ClientData<T extends Dict = Dict> = {
     view: string;
     request: RequestView;
-    spa: boolean;
+    csr: boolean;
     ssr: boolean;
     mode: Mode;
 } & T;

package/lib/private/client/boot.js

@@ -2,7 +2,7 @@ import navigate from "#client/navigate";
 import root from "#client/root";
 import storage from "#client/storage";
 import submit from "#client/submit";
-import { MIME } from "@rcompat/http";
+import http from "@rcompat/http";
 export default (u) => {
     root.set(u);
     const { location, history } = globalThis;
@@ -50,7 +50,7 @@ export default (u) => {
         const action = target.action ?? location.pathname;
         const url = new URL(action);
         const data = new FormData(target);
-        const form = enctype === MIME.MULTIPART_FORM_DATA
+        const form = enctype === http.MIME.MULTIPART_FORM_DATA
             ? data
             : new URLSearchParams(data);
         try {

package/lib/private/client/create-form.d.ts

@@ -1,6 +1,6 @@
 import type { Dict } from "@rcompat/type";
 type FormId = string;
-type FieldErrors = readonly string[];
+type FieldErrors = string[];
 type FormErrors = {
     form: FieldErrors;
     fields: Dict<FieldErrors>;
@@ -15,11 +15,21 @@ export type FormView = FormSnapshot & {
     submit: (event?: Event) => Promise<void>;
 };
 type FormSubscriber = (snapshot: FormSnapshot) => void;
+export type MethodMeta = {
+    contentType?: string;
+};
+export type ClientMethod<Values extends Dict = Dict> = MethodMeta & ((args: {
+    body: Values;
+}) => Promise<Response>);
 export type FormInit = {
     id?: string;
     method?: "POST" | "PUT" | "PATCH" | "DELETE";
     url?: string;
     headers?: Dict<string>;
+    action?: (args: {
+        body: unknown;
+    }) => Promise<Response>;
+    contentType?: string;
 };
 type FormController = {
     subscribe(fn: FormSubscriber): () => void;

package/lib/private/client/create-form.js

@@ -1,5 +1,6 @@
 import extract_issues from "#client/extract-issues";
 import submit from "#client/submit";
+import is from "@rcompat/is";
 function decode_pointer_segment(segment) {
     // decode JSON Pointer: ~1 -> /, ~0 -> ~
     return segment.replace(/~1/g, "/").replace(/~0/g, "~");
@@ -21,6 +22,21 @@ function pointer_to_fieldname(path) {
     }
     return name;
 }
+function content_type_body(contentType, form_data) {
+    if (contentType === "application/json")
+        return Object.fromEntries(form_data);
+    if (contentType === "multipart/form-data")
+        return form_data;
+    // default: application/x-www-form-urlencoded
+    return new URLSearchParams(form_data);
+}
+function form_data_body(form_data) {
+    for (const value of form_data.values()) {
+        if (value instanceof File && value.size > 0)
+            return form_data;
+    }
+    return new URLSearchParams(form_data);
+}
 export default function createForm(init) {
     const id = init.id ?? `form-${crypto.randomUUID()}`;
     let snapshot = {
@@ -83,7 +99,9 @@ export default function createForm(init) {
         const form_data = new FormData(form_element);
         setSubmitting(true);
         try {
-            const response = await submit(url, form_data, method);
+            const response = await (is.defined(init.action)
+                ? init.action({ body: content_type_body(init.contentType, form_data) })
+                : submit(url, form_data_body(form_data), method));
             if (response.ok) {
                 // on success: clear errors, let the app decide what to do next
                 // (redirect/reload)
@@ -91,8 +109,8 @@ export default function createForm(init) {
                 publish();
                 return;
             }
-            const payload = await response.json();
-            const issues = extract_issues(payload); // all issues, all paths
+            // all issues, all paths
+            const issues = extract_issues(await response.json());
             setErrors(issues);
         }
         catch (error) {

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

@@ -1,4 +1,4 @@
-import type { FormInit, FormView } from "#client/create-form";
+import type { ClientMethod, FormInit, FormView, MethodMeta } from "#client/create-form";
 import createForm from "#client/create-form";
 import type Data from "#client/Data";
 import type Publish from "#client/Publish";
@@ -19,5 +19,5 @@ declare const client: {
     toValidated: typeof toValidated;
 };
 export default client;
-export type { Data, FormInit, FormView, Publish, Render, ValidateInit, ValidateUpdater, ValidationError, ViewResponse, };
+export type { ClientMethod, Data, FormInit, FormView, MethodMeta, Publish, Render, ValidateInit, ValidateUpdater, ValidationError, ViewResponse };
 //# sourceMappingURL=index.d.ts.map

package/lib/private/client/navigate.d.ts

@@ -1,6 +1,7 @@
 type Location = {
     hash: string;
     pathname: string;
+    search: string;
 };
 declare function goto(target: Location, state?: boolean, after?: () => void): Promise<void>;
 declare function go(href: string, event?: Event): Promise<void>;

package/lib/private/client/navigate.js

@@ -1,9 +1,9 @@
-import http from "#client/http";
 import root from "#client/root";
 import storage from "#client/storage";
-import { MIME } from "@rcompat/http";
+import transport from "#client/transport";
+import http from "@rcompat/http";
 const headers = {
-    Accept: MIME.APPLICATION_JSON,
+    Accept: http.MIME.APPLICATION_JSON,
 };
 const get_by_id_or_name = (name) => document.getElementById(name) ?? document.getElementsByName(name)[0];
 const scroll_hash = (hash) => {
@@ -18,13 +18,14 @@ async function goto(target, state = false, after) {
     try {
         const { scrollTop } = globalThis.document.scrollingElement;
         const { location } = globalThis;
-        const { requested, response } = await http.refetch(target.pathname, { headers });
-        if (http.is_json(response)) {
+        const path = target.pathname + target.search;
+        const { requested, response } = await transport.refetch(path, { headers });
+        if (transport.is_json(response)) {
             if (response.ok)
                 root.update(await response.json());
             if (state) {
                 storage.new({ hash: location.hash, pathname: location.pathname, scrollTop });
-                history.pushState({}, "", `${target.pathname}${target.hash}`);
+                history.pushState({}, "", `${path}${target.hash}`);
             }
             after?.();
             return;

package/lib/private/client/submit.d.ts

@@ -1,2 +1,3 @@
-export default function submit(pathname: string, body: any, method: string): Promise<Response>;
+declare function submit(pathname: string, body: any, method: string): Promise<Response>;
+export default submit;
 //# sourceMappingURL=submit.d.ts.map

package/lib/private/client/submit.js

@@ -1,18 +1,18 @@
-import http from "#client/http";
 import root from "#client/root";
 import storage from "#client/storage";
-import { MIME } from "@rcompat/http";
+import transport from "#client/transport";
+import http from "@rcompat/http";
 const headers = {
-    Accept: MIME.APPLICATION_JSON,
+    Accept: http.MIME.APPLICATION_JSON,
 };
-export default async function submit(pathname, body, method) {
-    const { requested, response } = await http.refetch(pathname, {
+async function submit(pathname, body, method) {
+    const { requested, response } = await transport.refetch(pathname, {
         body, headers, method,
     });
     if (response.redirected) {
         const { location, document, history } = globalThis;
         const scrollTop = document.scrollingElement?.scrollTop ?? 0;
-        if (http.is_json(response))
+        if (transport.is_json(response))
             root.update(await response.json());
         storage.new({
             hash: location.hash,
@@ -23,7 +23,7 @@ export default async function submit(pathname, body, method) {
         history.pushState({}, "", url.pathname + url.search);
         return response;
     }
-    if (http.is_json(response)) {
+    if (transport.is_json(response)) {
         if (response.ok) {
             root.update(await response.json());
             history.replaceState({}, "", requested.pathname + requested.search);
@@ -38,4 +38,5 @@ export default async function submit(pathname, body, method) {
     globalThis.location.assign(target);
     return response;
 }
+export default submit;
 //# sourceMappingURL=submit.js.map

package/lib/private/client/{http.d.ts → transport.d.ts}

@@ -4,10 +4,10 @@ declare function refetch(input: string | URL, init?: RequestInit, max_hops?: num
 }>;
 declare function is_json(response: Response): boolean;
 declare function submit(pathname: string, body: any, method: string): Promise<Response>;
-declare const http: {
+declare const transport: {
     refetch: typeof refetch;
     is_json: typeof is_json;
     submit: typeof submit;
 };
-export default http;
-//# sourceMappingURL=http.d.ts.map
+export default transport;
+//# sourceMappingURL=transport.d.ts.map

package/lib/private/client/{http.js → transport.js}

@@ -1,4 +1,4 @@
-import { MIME } from "@rcompat/http";
+import http from "@rcompat/http";
 const sameorigin = (url) => url.origin === globalThis.location.origin;
 const get_location = (response, base) => {
     if (response.type === "opaqueredirect")
@@ -7,6 +7,8 @@ const get_location = (response, base) => {
     return location !== null ? new URL(location, base) : null;
 };
 async function refetch(input, init = {}, max_hops = 5) {
+    console.log("location.href", globalThis.location.href);
+    console.log("input", input.toString());
     let url = new URL(input.toString(), globalThis.location.href);
     const method = (init.method ?? "GET").toUpperCase();
     let hops = 0;
@@ -36,7 +38,7 @@ async function refetch(input, init = {}, max_hops = 5) {
 }
 function is_json(response) {
     const raw = response.headers.get("content-type") ?? "";
-    return raw.split(";")[0].trim() === MIME.APPLICATION_JSON;
+    return raw.split(";")[0].trim() === http.MIME.APPLICATION_JSON;
 }
 async function submit(pathname, body, method) {
     const { requested, response } = await refetch(pathname, { body, method });
@@ -48,10 +50,6 @@ async function submit(pathname, body, method) {
     }
     return response;
 }
-const http = {
-    refetch,
-    is_json,
-    submit,
-};
-export default http;
-//# sourceMappingURL=http.js.map
+const transport = { refetch, is_json, submit };
+export default transport;
+//# sourceMappingURL=transport.js.map

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

@@ -3,6 +3,7 @@ import type Module from "#Module";
 import type { Dict } from "@rcompat/type";
 import type { ObjectType, Parsed } from "pema";
 declare const _default: ObjectType<import("pema").NormalizeSchemaObject<{
+    readonly conditions: import("pema").DefaultType<import("pema").ArrayType<import("pema").StringType>, string[]>;
     readonly http: {
         readonly csp: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").ArrayType<import("pema").StringType>>>;
         readonly headers: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").StringType>>;
@@ -24,10 +25,10 @@ declare const _default: ObjectType<import("pema").NormalizeSchemaObject<{
     readonly db: {
         readonly migrations: import("pema").OptionalType<ObjectType<{
             table: import("pema").StringType;
-            db: import("pema").PureType<DB, "PureType">;
+            db: import("pema").PureType<DB<unknown>, "PureType">;
         }, {
             table: string;
-            db: DB;
+            db: DB<unknown>;
         }>>;
     };
     readonly env: {
@@ -39,12 +40,8 @@ declare const _default: ObjectType<import("pema").NormalizeSchemaObject<{
         name: import("pema").StringType;
         setup: import("pema").FunctionType;
     }, Module>>, Module[]>;
-    readonly request: {
-        readonly body: {
-            readonly parse: import("pema").DefaultType<import("pema").BooleanType, true>;
-        };
-    };
 }>, {
+    conditions: string[];
     http: {
         csp: Record<string, string[]> | undefined;
         headers: Record<string, string> | undefined;
@@ -66,7 +63,7 @@ declare const _default: ObjectType<import("pema").NormalizeSchemaObject<{
     db: {
         migrations: {
             table: string;
-            db: DB;
+            db: DB<unknown>;
         } | undefined;
     };
     env: {
@@ -75,11 +72,6 @@ declare const _default: ObjectType<import("pema").NormalizeSchemaObject<{
         }> | undefined;
     };
     modules: Module[];
-    request: {
-        body: {
-            parse: boolean;
-        };
-    };
 }>;
 export default _default;
 //# sourceMappingURL=schema.d.ts.map

package/lib/private/config/schema.js

@@ -1,6 +1,7 @@
 import fs from "@rcompat/fs";
 import p from "pema";
 export default p({
+    conditions: p.array(p.string).unique().default([]),
     http: {
         csp: p.dict(p.array(p.string)).optional(),
         headers: p.dict().optional(),
@@ -34,10 +35,5 @@ export default p({
     }).shape())
         .uniqueBy(member => member.name)
         .default([]),
-    request: {
-        body: {
-            parse: p.boolean.default(true),
-        },
-    },
 });
 //# sourceMappingURL=schema.js.map

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

@@ -21,9 +21,10 @@ export type Schema = {
     introspect(name: string, pk?: PK): MaybePromise<MaybeTable>;
     alter(name: string, diff: SchemaDiff): MaybePromise<void>;
 };
-export default interface DB {
+export default interface DB<Client = unknown> {
     schema: Schema;
     close(): MaybePromise<void>;
+    readonly client: Client;
     create<O extends Dict>(as: As, record: Dict): MaybePromise<O>;
     read(as: As, args: {
         count: true;
@@ -34,6 +35,7 @@ export default interface DB {
         where: Dict;
         fields?: string[];
         limit?: number;
+        offset?: number;
         sort?: Sort;
         with?: With;
     }): MaybePromise<Dict[]>;

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

@@ -4,9 +4,11 @@ import type { Schema } from "#db/DB";
 import type DataDict from "#db/DataDict";
 import type Sort from "#db/Sort";
 import type With from "#db/With";
-import type { Dict, MaybePromise } from "@rcompat/type";
-export default class MemoryDB implements DB {
+import type { Dict, MaybePromise, PartialDict } from "@rcompat/type";
+type Tables = PartialDict<Dict[]>;
+export default class MemoryDB implements DB<Tables> {
     #private;
+    get client(): Tables;
     get schema(): Schema;
     close(): void;
     create<O extends Dict>(as: As, record: Dict): MaybePromise<O>;
@@ -30,4 +32,5 @@ export default class MemoryDB implements DB {
         where: DataDict;
     }): number;
 }
+export {};
 //# sourceMappingURL=MemoryDB.d.ts.map

package/lib/private/db/MemoryDB.js

@@ -1,6 +1,6 @@
 import E from "#db/errors";
 import assert from "@rcompat/assert";
-import entries from "@rcompat/dict/entries";
+import dict from "@rcompat/dict";
 import is from "@rcompat/is";
 function escape_re(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -83,6 +83,22 @@ function match(record, where) {
                             return false;
                         break;
                     }
+                    case "$in": {
+                        const arr = op_val;
+                        if (is.date(value)) {
+                            if (!arr.some(v => is.date(v) && v.getTime() === value.getTime()))
+                                return false;
+                            break;
+                        }
+                        if (is.url(value)) {
+                            if (!arr.some(v => is.url(v) && v.href === value.href))
+                                return false;
+                            break;
+                        }
+                        if (!arr.includes(value))
+                            return false;
+                        break;
+                    }
                     default:
                         throw E.operator_unknown(k, op);
                 }
@@ -101,24 +117,20 @@ function filter(record, fields) {
     return Object.fromEntries(Object.entries(record)
         .filter(([key]) => fields.includes(key)));
 }
-function toSorted(d1, d2, sort) {
-    return [...entries(sort).valmap(([, value]) => value === "asc" ? 1 : -1)]
+function to_sorted(d1, d2, sort) {
+    return (dict.entries(sort)
+        .map(([k, value]) => [k, value === "asc" ? 1 : -1])
         .reduce((sorting, [field, direction]) => {
         const left = d1[field];
         const right = d2[field];
-        // if sorting has been established, it stays fixed
-        if (sorting !== 0) {
+        if (sorting !== 0)
             return sorting;
-        }
-        // equal, sorting doesn't change
-        if (left === right) {
+        if (left === right)
             return sorting;
-        }
-        if (left < right) {
+        if (left < right)
             return -1 * direction;
-        }
         return direction;
-    }, 0);
+    }, 0));
 }
 export default class MemoryDB {
     #tables = {};
@@ -127,6 +139,9 @@ export default class MemoryDB {
         this.#tables[name] ??= [];
         return this.#tables[name];
     }
+    get client() {
+        return this.#tables;
+    }
     get schema() {
         return {
             create: async (table, _pk, types) => {
@@ -206,9 +221,10 @@ export default class MemoryDB {
         const sort = args.sort ?? {};
         const sorted = Object.keys(sort).length === 0
             ? matches
-            : matches.toSorted((a, b) => toSorted(a, b, sort));
+            : matches.toSorted((a, b) => to_sorted(a, b, sort));
+        const offset = args.offset ?? 0;
         const limit = args.limit ?? sorted.length;
-        const base_rows = sorted.slice(0, limit);
+        const base_rows = sorted.slice(offset, offset + limit);
         // no relations -> preserve existing behavior
         if (args.with === undefined) {
             const fields = args.fields ?? [];
@@ -258,7 +274,7 @@ export default class MemoryDB {
                     // filter by target_pk equality + optional where
                     let candidates = target.filter(t => t[target_pk] === fk_value && match(t, r_where));
                     if (r_sort !== undefined && Object.keys(r_sort).length > 0) {
-                        candidates = candidates.toSorted((a, b) => toSorted(a, b, r_sort));
+                        candidates = candidates.toSorted((a, b) => to_sorted(a, b, r_sort));
                     }
                     if (r_limit !== undefined)
                         candidates = candidates.slice(0, r_limit);
@@ -290,7 +306,7 @@ export default class MemoryDB {
                 const key = parent_full[parent_pk];
                 let rows = grouped.get(key) ?? [];
                 if (r_sort !== undefined && Object.keys(r_sort).length > 0) {
-                    rows = rows.toSorted((a, b) => toSorted(a, b, r_sort));
+                    rows = rows.toSorted((a, b) => to_sorted(a, b, r_sort));
                 }
                 if (kind === "one") {
                     if (r_limit !== undefined)
@@ -314,9 +330,7 @@ export default class MemoryDB {
         const matched = table.filter(record => match(record, args.where));
         const pk = as.pk;
         return matched.map(record => {
-            const changed = entries({ ...record, ...args.set })
-                .filter(([, value]) => value !== null)
-                .get();
+            const changed = dict.filter({ ...record, ...args.set }, (_, value) => !is.null(value));
             const index = pk !== null
                 ? table.findIndex(stored => stored[pk] === record[pk])
                 : table.findIndex(stored => stored === record);

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

@@ -0,0 +1,23 @@
+import type DB from "#db/DB";
+import type { ArrayType, ObjectType, OptionalType, Parsed } from "pema";
+export type SQLInput = ObjectType<any>;
+export type SQLOutput = ArrayType<any>;
+export type WordChar = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" | "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "_";
+export type ReadWord<S extends string, Acc extends string = ""> = S extends `${infer C extends WordChar}${infer Rest}` ? ReadWord<Rest, `${Acc}${C}`> : Acc;
+export type ExtractPlaceholders<S extends string> = S extends `${string}:${infer After}` ? ReadWord<After> | ExtractPlaceholders<After> : never;
+type RequiredKeys<I extends ObjectType<any>> = {
+    [K in keyof I["properties"]]: I["properties"][K] extends OptionalType<any> ? never : K;
+}[keyof I["properties"]];
+type MissingPlaceholders<I extends ObjectType<any>, Q extends string> = Exclude<RequiredKeys<I>, ExtractPlaceholders<Q>>;
+export type CheckPlaceholders<I extends ObjectType<any>, Q extends string> = MissingPlaceholders<I, Q> extends never ? I : `Missing placeholders in query: ${MissingPlaceholders<I, Q> & string}`;
+export default interface SQLDB<Client = unknown> extends DB<Client> {
+    sql<Q extends string, I extends ObjectType<{
+        [K in ExtractPlaceholders<Q>]: Parsed<unknown>;
+    }> | undefined, O extends Parsed<unknown> | undefined>(options: {
+        input?: I extends ObjectType<any> ? CheckPlaceholders<I, Q> : I;
+        query: Q;
+        output?: O;
+    }): (args: I extends ObjectType<any> ? I["infer"] : void) => Promise<O extends Parsed<unknown> ? O["infer"] : void>;
+}
+export {};
+//# sourceMappingURL=SQLDB.d.ts.map

package/lib/private/db/SQLDB.js

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