@primate/core 0.4.6 → 0.6.0

package/lib/private/db/migrate/status.d.ts

@@ -0,0 +1,2 @@
+export default function status_migration(): Promise<void>;
+//# sourceMappingURL=status.d.ts.map

package/lib/private/db/migrate/status.js

@@ -0,0 +1,38 @@
+import store from "#db/migrate/store";
+import c from "@rcompat/cli/color";
+import print from "@rcompat/cli/print";
+import fs from "@rcompat/fs";
+export default async function status_migration() {
+    const root = await fs.project.root();
+    const migrations_dir = root.join("migrations");
+    const Migration = await store();
+    await Migration.table.create();
+    const applied = await Migration.find({
+        limit: 3,
+        sort: { id: "desc" },
+    });
+    const files = await (async () => {
+        if (!await migrations_dir.exists())
+            return [];
+        return (await migrations_dir.files({ filter: /\d+-.*\.[jt]s$/ }))
+            .map(f => ({ name: f.name, n: parseInt(f.name.split("-")[0]) }))
+            .toSorted((a, b) => a.n - b.n);
+    })();
+    const last_id = applied.length === 0 ? 0 : applied[0].id;
+    const pending = files.filter(f => f.n > last_id);
+    const last_applied = applied.toReversed();
+    for (const { id, applied: date } of last_applied) {
+        const file = files.find(f => f.n === id);
+        print(`${c.green("Applied")} ${file?.name ?? "unknown"} (${date.toISOString()})\n`);
+    }
+    if (last_applied.length > 0 && pending.length > 0) {
+        print("---\n");
+    }
+    for (const { name, n } of pending) {
+        print(`${c.yellow("Pending")} ${c.bold(name)}\n`);
+    }
+    if (last_applied.length === 0 && pending.length === 0) {
+        print("No migrations found.\n");
+    }
+}
+//# sourceMappingURL=status.js.map

package/lib/private/db/migrate/store.d.ts

@@ -0,0 +1,5 @@
+export default function migration_store(): Promise<import("#orm/store").Store<{
+    id: import("../../orm/PrimaryKey.js").default<import("pema").UintType<"u16">>;
+    applied: import("pema").DateType;
+}, {}>>;
+//# sourceMappingURL=store.d.ts.map

package/lib/private/db/migrate/store.js

@@ -0,0 +1,33 @@
+import bundle from "#db/migrate/bundle";
+import E from "#errors";
+import key from "#orm/key";
+import store from "#orm/store";
+import fs from "@rcompat/fs";
+import p from "pema";
+export default async function migration_store() {
+    const root = await fs.project.root();
+    const { path } = await (async () => {
+        const ts = root.join("config", "app.ts");
+        if (await ts.exists())
+            return ts;
+        const js = root.join("config", "app.js");
+        if (await js.exists())
+            return js;
+        throw E.config_file_missing();
+    })();
+    const entry = `export { default } from "${path}";`;
+    const app = await bundle(entry);
+    const migrations_config = app.config("db.migrations");
+    if (migrations_config == undefined)
+        throw E.config_missing("db.migrations");
+    const { table, db } = migrations_config;
+    return store({
+        name: table,
+        db,
+        schema: {
+            id: key.primary(p.u16, { generate: false }),
+            applied: p.date,
+        },
+    });
+}
+//# sourceMappingURL=store.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/errors";
+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, E.field_unknown(key, "unbind"));
+            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 = unbind(as.types[as.pk], 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.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