@rwillians/qx 0.1.1 → 0.1.3

package/dist/cjs/bun-sqlite.d.ts

@@ -0,0 +1,47 @@
+import { Database } from 'bun:sqlite';
+import { type CreateTableStatement, type IDatabase, type ILogger, type InsertStatement, type SelectStatement } from './index';
+/**
+ * @private Bun SQLite database adapter implementation.
+ * @since   0.1.0
+ * @version 1
+ */
+declare class BunSQLite implements IDatabase {
+    private conn;
+    private loggers;
+    constructor(conn: Database, loggers?: ILogger[]);
+    /**
+     * @public  Attaches a logger to the database instance.
+     * @since   0.1.0
+     * @version 1
+     */
+    attachLogger(logger: ILogger): this;
+    /**
+     * @public  Executes a create table statement.
+     * @since   0.1.0
+     * @version 1
+     */
+    createTable(op: CreateTableStatement): Promise<void>;
+    /**
+     * @public  Executes an insert statement.
+     * @since   0.1.0
+     * @version 1
+     */
+    insert(op: InsertStatement): Promise<{
+        [k: string]: any;
+    }[]>;
+    /**
+     * @public  Executes a select statement.
+     * @since   0.1.0
+     * @version 1
+     */
+    query(op: SelectStatement): Promise<{
+        [k: string]: any;
+    }[]>;
+}
+/**
+ * @public  Creates a connection to the database.
+ * @since   0.1.0
+ * @version 1
+ */
+declare const connect: (...args: ConstructorParameters<typeof Database>) => BunSQLite;
+export { connect, };

package/dist/cjs/bun-sqlite.js

@@ -0,0 +1,483 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connect = void 0;
+const bun_sqlite_1 = require("bun:sqlite");
+const node_util_1 = require("node:util");
+const u = require("./utils");
+const index_1 = require("./index");
+/**
+ * @private Mapping of qx's primitive types to SQLite native types.
+ * @since   0.1.0
+ * @version 1
+ */
+const TYPES_MAPPING = {
+    BINARY: () => 'BLOB',
+    BOOLEAN: () => 'INTEGER',
+    DATETIME: () => 'INTEGER',
+    FLOAT: () => 'REAL',
+    INTEGER: () => 'INTEGER',
+    TEXT: () => 'TEXT',
+    VARCHAR: () => `TEXT`,
+};
+/**
+ * @private Registry of codecs for Bun SQLite.
+ * @since   0.1.0
+ * @version 1
+ */
+const CODECS = {
+    BINARY: {
+        encode: (value) => value,
+        decode: (value) => value,
+    },
+    BOOLEAN: {
+        encode: (value) => (value ? 1 : 0),
+        decode: (value) => value === 1,
+    },
+    DATETIME: {
+        encode: (value) => value.valueOf(),
+        decode: (value) => new Date(value),
+    },
+    FLOAT: {
+        encode: (value) => value * 1.0,
+        decode: (value) => value * 1.0,
+    },
+    INTEGER: {
+        encode: (value) => ~~value, // ← nifty little trick to truncate to integer
+        decode: (value) => ~~value,
+    },
+    TEXT: {
+        encode: (value) => value,
+        decode: (value) => value,
+    },
+    VARCHAR: {
+        encode: (value) => value,
+        decode: (value) => value,
+    },
+};
+/**
+ * @private An empty rendered result.
+ * @since   0.1.0
+ * @version 1
+ */
+const EMPTY_RENDER_RESULT = { frags: [], params: [] };
+/**
+ * @private A function combinator that accumulates rendered fragments
+ *          and parameters when used in a reduce operation.
+ * @since   0.1.0
+ * @version 1
+ */
+const collect = (fn) => (acc, value) => {
+    const result = fn(value);
+    return { frags: [...acc.frags, ...result.frags], params: [...acc.params, ...result.params] };
+};
+/**
+ * @private A function combinator that glues rendered fragments
+ *          together.
+ * @since   0.1.0
+ * @version 1
+ */
+const glue = (fn) => (...args) => {
+    const result = fn(...args);
+    return { frags: [result.frags.join('')], params: result.params };
+};
+/**
+ * @private Functions for rendering fragments while generateing DDL.
+ * @since   0.1.0
+ * @version 1
+ */
+const render = {
+    /**
+     * @private Renders an object reference (e.g., table name, column
+     *          name, etc).
+     * @since   0.1.0
+     * @version 1
+     */
+    ref: (value) => `"${value}"`,
+    /**
+     * @private Renders a column definition, for the create table
+     *          statement.
+     * @since   0.1.0
+     * @version 1
+     */
+    column: glue((col) => {
+        const { name, primaryKey = false, autoincrement = false, nullable = false, unique = false, } = col;
+        const type = TYPES_MAPPING[col.type](col);
+        // @TODO DDL should not have to know that it needs to snake_case here
+        const frags = [render.ref(u.snakeCase(name)), type];
+        if (primaryKey)
+            frags.push('PRIMARY KEY ASC');
+        if (autoincrement)
+            frags.push('AUTOINCREMENT');
+        if (primaryKey)
+            return { frags: [frags.join(' ')], params: [] };
+        if (!nullable)
+            frags.push('NOT NULL');
+        if (unique)
+            frags.push('UNIQUE');
+        return { frags: [frags.join(' ')], params: [] };
+    }),
+    /**
+     * @private Renders a value placeholder for an insert statement.
+     * @since   0.1.0
+     * @version 1
+     */
+    row: (shape) => glue((record) => {
+        const frags = [];
+        const params = [];
+        for (const key of Object.keys(shape)) {
+            frags.push('?');
+            params.push(record[key]);
+        }
+        return { frags: ['(' + frags.join(', ') + ')'], params };
+    }),
+    /**
+     * @private Renders the columns of a query's selection.
+     * @since   0.1.0
+     * @version 1
+     */
+    selection: glue((selection) => {
+        const frags = Object
+            .entries(selection)
+            // @TODO DDL should not have to know that it needs to snake_case here
+            .map(([alias, col]) => `${render.expr.column(col).frags.join('')} AS ${render.ref(alias)}`);
+        return { frags: [frags.join(', ')], params: [] };
+    }),
+    /**
+     * @private Renders an order by clause.
+     * @since   0.1.0
+     * @version 1
+     *
+     * Not using {@link glue} here becuase it's breaking typescript
+     * ¯\_(ツ)_/¯
+     */
+    orderBy: ([expr, dir]) => {
+        const { frags, params } = render.expr.any(expr);
+        return { frags: [[...frags, dir].join(' ')], params };
+    },
+    /**
+     * @private Expression rendering functions.
+     * @since   0.1.0
+     * @version 1
+     */
+    expr: {
+        /**
+         * @private Renders any {@link Expr}.
+         * @since   0.1.0
+         * @version 1
+         */
+        any: glue((value) => {
+            if (index_1.is.binaryOp(value))
+                return render.expr.binaryOp(value);
+            if (index_1.is.and(value))
+                return render.expr.and(value);
+            if (index_1.is.or(value))
+                return render.expr.or(value);
+            if (index_1.is.not(value))
+                return render.expr.not(value);
+            if (index_1.is.column(value))
+                return render.expr.column(value);
+            if (index_1.is.literal(value))
+                return render.expr.literal(value);
+            throw new Error(`Unsupported expression type: ${(0, node_util_1.inspect)(value)}`);
+        }),
+        // // // // // // // // // // // // // // // // // // // // // //
+        //                    BINARY OP EXPRESSIONS                    //
+        // // // // // // // // // // // // // // // // // // // // // //
+        /**
+         * @private Renders any binary op expression.
+         * @since   0.1.0
+         * @version 1
+         */
+        binaryOp: glue((value) => {
+            const lhs = render.expr.any(value.lhs);
+            const rhs = Array.isArray(value.rhs)
+                ? render.expr.array(value.rhs)
+                : render.expr.any(value.rhs);
+            return { frags: ['(', ...lhs.frags, ` ${value.op} `, ...rhs.frags, ')'], params: [...lhs.params, ...rhs.params] };
+        }),
+        // // // // // // // // // // // // // // // // // // // // // //
+        //                   BOOLEAN OP EXPRESSIONS                    //
+        // // // // // // // // // // // // // // // // // // // // // //
+        /**
+         * @private Renders an AND expression.
+         * @since   0.1.0
+         * @version 1
+         */
+        and: glue((value) => {
+            const inner = value.and.reduce(collect(render.expr.any), EMPTY_RENDER_RESULT);
+            return { frags: ['(', inner.frags.join(' AND '), ')'], params: inner.params };
+        }),
+        /**
+         * @private Renders an OR expression.
+         * @since   0.1.0
+         * @version 1
+         */
+        or: glue((value) => {
+            const inner = value.or.reduce(collect(render.expr.any), EMPTY_RENDER_RESULT);
+            return { frags: ['(', inner.frags.join(' OR '), ')'], params: inner.params };
+        }),
+        /**
+         * @private Renders a NOT expression.
+         * @since   0.1.0
+         * @version 1
+         */
+        not: glue((value) => {
+            const inner = render.expr.any(value.not);
+            return { frags: ['NOT ', ...inner.frags], params: inner.params };
+        }),
+        // // // // // // // // // // // // // // // // // // // // // //
+        //                      OTHER EXPRESSIONS                      //
+        // // // // // // // // // // // // // // // // // // // // // //
+        array: glue((values) => {
+            const { frags, params } = values.reduce(collect(render.expr.any), EMPTY_RENDER_RESULT);
+            return { frags: ['(', frags.join(', '), ')'], params };
+        }),
+        /**
+         * @private Renders a column expression.
+         * @since   0.1.0
+         * @version 1
+         */
+        column: glue((col) => ({
+            // @TODO DDL should not have to know that it needs to snake_case here
+            frags: [`${render.ref(col.table)}.${render.ref(u.snakeCase(col.name))}`],
+            params: [],
+        })),
+        /**
+         * @private Renders a literal expression.
+         * @since   0.1.0
+         * @version 1
+         */
+        literal: glue((value) => {
+            if (index_1.is.null(value))
+                return render.expr.null();
+            if (index_1.is.boolean(value))
+                return render.expr.boolean(value);
+            if (index_1.is.date(value))
+                return render.expr.date(value);
+            if (index_1.is.number(value))
+                return render.expr.number(value);
+            if (index_1.is.string(value))
+                return render.expr.string(value);
+            throw new Error(`Unsupported literal expression: ${(0, node_util_1.inspect)(value)}`);
+        }),
+        // // // // // // // // // // // // // // // // // // // // // //
+        //                          LITERALS                           //
+        // // // // // // // // // // // // // // // // // // // // // //
+        /**
+         * @private Renders a boolean literal expression.
+         * @since   0.1.0
+         * @version 1
+         */
+        boolean: glue((value) => ({
+            frags: [value ? 'TRUE' : 'FALSE'],
+            params: [],
+        })),
+        /**
+         * @private Renders a date literal expression.
+         * @since   0.1.0
+         * @version 1
+         */
+        date: glue((value) => ({
+            frags: ['?'],
+            params: [CODECS.DATETIME.encode(value)],
+        })),
+        /**
+         * @private Renders a null literal expression.
+         * @since   0.1.0
+         * @version 1
+         */
+        null: glue(() => ({ frags: ['NULL'], params: [] })),
+        /**
+         * @private Renders a number literal expression.
+         * @since   0.1.0
+         * @version 1
+         */
+        number: glue((value) => ({ frags: ['?'], params: [value] })),
+        /**
+         * @private Renders a string literal expression.
+         * @since   0.1.0
+         * @version 1
+         */
+        string: glue((value) => ({ frags: ['?'], params: [value] })),
+    },
+};
+/**
+ * @private DDL generation functions.
+ * @since   0.1.0
+ * @version 1
+ */
+const ddl = {
+    /**
+     * @private Generates DDL for create table statement.
+     * @since   0.1.0
+     * @version 1
+     */
+    createTable: (op) => {
+        const columns = op
+            .columns
+            .map(col => render.column(col).frags.join(''))
+            .join(', ');
+        const frags = [
+            'CREATE ',
+            (op.unlogged ? 'UNLOGGED ' : ''),
+            'TABLE ',
+            (op.ifNotExists ? 'IF NOT EXISTS ' : ''),
+            render.ref(op.table),
+            ' (',
+            ...columns,
+            ');',
+        ];
+        return { sql: frags.join(''), params: [] };
+    },
+    /**
+     * @private Generates DDL for insert statement.
+     * @since   0.1.0
+     * @version 1
+     */
+    insert: (op) => {
+        const values = op
+            .records
+            .reduce(collect(render.row(op.insertShape)), EMPTY_RENDER_RESULT);
+        const frags = [
+            'INSERT INTO ',
+            render.ref(op.table),
+            ' (',
+            Object.keys(op.insertShape).map(render.ref).join(', '),
+            ') VALUES ',
+            values.frags.join(', '),
+            ' RETURNING ',
+            render.selection(op.returnShape).frags.join(', '),
+            ';'
+        ];
+        return { sql: frags.join(''), params: values.params };
+    },
+    /**
+     * @private Generates DDL for select statement.
+     * @since   0.1.0
+     * @version 1
+     */
+    select: (op) => {
+        const where = op.where
+            ? render.expr.any(op.where)
+            : EMPTY_RENDER_RESULT;
+        const orderBy = op.orderBy && op.orderBy.length > 0
+            ? op.orderBy.reduce(collect(render.orderBy), EMPTY_RENDER_RESULT)
+            : EMPTY_RENDER_RESULT;
+        const limit = op.limit !== undefined
+            ? { frags: [' LIMIT ', '?'], params: [op.limit] }
+            : EMPTY_RENDER_RESULT;
+        const offset = op.offset !== undefined
+            ? { frags: [' OFFSET ', '?'], params: [op.offset] }
+            : EMPTY_RENDER_RESULT;
+        const frags = [
+            'SELECT ',
+            render.selection(op.select).frags.join(', '),
+            ' FROM ',
+            render.ref(op.registry[op.from]),
+            ' AS ',
+            render.ref(op.from),
+            (where.frags.length > 0 ? ' WHERE ' : ''),
+            ...where.frags,
+            (orderBy.frags.length > 0 ? ' ORDER BY ' + orderBy.frags.join(', ') : ''),
+            ...limit.frags,
+            ...offset.frags,
+            ';'
+        ];
+        return { sql: frags.join(''), params: [...where.params, ...limit.params, ...offset.params] };
+    },
+};
+/**
+ * @private Creates an encoder function that converts a row into the
+ *          expected shape and format expected by the database.
+ * @since   0.1.0
+ * @version 1
+ */
+const createEncoder = (shape) => {
+    const encoders = Object.fromEntries(Object
+        .entries(shape)
+        .map(([key, col]) => [key, (value) => value === null ? null : CODECS[col.type].encode(value)]));
+    return (row) => Object.fromEntries(Object
+        .entries(encoders)
+        .map(([key, encode]) => [u.snakeCase(key), encode(row[key])]));
+};
+/**
+ * @private Creates a decoder function that converts a database row
+ *          into the shape and format expected by the application.
+ * @since   0.1.0
+ * @version 1
+ */
+const createDecoder = (shape) => {
+    const decoders = Object.fromEntries(Object
+        .entries(shape)
+        .map(([key, col]) => [key, (value) => value === null ? null : CODECS[col.type].decode(value)]));
+    return (row) => Object.fromEntries(Object
+        .entries(decoders)
+        .map(([key, decode]) => [key, decode(row[key])]));
+};
+/**
+ * @private Bun SQLite database adapter implementation.
+ * @since   0.1.0
+ * @version 1
+ */
+class BunSQLite {
+    conn;
+    loggers;
+    constructor(conn, loggers = []) {
+        this.conn = conn;
+        this.loggers = loggers;
+    }
+    /**
+     * @public  Attaches a logger to the database instance.
+     * @since   0.1.0
+     * @version 1
+     */
+    attachLogger(logger) {
+        this.loggers.push(logger);
+        return this;
+    }
+    /**
+     * @public  Executes a create table statement.
+     * @since   0.1.0
+     * @version 1
+     */
+    async createTable(op) {
+        const { sql } = ddl.createTable(op);
+        this.loggers.forEach(logger => logger.debug(sql, []));
+        this.conn.run(sql);
+    }
+    /**
+     * @public  Executes an insert statement.
+     * @since   0.1.0
+     * @version 1
+     */
+    async insert(op) {
+        const { sql, params } = ddl.insert({
+            ...op,
+            records: op.records.map(createEncoder(op.insertShape)),
+            insertShape: u.mapKeys(op.insertShape, u.snakeCase),
+        });
+        this.loggers.forEach(logger => logger.debug(sql, params));
+        const stmt = this.conn.prepare(sql);
+        const rows = stmt.all(...params);
+        return rows.map(createDecoder(op.returnShape));
+    }
+    /**
+     * @public  Executes a select statement.
+     * @since   0.1.0
+     * @version 1
+     */
+    async query(op) {
+        const { sql, params } = ddl.select(op);
+        this.loggers.forEach(logger => logger.debug(sql, params));
+        const stmt = this.conn.prepare(sql);
+        const rows = stmt.all(...params);
+        return rows.map(createDecoder(op.select));
+    }
+}
+/**
+ * @public  Creates a connection to the database.
+ * @since   0.1.0
+ * @version 1
+ */
+const connect = (...args) => new BunSQLite(new bun_sqlite_1.Database(...args));
+exports.connect = connect;