@devmoods/express-extras 0.64.0 → 0.65.0

package/dist/postgres-ts-generator.js

@@ -1,114 +0,0 @@
-import { promises as fs } from 'node:fs';
-import { resolve, dirname } from 'node:path';
-import {} from 'pg-structure';
-import { pgStructure } from 'pg-structure/dist/main.js';
-/**
- * Converts PostgreSQL data type to TypeScript type
- */
-function pgTypeToTsType(pgType, isNullable) {
-    const nullableSuffix = isNullable ? ' | null' : '';
-    switch (pgType.name.toLowerCase()) {
-        case 'uuid':
-            return `string${nullableSuffix}`;
-        case 'text':
-        case 'varchar':
-        case 'char':
-        case 'character varying':
-            return `string${nullableSuffix}`;
-        case 'integer':
-        case 'int':
-        case 'int2':
-        case 'int4':
-        case 'int8':
-        case 'serial':
-        case 'smallint':
-            return `number${nullableSuffix}`;
-        case 'bigint':
-        case 'bigserial':
-        case 'decimal':
-        case 'numeric':
-            return `string${nullableSuffix}`;
-        case 'real':
-        case 'double precision':
-        case 'float':
-        case 'float4':
-        case 'float8':
-            return `number${nullableSuffix}`;
-        case 'boolean':
-        case 'bool':
-            return `boolean${nullableSuffix}`;
-        case 'timestamp':
-        case 'timestamp with time zone':
-        case 'timestamptz':
-            return `Date${nullableSuffix}`;
-        case 'date':
-            return `Date${nullableSuffix}`;
-        case 'time':
-        case 'time with time zone':
-            return `string${nullableSuffix}`;
-        case 'json':
-        case 'jsonb':
-            return `Record<string, any>${nullableSuffix}`;
-        case 'bytea':
-            return `Buffer${nullableSuffix}`;
-        case 'inet':
-        case 'cidr':
-            return `string${nullableSuffix}`;
-        case 'array':
-            return `any[]${nullableSuffix}`;
-        default:
-            return `any${nullableSuffix}`;
-    }
-}
-/**
- * Generates TypeScript interface for a table
- */
-function generateTableInterface(table, tableName) {
-    const interfaceName = tableName.charAt(0).toUpperCase() + tableName.slice(1);
-    let interfaceCode = `\n/**\n * ${interfaceName} table interface\n */\nexport interface ${interfaceName} {\n`;
-    for (const column of table.columns) {
-        const tsType = pgTypeToTsType(column.type, !column.notNull);
-        const comment = column.comment ? ` /** ${column.comment} */` : '';
-        interfaceCode += `  /** ${column.name} */\n  ${column.name}: ${tsType};${comment}\n`;
-    }
-    interfaceCode += '}\n';
-    return interfaceCode;
-}
-/**
- * Generates complete TypeScript definitions from database schema
- */
-export async function generateDatabaseTypes(options) {
-    const { outputPath, connectionString, schema = 'public', excludeTables = ['migrations', 'migration_lock'], includeTables, } = options;
-    // Connect to database and get schema
-    const db = await pgStructure(connectionString);
-    let output = `/**
- * TypeScript definitions for database tables
- * Auto-generated from database schema
- */
-
-`;
-    const tables = db.schemas.get(schema)?.tables || [];
-    const filteredTables = tables.filter((table) => {
-        if (includeTables && includeTables.length > 0) {
-            return includeTables.includes(table.name);
-        }
-        return !excludeTables.includes(table.name);
-    });
-    // Generate table interfaces
-    for (const table of filteredTables) {
-        output += generateTableInterface(table, table.name);
-    }
-    // Generate DB interface
-    output +=
-        '\n/**\n * Database schema interface\n * Maps table names to their respective interfaces\n */\nexport interface DB {\n';
-    for (const table of filteredTables) {
-        const interfaceName = table.name.charAt(0).toUpperCase() + table.name.slice(1);
-        output += `  ${table.name}: ${interfaceName};\n`;
-    }
-    output += '}\n';
-    // Ensure output directory exists
-    const outputDir = dirname(resolve(outputPath));
-    await fs.mkdir(outputDir, { recursive: true });
-    // Write the generated types
-    await fs.writeFile(resolve(outputPath), output, 'utf-8');
-}

package/dist/postgres.d.ts

@@ -1,71 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { type RequestHandler } from 'express';
-import { type PoolClient, type PoolConfig, type QueryResult, type QueryResultRow } from 'pg';
-import { type SqlStatement } from './sql.js';
-export declare const escapePostgresIdentifier: typeof import("pg").escapeIdentifier;
-export declare const escapePostgresLiteral: typeof import("pg").escapeLiteral;
-export interface PostgresOptions extends PoolConfig, ConnectionOptions {
-    onError?: (error: Error, client: any) => void;
-    url?: PoolConfig['connectionString'];
-}
-export declare class DoesNotExistError extends Error {
-    constructor(message: string);
-}
-export declare class MultipleRowsReturnedError extends Error {
-    constructor(message: string);
-}
-export declare class IntegrityError extends Error {
-    constructor(message: string);
-}
-type Value = null | string | number | Date;
-export interface ConnectionOptions {
-    onLogStatement?: (statement: SqlStatement | string, values: unknown[] | undefined, duration: number) => void;
-}
-export interface TransactionContext {
-    connection: Connection;
-    savepoints: string[];
-    isCommitted: boolean;
-    isRolledBack: boolean;
-}
-export declare const transactionStorage: AsyncLocalStorage<TransactionContext>;
-export declare class Connection {
-    client: PoolClient;
-    options: ConnectionOptions;
-    constructor(client: PoolClient, options: ConnectionOptions);
-    private logStatement;
-    query<T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]): Promise<QueryResult<T>>;
-    all<T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]): Promise<T[]>;
-    insert<T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]): Promise<QueryResult<T>>;
-    first<T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]): Promise<T | null>;
-    get<T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]): Promise<T>;
-}
-export declare class Transaction extends Connection {
-    savepoints: string[];
-    isCommitted: boolean;
-    isRolledBack: boolean;
-    createSavepoint(): Promise<string>;
-    rollbackToSavepoint(savepointName: string): Promise<void>;
-    releaseSavepoint(savepointName: string): Promise<void>;
-}
-/**
- * Create a new Postgres connection pool with
- * conveience methods for executing queries using
- * one of the available connections.
- *
- * @param config
- */
-export declare function createPostgres({ onError, url, ...postgresOptions }?: PostgresOptions): {
-    insert: <T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]) => Promise<QueryResult<T>>;
-    query: <T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]) => Promise<QueryResult<T>>;
-    first: <T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]) => Promise<T | null>;
-    all: <T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]) => Promise<T[]>;
-    get: <T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]) => Promise<T>;
-    withConnection: <T>(callback: (connection: Connection) => Promise<T>) => Promise<T>;
-    transaction: <T>(callback: () => Promise<T> | T) => Promise<T>;
-    getCurrentTransaction: () => Transaction | null;
-    instance: import("pg").Pool;
-    clear: (force?: boolean) => Promise<void>;
-    end(): Promise<void>;
-};
-export declare function withTransaction(postgres: ReturnType<typeof createPostgres>): RequestHandler;
-export {};

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.d.ts

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

package/dist/vite.js

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