@rwillians/exto 0.1.1 → 0.2.0

package/dist/cjs/bun-sqlite.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dialect = exports.connect = void 0;
+const bun_sqlite_1 = require("bun:sqlite");
+const TYPES = {
+    BIGINT: 'INTEGER',
+    BINARY: 'BLOB',
+    BOOLEAN: 'INTEGER',
+    CITEXT: 'TEXT COLLATE NOCASE',
+    DATE: 'TEXT',
+    DECIMAL: 'NUMERIC',
+    FLOAT: 'REAL',
+    INTEGER: 'INTEGER',
+    JSON: 'TEXT',
+    SEQUENCE: 'INTEGER',
+    STRING: 'TEXT',
+    TEXT: 'TEXT',
+    TIMESTAMP: 'INTEGER',
+    UUID: 'TEXT',
+};
+const identity = () => ({
+    encode: (value) => value,
+    decode: (value) => value,
+});
+// integers are read as bigints (see `execute`), so those that aren't BIGINT
+// columns go back to being numbers
+const numeric = {
+    encode: (value) => value,
+    decode: (value) => Number(value),
+};
+// sqlite's JSON paths quote each key, so that any key is a valid one
+const jsonPath = (path) => `'$${path.map(key => `."${key.replaceAll('"', '\\"').replaceAll('\'', '\'\'')}"`).join('')}'`;
+const dialect = {
+    name: 'sqlite',
+    placeholder: () => '?',
+    type: (col) => TYPES[col.type],
+    generated: (col) => {
+        if (col.type === 'SEQUENCE' && col.primaryKey)
+            return 'AUTOINCREMENT';
+        if (col.type === 'SEQUENCE')
+            throw new Error(`SQLite can only generate sequences for primary keys, column "${col.name}" isn't one`);
+        return undefined;
+    },
+    json: (sql, path, type) => `${sql} ${type === 'JSON' ? '->' : '->>'} ${jsonPath(path)}`,
+    codecs: {
+        BIGINT: { encode: (value) => value, decode: (value) => BigInt(value) },
+        BINARY: { encode: (value) => value, decode: (value) => new Uint8Array(value) },
+        BOOLEAN: { encode: (value) => (value ? 1 : 0), decode: (value) => Number(value) === 1 },
+        CITEXT: identity(),
+        DATE: identity(),
+        DECIMAL: numeric,
+        FLOAT: numeric,
+        INTEGER: numeric,
+        JSON: { encode: (value) => JSON.stringify(value), decode: (value) => JSON.parse(value) },
+        SEQUENCE: numeric,
+        STRING: identity(),
+        TEXT: identity(),
+        TIMESTAMP: { encode: (value) => value.getTime(), decode: (value) => new Date(Number(value)) },
+        UUID: identity(),
+    },
+};
+exports.dialect = dialect;
+class BunSQLite {
+    conn;
+    loggers;
+    depth;
+    dialect = dialect;
+    constructor(conn, loggers = [], depth = 0) {
+        this.conn = conn;
+        this.loggers = loggers;
+        this.depth = depth;
+    }
+    async execute(sql, params) {
+        // without safe integers, bun:sqlite rounds anything beyond 2^53
+        return this.conn.prepare(sql).safeIntegers(true).all(...params);
+    }
+    async close() {
+        this.conn.close();
+    }
+    // bun:sqlite's own `transaction()` is synchronous and would commit before an
+    // async callback settles, hence the manual BEGIN/COMMIT (SAVEPOINT if nested)
+    async transaction(fn) {
+        const savepoint = `"sp_${this.depth}"`;
+        const [begin, commit, rollback] = this.depth === 0
+            ? ['BEGIN', 'COMMIT', 'ROLLBACK']
+            : [`SAVEPOINT ${savepoint}`, `RELEASE ${savepoint}`, `ROLLBACK TO ${savepoint}; RELEASE ${savepoint}`];
+        this.conn.run(begin);
+        try {
+            const result = await fn(new BunSQLite(this.conn, this.loggers, this.depth + 1));
+            this.conn.run(commit);
+            return result;
+        }
+        catch (error) {
+            this.conn.run(rollback);
+            throw error;
+        }
+    }
+}
+const connect = (filename = ':memory:', { loggers = [] } = {}) => new BunSQLite(new bun_sqlite_1.Database(filename), loggers);
+exports.connect = connect;