@rwillians/qx 0.1.18 → 0.1.20

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rwillians/qx",
   "description": "A zero-dependencies teeny tiny ORM for SQLite.",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "author": "Rafael Willians <me@rwillians.com>",
   "license": "MIT",
   "repository": {
@@ -65,6 +65,6 @@
     "@types/bun": "latest"
   },
   "peerDependencies": {
-    "typescript": "^5.9.3"
+    "typescript": "latest"
   }
 }

package/dist/cjs/adapter.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.is = exports.withLoggedQuery = void 0;
-const u = require("./utils");
-/**
- * @public  Wraps a function call that executes DDL with logging
- *          capabilities.
- *
- *          A `debug` log is emitted before the function is executed,
- *          and an `error` log if the function throws an error. After
- *          logging, the error is re-thrown.
- * @since   0.1.17
- * @version 1
- */
-const withLoggedQuery = async (logger, data, fn) => {
-    const loggers = u.wrap(logger);
-    const { sql, params } = data;
-    loggers.forEach(logger => logger.debug(sql, params));
-    return Promise.resolve().then(() => fn(sql, params)).catch(error => {
-        loggers.forEach(logger => logger.error(sql, params, error));
-        return Promise.reject(error); // propagate the error without
-        // appending stack traces
-    });
-};
-exports.withLoggedQuery = withLoggedQuery;
-var index_1 = require("./index");
-Object.defineProperty(exports, "is", { enumerable: true, get: function () { return index_1.is; } });

package/dist/cjs/bun-sqlite.js

@@ -1,513 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.inmemory = exports.connect = void 0;
-const bun_sqlite_1 = require("bun:sqlite");
-const node_util_1 = require("node:util");
-const u = require("./utils");
-const adapter_1 = require("./adapter");
-/**
- * @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 Renders a join clause.
-     * @since   0.1.9
-     * @version 1
-     */
-    join: glue((join) => {
-        const result = render.expr.any(join.on);
-        return {
-            frags: [' ', join.type, ' ', render.ref(join.table), ' AS ', render.ref(join.alias), ' ON ', ...result.frags],
-            params: result.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 (adapter_1.is.binaryOp(value))
-                return render.expr.binaryOp(value);
-            if (adapter_1.is.and(value))
-                return render.expr.and(value);
-            if (adapter_1.is.or(value))
-                return render.expr.or(value);
-            if (adapter_1.is.not(value))
-                return render.expr.not(value);
-            if (adapter_1.is.column(value))
-                return render.expr.column(value);
-            if (adapter_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 (adapter_1.is.null(value))
-                return render.expr.null();
-            if (adapter_1.is.boolean(value))
-                return render.expr.boolean(value);
-            if (adapter_1.is.date(value))
-                return render.expr.date(value);
-            if (adapter_1.is.number(value))
-                return render.expr.number(value);
-            if (adapter_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 joins = op.joins && op.joins.length > 0
-            ? op.joins.reduce(collect(render.join), EMPTY_RENDER_RESULT)
-            : EMPTY_RENDER_RESULT;
-        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),
-            ...joins.frags,
-            (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: [...joins.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, params } = ddl.createTable(op);
-        await (0, adapter_1.withLoggedQuery)(this.loggers, { sql, params }, () => 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),
-        });
-        const rows = await (0, adapter_1.withLoggedQuery)(this.loggers, { sql, params }, () => this.conn
-            .prepare(sql)
-            .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);
-        const rows = await (0, adapter_1.withLoggedQuery)(this.loggers, { sql, params }, () => this.conn
-            .prepare(sql)
-            .all(...params));
-        return rows.map(createDecoder(op.select));
-    }
-    /**
-     * @public  Executes a function within a transaction.
-     * @since   0.1.10
-     * @version 1
-     */
-    async transaction(fn) {
-        return this.conn.transaction(fn)();
-    }
-}
-/**
- * @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;
-/**
- * @public  Creates a connection to an in-memory database.
- * @since   0.1.12
- * @version 2
- */
-const inmemory = () => connect(':memory:');
-exports.inmemory = inmemory;

package/dist/cjs/console-logger.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createConsoleLogger = void 0;
-const node_util_1 = require("node:util");
-/**
- * @public  Creates a basic console logger that logs all queries.
- * @since   0.1.0
- * @version 2
- */
-const createConsoleLogger = () => ({
-    debug: (sql, params) => { process.stdout.write(sql + ' ' + (0, node_util_1.inspect)(params, false, null, true) + '\n'); },
-    error: (sql, params) => { process.stderr.write(sql + ' ' + (0, node_util_1.inspect)(params, false, null, true) + '\n'); },
-});
-exports.createConsoleLogger = createConsoleLogger;

package/dist/cjs/experimental-migrations.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineMigrations = void 0;
-const index_1 = require("./index");
-// // // // // // // // // // // // // // // // // // // // // // // //
-//                         CREATE STATEMENTS                         //
-// // // // // // // // // // // // // // // // // // // // // // // //
-/**
- * @public  Create statement builder.
- * @since   0.1.0
- * @version 1
- */
-const create = {
-    /**
-     * @public  Prepares a create table statement.
-     * @since   0.1.0
-     * @version 1
-     */
-    table: (table, options = {}) => ({
-        /**
-         * @public  Executes the create table statement onto the given
-         *          database.
-         * @since   0.1.0
-         * @version 1
-         */
-        onto: async (db) => db.createTable({
-            ...options,
-            table: table.name,
-            columns: Object.values(table.columns),
-        }),
-    }),
-};
-// // // // // // // // // // // // // // // // // // // // // // // //
-//                       MIGRATIONS MANAGEMENT                       //
-// // // // // // // // // // // // // // // // // // // // // // // //
-/**
- * @private Defines the schema migrations table.
- * @since   0.1.6
- * @version 1
- */
-const migrations = (0, index_1.table)('schema_migrations', t => ({
-    id: t.string({ size: 36 }).primaryKey(),
-    timestamp: t.datetime(),
-}));
-/**
- * @public  Defines a set of migrations to be executed against a
- *          database.
- * @since   0.1.6
- * @version 2
- *
- * @example
- * ```ts
- * // src/db/migrations.ts
- * import { create, defineMigrations } from '@rwillians/qx/experimental-migrations';
- * import { users } from './users';
- * import { profiles } from './profiles';
- *
- * export const migrate = defineMigrations({
- *   '0001': async (db) => {
- *     await create.table(users).onto(db);
- *   },
- *   '0002': async (db) => {
- *     await create.table(profiles).onto(db);
- *   },
- * });
- *
- * // src/index.ts
- * import * as sqlite from '@rwillians/qx/bun-sqlite';
- * import { migrate } from './db/migrations';
- *
- * const db = sqlite.connect('./db.sqlite');
- * await migrate(db)
- * ```
- */
-const defineMigrations = (migs) => async (db) => {
-    await create.table(migrations, { ifNotExists: true }).onto(db);
-    const { mostRecentId } = await (0, index_1.from)(migrations.as('m'))
-        .orderBy(({ m }) => [index_1.expr.desc(m.timestamp)])
-        .select(({ m }) => ({ mostRecentId: m.id }))
-        .one(db) || { mostRecentId: '' };
-    for (const [id, migrate] of Object.entries(migs)) {
-        if (id <= mostRecentId)
-            continue;
-        await (0, index_1.transaction)(db, async () => {
-            await migrate(db);
-            await (0, index_1.into)(migrations).values({ id, timestamp: new Date() }).insert(db);
-        });
-    }
-};
-exports.defineMigrations = defineMigrations;