@bibliotek/sqlite 0.0.1

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@bibliotek/sqlite",
+  "version": "0.0.1",
+  "description": "Sqlite3 database using async/await",
+  "type": "module",
+  "exports": "./sqlite.js",
+  "scripts": {
+    "test": "mocha"
+  },
+  "dependencies": {
+    "@bibliotek/synch": "^0.0.1",
+    "sqlite3": "^5.0.2"
+  },
+  "devDependencies": {
+    "expect.js": "^0.3.1",
+    "mocha": "^9.2.0",
+    "sinon": "^13.0.1"
+  }
+}

package/sqlite.js

@@ -0,0 +1,146 @@
+import Sqlite3 from "sqlite3";
+import synch from "@bibliotek/synch";
+
+export class Sqlite {
+  constructor(db) {
+    if (typeof db === "string") {
+      db = new Sqlite3.Database(db);
+    }
+
+    this.db = db;
+  }
+
+  static memory() {
+    return new Sqlite(":memory:");
+  }
+
+  static disk() {
+    return new Sqlite("");
+  }
+
+  static get Statement() {
+    return Statement;
+  }
+
+  async close() {
+    return new Promise((resolve, reject) => {
+      this.db.close(err => {
+        if (err) reject(err); else resolve();
+      });
+    });
+  }
+
+  async *each(sql) {
+    const buffer = [];
+    let done = false;
+    let sync = synch();
+
+    this.db.each(sql, record, complete);
+
+    while (!done) {
+      await sync;
+      if (done instanceof Error) throw done;
+      while (buffer.length) yield buffer.shift();
+      sync.reset();
+    };
+
+    function record(err, row) {
+      if (err) done = err; else buffer.push(row);
+      sync();
+    }
+
+    function complete() {
+      done = true;
+      sync();
+    }
+  }
+
+  async exec(sql) {
+    return new Promise((resolve, reject) => {
+      this.db.exec(sql, err => {
+        if (err) reject(err); else resolve();
+      });
+    });
+  }
+
+  async get(sql, ...params) {
+    return new Promise((resolve, reject) => {
+      this.db.get(sql, ...params, (err, row) => {
+        if (err) reject(err); else resolve(row);
+      });
+    });
+  }
+
+  prepare(sql) {
+    return new Statement(this.db.prepare(sql));
+  }
+
+  async run(sql) {
+    return new Promise((resolve, reject) => {
+      this.db.run(sql, err => {
+        if (err) reject(err); else resolve();
+      });
+    });
+  }
+}
+
+class Statement {
+  constructor(stmt) {
+    this.stmt = stmt;
+  }
+
+  async *each(...params) {
+    const buffer = [];
+    let done = false;
+    let sync = synch();
+
+    this.stmt.each(...params, record, complete);
+
+    while (!done) {
+      await sync;
+      if (done instanceof Error) throw done;
+      while (buffer.length) yield buffer.shift();
+      sync.reset();
+    }
+
+    function record(err, row) {
+      if (err) done = err; else buffer.push(row);
+      sync();
+    }
+
+    function complete() {
+      done = true;
+      sync();
+    }
+  }
+
+  async finalize() {
+    return new Promise((resolve, reject) => {
+      this.stmt.finalize(() => resolve());
+    });
+  }
+
+  async get(...params) {
+    return new Promise((resolve, reject) => {
+      this.stmt.get(...params, (err, row) => {
+        if (err) reject(err); else resolve(row);
+      });
+    });
+  }
+
+  async reset() {
+    return new Promise((resolve, reject) => {
+      this.stmt.reset(err => {
+        if (err) reject(err); else resolve();
+      });
+    });
+  }
+
+  async run(...params) {
+    return new Promise((resolve, reject) => {
+      this.stmt.run(...params, err => {
+        if (err) reject(err); else resolve();
+      });
+    });
+  }
+}

package/test/test-sqlite.js

@@ -0,0 +1,191 @@
+import expect from "expect.js";
+import sinon from "sinon";
+import Sqlite3 from "sqlite3";
+import {Sqlite} from "@bibliotek/sqlite";
+
+describe("Sqlite", () => {
+  describe("constructor(db)", () => {
+    it("should initialize db from file path", async () => {
+      const db = new Sqlite(":memory:");
+      expect(db).to.be.a(Sqlite);
+      expect(db.db).to.be.a(Sqlite3.Database);
+      expect(db.db.filename).to.be(":memory:");
+      await db.close();
+    });
+
+    it("should use database if provided", async () => {
+      const sqlite = {};
+      const db = new Sqlite(sqlite);
+      expect(db.db).to.be(sqlite);
+    });
+  });
+
+  describe("Sqlite.memory()", () => {
+    it("should return in-memory DB", async () => {
+      const db = Sqlite.memory();
+      expect(db.db.filename).to.be(":memory:");
+      await db.close();
+    });
+  });
+
+  describe("Sqlite.disk()", () => {
+    it("should return on-disk temp DB", async () => {
+      const db = Sqlite.disk();
+      expect(db.db.filename).to.be("");
+      await db.close();
+    });
+  });
+
+  describe(".close()", () => {
+    it("should close the DB", async () => {
+      const db = {close: sinon.spy(fn => fn())};
+      const sqlite = new Sqlite(db);
+
+      await sqlite.close();
+      expect(db.close.calledOnce).to.be(true);
+    });
+  });
+
+  describe(".run(sql)", () => {
+    it("should run query on the DB", async () => {
+      const db = {run: sinon.spy((_, fn) => fn())};
+      const sqlite = new Sqlite(db);
+      const sql = "select 1";
+
+      await sqlite.run(sql);
+      expect(db.run.calledOnce).to.be(true);
+      expect(db.run.calledWith(sql)).to.be(true);
+    });
+  });
+
+  describe(".each(sql)", () => {
+    let sqlite;
+
+    beforeEach(async () => {
+      sqlite = Sqlite.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')");
+    });
+
+    it("should iterate over results", async () => {
+      const rows = [];
+
+      for await (const row of sqlite.each("select * from t order by id")) {
+        rows.push(row);
+      }
+
+      expect(rows.length).to.be(2);
+      expect(rows[0]).to.be.an("object");
+      expect(rows[0].id).to.be(1);
+      expect(rows[0].key).to.be("foo");
+      expect(rows[1]).to.be.an("object");
+      expect(rows[1].id).to.be(2);
+      expect(rows[1].key).to.be("bar");
+    });
+  });
+
+  describe(".get(sql)", () => {
+    let sqlite;
+
+    beforeEach(async () => {
+      sqlite = Sqlite.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')");
+    });
+
+    it("should return first row", async () => {
+      const row = await sqlite.get("select * from t order by id");
+
+      expect(row).to.be.an("object");
+      expect(row.id).to.be(1);
+      expect(row.key).to.be("foo");
+    });
+  });
+
+  describe(".prepare(sql)", () => {
+    it("should return a prepared statment", async () => {
+      const sqlite = Sqlite.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);
+    });
+  });
+});
+
+describe("Sqlite.Statement", () => {
+  let sqlite, insert, select;
+
+  beforeEach(async () => {
+    sqlite = Sqlite.memory();
+    await sqlite.run("create table t (id int, key text)");
+    insert = sqlite.prepare("insert into t values (?, ?)");
+    select = sqlite.prepare("select key from t where id between ? and ? order by id");
+  });
+
+  describe(".run(...params)", () => {
+    it("should execute statement using params", async () => {
+      await insert.run(1, "foo");
+      await insert.run(2, "bar");
+
+      const row = await sqlite.get("select count(*) c from t");
+      expect(row.c).to.be(2);
+    });
+  });
+
+  describe(".each(...params)", () => {
+    let sqlite;
+
+    beforeEach(async () => {
+      await insert.run(1, "foo");
+      await insert.run(2, "bar");
+    });
+
+    it("should execute statement and iterate over results", async () => {
+      const rows = [];
+
+      for await (const row of select.each(0, 5)) {
+        rows.push(row);
+      }
+
+      expect(rows.length).to.be(2);
+      expect(rows[0]).to.be.an("object");
+      expect(rows[0].key).to.be("foo");
+      expect(rows[1]).to.be.an("object");
+      expect(rows[1].key).to.be("bar");
+    });
+  });
+
+  describe(".finalize()", () => {
+    it("should finalize the statement", async () => {
+      insert.stmt = {finalize: sinon.spy(fn => fn())};
+      await insert.finalize();
+      expect(insert.stmt.finalize.calledOnce).to.be(true);
+    });
+  });
+
+  describe(".get(...params)", () => {
+    beforeEach(async () => {
+      await insert.run(1, "foo");
+      await insert.run(2, "bar");
+    });
+
+    it("should execute statement and return first row", async () => {
+      const row = await select.get(1, 5);
+
+      expect(row).to.be.an("object");
+      expect(row.key).to.be("foo");
+    });
+  });
+
+  describe(".reset()", () => {
+    it("should reset the statment", async () => {
+      insert.stmt = {reset: sinon.spy(fn => fn())};
+      await insert.reset();
+      expect(insert.stmt.reset.calledOnce).to.be(true);
+    });
+  });
+});