@primate/core 0.6.2 → 0.7.0

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

@@ -1,7 +1,7 @@
 declare function db_missing(): import("@rcompat/error").TemplateError;
 declare function store_directory_missing(): import("@rcompat/error").TemplateError;
 declare function store_directory_empty(): import("@rcompat/error").TemplateError;
-declare function store_name_required(): import("@rcompat/error").TemplateError;
+declare function store_table_required(): import("@rcompat/error").TemplateError;
 declare function unregistered_schema(): import("@rcompat/error").TemplateError;
 declare function record_not_found(field: string, value: string | number | bigint): import("@rcompat/error").TemplateError;
 declare function key_duplicate(key: string): import("@rcompat/error").TemplateError;
@@ -23,10 +23,11 @@ declare function field_required(operator: string): import("@rcompat/error").Temp
 declare function field_undefined(field: string, context: Context): import("@rcompat/error").TemplateError;
 declare function fields_unknown(fields: string[]): import("@rcompat/error").TemplateError;
 declare function null_not_allowed(field: string): import("@rcompat/error").TemplateError;
-declare function wrong_type(type: "string" | "number" | "bigint" | "boolean" | "url" | "date" | "blob", field: string, got: unknown, op?: string): import("@rcompat/error").TemplateError;
+declare function wrong_type(type: "string" | "number" | "bigint" | "boolean" | "url" | "date" | "blob" | "array", field: string, got: unknown, op?: string): import("@rcompat/error").TemplateError;
 declare function operator_unknown(field: string, operator: string): import("@rcompat/error").TemplateError;
 declare function operator_empty(field: string): import("@rcompat/error").TemplateError;
 declare function operator_scalar(field: string): import("@rcompat/error").TemplateError;
+declare function operator_empty_in(key: string): import("@rcompat/error").TemplateError;
 declare function sort_empty(): import("@rcompat/error").TemplateError;
 declare function sort_invalid(): import("@rcompat/error").TemplateError;
 declare function sort_invalid_value(field: string, value: unknown): import("@rcompat/error").TemplateError;
@@ -38,9 +39,12 @@ declare function where_required(): import("@rcompat/error").TemplateError;
 declare function where_invalid(): import("@rcompat/error").TemplateError;
 declare function where_invalid_value(field: string, value: unknown): import("@rcompat/error").TemplateError;
 declare function set_empty(): import("@rcompat/error").TemplateError;
-declare function relation_unknown(relation: string): import("@rcompat/error").TemplateError;
+declare function offset_invalid(): import("@rcompat/error").TemplateError;
+declare function offset_requires_limit(): import("@rcompat/error").TemplateError;
+declare function relation_unknown(relation: PropertyKey): import("@rcompat/error").TemplateError;
 declare function relation_requires_pk(type: "target" | "parent"): import("@rcompat/error").TemplateError;
-declare function relation_conflicts_with_field(relation: string): import("@rcompat/error").TemplateError;
+declare function relation_table_mismatch(expected: string, actual: string): import("@rcompat/error").TemplateError;
+declare function relation_store_required(name: PropertyKey): import("@rcompat/error").TemplateError;
 declare function option_unknown(option: string): import("@rcompat/error").TemplateError;
 declare function identifier_invalid(identifier: string): import("@rcompat/error").TemplateError;
 declare function count_with_invalid(): import("@rcompat/error").TemplateError;
@@ -48,6 +52,8 @@ declare function count_overflow(table: string, count: unknown): import("@rcompat
 declare function migration_directory_missing(): import("@rcompat/error").TemplateError;
 declare function migration_store_conflict(message: string): import("@rcompat/error").TemplateError;
 declare function unapplied_migrations(): import("@rcompat/error").TemplateError;
+declare function sql_placeholder_missing(key: string): import("@rcompat/error").TemplateError;
+declare function sql_input_missing(key: string): import("@rcompat/error").TemplateError;
 declare const errors: {
     option_unknown: typeof option_unknown;
     identifier_invalid: typeof identifier_invalid;
@@ -56,9 +62,12 @@ declare const errors: {
     migration_directory_missing: typeof migration_directory_missing;
     migration_store_conflict: typeof migration_store_conflict;
     unapplied_migrations: typeof unapplied_migrations;
+    sql_placeholder_missing: typeof sql_placeholder_missing;
+    sql_input_missing: typeof sql_input_missing;
     relation_unknown: typeof relation_unknown;
     relation_requires_pk: typeof relation_requires_pk;
-    relation_conflicts_with_field: typeof relation_conflicts_with_field;
+    relation_table_mismatch: typeof relation_table_mismatch;
+    relation_store_required: typeof relation_store_required;
     sort_empty: typeof sort_empty;
     sort_invalid: typeof sort_invalid;
     sort_invalid_value: typeof sort_invalid_value;
@@ -70,10 +79,13 @@ declare const errors: {
     where_invalid_value: typeof where_invalid_value;
     set_empty: typeof set_empty;
     limit_invalid: typeof limit_invalid;
+    offset_invalid: typeof offset_invalid;
+    offset_requires_limit: typeof offset_requires_limit;
     operator_unknown: typeof operator_unknown;
     operator_empty: typeof operator_empty;
     wrong_type: typeof wrong_type;
     operator_scalar: typeof operator_scalar;
+    operator_empty_in: typeof operator_empty_in;
     null_not_allowed: typeof null_not_allowed;
     field_unknown: typeof field_unknown;
     field_duplicate: typeof field_duplicate;
@@ -90,7 +102,7 @@ declare const errors: {
     db_missing: typeof db_missing;
     store_directory_missing: typeof store_directory_missing;
     store_directory_empty: typeof store_directory_empty;
-    store_name_required: typeof store_name_required;
+    store_table_required: typeof store_table_required;
     unregistered_schema: typeof unregistered_schema;
     record_not_found: typeof record_not_found;
     record_number_invalid: typeof record_number_invalid;
@@ -98,7 +110,62 @@ declare const errors: {
     key_duplicate: typeof key_duplicate;
     table_not_found: typeof table_not_found;
 };
+export declare const Code: {
+    option_unknown: "option_unknown";
+    identifier_invalid: "identifier_invalid";
+    count_with_invalid: "count_with_invalid";
+    count_overflow: "count_overflow";
+    migration_directory_missing: "migration_directory_missing";
+    migration_store_conflict: "migration_store_conflict";
+    unapplied_migrations: "unapplied_migrations";
+    sql_placeholder_missing: "sql_placeholder_missing";
+    sql_input_missing: "sql_input_missing";
+    relation_unknown: "relation_unknown";
+    relation_requires_pk: "relation_requires_pk";
+    relation_table_mismatch: "relation_table_mismatch";
+    relation_store_required: "relation_store_required";
+    sort_empty: "sort_empty";
+    sort_invalid: "sort_invalid";
+    sort_invalid_value: "sort_invalid_value";
+    select_empty: "select_empty";
+    select_invalid: "select_invalid";
+    select_invalid_value: "select_invalid_value";
+    where_required: "where_required";
+    where_invalid: "where_invalid";
+    where_invalid_value: "where_invalid_value";
+    set_empty: "set_empty";
+    limit_invalid: "limit_invalid";
+    offset_invalid: "offset_invalid";
+    offset_requires_limit: "offset_requires_limit";
+    operator_unknown: "operator_unknown";
+    operator_empty: "operator_empty";
+    wrong_type: "wrong_type";
+    operator_scalar: "operator_scalar";
+    operator_empty_in: "operator_empty_in";
+    null_not_allowed: "null_not_allowed";
+    field_unknown: "field_unknown";
+    field_duplicate: "field_duplicate";
+    field_required: "field_required";
+    field_undefined: "field_undefined";
+    fields_unknown: "fields_unknown";
+    pk_undefined: "pk_undefined";
+    pk_immutable: "pk_immutable";
+    pk_duplicate: "pk_duplicate";
+    pk_invalid: "pk_invalid";
+    pk_required: "pk_required";
+    pk_multiple_pks: "pk_multiple_pks";
+    pk_invalid_type: "pk_invalid_type";
+    db_missing: "db_missing";
+    store_directory_missing: "store_directory_missing";
+    store_directory_empty: "store_directory_empty";
+    store_table_required: "store_table_required";
+    unregistered_schema: "unregistered_schema";
+    record_not_found: "record_not_found";
+    record_number_invalid: "record_number_invalid";
+    return_invalid: "return_invalid";
+    key_duplicate: "key_duplicate";
+    table_not_found: "table_not_found";
+};
 export type Code = keyof typeof errors;
-export declare const Code: { [K in Code]: K; };
 export default errors;
 //# sourceMappingURL=errors.d.ts.map

package/lib/private/db/errors.js

@@ -21,8 +21,8 @@ function store_directory_missing() {
 function store_directory_empty() {
     return t `store directory empty`;
 }
-function store_name_required() {
-    return t `store name required`;
+function store_table_required() {
+    return t `store ${"table"} required`;
 }
 function unregistered_schema() {
     return t `no store registered for schema`;
@@ -46,7 +46,7 @@ const STORE = error.coded({
     db_missing,
     store_directory_missing,
     store_directory_empty,
-    store_name_required,
+    store_table_required,
     unregistered_schema,
     record_not_found,
     record_number_invalid,
@@ -124,11 +124,15 @@ function operator_empty(field) {
 function operator_scalar(field) {
     return t `${field}: operator requires scalar value`;
 }
+function operator_empty_in(key) {
+    return t `$in operator on ${key} requires a non-empty array`;
+}
 const OPERATOR = error.coded({
     operator_unknown,
     operator_empty,
     wrong_type,
     operator_scalar,
+    operator_empty_in,
 });
 function sort_empty() {
     return t `empty sort`;
@@ -163,6 +167,12 @@ function where_invalid_value(field, value) {
 function set_empty() {
     return t `empty set on update`;
 }
+function offset_invalid() {
+    return t `offset must be a non-negative integer`;
+}
+function offset_requires_limit() {
+    return t `offset requires limit to be set`;
+}
 const QUERY = error.coded({
     sort_empty,
     sort_invalid,
@@ -175,6 +185,8 @@ const QUERY = error.coded({
     where_invalid_value,
     set_empty,
     limit_invalid,
+    offset_invalid,
+    offset_requires_limit,
 });
 function relation_unknown(relation) {
     return t `unknown relation ${relation}`;
@@ -182,13 +194,17 @@ function relation_unknown(relation) {
 function relation_requires_pk(type) {
     return t `relation loading requires ${type} primary key`;
 }
-function relation_conflicts_with_field(relation) {
-    return t `relation ${relation} conflicts with an existing schema field`;
+function relation_table_mismatch(expected, actual) {
+    return t `relation table mismatch: expected ${expected}, got ${actual}`;
+}
+function relation_store_required(name) {
+    return t `relation ${name} requires a store`;
 }
 const RELATION = error.coded({
     relation_unknown,
     relation_requires_pk,
-    relation_conflicts_with_field,
+    relation_table_mismatch,
+    relation_store_required,
 });
 function option_unknown(option) {
     return t `unknown option ${option}`;
@@ -213,6 +229,12 @@ function unapplied_migrations() {
 — Show migration status ${"npx primate migrate:status"}
 - Apply pending migrations ${"npx primate migrate:apply"}`;
 }
+function sql_placeholder_missing(key) {
+    return t `input key ${key} has no matching placeholder in query`;
+}
+function sql_input_missing(key) {
+    return t `query placeholder ${key} has no matching input key`;
+}
 const MISC = error.coded({
     option_unknown,
     identifier_invalid,
@@ -221,6 +243,8 @@ const MISC = error.coded({
     migration_directory_missing,
     migration_store_conflict,
     unapplied_migrations,
+    sql_placeholder_missing,
+    sql_input_missing,
 });
 const errors = {
     ...STORE,
@@ -232,6 +256,6 @@ const errors = {
     ...RELATION,
     ...MISC,
 };
-export const Code = Object.fromEntries(Object.keys(errors).map(k => [k, k]));
+export const Code = error.names(errors);
 export default errors;
 //# sourceMappingURL=errors.js.map

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

@@ -1,14 +1,13 @@
 import E from "#db/errors";
 import store from "#db/migrate/store";
-import color from "@rcompat/cli/color";
-import print from "@rcompat/cli/print";
-import fs from "@rcompat/fs";
+import cli from "@rcompat/cli";
+import runtime from "@rcompat/runtime";
 export default async function apply_migration() {
     const Migration = await store();
-    await Migration.table.create();
+    await Migration.create();
     const last = await Migration.find({ limit: 1, sort: { id: "desc" } });
     const last_id = last.length === 0 ? 0 : last[0].id;
-    const root = await fs.project.root();
+    const root = await runtime.projectRoot();
     const migrations_dir = root.join("migrations");
     if (!await migrations_dir.exists())
         throw E.migration_directory_missing();
@@ -17,17 +16,17 @@ export default async function apply_migration() {
         .filter(({ n }) => n > last_id)
         .toSorted((a, b) => a.n - b.n);
     if (files.length === 0) {
-        print("No pending migrations.\n");
+        cli.print("No pending migrations.\n");
         return;
     }
     for (const { file, n } of files) {
         const { default: migration } = await import(file.path);
         await migration(Migration.db);
         await Migration.insert({ id: n, applied: new Date() });
-        print(`Applied migration ${color.bold(file.name)}.\n`);
+        cli.print(`Applied migration ${cli.fg.bold(file.name)}.\n`);
     }
     const plural = files.length === 1 ? "" : "s";
-    print(`Done. Applied ${files.length} migration${plural}.\n`);
-    process.exit();
+    cli.print(`Done. Applied ${files.length} migration${plural}.\n`);
+    runtime.exit();
 }
 //# sourceMappingURL=apply.js.map

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

@@ -1,7 +1,7 @@
-import fs from "@rcompat/fs";
+import runtime from "@rcompat/runtime";
 import esbuild from "esbuild";
 export default async (contents) => {
-    const root = await fs.project.root();
+    const root = await runtime.projectRoot();
     const id = Date.now();
     const entrypoint = root.join(`.migrate-in-${id}.js`);
     const out = root.join(`.migrate-out-${id}.js`);
@@ -14,6 +14,7 @@ export default async (contents) => {
             format: "esm",
             platform: "node",
             tsconfig: root.join("tsconfig.json").path,
+            packages: "external",
         });
     }
     finally {

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

@@ -1,11 +1,8 @@
 import E from "#db/errors";
 import bundle from "#db/migrate/bundle";
 import toMigrationStore from "#db/migrate/store";
-import c from "@rcompat/cli/color";
-import print from "@rcompat/cli/print";
-import is_cancel from "@rcompat/cli/prompts/is-cancel";
-import text from "@rcompat/cli/prompts/text";
-import fs from "@rcompat/fs";
+import cli from "@rcompat/cli";
+import runtime from "@rcompat/runtime";
 import string from "@rcompat/string";
 function generate_migration(diffs) {
     const lines = ["export default async db => {"];
@@ -16,13 +13,13 @@ function generate_migration(diffs) {
                 .map(([k, v]) => `    ${k}: "${v}"`)
                 .join(",\n");
             const options = `{ name: "${store.pk}", generate: true }`;
-            lines.push(`  await db.schema.create("${store.name}", ${options}, {`);
+            lines.push(`  await db.schema.create("${store.table}", ${options}, {`);
             lines.push(`${types}`);
             lines.push("  });");
         }
         else {
             const { store, diff } = entry;
-            lines.push(`  await db.schema.alter("${store.name}", {`);
+            lines.push(`  await db.schema.alter("${store.table}", {`);
             lines.push(`    add: { ${Object.entries(diff.add).map(([k, v]) => `${k}: "${v}"`).join(", ")} },`);
             lines.push(`    drop: [${diff.drop.map(f => `"${f}"`).join(", ")}],`);
             lines.push(`    rename: [${diff.rename.map(([f, t]) => `["${f}", "${t}"]`).join(", ")}],`);
@@ -33,7 +30,7 @@ function generate_migration(diffs) {
     return lines.join("\n");
 }
 export default async function create_migration(desc) {
-    const root = await fs.project.root();
+    const root = await runtime.projectRoot();
     const migrations = root.join("migrations");
     // discover store files
     const stores_dir = root.join("stores");
@@ -48,7 +45,7 @@ export default async function create_migration(desc) {
     let next = 1;
     if (await migrations.exists()) {
         const Migration = await toMigrationStore();
-        await Migration.table.create();
+        await Migration.create();
         const last = await Migration.find({ limit: 1, sort: { id: "desc" } });
         const last_id = last.length === 0 ? 0 : last[0].id;
         const files = await migrations.files({ filter: /\d+-.*\.ts$/ });
@@ -60,6 +57,7 @@ export default async function create_migration(desc) {
     // generate virtual entry
     const entry = store_files.map((f, i) => `import s${i} from "${f.path}";`).join("\n") + `\nexport default [
     ${store_files.map((_, i) => `s${i}`).join(",\n ")}\n];`;
+    console.log("entry", entry);
     const stores = await bundle(entry);
     const diffs = [];
     const seen = new Set();
@@ -74,8 +72,8 @@ export default async function create_migration(desc) {
             continue;
         seen.add(store.id);
         migration_stores.push(store);
-        const existing = names.get(store.name) ?? [];
-        names.set(store.name, [...existing, file.name]);
+        const existing = names.get(store.table) ?? [];
+        names.set(store.table, [...existing, file.name]);
     }
     const conflicts = [...names].filter(([, files]) => files.length > 1);
     if (conflicts.length > 0) {
@@ -85,7 +83,7 @@ export default async function create_migration(desc) {
         throw E.migration_store_conflict(messages);
     }
     for (const store of migration_stores) {
-        const current = await store.db.schema.introspect(store.name, store.pk);
+        const current = await store.db.schema.introspect(store.table, store.pk);
         // table doesn't exist yet, create
         if (current === null) {
             diffs.push({
@@ -112,7 +110,7 @@ export default async function create_migration(desc) {
         if (diff_entry.op !== "alter")
             continue;
         const { diff, store } = diff_entry;
-        const current = await store.db.schema.introspect(store.name, store.pk);
+        const current = await store.db.schema.introspect(store.table, store.pk);
         const confirmed_renames = [];
         const confirmed_drops = [];
         for (const dropped of diff.drop) {
@@ -125,13 +123,13 @@ export default async function create_migration(desc) {
                 continue;
             }
             for (const added of matching_added) {
-                const d = c.bold(dropped);
-                const a = c.bold(added);
-                const answer = await text({
+                const d = cli.fg.bold(dropped);
+                const a = cli.fg.bold(added);
+                const answer = await cli.prompt.text({
                     message: `${d} was removed and ${a} was `
                         + `added with a compatible type. Rename ${d} → ${a}? (y/N)`,
                 });
-                if (!is_cancel(answer) && answer.toLowerCase() === "y") {
+                if (!cli.prompt.isCancel(answer) && answer.toLowerCase() === "y") {
                     confirmed_renames.push([dropped, added]);
                     delete diff.add[added];
                 }
@@ -144,7 +142,7 @@ export default async function create_migration(desc) {
         diff.drop = confirmed_drops;
     }
     if (diffs.length === 0) {
-        print("No schema changes detected.\n");
+        cli.print("No schema changes detected.\n");
         return;
     }
     if (!await migrations.exists())
@@ -152,8 +150,8 @@ export default async function create_migration(desc) {
     const content = generate_migration(diffs);
     const filename = `${next}-${string.toSlug(desc)}.ts`;
     await migrations.join(filename).write(content);
-    print(`Created ${c.bold(`migrations/${filename}`)}.\n`);
-    process.exit();
+    cli.print(`Created ${cli.fg.bold(`migrations/${filename}`)}.\n`);
+    runtime.exit();
 }
 ;
 //# sourceMappingURL=create.js.map

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

@@ -1,12 +1,11 @@
 import store from "#db/migrate/store";
-import c from "@rcompat/cli/color";
-import print from "@rcompat/cli/print";
-import fs from "@rcompat/fs";
+import cli from "@rcompat/cli";
+import runtime from "@rcompat/runtime";
 export default async function status_migration() {
-    const root = await fs.project.root();
+    const root = await runtime.projectRoot();
     const migrations_dir = root.join("migrations");
     const Migration = await store();
-    await Migration.table.create();
+    await Migration.create();
     const applied = await Migration.find({
         limit: 3,
         sort: { id: "desc" },
@@ -23,16 +22,16 @@ export default async function status_migration() {
     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`);
+        cli.print(`${cli.fg.green("Applied")} ${file?.name ?? "unknown"} (${date.toISOString()})\n`);
     }
     if (last_applied.length > 0 && pending.length > 0) {
-        print("---\n");
+        cli.print("---\n");
     }
-    for (const { name, n } of pending) {
-        print(`${c.yellow("Pending")} ${c.bold(name)}\n`);
+    for (const { name } of pending) {
+        cli.print(`${cli.fg.yellow("Pending")} ${cli.fg.bold(name)}\n`);
     }
     if (last_applied.length === 0 && pending.length === 0) {
-        print("No migrations found.\n");
+        cli.print("No migrations found.\n");
     }
 }
 //# sourceMappingURL=status.js.map

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

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

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

@@ -1,11 +1,11 @@
 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 key from "#store/key";
+import store from "#store";
+import runtime from "@rcompat/runtime";
 import p from "pema";
 export default async function migration_store() {
-    const root = await fs.project.root();
+    const root = await runtime.projectRoot();
     const { path } = await (async () => {
         const ts = root.join("config", "app.ts");
         if (await ts.exists())
@@ -22,7 +22,7 @@ export default async function migration_store() {
         throw E.config_missing("db.migrations");
     const { table, db } = migrations_config;
     return store({
-        name: table,
+        table,
         db,
         schema: {
             id: key.primary(p.u16, { generate: false }),