@primate/sqlite 0.1.0

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) Terrablue <terrablue@proton.me> and contributors.
+
+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/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@primate/sqlite",
+  "version": "0.1.0",
+  "description": "Primate SQLite database",
+  "homepage": "https://primatejs.com/modules/sqlite",
+  "bugs": "https://github.com/primatejs/primate/issues",
+  "license": "MIT",
+  "files": [
+    "src/**/*.js",
+    "!src/**/*.spec.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/primatejs/primate",
+    "directory": "packages/sqlite"
+  },
+  "dependencies": {
+    "@rcompat/invariant": "^0.5.0",
+    "@rcompat/object": "^0.5.0",
+    "@primate/core": "^0.1.0",
+    "@primate/store": "^0.25.0"
+  },
+  "devDependencies": {
+    "better-sqlite3": "^11.1.2"
+  },
+  "peerDependencies": {
+    "better-sqlite3": "11"
+  },
+  "type": "module",
+  "imports": {
+    "#*": {
+      "@primate/lt": "./src/private/*.js",
+      "default": "./src/private/*.js"
+    }
+  },
+  "exports": {
+    ".": "./src/default.js"
+  }
+}

package/src/default.js

@@ -0,0 +1,8 @@
+import defaults from "#defaults";
+import serve from "#serve";
+
+export default ({
+  database = defaults.database,
+} = {}) => ({
+  serve: serve({ database }),
+});

package/src/private/Facade.js

@@ -0,0 +1,115 @@
+import typemap from "#typemap";
+import make_sort from "@primate/store/sql/make-sort";
+import filter from "@rcompat/object/filter";
+import keymap from "@rcompat/object/keymap";
+import valmap from "@rcompat/object/valmap";
+import platform from "@rcompat/platform";
+
+const is_bun = platform === "bun";
+
+const filter_null = results =>
+  results.map(result => filter(result, ([, value]) => value !== null));
+
+const predicate = criteria => {
+  const keys = Object.keys(criteria);
+  if (keys.length === 0) {
+    return { where: "", bindings: {} };
+  }
+
+  const where = `where ${keys.map(key => `"${key}"=$${key}`).join(" and ")}`;
+
+  return { where, bindings: criteria };
+};
+
+const change = delta => {
+  const keys = Object.keys(delta);
+  const set = keys.map(field => `"${field}"=$s_${field}`).join(",");
+  return {
+    set: `set ${set}`,
+    bindings: keymap(delta, key => `s_${key}`),
+  };
+};
+
+export default class Connection {
+  schema = {
+    create: async (name, description) => {
+      const body =
+        Object.entries(valmap(description, value => typemap(value.base)))
+          .map(([column, dataType]) => `"${column}" ${dataType}`).join(",");
+      const query = `create table if not exists ${name} (${body})`;
+      this.connection.prepare(query).run();
+    },
+    delete: async name => {
+      const query = `drop table if exists ${name}`;
+      return this.connection.prepare(query).run();
+    },
+  };
+
+  constructor(connection) {
+    this.connection = connection;
+  }
+
+  find(collection, criteria = {}, projection = [], options = {}) {
+    const rest = make_sort(options);
+    const { where, bindings } = predicate(criteria);
+    const select = projection.length === 0 ? "*" : projection.join(", ");
+    const query = `select ${select} from ${collection} ${where} ${rest};`;
+    const statement = this.connection.prepare(query);
+    if (!is_bun) {
+      statement.safeIntegers(true);
+    }
+    return filter_null(statement.all(bindings));
+  }
+
+  count(collection, criteria = {}) {
+    const { where, bindings } = predicate(criteria);
+    const query = `select count(*) from ${collection} ${where}`;
+    const prepared = this.connection.prepare(query);
+    if (is_bun) {
+      const [count] = Object.values(prepared.get(bindings));
+      return count;
+    }
+
+    return prepared.pluck(true).get(bindings);
+  }
+
+  get(collection, primary, value) {
+    const query = `select * from ${collection} where ${primary}=$primary`;
+    const statement = this.connection.prepare(query);
+    if (!is_bun) {
+      statement.safeIntegers(true);
+    }
+    const result = statement.get({ primary: value });
+    return result === undefined
+      ? result
+      : filter(result, ([, $value]) => $value !== null);
+  }
+
+  insert(collection, primary, document) {
+    const keys = Object.keys(document);
+    const columns = keys.map(key => `"${key}"`);
+    const values = keys.map(key => `$${key}`).join(",");
+    const $predicate = columns.length > 0
+      ? `(${columns.join(",")}) values (${values})`
+      : "default values";
+    const query = `insert into ${collection} ${$predicate} returning id`;
+    const prepared = this.connection.prepare(query);
+    const $document = is_bun ? keymap(document, key => `$${key}`) : document;
+    const { id } = prepared.get($document);
+    return { ...document, id };
+  }
+
+  update(collection, criteria = {}, delta = {}) {
+    const { where, bindings } = predicate(criteria);
+    const { set, bindings: bindings2 } = change(delta);
+    const query = `update ${collection} ${set} ${where}`;
+    return this.connection.prepare(query).run({ ...bindings, ...bindings2 })
+      .changes;
+  }
+
+  delete(collection, criteria = {}) {
+    const { where, bindings } = predicate(criteria);
+    const query = `delete from ${collection} ${where}`;
+    return this.connection.prepare(query).run({ ...bindings }).changes;
+  }
+}

package/src/private/connect.js

@@ -0,0 +1,9 @@
+import Pool from "@primate/store/core/pool";
+import Database from "@rcompat/sql/sqlite";
+
+export default ({ database }) => new Pool({
+  manager: {
+    new: () => new Database(database, { create: true }),
+    kill: connection => connection.close(),
+  },
+});

package/src/private/defaults.js

@@ -0,0 +1,3 @@
+export default {
+  database: ":memory:",
+};

package/src/private/serve.js

@@ -0,0 +1,88 @@
+import Facade from "#Facade";
+import connect from "#connect";
+import ident from "@primate/store/core/ident";
+import wrap from "@primate/store/core/wrap";
+import numeric from "@rcompat/invariant/numeric";
+
+export default options => async () => {
+  const client = await connect(options);
+
+  const types = {
+    primary: {
+      validate(value) {
+        if (typeof value === "number" || numeric(value)) {
+          return Number(value);
+        }
+        throw new Error(`\`${value}\` is not a valid primary key value`);
+      },
+      ...ident,
+      out(value) {
+        // bigint
+        return Number(value);
+      },
+    },
+    object: {
+      in(value) {
+        return JSON.stringify(value);
+      },
+      out(value) {
+        return JSON.parse(value);
+      },
+    },
+    number: {
+      in(value) {
+        return value;
+      },
+      out(value) {
+        return Number(value);
+      },
+    },
+    // in: driver accepts both number and bigint
+    // out: find/get currently set statement.safeIntegers(true);
+    bigint: ident,
+    boolean: {
+      in(value) {
+        return value === true ? 1 : 0;
+      },
+      out(value) {
+        // out: find/get currently set statement.safeIntegers(true);
+        return Number(value) === 1;
+      },
+    },
+    date: {
+      in(value) {
+        return value.toJSON();
+      },
+      out(value) {
+        return new Date(value);
+      },
+    },
+    string: ident,
+  };
+
+  return {
+    name: "@primate/sqlite",
+    types,
+    async transact(stores) {
+      return async (others, next) => {
+        const connection = await client.acquire();
+        const facade = new Facade(connection);
+        try {
+          connection.prepare("begin transaction").run();
+          const response = await next([...others, ...stores.map(([_, store]) =>
+            [_, wrap(store, facade, types)]),
+          ]);
+          connection.prepare("commit transaction").run();
+          return response;
+        } catch (error) {
+          connection.prepare("rollback transaction").run();
+          // bubble up
+          throw error;
+        } finally {
+          // noop, no end transaction
+          client.release(connection);
+        }
+      };
+    },
+  };
+};

package/src/private/typemap.js

@@ -0,0 +1,21 @@
+const types = {
+  /* array */
+  blob: "blob",
+  boolean: "integer",
+  datetime: "text",
+  embedded: "text",
+  f64: "real",
+  i8: "integer",
+  i16: "integer",
+  i32: "integer",
+  i64: "integer",
+  json: "text",
+  primary: "integer primary key",
+  string: "text",
+  time: "text",
+  u8: "integer",
+  u16: "integer",
+  u32: "integer",
+};
+
+export default value => types[value];