@bibliotek/sqlite 0.0.1 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bibliotek/sqlite",
-  "version": "0.0.1",
+  "version": "0.0.4",
   "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

@@ -1,7 +1,7 @@
 import Sqlite3 from "sqlite3";
 import synch from "@bibliotek/synch";
 
-export class Sqlite {
+export class Database {
   constructor(db) {
     if (typeof db === "string") {
       db = new Sqlite3.Database(db);
@@ -11,11 +11,11 @@ export class Sqlite {
   }
 
   static memory() {
-    return new Sqlite(":memory:");
+    return new Database(":memory:");
   }
 
   static disk() {
-    return new Sqlite("");
+    return new Database("");
   }
 
   static get Statement() {
@@ -77,14 +77,19 @@ export class Sqlite {
 
   async run(sql) {
     return new Promise((resolve, reject) => {
-      this.db.run(sql, err => {
-        if (err) reject(err); else resolve();
+      this.db.run(sql, function(err) {
+        if (err) {
+          reject(err);
+        } else {
+          const {lastID, changes} = this || {};
+          resolve({lastID, changes});
+        }
       });
     });
   }
 }
 
-class Statement {
+export class Statement {
   constructor(stmt) {
     this.stmt = stmt;
   }
@@ -143,4 +148,7 @@ class Statement {
       });
     });
   }
+
+  get lastID() { return this.stmt.lastID; }
+  get changes() { return this.stmt.changes; }
 }

package/test/test-sqlite.js

@@ -1,13 +1,13 @@
 import expect from "expect.js";
 import sinon from "sinon";
 import Sqlite3 from "sqlite3";
-import {Sqlite} from "@bibliotek/sqlite";
+import {Database, Statement} from "@bibliotek/sqlite";
 
-describe("Sqlite", () => {
+describe("Database", () => {
   describe("constructor(db)", () => {
     it("should initialize db from file path", async () => {
-      const db = new Sqlite(":memory:");
-      expect(db).to.be.a(Sqlite);
+      const db = new Database(":memory:");
+      expect(db).to.be.a(Database);
       expect(db.db).to.be.a(Sqlite3.Database);
       expect(db.db.filename).to.be(":memory:");
       await db.close();
@@ -15,22 +15,22 @@ describe("Sqlite", () => {
 
     it("should use database if provided", async () => {
       const sqlite = {};
-      const db = new Sqlite(sqlite);
+      const db = new Database(sqlite);
       expect(db.db).to.be(sqlite);
     });
   });
 
-  describe("Sqlite.memory()", () => {
+  describe("Database.memory()", () => {
     it("should return in-memory DB", async () => {
-      const db = Sqlite.memory();
+      const db = Database.memory();
       expect(db.db.filename).to.be(":memory:");
       await db.close();
     });
   });
 
-  describe("Sqlite.disk()", () => {
+  describe("Database.disk()", () => {
     it("should return on-disk temp DB", async () => {
-      const db = Sqlite.disk();
+      const db = Database.disk();
       expect(db.db.filename).to.be("");
       await db.close();
     });
@@ -39,7 +39,7 @@ describe("Sqlite", () => {
   describe(".close()", () => {
     it("should close the DB", async () => {
       const db = {close: sinon.spy(fn => fn())};
-      const sqlite = new Sqlite(db);
+      const sqlite = new Database(db);
 
       await sqlite.close();
       expect(db.close.calledOnce).to.be(true);
@@ -49,20 +49,41 @@ describe("Sqlite", () => {
   describe(".run(sql)", () => {
     it("should run query on the DB", async () => {
       const db = {run: sinon.spy((_, fn) => fn())};
-      const sqlite = new Sqlite(db);
+      const sqlite = new Database(db);
       const sql = "select 1";
 
       await sqlite.run(sql);
       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);
+    });
   });
 
   describe(".each(sql)", () => {
     let sqlite;
 
     beforeEach(async () => {
-      sqlite = Sqlite.memory();
+      sqlite = Database.memory();
       await sqlite.run("create table t (id int, key text)");
       await sqlite.run("insert into t values (1, 'foo')");
       await sqlite.run("insert into t values (2, 'bar')");
@@ -89,7 +110,7 @@ describe("Sqlite", () => {
     let sqlite;
 
     beforeEach(async () => {
-      sqlite = Sqlite.memory();
+      sqlite = Database.memory();
       await sqlite.run("create table t (id int, key text)");
       await sqlite.run("insert into t values (1, 'foo')");
       await sqlite.run("insert into t values (2, 'bar')");
@@ -106,24 +127,25 @@ describe("Sqlite", () => {
 
   describe(".prepare(sql)", () => {
     it("should return a prepared statment", async () => {
-      const sqlite = Sqlite.memory();
+      const sqlite = Database.memory();
       await sqlite.run("create table t (i int, f text)");
 
       const stmt = sqlite.prepare("select f from t where i = ?");
 
-      expect(stmt).to.be.a(Sqlite.Statement);
+      expect(stmt).to.be.a(Statement);
     });
   });
 });
 
-describe("Sqlite.Statement", () => {
-  let sqlite, insert, select;
+describe("Statement", () => {
+  let sqlite, insert, select, update;
 
   beforeEach(async () => {
-    sqlite = Sqlite.memory();
-    await sqlite.run("create table t (id int, key text)");
+    sqlite = Database.memory();
+    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 +156,22 @@ describe("Sqlite.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)", () => {