@bibliotek/sqlite 0.0.3 → 0.0.6

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright © 2022 Richard Remer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,40 @@
+The **@bibliotek/sqlite** library is a light async/await wrapper around the
+**sqlite3** library.
+
+@bibliotek/sqlite
+=================
+For more detailed information, check the unit tests in the **./test**
+directory.
+
+Examples
+--------
+```js
+import {Database, Statement} from "@bibliotek/sqlite";
+
+let result = null;
+let stmt = null;
+
+const db = Database.memory();       // in-memory DB
+        // new Database("./my.db"); // ...or load from file
+
+// use .run to execute DML statements
+await db.run(`create table thing (id integer primary key autoincrement, value text)`);
+result = await db.run(`insert into thing (value) values ('foo')`);
+result = await db.run(`insert into thing (value) values ('bar')`);
+console.log("insert id", result.lastID);
+console.log("inserted", result.changes, "rows");
+
+// use .each to iterate over results
+for await (const row of db.each(`select * from thing`)) {
+    console.log(row);
+}
+
+// use .get to fetch a single row
+console.log(await db.get("select * from thing where id = 1"));
+
+// use .prepare for prepared statements
+stmt = db.prepare("select * from thing where id = ?");
+
+// pass params to statement methods to bind data to statement
+result = await stmt.get(1);     // bind 1 to id in prepared statement
+```

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@bibliotek/sqlite",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "description": "Sqlite3 database using async/await",
   "type": "module",
   "exports": "./sqlite.js",
   "scripts": {
     "test": "mocha"
   },
+  "license": "MIT",
   "dependencies": {
     "@bibliotek/synch": "^0.0.1",
     "sqlite3": "^4.2.0"

package/sqlite.js

@@ -35,7 +35,7 @@ export class Database {
     let done = false;
     let sync = synch();
 
-    this.db.each(sql, record, complete);
+    this.db.each(String(sql), record, complete);
 
     while (!done) {
       await sync;
@@ -57,7 +57,7 @@ export class Database {
 
   async exec(sql) {
     return new Promise((resolve, reject) => {
-      this.db.exec(sql, err => {
+      this.db.exec(String(sql), err => {
         if (err) reject(err); else resolve();
       });
     });
@@ -65,19 +65,19 @@ export class Database {
 
   async get(sql, ...params) {
     return new Promise((resolve, reject) => {
-      this.db.get(sql, ...params, (err, row) => {
+      this.db.get(String(sql), ...params, (err, row) => {
         if (err) reject(err); else resolve(row);
       });
     });
   }
 
   prepare(sql) {
-    return new Statement(this.db.prepare(sql));
+    return new Statement(this.db.prepare(String(sql)));
   }
 
   async run(sql) {
     return new Promise((resolve, reject) => {
-      this.db.run(sql, function(err) {
+      this.db.run(String(sql), function(err) {
         if (err) {
           reject(err);
         } else {
@@ -148,4 +148,7 @@ export class Statement {
       });
     });
   }
+
+  get lastID() { return this.stmt.lastID; }
+  get changes() { return this.stmt.changes; }
 }

package/test/test-sqlite.js

@@ -59,7 +59,7 @@ describe("Database", () => {
 
     it("should resolve with .lastID", async () => {
       const db = Database.memory();
-      await db.run("create table t (id int, key text)");
+      await db.run("create table t (id integer not null primary key autoincrement, key text)");
       await db.run("insert into t values (null, 'foo')");
       const result = await db.run("insert into t values (null, 'bar')");
 
@@ -77,6 +77,16 @@ describe("Database", () => {
       expect(result).to.be.an("object");
       expect(result.changes).to.be(2);
     });
+
+    it("should handle String instances", async () => {
+      const db = {run: sinon.spy((_, fn) => fn())};
+      const sqlite = new Database(db);
+      const sql = new String("select 1");
+
+      await sqlite.run(sql);
+      expect(db.run.calledOnce).to.be(true);
+      expect(db.run.calledWith("select 1")).to.be(true);
+    });
   });
 
   describe(".each(sql)", () => {
@@ -138,13 +148,14 @@ describe("Database", () => {
 });
 
 describe("Statement", () => {
-  let sqlite, insert, select;
+  let sqlite, insert, select, update;
 
   beforeEach(async () => {
     sqlite = Database.memory();
-    await sqlite.run("create table t (id int, key text)");
+    await sqlite.run("create table t (id integer not null primary key autoincrement, key text)");
     insert = sqlite.prepare("insert into t values (?, ?)");
     select = sqlite.prepare("select key from t where id between ? and ? order by id");
+    update = sqlite.prepare("update t set key = 'none' where id > ?");
   });
 
   describe(".run(...params)", () => {
@@ -155,6 +166,22 @@ describe("Statement", () => {
       const row = await sqlite.get("select count(*) c from t");
       expect(row.c).to.be(2);
     });
+
+    it("should set .lastID on statement", async () => {
+      await insert.run(null, "foo");
+      await insert.run(null, "bar");
+
+      expect(insert.lastID).to.be(2);
+    });
+
+    it("should set .changes on statement", async () => {
+      await insert.run(null, "foo");
+      await insert.run(null, "bar");
+      await insert.run(null, "baz");
+      await update.run(0);
+
+      expect(update.changes).to.be(3);
+    });
   });
 
   describe(".each(...params)", () => {