@primate/sqlite 0.7.0 → 0.9.0

package/lib/private/SQLite.d.ts

@@ -1,23 +1,24 @@
-import type { As, DataDict, DB, Sort, With } from "@primate/core/db";
+import type { As, CheckPlaceholders, DataDict, ExtractPlaceholders, Schema, Sort, SQLDB, With } from "@primate/core/db";
+import Client from "@rcompat/sqlite";
 import type { Dict } from "@rcompat/type";
-import type { StoreSchema } from "pema";
-declare const schema: import("pema").ObjectType<{
-    database: import("pema").DefaultType<import("pema").StringType, ":memory:">;
+import type { ObjectType, Parsed } from "pema";
+declare const schema: ObjectType<import("pema").NormalizeSchemaObject<{
+    readonly database: import("pema").DefaultType<import("pema").StringType, ":memory:">;
+}>, {
+    database: string;
 }>;
-export default class SQLite implements DB {
+export default class SQLite implements SQLDB<Client> {
     #private;
     static config: typeof schema.input;
     constructor(config?: typeof schema.input, options?: {
         debug?: boolean;
     });
+    get client(): Client;
     get explain(): Dict<{
         query: string;
         plans: string[];
     }>;
-    get schema(): {
-        create: (as: As, store: StoreSchema) => void;
-        delete: (table: string) => void;
-    };
+    get schema(): Schema;
     create<O extends Dict>(as: As, record: Dict): Promise<O>;
     read(as: As, args: {
         count: true;
@@ -39,6 +40,13 @@ export default class SQLite implements DB {
         where: DataDict;
     }): Promise<number>;
     close(): void;
+    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=SQLite.d.ts.map

package/lib/private/SQLite.js

@@ -1,6 +1,6 @@
 import typemap from "#typemap";
-import common from "@primate/core/db";
-import E from "@primate/core/db/error";
+import base from "@primate/core/db";
+import E from "@primate/core/db/errors";
 import sql from "@primate/core/db/sql";
 import assert from "@rcompat/assert";
 import is from "@rcompat/is";
@@ -65,8 +65,8 @@ function cmp_expr(field, key, op, datatype) {
     const rhs = `${BIND_BY}${key}`;
     const sql_op = sql.OPS[op];
     assert.defined(sql_op, E.operator_unknown(field, op));
-    if (common.BIGINT_STRING_TYPES.includes(datatype)) {
-        const cmp = common.UNSIGNED_BIGINT_TYPES.includes(datatype)
+    if (base.BIGINT_STRING_TYPES.includes(datatype)) {
+        const cmp = base.UNSIGNED_BIGINT_TYPES.includes(datatype)
             ? u_cmp(field, `CAST(${field} AS TEXT)`, `CAST(${rhs} AS TEXT)`, sql_op)
             : i_cmp(field, rhs, sql_op);
         return `(${cmp})`;
@@ -91,16 +91,35 @@ function unbind_one(key, value) {
 async function bind(types, fields) {
     const out = {};
     for (const [key, value] of Object.entries(fields)) {
-        if (is.dict(value))
-            throw E.operator_scalar(key);
         const raw = key.startsWith("s_") ? key.slice(2) : key;
-        out[`${BIND_BY}${key}`] = await bind_one(types[raw.split("__")[0]], value);
+        const type = types[raw.split("__")[0]];
+        if (is.dict(value) && type !== "json")
+            throw E.operator_scalar(key);
+        out[`${BIND_BY}${key}`] = await bind_one(type, value);
     }
     return out;
 }
 function unbind(types, row) {
     return sql.unbind(types, row, unbind_one);
 }
+function columns_to_types(type) {
+    const t = type.toUpperCase();
+    if (t === "TEXT")
+        return [
+            "string", "url", "time", "datetime", "json",
+            "u64", "u128", "i64", "i128",
+            ...base.UUID_TYPES,
+        ];
+    if (t === "INTEGER")
+        return [
+            "boolean", "i8", "u8", "i16", "u16", "i32", "u32",
+        ];
+    if (t === "REAL")
+        return ["f32", "f64"];
+    if (t === "BLOB")
+        return ["blob"];
+    return [];
+}
 export default class SQLite {
     #factory;
     #client;
@@ -115,6 +134,9 @@ export default class SQLite {
     get #db() {
         return this.#client ??= this.#factory();
     }
+    get client() {
+        return this.#db;
+    }
     #sql(query) {
         return this.#db.prepare(query);
     }
@@ -137,25 +159,55 @@ export default class SQLite {
     }
     get schema() {
         return {
-            create: (as, store) => {
+            create: (table, pk, types) => {
                 const columns = [];
-                for (const [key, value] of Object.entries(store)) {
-                    const column_type = get_column(value.datatype);
+                for (const [key, value] of Object.entries(types)) {
+                    const column_type = get_column(value);
                     const column = `${sql.quote(key)} ${column_type}`;
                     const is_int = column_type === "INTEGER";
-                    if (key === as.pk) {
-                        const generate = as.generate_pk && is_int ? " AUTOINCREMENT" : "";
+                    if (key === pk.name) {
+                        const generate = pk.generate && is_int ? " AUTOINCREMENT" : "";
                         columns.push(`${column} PRIMARY KEY${generate}`);
                     }
                     else {
                         columns.push(column);
                     }
                 }
-                this.#sql(Q `CREATE TABLE IF NOT EXISTS ${as.table} (${columns})`).run();
+                this.#sql(Q `CREATE TABLE IF NOT EXISTS ${table} (${columns})`).run();
             },
             delete: (table) => {
                 this.#sql(Q `DROP TABLE IF EXISTS ${table}`).run();
             },
+            introspect: (table) => {
+                const rows = this.#sql(`PRAGMA table_info(${sql.quote(table)})`)
+                    .all();
+                if (rows.length === 0)
+                    return null;
+                const result = {};
+                for (const row of rows) {
+                    const candidates = columns_to_types(row.type);
+                    if (candidates.length > 0)
+                        result[row.name] = candidates;
+                }
+                return result;
+            },
+            alter: (table, diff) => {
+                const existing = this.schema.introspect(table);
+                if (existing === null)
+                    throw E.table_not_found(table);
+                for (const [from, to] of diff.rename) {
+                    this.#sql(Q `ALTER TABLE ${table}
+            RENAME COLUMN ${[sql.quote(from)]} TO ${[sql.quote(to)]}`).run();
+                }
+                for (const field of diff.drop) {
+                    this.#sql(Q `ALTER TABLE ${table}
+            DROP COLUMN ${[sql.quote(field)]}`).run();
+                }
+                for (const [field, type] of Object.entries(diff.add)) {
+                    this.#sql(Q `ALTER TABLE ${table}
+            ADD COLUMN ${[`${sql.quote(field)} ${get_column(type)}`]}`).run();
+                }
+            },
         };
     }
     #where(types, where, alias) {
@@ -167,7 +219,7 @@ export default class SQLite {
             const value = where[field];
             const datatype = types[field];
             const q = sql.quote(field);
-            const quoted = alias ? `${alias}.${q}` : q;
+            const quoted = is.defined(alias) ? `${alias}.${q}` : q;
             if (value === null) {
                 parts.push(`${quoted} IS NULL`);
                 continue;
@@ -196,6 +248,12 @@ export default class SQLite {
                         case "$before":
                             parts.push(cmp_expr(quoted, bound_key, op, datatype));
                             break;
+                        case "$in": {
+                            const arr = value.$in;
+                            const placeholders = arr.map((_, i) => `${BIND_BY}${sql.bindKey(field, `in${i}`)}`);
+                            parts.push(`${quoted} IN (${placeholders.join(", ")})`);
+                            break;
+                        }
                         default:
                             throw E.operator_unknown(field, op);
                     }
@@ -229,6 +287,14 @@ export default class SQLite {
                         case "$ne":
                             filtered[bound_key] = op_value;
                             break;
+                        case "$in": {
+                            const arr = op_value;
+                            for (let i = 0; i < arr.length; i++) {
+                                const bound_key = sql.bindKey(field, `in${i}`);
+                                filtered[bound_key] = arr[i];
+                            }
+                            break;
+                        }
                         default:
                             throw E.operator_unknown(field, op);
                     }
@@ -255,9 +321,9 @@ export default class SQLite {
     #generate_pk(as) {
         const pk = as.pk;
         const type = as.types[pk];
-        if (type === "string")
-            return crypto.randomUUID();
-        if (common.BIGINT_STRING_TYPES.includes(type)) {
+        if (base.is_uuid_type(type))
+            return base.generate_uuid(type);
+        if (base.BIGINT_STRING_TYPES.includes(type)) {
             const query = Q `SELECT ${pk} AS v
         FROM ${as.table} ORDER BY LENGTH(${pk}) DESC, ${pk} DESC LIMIT 1`;
             const rows = this.#sql(query).all();
@@ -289,7 +355,7 @@ export default class SQLite {
             throw E.pk_required(pk);
         const type = as.types[pk];
         // integer types, use RETURNING
-        if (!common.BIGINT_STRING_TYPES.includes(type) && type !== "string") {
+        if (!base.BIGINT_STRING_TYPES.includes(type) && !base.is_uuid_type(type)) {
             const [keys, values] = this.#create(record);
             const query = keys.length > 0
                 ? Q `INSERT INTO ${table} (${keys}) VALUES (${values}) RETURNING ${pk}`
@@ -311,7 +377,7 @@ export default class SQLite {
         this.#explain = {};
         if (args.count === true)
             return this.#count(as, args.where);
-        if (common.withed(args)) {
+        if (base.withed(args)) {
             return sql.joinable(as, args.with)
                 ? this.#read_joined(as, args)
                 : this.#read_phased(as, args);
@@ -325,9 +391,10 @@ export default class SQLite {
         const query = `SELECT COUNT(*) AS n FROM ${sql.quote(table)} ${WHERE}`;
         this.#capture(table, query, binds);
         const rows = this.#sql(query).all(binds);
-        assert.true(rows.length === 1, `COUNT(*) must return 1 row (got ${rows.length})`);
+        const length = rows.length;
+        assert.true(length === 1, E.record_number_invalid(length, "count"));
         const n = rows[0].n;
-        assert.bigint(n, `COUNT returned non-bigint: ${typeof n}`);
+        assert.bigint(n, E.return_invalid(n, "bigint", "count"));
         if (n > BigInt(Number.MAX_SAFE_INTEGER))
             throw E.count_overflow(table, n);
         return Number(n);
@@ -338,9 +405,9 @@ export default class SQLite {
         return this.#query_all(as, query, binds);
     }
     async #read_phased(as, args) {
-        const fields = common.expand(as, args.fields, args.with);
+        const fields = base.expand(as, args.fields, args.with);
         const rows = await this.#read_base(as, { ...args, fields });
-        const out = rows.map(row => common.project(row, args.fields));
+        const out = rows.map(row => base.project(row, args.fields));
         for (const [table, relation] of Object.entries(args.with)) {
             await this.#attach_relation(as, { rows, out, table, relation });
         }
@@ -348,10 +415,11 @@ export default class SQLite {
     }
     async #attach_relation(as, args) {
         const relation = args.relation;
-        const by = relation.reverse ? relation.as.pk : relation.fk;
+        const reverse = assert.maybe.boolean(relation.reverse) ?? false;
+        const by = reverse ? relation.as.pk : relation.fk;
         if (by === null)
             throw E.relation_requires_pk("target");
-        const parent_by = relation.reverse ? relation.fk : as.pk;
+        const parent_by = reverse ? relation.fk : as.pk;
         if (parent_by === null)
             throw E.relation_requires_pk("parent");
         const join_values = [...new Set(args.rows.map(r => r[parent_by]).filter(v => v != null))];
@@ -376,8 +444,8 @@ export default class SQLite {
             }
             const rows = grouped.get(join_value) ?? [];
             args.out[i][args.table] = is_many
-                ? rows.map(r => common.project(r, relation.fields))
-                : rows[0] ? common.project(rows[0], relation.fields) : null;
+                ? rows.map(r => base.project(r, relation.fields))
+                : rows[0] ? base.project(rows[0], relation.fields) : null;
         }
     }
     async #load_related(args) {
@@ -400,7 +468,7 @@ export default class SQLite {
         const fields = args.fields !== undefined && args.fields.length > 0
             ? args.fields
             : all_columns;
-        const SELECT = sql.columns(args.as.types, common.fields(fields, args.by));
+        const SELECT = sql.columns(args.as.types, base.fields(fields, args.by));
         const base_order = `${sql.quote(args.by)} ASC`;
         const user_order = sql.orderBy(args.as.types, args.sort)
             .replace(/^ ORDER BY /, "");
@@ -442,11 +510,12 @@ export default class SQLite {
         return this.#query_all(args.as, query, binds);
     }
     #join(as, aliases, relation) {
+        const reverse = assert.maybe.boolean(relation.reverse) ?? false;
         const parent_alias = aliases[as.table];
         const alias = aliases[relation.as.table];
         const table = sql.quote(relation.as.table);
-        const by = relation.reverse ? relation.as.pk : relation.fk;
-        const parent_by = relation.reverse ? relation.fk : as.pk;
+        const by = reverse ? relation.as.pk : relation.fk;
+        const parent_by = reverse ? relation.fk : as.pk;
         if (by === null)
             throw E.relation_requires_pk("target");
         if (parent_by === null)
@@ -460,8 +529,9 @@ export default class SQLite {
         const WHERE = this.#where(as.types, args.where);
         const ORDER_BY = sql.orderBy(as.types, args.sort);
         const LIMIT = sql.limit(args.limit);
+        const OFFSET = args.offset !== undefined ? ` OFFSET ${args.offset}` : "";
         const table = sql.quote(as.table);
-        return `SELECT ${SELECT} FROM ${table} ${WHERE}${ORDER_BY}${LIMIT}`;
+        return `SELECT ${SELECT} FROM ${table} ${WHERE}${ORDER_BY}${LIMIT}${OFFSET}`;
     }
     async #read_joined(as, args) {
         if (as.pk === null)
@@ -469,13 +539,13 @@ export default class SQLite {
         const tables = [as.table, ...Object.values(args.with).map(r => r.as.table)];
         const aliases = sql.aliases(tables);
         const alias = aliases[as.table];
-        const fields = common.fields(args.fields, as.pk);
+        const fields = base.fields(args.fields, as.pk);
         // subquery for limited parents
         const SELECT = [
             sql.aliased(aliases, as, fields),
             ...Object.values(args.with).map(relation => {
                 return sql.aliased(aliases, relation.as, relation.as.pk !== null
-                    ? common.fields(relation.fields, relation.as.pk)
+                    ? base.fields(relation.fields, relation.as.pk)
                     : relation.fields);
             }),
         ].join(", ");
@@ -511,5 +581,33 @@ export default class SQLite {
     close() {
         this.#db.close();
     }
+    sql(options) {
+        if (is.defined(options.input)) {
+            const placeholders = new Set([...options.query.matchAll(/:(\w+)/g)].map(m => m[1]));
+            const input_keys = new Set(Object.keys(options.input.properties));
+            for (const key of input_keys) {
+                if (!placeholders.has(key))
+                    throw E.sql_placeholder_missing(key);
+            }
+            for (const key of placeholders) {
+                if (!input_keys.has(key))
+                    throw E.sql_input_missing(key);
+            }
+        }
+        return async (args) => {
+            const input = is.defined(options.input)
+                ? options.input.parse(args)
+                : undefined;
+            const query = options.query.replace(/:(\w+)/g, (_, name) => `$${name}`);
+            const binds = is.defined(input)
+                ? await bind(Object.fromEntries(Object.entries(options.input.properties)
+                    .map(([k, v]) => [k, v.datatype])), input)
+                : {};
+            const rows = this.#sql(query).all(binds);
+            return (is.defined(options.output)
+                ? options.output.parse(rows)
+                : undefined);
+        };
+    }
 }
 //# sourceMappingURL=SQLite.js.map

package/lib/private/typemap.js

@@ -63,6 +63,15 @@ const typemap = {
         },
     },
     i8: number("INTEGER"),
+    json: {
+        bind(value) {
+            return JSON.stringify(value);
+        },
+        column: "TEXT",
+        unbind(value) {
+            return JSON.parse(value);
+        },
+    },
     string: identity("TEXT"),
     time: identity("TEXT"),
     u128: {
@@ -95,6 +104,9 @@ const typemap = {
             return new URL(value);
         },
     },
+    uuid: identity("TEXT"),
+    uuid_v4: identity("TEXT"),
+    uuid_v7: identity("TEXT"),
 };
 export default typemap;
 //# sourceMappingURL=typemap.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primate/sqlite",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "SQLite databases for Primate",
   "homepage": "https://primate.run/docs/database/sqlite",
   "bugs": "https://github.com/primate-run/primate/issues",
@@ -17,27 +17,27 @@
     "!/**/*.spec.*"
   ],
   "dependencies": {
-    "@rcompat/assert": "^0.6.0",
-    "@rcompat/is": "^0.4.2",
-    "@rcompat/sqlite": "^0.8.0",
-    "@primate/core": "^0.5.0"
+    "@rcompat/assert": "^0.13.0",
+    "@rcompat/is": "^0.11.0",
+    "@rcompat/sqlite": "^0.16.0",
+    "@primate/core": "^0.7.0"
   },
   "devDependencies": {
-    "@rcompat/type": "^0.9.0",
-    "pema": "^0.5.0"
+    "@rcompat/type": "^0.17.0",
+    "pema": "^0.7.0"
   },
   "peerDependencies": {
-    "primate": "^0.36.0"
+    "primate": "^0.38.0"
   },
   "imports": {
     "#*": {
-      "apekit": "./src/private/*.ts",
+      "@primate/source": "./src/private/*.ts",
       "default": "./lib/private/*.js"
     }
   },
   "exports": {
     ".": {
-      "apekit": "./src/public/index.ts",
+      "@primate/source": "./src/public/index.ts",
       "default": "./lib/public/index.js"
     }
   },
@@ -45,8 +45,8 @@
     "build": "npm run clean && tsc",
     "clean": "rm -rf ./lib",
     "lint": "eslint .",
-    "test": "npm run build && npx proby",
-    "test:bun": "npm run build && bun x --bun proby",
-    "test:deno": "npm run build && deno run -A npm:proby"
+    "test": "npx proby",
+    "test:bun": "bunx --bun proby",
+    "test:deno": "deno run -A npm:proby"
   }
 }