@devmoods/express-extras 0.63.1 → 0.65.0

package/dist/postgres.js

@@ -1,261 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import {} from 'express';
-import pg, {} from 'pg';
-import { config } from './config.js';
-import { formatSql } from './sql.js';
-import { startTimer } from './utils.js';
-export const escapePostgresIdentifier = pg.escapeIdentifier;
-export const escapePostgresLiteral = pg.escapeLiteral;
-export class DoesNotExistError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'DoesNotExistError';
-    }
-}
-export class MultipleRowsReturnedError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'MultipleRowsReturnedError';
-    }
-}
-export class IntegrityError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'IntegrityError';
-    }
-}
-export const transactionStorage = new AsyncLocalStorage();
-export class Connection {
-    client;
-    options;
-    constructor(client, options) {
-        this.client = client;
-        this.options = options;
-    }
-    logStatement(text, values, duration) {
-        if (this.options.onLogStatement) {
-            return this.options.onLogStatement(text, values, duration);
-        }
-        if (config.value.LOG_SQL) {
-            console.log(`\n${formatSql(text)}\n\nValues: ${JSON.stringify(values)}\nDuration: ${duration}ms\n`);
-        }
-    }
-    async query(text, values) {
-        const timer = startTimer();
-        try {
-            return await this.client.query(text, values);
-        }
-        catch (error) {
-            if (error.code && error.code === '23505') {
-                throw new IntegrityError(`${error.message}: ${error.detail}`);
-            }
-            throw error;
-        }
-        finally {
-            this.logStatement?.(text, values, timer.getDuration());
-        }
-    }
-    async all(text, values) {
-        const result = await this.query(text, values);
-        if (result.rows) {
-            return result.rows;
-            /* c8 ignore next 2*/
-        }
-        return [];
-    }
-    async insert(text, values) {
-        return await this.query(text, values);
-    }
-    async first(text, values) {
-        const result = await this.query(text, values);
-        return result.rows && result.rows.length ? result.rows[0] : null;
-    }
-    async get(text, values) {
-        const result = await this.query(text, values);
-        if (result.rowCount === 0) {
-            throw new DoesNotExistError('Row matching query not found');
-        }
-        if (result.rowCount > 1) {
-            throw new MultipleRowsReturnedError(`Call to postgres.get() returned ${result.rowCount} rows. Expected 1.`);
-        }
-        return result.rows[0];
-    }
-}
-export class Transaction extends Connection {
-    savepoints = [];
-    isCommitted = false;
-    isRolledBack = false;
-    async createSavepoint() {
-        const savepointName = `sp_${this.savepoints.length + 1}`;
-        await this.query(`SAVEPOINT ${savepointName}`);
-        this.savepoints.push(savepointName);
-        return savepointName;
-    }
-    async rollbackToSavepoint(savepointName) {
-        await this.query(`ROLLBACK TO SAVEPOINT ${savepointName}`);
-    }
-    async releaseSavepoint(savepointName) {
-        await this.query(`RELEASE SAVEPOINT ${savepointName}`);
-        const index = this.savepoints.indexOf(savepointName);
-        if (index !== -1) {
-            this.savepoints.splice(index, 1);
-        }
-    }
-}
-/**
- * Create a new Postgres connection pool with
- * conveience methods for executing queries using
- * one of the available connections.
- *
- * @param config
- */
-export function createPostgres({ onError, url = config.value.POSTGRES_URL, ...postgresOptions } = {}) {
-    const pool = new pg.Pool({ connectionString: url, ...postgresOptions });
-    pool.on('error', (e, client) => {
-        onError?.(e, client);
-    });
-    async function withConnection(callback) {
-        // Check if we're already in a transaction context
-        const txContext = transactionStorage.getStore();
-        if (txContext) {
-            return callback(txContext.connection);
-        }
-        const client = await pool.connect();
-        try {
-            const result = await callback(new Connection(client, {
-                onLogStatement: postgresOptions.onLogStatement,
-            }));
-            return result;
-        }
-        finally {
-            client.release();
-        }
-    }
-    /**
-     * Wipe the database schema
-     */
-    async function clear(force = false) {
-        if (!force) {
-            return;
-        }
-        return withConnection(async (connection) => {
-            await connection.query('DROP SCHEMA public CASCADE');
-            await connection.query(`CREATE SCHEMA public`);
-        });
-    }
-    /**
-     * Run queries inside a BEGIN, COMMIT / ROLLBACK transaction.
-     * Supports nested transactions using SAVEPOINT.
-     */
-    async function transaction(callback) {
-        // Check if we're already in a transaction context
-        const existingTxContext = transactionStorage.getStore();
-        if (existingTxContext) {
-            // We're already in a transaction, create a savepoint for nested transaction
-            const txConnection = existingTxContext.connection;
-            const savepointName = await txConnection.createSavepoint();
-            try {
-                const result = await callback();
-                await txConnection.releaseSavepoint(savepointName);
-                return result;
-            }
-            catch (error) {
-                await txConnection.rollbackToSavepoint(savepointName);
-                throw error;
-            }
-        }
-        // Start a new top-level transaction
-        const client = await pool.connect();
-        const txConnection = new Transaction(client, {
-            onLogStatement: postgresOptions.onLogStatement,
-        });
-        try {
-            await txConnection.query('BEGIN');
-            // Create transaction context
-            const txContext = {
-                connection: txConnection,
-                savepoints: [],
-                isCommitted: false,
-                isRolledBack: false,
-            };
-            // Run the callback within the transaction context
-            const result = await transactionStorage.run(txContext, async () => {
-                return await callback();
-            });
-            await txConnection.query('COMMIT');
-            txContext.isCommitted = true;
-            return result;
-        }
-        catch (error) {
-            await txConnection.query('ROLLBACK');
-            throw error;
-        }
-        finally {
-            client.release();
-        }
-    }
-    const query = async (...args) => {
-        return await withConnection(async (connection) => {
-            return connection.query(...args);
-        });
-    };
-    const insert = async (...args) => {
-        return await withConnection(async (connection) => {
-            return connection.insert(...args);
-        });
-    };
-    const first = async (...args) => {
-        return await withConnection(async (connection) => {
-            return connection.first(...args);
-        });
-    };
-    const all = async (...args) => {
-        return await withConnection(async (connection) => {
-            return connection.all(...args);
-        });
-    };
-    const get = async (...args) => {
-        return await withConnection(async (connection) => {
-            return connection.get(...args);
-        });
-    };
-    /**
-     * Get the current transaction from the AsyncLocalStorage context.
-     * Returns null if not in a transaction.
-     */
-    function getCurrentTransaction() {
-        const txContext = transactionStorage.getStore();
-        return txContext ? txContext.connection : null;
-    }
-    return {
-        insert,
-        query,
-        first,
-        all,
-        get,
-        withConnection,
-        transaction,
-        getCurrentTransaction,
-        instance: pool,
-        clear,
-        end() {
-            return pool.end();
-        },
-    };
-}
-export function withTransaction(postgres) {
-    return async function withTransactionMiddleware(req, res, next) {
-        try {
-            await postgres.transaction(async () => {
-                await new Promise((resolve, reject) => {
-                    res.on('finish', resolve);
-                    res.on('error', reject);
-                    next();
-                });
-            });
-        }
-        catch (error) {
-            next(error);
-        }
-    };
-}

package/dist/sql.d.ts

@@ -1,33 +0,0 @@
-export declare class SqlStatement {
-    stringsAndValues: [string, unknown | undefined][];
-    constructor(strings: string[], values: unknown[]);
-    _extract(strings: string[], values: unknown[]): void;
-    append(statement: SqlStatement | string): this;
-    get values(): ({} | null)[];
-    get text(): string;
-}
-export declare const sql: {
-    (strings: TemplateStringsArray, ...values: unknown[]): SqlStatement;
-    identifier(name: string): {
-        name: string;
-        raw: boolean;
-    };
-    raw(name: string): {
-        name: string;
-        raw: boolean;
-    };
-    literal(name: string | null): {
-        name: string;
-        raw: boolean;
-    };
-    spreadUpdate: typeof spreadUpdate;
-    spreadInsert: typeof spreadInsert;
-};
-declare function spreadUpdate(data: Record<string, any>): SqlStatement;
-declare function spreadInsert<TData extends Record<string, any>>(data: TData | TData[]): SqlStatement;
-export declare function joinStatements(statements: SqlStatement[], separator: string): SqlStatement;
-/**
- * Returns a pretty-printed SQL statement.
- */
-export declare const formatSql: (statement: SqlStatement | string) => string;
-export {};

package/dist/sql.js

@@ -1,135 +0,0 @@
-import { format } from 'sql-formatter';
-import { escapePostgresIdentifier, escapePostgresLiteral } from './postgres.js';
-const isRaw = (value) => {
-    return (typeof value === 'object' && value !== null && 'raw' in value && !!value.raw);
-};
-export class SqlStatement {
-    stringsAndValues;
-    constructor(strings, values) {
-        this.stringsAndValues = [];
-        this._extract(strings, values);
-    }
-    _extract(strings, values) {
-        for (let i = 0; i < strings.length; i++) {
-            const string = strings[i];
-            const value = values[i];
-            if (isRaw(value)) {
-                this.stringsAndValues.push([string + value.name, undefined]);
-            }
-            else if (value instanceof SqlStatement) {
-                this.stringsAndValues.push([string, undefined]);
-                this.stringsAndValues.push(...value.stringsAndValues);
-            }
-            else {
-                this.stringsAndValues.push([string, value]);
-            }
-        }
-    }
-    append(statement) {
-        if (statement instanceof SqlStatement) {
-            this.stringsAndValues.push(...statement.stringsAndValues);
-        }
-        else {
-            this.stringsAndValues.push([statement, undefined]);
-        }
-        return this;
-    }
-    get values() {
-        return this.stringsAndValues
-            .map(([, value]) => value)
-            .filter((x) => x !== undefined);
-    }
-    get text() {
-        let i = 1;
-        let result = '';
-        for (const [string, value] of this.stringsAndValues) {
-            if (value == null) {
-                result += string;
-            }
-            else {
-                result += `${string}$${i}`;
-                i += 1;
-            }
-        }
-        return result;
-    }
-}
-export const sql = (strings, ...values) => {
-    return new SqlStatement(Array.from(strings), values);
-};
-function spreadUpdate(data) {
-    const entries = Object.entries(data);
-    if (entries.length === 0) {
-        return sql ``;
-    }
-    return joinStatements(entries
-        .filter(([, value]) => typeof value !== 'undefined')
-        .map(([key, value]) => sql `${sql.identifier(key)} = ${value == null ? sql.raw('NULL') : value}`), ', ');
-}
-function spreadInsert(data) {
-    const rows = Array.isArray(data) ? data : [data];
-    if (rows.length === 0) {
-        return sql ``;
-    }
-    const statement = sql `(`;
-    statement.append(Object.keys(rows[0])
-        .map((k) => escapePostgresIdentifier(k))
-        .join(', '));
-    statement.append(sql `) VALUES `);
-    const toInsert = [];
-    for (const row of rows) {
-        const values = Object.values(row);
-        if (values.length === 0) {
-            continue;
-        }
-        toInsert.push(sql `(${joinStatements(values.map((value) => sql `${value ?? sql.raw('NULL')}`), ', ')})`);
-    }
-    statement.append(joinStatements(toInsert, ', '));
-    return statement;
-}
-/**
- * Inject an identifier into the template string
- */
-sql.identifier = (name) => {
-    return { name: escapePostgresIdentifier(name), raw: true };
-};
-/**
- * Inject a raw value into the template string
- */
-sql.raw = (name) => {
-    return { name, raw: true };
-};
-/**
- * Inject a literal value into the template string
- */
-sql.literal = (name) => {
-    if (name === null) {
-        return { name: 'NULL', raw: true };
-    }
-    return { name: escapePostgresLiteral(name), raw: true };
-};
-sql.spreadUpdate = spreadUpdate;
-sql.spreadInsert = spreadInsert;
-export function joinStatements(statements, separator) {
-    let i = 0;
-    const statement = sql ``;
-    for (const o of statements) {
-        if (i++ !== 0) {
-            statement.append(separator);
-        }
-        statement.append(o);
-    }
-    return statement;
-}
-/**
- * Returns a pretty-printed SQL statement.
- */
-export const formatSql = (statement) => {
-    const value = statement instanceof SqlStatement ? statement.text : statement;
-    return format(value, {
-        language: 'postgresql',
-        keywordCase: 'upper',
-        tabWidth: 2,
-        useTabs: false,
-    });
-};

package/dist/vite/vitest.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/vite/vitest.js

@@ -1 +0,0 @@
-export {};

package/dist/vite.d.ts

@@ -1 +0,0 @@
-export { defineViteConfig } from './vite/defineViteConfig.js';

package/dist/vite.js

@@ -1 +0,0 @@
-export { defineViteConfig } from './vite/defineViteConfig.js';