@primate/sqlite 0.1.3 → 0.3.0

package/lib/private/ColumnTypes.d.ts

@@ -0,0 +1,15 @@
+import type PrimitiveParam from "@rcompat/sqlite/PrimitiveParam";
+import type TypedArray from "@rcompat/type/TypedArray";
+type Validate<T extends {
+    [K in keyof T]: PrimitiveParam;
+}> = T;
+type ColumnTypes = Validate<{
+    BLOB: TypedArray;
+    INTEGER: bigint | number;
+    "INTEGER PRIMARY KEY": number;
+    NULL: null;
+    REAL: number;
+    TEXT: string;
+}>;
+export type { ColumnTypes as default };
+//# sourceMappingURL=ColumnTypes.d.ts.map

package/lib/private/ColumnTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ColumnTypes.js.map

package/lib/private/Database.d.ts

@@ -0,0 +1,42 @@
+import Database from "@primate/core/Database";
+import type As from "@primate/core/database/As";
+import type DataDict from "@primate/core/database/DataDict";
+import type TypeMap from "@primate/core/database/TypeMap";
+import type Dict from "@rcompat/type/Dict";
+import type StoreSchema from "pema/StoreSchema";
+declare const schema: import("pema").ObjectType<{
+    database: import("pema").DefaultType<import("pema/string").StringType, ":memory:">;
+}>;
+export default class SQLiteDatabase extends Database {
+    #private;
+    static config: typeof schema.input;
+    constructor(config?: typeof schema.input);
+    close(): void;
+    get typemap(): TypeMap<Dict>;
+    get schema(): {
+        create: (name: string, store: StoreSchema) => void;
+        delete: (name: string) => void;
+    };
+    create<O extends Dict>(as: As, args: {
+        record: DataDict;
+    }): Promise<O>;
+    read(as: As, args: {
+        count: true;
+        criteria: DataDict;
+    }): Promise<number>;
+    read(as: As, args: {
+        criteria: DataDict;
+        fields?: string[];
+        limit?: number;
+        sort?: Dict<"asc" | "desc">;
+    }): Promise<Dict[]>;
+    update(as: As, args: {
+        changes: DataDict;
+        criteria: DataDict;
+    }): Promise<number>;
+    delete(as: As, args: {
+        criteria: DataDict;
+    }): Promise<number>;
+}
+export {};
+//# sourceMappingURL=Database.d.ts.map

package/lib/private/Database.js

@@ -0,0 +1,104 @@
+import typemap from "#typemap";
+import Database from "@primate/core/Database";
+import assert from "@rcompat/assert";
+import Client from "@rcompat/sqlite";
+import pema from "pema";
+import string from "pema/string";
+const schema = pema({
+    database: string.default(":memory:"),
+});
+const options = { safeIntegers: true };
+export default class SQLiteDatabase extends Database {
+    #factory;
+    #client;
+    static config;
+    constructor(config) {
+        super("$");
+        const parsed = schema.parse(config);
+        this.#factory = () => new Client(parsed.database, options);
+    }
+    #get() {
+        if (this.#client === undefined) {
+            this.#client = this.#factory();
+        }
+        return this.#client;
+    }
+    close() {
+        this.#get().close();
+    }
+    get typemap() {
+        return typemap;
+    }
+    #new(name, store) {
+        const body = Object.entries(store)
+            .map(([key, value]) => `${this.ident(key)} ${this.column(value.datatype)}`)
+            .join(",");
+        const query = `CREATE TABLE IF NOT EXISTS ${this.ident(name)} (${body})`;
+        this.#get().prepare(query).run();
+    }
+    #drop(name) {
+        const query = `DROP TABLE IF EXISTS ${this.ident(name)}`;
+        this.#get().prepare(query).run();
+    }
+    get schema() {
+        return {
+            create: this.#new.bind(this),
+            delete: this.#drop.bind(this),
+        };
+    }
+    async create(as, args) {
+        const keys = Object.keys(args.record);
+        const columns = keys.map(k => this.ident(k));
+        const values = keys.map(key => `$${key}`).join(",");
+        const payload = columns.length > 0
+            ? `(${columns.join(",")}) VALUES (${values})`
+            : "DEFAULT VALUES";
+        const query = `INSERT INTO ${this.table(as)} ${payload} RETURNING id;`;
+        const binds = await this.bind(as.types, args.record);
+        const statement = this.#get().prepare(query);
+        const changes = statement.run(binds);
+        const id = BigInt(changes.lastInsertRowid);
+        return this.unbind(as.types, { ...args.record, id });
+    }
+    async read(as, args) {
+        const where = this.toWhere(as.types, args.criteria);
+        const binds = await this.bindCriteria(as.types, args.criteria);
+        if (args.count === true) {
+            const query = `SELECT COUNT(*) AS n FROM ${this.table(as)} ${where};`;
+            const [{ n }] = this.#get().prepare(query).all(binds);
+            return Number(n);
+        }
+        const select = this.toSelect(as.types, args.fields);
+        const sort = this.toSort(as.types, args.sort);
+        const limit = this.toLimit(args.limit);
+        const query = `SELECT
+      ${select} FROM ${this.table(as)} ${where}${sort}${limit};`;
+        const records = this.#get().prepare(query).all(binds);
+        return records.map(record => this.unbind(as.types, record));
+    }
+    async update(as, args) {
+        assert(Object.keys(args.criteria).length > 0, "update: no criteria");
+        const where = this.toWhere(as.types, args.criteria);
+        const criteria = await this.bindCriteria(as.types, args.criteria);
+        const { set, binds: set_binds } = await this.toSet(as.types, args.changes);
+        const binds = { ...criteria, ...set_binds };
+        const query = `
+      WITH to_update AS (
+        SELECT id FROM ${this.table(as)}
+        ${where}
+      )
+      UPDATE ${this.table(as)}
+      ${set}
+      WHERE id IN (SELECT id FROM to_update)
+    `;
+        return Number(this.#get().prepare(`${query};`).run(binds).changes);
+    }
+    async delete(as, args) {
+        assert(Object.keys(args.criteria).length > 0, "delete: no criteria");
+        const where = this.toWhere(as.types, args.criteria);
+        const binds = await this.bindCriteria(as.types, args.criteria);
+        const query = `DELETE FROM ${this.table(as)} ${where}`;
+        return Number(this.#get().prepare(query).run(binds).changes);
+    }
+}
+//# sourceMappingURL=Database.js.map

package/lib/private/typemap.d.ts

@@ -0,0 +1,5 @@
+import type ColumnTypes from "#ColumnTypes";
+import type TypeMap from "@primate/core/database/TypeMap";
+declare const typemap: TypeMap<ColumnTypes>;
+export default typemap;
+//# sourceMappingURL=typemap.d.ts.map

package/lib/private/typemap.js

@@ -0,0 +1,114 @@
+import numeric from "@rcompat/is/numeric";
+function identity(column) {
+    return {
+        bind: value => value,
+        column,
+        unbind: value => value,
+    };
+}
+function number(column) {
+    return {
+        bind: (value) => value,
+        column,
+        unbind: (value) => Number(value),
+    };
+}
+const typemap = {
+    blob: {
+        async bind(value) {
+            const arrayBuffer = await value.arrayBuffer();
+            return new Uint8Array(arrayBuffer);
+        },
+        column: "BLOB",
+        unbind(value) {
+            return new Blob([value], { type: "application/octet-stream" });
+        },
+    },
+    boolean: {
+        bind(value) {
+            return value === true ? 1 : 0;
+        },
+        column: "INTEGER",
+        unbind(value) {
+            return Number(value) === 1;
+        },
+    },
+    datetime: {
+        bind(value) {
+            return value.toJSON();
+        },
+        column: "TEXT",
+        unbind(value) {
+            return new Date(value);
+        },
+    },
+    f32: identity("REAL"),
+    f64: identity("REAL"),
+    i128: {
+        bind(value) {
+            return String(value);
+        },
+        column: "TEXT",
+        unbind(value) {
+            return BigInt(value);
+        },
+    },
+    i16: number("INTEGER"),
+    i32: number("INTEGER"),
+    i64: {
+        bind(value) {
+            return value;
+        },
+        column: "INTEGER",
+        unbind(value) {
+            return BigInt(value);
+        },
+    },
+    i8: number("INTEGER"),
+    primary: {
+        bind(value) {
+            if (numeric(value)) {
+                return Number(value);
+            }
+            throw new Error(`\`${value}\` is not a valid primary key value`);
+        },
+        column: "INTEGER PRIMARY KEY",
+        unbind(value) {
+            return String(value);
+        },
+    },
+    string: identity("TEXT"),
+    time: identity("TEXT"),
+    u128: {
+        bind(value) {
+            return String(value);
+        },
+        column: "TEXT",
+        unbind(value) {
+            return BigInt(value);
+        },
+    },
+    u16: number("INTEGER"),
+    u32: number("INTEGER"),
+    u64: {
+        bind(value) {
+            return String(value);
+        },
+        column: "TEXT",
+        unbind(value) {
+            return BigInt(value);
+        },
+    },
+    u8: number("INTEGER"),
+    url: {
+        bind(value) {
+            return value.toString();
+        },
+        column: "TEXT",
+        unbind(value) {
+            return new URL(value);
+        },
+    },
+};
+export default typemap;
+//# sourceMappingURL=typemap.js.map

package/lib/public/index.d.ts

@@ -0,0 +1,4 @@
+import Database from "#Database";
+declare const _default: (config?: typeof Database.config) => Database;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/public/index.js

@@ -0,0 +1,3 @@
+import Database from "#Database";
+export default (config) => new Database(config);
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,35 +1,50 @@
 {
   "name": "@primate/sqlite",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "description": "Primate SQLite database",
-  "homepage": "https://primatejs.com/modules/sqlite",
-  "bugs": "https://github.com/primatejs/primate/issues",
+  "homepage": "https://primate.run/docs/database/sqlite",
+  "bugs": "https://github.com/primate-run/primate/issues",
   "license": "MIT",
   "files": [
-    "src/**/*.js",
-    "!src/**/*.spec.js"
+    "/lib/**/*.js",
+    "/lib/**/*.d.ts",
+    "!/**/*.spec.*"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/primatejs/primate",
+    "url": "https://github.com/primate-run/primate",
     "directory": "packages/sqlite"
   },
   "dependencies": {
-    "@rcompat/invariant": "^0.5.0",
-    "@rcompat/object": "^0.5.0",
-    "@rcompat/runtime": "^0.1.0",
-    "better-sqlite3": "^11.2.1",
-    "@primate/core": "^0.1.9",
-    "@primate/store": "^0.25.4"
+    "@rcompat/assert": "^0.3.1",
+    "@rcompat/async": "^0.9.0",
+    "@rcompat/is": "^0.1.4",
+    "@rcompat/record": "^0.9.1",
+    "@rcompat/sqlite": "^0.4.0",
+    "@primate/core": "^0.3.0"
+  },
+  "devDependencies": {
+    "pema": "^0.3.0"
   },
   "type": "module",
   "imports": {
     "#*": {
-      "livetypes": "./src/private/*.js",
-      "default": "./src/private/*.js"
+      "apekit": "./src/private/*.ts",
+      "default": "./lib/private/*.js"
     }
   },
   "exports": {
-    ".": "./src/default.js"
+    ".": {
+      "apekit": "./src/public/index.ts",
+      "default": "./lib/public/index.js"
+    }
+  },
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "clean": "rm -rf ./lib",
+    "lint": "eslint .",
+    "test": "npm run build && npx proby",
+    "test:bun": "npm run build && bun x --bun proby",
+    "test:deno": "npm run build && deno run -A npm:proby"
   }
 }

package/src/default.js

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

package/src/private/Facade.js

@@ -1,115 +0,0 @@
-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 runtime from "@rcompat/runtime";
-
-const is_bun = runtime === "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

@@ -1,9 +0,0 @@
-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

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

package/src/private/serve.js

@@ -1,88 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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];