@bibliotek/sqlite 0.0.2 → 0.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bibliotek/sqlite",
-  "version": "0.0.2",
+  "version": "0.0.5",
   "description": "Sqlite3 database using async/await",
   "type": "module",
   "exports": "./sqlite.js",
@@ -9,7 +9,7 @@
   },
   "dependencies": {
     "@bibliotek/synch": "^0.0.1",
-    "sqlite3": "^5.0.2"
+    "sqlite3": "^4.2.0"
   },
   "devDependencies": {
     "expect.js": "^0.3.1",

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,20 +65,25 @@ 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, err => {
-        if (err) reject(err); else resolve();
+      this.db.run(String(sql), function(err) {
+        if (err) {
+          reject(err);
+        } else {
+          const {lastID, changes} = this || {};
+          resolve({lastID, changes});
+        }
       });
     });
   }
@@ -143,4 +148,7 @@ export class Statement {
       });
     });
   }
+
+  get lastID() { return this.stmt.lastID; }
+  get changes() { return this.stmt.changes; }
 }

package/test/test-sqlite.js

@@ -56,6 +56,37 @@ describe("Database", () => {
       expect(db.run.calledOnce).to.be(true);
       expect(db.run.calledWith(sql)).to.be(true);
     });
+
+    it("should resolve with .lastID", async () => {
+      const db = Database.memory();
+      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')");
+
+      expect(result).to.be.an("object");
+      expect(result.lastID).to.be(2);
+    });
+
+    it("should resolve with .changes", async () => {
+      const db = Database.memory();
+      await db.run("create table t (id int, key text)");
+      await db.run("insert into t values (1, 'foo')");
+      await db.run("insert into t values (3, 'bar')");
+      const result = await db.run("update t set key = 'new'");
+
+      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)", () => {
@@ -117,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)", () => {
@@ -134,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)", () => {