@primate/sqlite 0.8.0 → 0.9.0

package/lib/private/SQLite.d.ts

@@ -1,16 +1,19 @@
-import type { As, DataDict, DB, Schema, 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";
-declare const schema: import("pema").ObjectType<import("pema").NormalizeSchemaObject<{
+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[];
@@ -37,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

@@ -134,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);
     }
@@ -216,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;
@@ -245,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);
                     }
@@ -278,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);
                     }
@@ -512,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)
@@ -563,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primate/sqlite",
-  "version": "0.8.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,17 +17,17 @@
     "!/**/*.spec.*"
   ],
   "dependencies": {
-    "@rcompat/assert": "^0.8.1",
-    "@rcompat/is": "^0.6.1",
-    "@rcompat/sqlite": "^0.11.1",
-    "@primate/core": "^0.6.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.11.1",
-    "pema": "^0.6.0"
+    "@rcompat/type": "^0.17.0",
+    "pema": "^0.7.0"
   },
   "peerDependencies": {
-    "primate": "^0.37.0"
+    "primate": "^0.38.0"
   },
   "imports": {
     "#*": {