@primate/core 0.4.5 → 0.5.0

package/lib/private/db/error.js

@@ -0,0 +1,199 @@
+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/sql.d.ts

@@ -0,0 +1,28 @@
+import type As from "#db/As";
+import type ReadRelationsArgs from "#db/ReadRelationsArgs";
+import type Sort from "#db/Sort";
+import type Types from "#db/Types";
+import type With from "#db/With";
+import type { Dict } from "@rcompat/type";
+import type { DataKey } from "pema";
+declare function quote(name: string): string;
+declare function Q(strings: TemplateStringsArray, ...values: (string | unknown[])[]): string;
+declare const sql: {
+    quote: typeof quote;
+    orderBy(types: Types, sort?: Sort, alias?: string): string;
+    limit(limit?: number): string;
+    aliases(tables: string[]): Dict<string>;
+    aliased(aliases: Dict<string>, as: As, fields?: string[]): string;
+    columns(types: Types, columns?: string[]): string;
+    bindKey(column: string, op: string): string;
+    joinable(parent: As, relations: With): boolean;
+    unbind<R>(types: Types, row: Dict, unbinder: (key: DataKey, value: unknown) => R): Dict<R>;
+    nest<T>(as: As, args: {
+        rows: Dict[];
+        aliases: Dict<string>;
+    }, relation_args: ReadRelationsArgs, unbind: (type: DataKey, value: unknown) => T): Dict[];
+    Q: typeof Q;
+    OPS: Dict<">" | ">=" | "<" | "<=">;
+};
+export default sql;
+//# sourceMappingURL=sql.d.ts.map

package/lib/private/db/sql.js

@@ -0,0 +1,177 @@
+import E from "#db/error";
+import assert from "@rcompat/assert";
+import is from "@rcompat/is";
+function normalize_sort(key, direction) {
+    if (!is.string(direction))
+        throw E.sort_invalid();
+    const l = direction.toLowerCase();
+    if (l !== "asc" && l !== "desc")
+        throw E.sort_invalid_value(key, direction);
+    return l.toUpperCase();
+}
+function assert_columns(types, columns) {
+    const known = new Set(Object.keys(types));
+    const unknown = columns.filter(c => !known.has(c));
+    if (unknown.length > 0)
+        throw E.fields_unknown(unknown);
+}
+function quote(name) {
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name))
+        throw E.identifier_invalid(name);
+    return `\`${name}\``;
+}
+function Q(strings, ...values) {
+    return strings.reduce((result, string, i) => {
+        if (i === values.length)
+            return result + string;
+        const value = values[i];
+        let processed;
+        if (Array.isArray(value)) {
+            processed = value.join(", ");
+        }
+        else if (typeof value === "string") {
+            processed = sql.quote(value);
+        }
+        else {
+            throw "Q: use only strings or arrays";
+        }
+        return result + string + processed;
+    }, "");
+}
+;
+const OPS = {
+    $gt: ">",
+    $gte: ">=",
+    $lt: "<",
+    $lte: "<=",
+    $after: ">",
+    $before: "<",
+};
+const sql = {
+    quote,
+    orderBy(types, sort, alias) {
+        if (sort === undefined)
+            return "";
+        const columns = Object.entries(sort);
+        if (columns.length === 0)
+            throw E.field_required("sort");
+        assert_columns(types, columns.map(([k]) => k));
+        const order = columns
+            .map(([k, direction]) => {
+            const quoted = quote(k);
+            const col = alias ? `${alias}.${quoted}` : quoted;
+            return `${col} ${normalize_sort(k, direction)}`;
+        })
+            .join(", ");
+        return ` ORDER BY ${order}`;
+    },
+    limit(limit) {
+        return limit !== undefined ? ` LIMIT ${limit}` : "";
+    },
+    aliases(tables) {
+        const counts = {};
+        const result = {};
+        for (const table of tables) {
+            const prefix = table[0].toLowerCase();
+            counts[prefix] ??= 0;
+            result[table] = `${prefix}${counts[prefix]++}`;
+        }
+        return result;
+    },
+    aliased(aliases, as, fields) {
+        const alias = aliases[as.table];
+        return (fields ?? Object.keys(as.types))
+            .map(f => `${alias}.${quote(f)} AS ${alias}_${f}`)
+            .join(", ");
+    },
+    columns(types, columns) {
+        if (columns === undefined)
+            return "*";
+        if (columns.length === 0)
+            throw E.field_required("select");
+        assert_columns(types, columns);
+        return columns.map(quote).join(", ");
+    },
+    bindKey(column, op) {
+        const suffix = op.startsWith("$") ? op.slice(1) : op;
+        return `${column}__${suffix}`;
+    },
+    joinable(parent, relations) {
+        const rels = Object.values(relations);
+        if (rels.length !== 1)
+            return false;
+        const r = rels[0];
+        if (parent.pk === null)
+            return false;
+        return (!r.reverse &&
+            r.kind === "many" &&
+            r.limit === undefined &&
+            r.sort === undefined &&
+            Object.keys(r.where).length === 0 &&
+            r.as.pk !== null);
+    },
+    unbind(types, row, unbinder) {
+        const out = {};
+        for (const [key, value] of Object.entries(row)) {
+            if (value === null)
+                continue;
+            assert.true(key in types, `unexpected column: ${key}`);
+            out[key] = unbinder(types[key], value);
+        }
+        return out;
+    },
+    nest(as, args, relation_args, unbind) {
+        if (as.pk === null)
+            throw E.relation_requires_pk("parent");
+        const base_alias = args.aliases[as.table];
+        const base_pk_key = `${base_alias}_${as.pk}`;
+        const base_fields = relation_args.fields ?? Object.keys(as.types);
+        const grouped = new Map();
+        for (const base_row of args.rows) {
+            const pk_value = base_row[base_pk_key];
+            const relation_entries = Object.entries(relation_args.with);
+            if (!grouped.has(pk_value)) {
+                const parent = {};
+                for (const f of base_fields) {
+                    const v = base_row[`${base_alias}_${f}`];
+                    if (v == null)
+                        continue;
+                    parent[f] = unbind(as.types[f], v);
+                }
+                for (const [name, relation] of relation_entries) {
+                    parent[name] = relation.kind === "many" ? [] : null;
+                }
+                grouped.set(pk_value, parent);
+            }
+            const parent = grouped.get(pk_value);
+            for (const [name, relation] of relation_entries) {
+                const alias = args.aliases[relation.as.table];
+                const pk = relation.as.pk;
+                if (pk === null)
+                    continue;
+                const pk_key = `${alias}_${pk}`;
+                if (base_row[pk_key] == null)
+                    continue;
+                const fields = relation.fields ?? Object.keys(relation.as.types);
+                const row = {};
+                for (const field of fields) {
+                    const v = base_row[`${alias}_${field}`];
+                    if (v == null)
+                        continue;
+                    row[field] = unbind(relation.as.types[field], v);
+                }
+                if (relation.kind === "many") {
+                    parent[name].push(row);
+                }
+                else if (parent[name] === null) {
+                    parent[name] = row;
+                }
+            }
+        }
+        return [...grouped.values()];
+    },
+    Q,
+    OPS,
+};
+export default sql;
+//# sourceMappingURL=sql.js.map

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

@@ -0,0 +1,3 @@
+declare const _default: import("node:async_hooks").AsyncLocalStorage<unknown>;
+export default _default;
+//# sourceMappingURL=storage.d.ts.map

package/lib/private/db/storage.js

@@ -0,0 +1,3 @@
+import io from "@rcompat/io";
+export default new io.async.Context();
+//# sourceMappingURL=storage.js.map

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

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

package/lib/private/db/symbol.js

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

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

@@ -0,0 +1,4 @@
+import type DB from "#db/DB";
+declare const _default: <D extends DB>(db: D) => void;
+export default _default;
+//# sourceMappingURL=test.d.ts.map