@possumtech/sqlrite 0.2.2 → 0.2.4

package/README.md

@@ -183,3 +183,5 @@ const sql = new SqlRite({ path: "path/to/your/database.sqlite3" });
 
 Additional arguments will be passed to the options object of the native sqlite
 module.
+
+To close the database connection, call the `.close()` method:

package/SqlRite.d.ts

@@ -0,0 +1,22 @@
+import { Database, DatabaseSync, Statement } from 'node:sqlite';
+
+interface SqlRiteOptions {
+	path?: string;
+	dir?: string;
+}
+
+interface SqlRiteAsyncPreparedStatements {
+	all: (params?: Record<string, any>) => Promise<any[]>;
+	get: (params?: Record<string, any>) => Promise<any>;
+	run: (params?: Record<string, any>) => Promise<void>;
+}
+
+interface SqlRiteAsyncMethods {
+	[key: string]: (() => Promise<void>) | SqlRiteAsyncPreparedStatements;
+}
+
+export default class SqlRite {
+	constructor(options?: SqlRiteOptions);
+	async: SqlRiteAsyncMethods;
+	[key: string]: (() => void) | Statement | SqlRiteAsyncMethods | any;
+}

package/SqlRite.js

@@ -12,6 +12,8 @@ export default class SqlRite {
 
 		const db = new DatabaseSync(merged.path, merged);
 
+		this.close = () => db.close();
+
 		// allow multiple directories
 		if (!Array.isArray(merged.dir)) merged.dir = [merged.dir];
 		const files = merged.dir.flatMap((d) => this.getFiles(d));
@@ -45,18 +47,26 @@ export default class SqlRite {
 		});
 
 		prepChunks.forEach((prep) => {
-			this[prep.name] = db.prepare(prep.sql);
+			const stmt = db.prepare(prep.sql);
+			this[prep.name] = {};
+
+			this[prep.name].all = (params = {}) => stmt.all(this.doJsonify(params));
+			this[prep.name].get = (params = {}) => stmt.get(this.doJsonify(params));
+			this[prep.name].run = (params = {}) => stmt.run(this.doJsonify(params));
 
 			this.async[prep.name] = {};
 
-			this.async[prep.name].all = async (params = {}) =>
-				this[prep.name].all(params);
+			this.async[prep.name].all = async (params = {}) => {
+				return stmt.all(this.doJsonify(params));
+			};
 
-			this.async[prep.name].get = async (params = {}) =>
-				this[prep.name].get(params);
+			this.async[prep.name].get = async (params = {}) => {
+				return stmt.get(this.doJsonify(params));
+			};
 
-			this.async[prep.name].run = async (params = {}) =>
-				this[prep.name].run(params);
+			this.async[prep.name].run = async (params = {}) => {
+				return stmt.run(this.doJsonify(params));
+			};
 		});
 	}
 
@@ -72,4 +82,14 @@ export default class SqlRite {
 
 		return files.sort();
 	}
+
+	doJsonify(params) {
+		for (const param in params) {
+			if (Array.isArray(params[param])) {
+				params[param] = JSON.stringify(params[param]);
+			}
+		}
+
+		return params;
+	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@possumtech/sqlrite",
-	"version": "0.2.2",
+	"version": "0.2.4",
 	"description": "SQL Done Right",
 	"keywords": [
 		"node",
@@ -22,7 +22,8 @@
 	"type": "module",
 	"main": "SqlRite.js",
 	"scripts": {
-		"syntax": "npx @biomejs/biome check",
-		"test": "node --test"
+		"lint": "npx @biomejs/biome check *.js",
+		"test": "node --experimental-test-coverage --inspect --test",
+		"debug": "node --experimental-test-coverage --inspect-brk --test"
 	}
 }

package/sql/test.sql

@@ -26,3 +26,10 @@ SELECT name, position FROM employees;
 
 -- PREP: getHighestPaidEmployee
 SELECT name FROM employees ORDER BY salary DESC LIMIT 1;
+
+-- PREP: getMultiEmployees
+SELECT name, position, salary FROM
+employees WHERE name IN (SELECT value FROM json_each($names));
+
+-- PREP: deleteEmployees
+DELETE FROM employees WHERE name IN (SELECT value FROM json_each($names));

package/test/test.js

@@ -1,19 +1,58 @@
 import assert from "node:assert";
+import test from "node:test";
 import SqlRite from "../SqlRite.js";
 
-const sql = new SqlRite();
+test("SqlRite.js", (t) => {
+	t.test("constructor()", () => {
+		const sql = new SqlRite();
+		assert(sql instanceof SqlRite, "sql is an instance of SqlRite");
+	});
 
-sql.addEmployee.run({ name: "John", position: "CEO", salary: 99999 });
-sql.addEmployee.run({ name: "Jane", position: "COO", salary: 49998 });
-sql.addEmployee.run({ name: "Jack", position: "CFO", salary: 49997 });
-sql.addEmployee.run({ name: "Jill", position: "CIO", salary: 49996 });
+		const sql = new SqlRite();
 
-const employee = sql.getHighestPaidEmployee.get();
+	t.test("run()", () => {
+		sql.addEmployee.run({ name: "John", position: "CEO", salary: 99999 });
+		sql.addEmployee.run({ name: "Jane", position: "COO", salary: 49998 });
+		sql.addEmployee.run({ name: "Jack", position: "CFO", salary: 49997 });
+		sql.addEmployee.run({ name: "Jill", position: "CIO", salary: 49996 });
+	});
 
-assert(employee?.name === "John", "The highest paid employee should be John");
+	t.test("get()", () => {
+		const employee = sql.getHighestPaidEmployee.get();
+		assert(employee?.name === "John", "Highest paid employee should be John");
+	});
 
-sql.async.getPositions.all().then((positions) => console.log(positions));
+	t.test("all()", () => {
+		const positionsSync = sql.getPositions.all();
+		assert(positionsSync.length === 4, "There should be four positions");
+	});
 
-console.log(`The highest paid employee is ${employee.name}.`);
+	t.test("async", async () => {
+		const positionsAsync = await sql.async.getPositions.all();
+		assert(positionsAsync.length === 4, "There should be four positions");
+	});
 
-sql.deleteTable();
+	t.test("json_each operations", () => {
+		sql.deleteEmployees.run({ names: ["Jane", "Jack"] });
+		const remaining = sql.getPositions.all();
+		assert(remaining.length === 2, "There should be two employees remaining");
+	});
+
+	t.test("exec operations", () => {
+		sql.deleteTable();
+	});
+
+	t.test("getFiles()", () => {
+		const files = sql.getFiles("sql");
+
+		assert(files.length > 0, "At least one SQL file in the sql directory?");
+	});
+
+	t.test("close()", () => {
+		const sql = new SqlRite();
+
+		sql.close();
+
+		assert(true, "Database closed without error");
+	});
+});