@devmoods/express-extras 0.63.1 → 0.65.0

package/dist/migrate.js

@@ -1,255 +0,0 @@
-import { promises as fs } from 'node:fs';
-import * as path from 'node:path';
-import chalk from 'chalk';
-import {} from 'commander';
-import {} from './cli.js';
-import { createPostgres } from './postgres.js';
-import { formatSql, sql } from './sql.js';
-export const asCli = (command, cli) => {
-    command.command('up').action(cli.wrap(async () => {
-        const migrator = new Migrator();
-        try {
-            await migrator.runMigrations('up');
-        }
-        finally {
-            await migrator.end();
-        }
-    }));
-    command.command('down').action(cli.wrap(async () => {
-        const migrator = new Migrator();
-        try {
-            await migrator.runMigrations('down');
-        }
-        finally {
-            await migrator.end();
-        }
-    }));
-    command.command('init').action(cli.wrap(async () => {
-        const migrator = new Migrator();
-        try {
-            const created = await migrator.init();
-            if (created) {
-                cli.greenLine('Migrations table was successfully setup.');
-            }
-            else {
-                cli.greenLine('Migrations table already existing.');
-            }
-        }
-        finally {
-            await migrator.end();
-        }
-    }));
-    command
-        .command('create')
-        .argument('<string>', 'name of migration')
-        .option('--typescript', 'use typescript')
-        .action(cli.wrap(async (name, flags) => {
-        const migrator = new Migrator();
-        try {
-            const createdMigration = await migrator.create(name, flags.typescript ? 'ts' : 'sql');
-            migrator.log(chalk.green('Created migration', createdMigration));
-        }
-        finally {
-            await migrator.end();
-        }
-    }));
-};
-export class Migrator {
-    postgres;
-    migrationTableName;
-    pathToMigrations;
-    filenameRegExp = /(\d+)_(.*)\.(js|ts|mjs|mts|sql)/;
-    verbose;
-    constructor({ postgres = createPostgres({ onLogStatement: () => { } }), pathToMigrations = path.resolve(process.cwd(), 'db', 'migrations'), migrationTableName = 'migrations', verbose = true, } = {}) {
-        this.postgres = postgres;
-        this.pathToMigrations = pathToMigrations;
-        this.migrationTableName = migrationTableName;
-        this.verbose = verbose;
-    }
-    end() {
-        return this.postgres.end();
-    }
-    async init() {
-        if (await this.isInstalled()) {
-            return false;
-        }
-        await fs.mkdir(this.pathToMigrations, { recursive: true });
-        await this.postgres.query(sql `
-      CREATE TABLE IF NOT EXISTS ${sql.identifier(this.migrationTableName)} (
-        id bigserial PRIMARY KEY,
-        version int NOT NULL,
-        run_at timestamp with time zone NOT NULL
-      );
-    `);
-        return true;
-    }
-    async isInstalled() {
-        try {
-            await this.postgres.query(sql `SELECT * FROM ${sql.identifier(this.migrationTableName)}`);
-            await fs.stat(this.pathToMigrations);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async create(name, format = 'sql') {
-        if (!name) {
-            throw new Error('Missing positional argument <name>');
-        }
-        if (!(await this.isInstalled())) {
-            await this.init();
-        }
-        const existingMigrations = await this.getMigrations();
-        const lastVersion = existingMigrations.length
-            ? existingMigrations[existingMigrations.length - 1].version
-            : 0;
-        const filename = path.join(this.pathToMigrations, `${lastVersion + 1}_${name}.${format}`);
-        const getTemplate = () => {
-            switch (format) {
-                case 'sql':
-                    return `-- Migration ${name} created ${new Date()}\n\nSELECT 1;\n\n-- ROLLBACK --\n\nSELECT 1;\n`;
-                case 'ts':
-                    return `// Migration ${name} created ${new Date()}\n\nexport function up(query: any) {}\n\nexport function down(query: any) {}\n`;
-            }
-        };
-        await fs.writeFile(filename, getTemplate());
-        return filename;
-    }
-    async runMigrations(direction) {
-        if (direction !== 'up' && direction !== 'down') {
-            throw new Error('Only up and down are supported.');
-        }
-        if (!(await this.isInstalled())) {
-            await this.init();
-        }
-        const migrations = await this.getMigrations();
-        const currentVersion = await this.getCurrentVersion();
-        return this.executeMigration(migrations, currentVersion, direction);
-    }
-    log(...args) {
-        if (this.verbose) {
-            console.log(...args);
-        }
-    }
-    async executeMigration(migrations, currentVersion, direction) {
-        if (direction === 'up') {
-            const pendingMigrations = this.getPendingMigrations(migrations, currentVersion);
-            if (!pendingMigrations.length) {
-                this.log(chalk.green('No pending migrations'));
-                return currentVersion;
-            }
-            for (const migration of pendingMigrations) {
-                this.log('Running migration', migration.filename);
-                const migrator = await this.readMigrationFile(migration.filename);
-                if (migrator.useTransaction !== false) {
-                    await this.postgres.transaction(async () => {
-                        await this.migrate(migrator, direction);
-                        await this.updateCurrentVersion(migration.version);
-                    });
-                }
-                else {
-                    await this.postgres.withConnection(async () => {
-                        await this.migrate(migrator, direction);
-                        await this.updateCurrentVersion(migration.version);
-                    });
-                }
-            }
-            this.log(chalk.green('Done!'));
-            return await this.getCurrentVersion();
-        }
-        else if (direction === 'down') {
-            const previousMigrations = this.getPreviousMigrations(migrations, currentVersion);
-            const previousMigration = previousMigrations[0];
-            const updatedVersion = previousMigration ? previousMigration.version : 0;
-            const migrationToRollback = migrations.find((migration) => migration.version === currentVersion);
-            if (!migrationToRollback) {
-                this.log(chalk.green('No migrations have been run, so nothing to rollback to.'));
-                return currentVersion;
-            }
-            this.log('Rolling back migration', migrationToRollback.filename);
-            const migrator = await this.readMigrationFile(migrationToRollback.filename);
-            if (migrator.useTransaction !== false) {
-                await this.postgres.transaction(async () => {
-                    await this.migrate(migrator, 'down');
-                    await this.updateCurrentVersion(updatedVersion);
-                });
-            }
-            else {
-                await this.postgres.withConnection(async () => {
-                    await this.migrate(migrator, 'down');
-                    await this.updateCurrentVersion(updatedVersion);
-                });
-            }
-            return await this.getCurrentVersion();
-            /* c8 ignore next 2 */
-        }
-        throw new Error(`Invalid direction ${direction}`);
-    }
-    async readMigrationFile(filename) {
-        if (!filename.endsWith('.sql')) {
-            return import(filename);
-        }
-        const content = await fs.readFile(filename, 'utf-8');
-        const [up, down] = content.split(/[-\s]+ROLLBACK[-\s]+/i);
-        return {
-            useTransaction: !/[-\s]+NO[\s]*TRANSACTION[-\s]+/i.test(content),
-            up() {
-                return up.trim();
-            },
-            down() {
-                return (down || '').trim();
-            },
-        };
-    }
-    async migrate(migrator, direction) {
-        try {
-            const queryWithLog = (statement) => {
-                this.log(chalk.yellow(formatSql(statement)));
-                return this.postgres.query(statement);
-            };
-            const returnValue = await migrator[direction](queryWithLog.bind(this.postgres));
-            if (typeof returnValue === 'string') {
-                if (returnValue !== '') {
-                    await queryWithLog(returnValue);
-                }
-            }
-            else {
-                await returnValue;
-            }
-            /* c8 ignore next 3 */
-        }
-        catch (error) {
-            throw new Error(`Migration failed: ${error.message}`);
-        }
-    }
-    updateCurrentVersion(version) {
-        return this.postgres.query(`INSERT INTO ${this.migrationTableName} (version, run_at) VALUES ($1, $2)`, [version, new Date()]);
-    }
-    async getCurrentVersion() {
-        const result = await this.postgres.first(`SELECT version FROM ${this.migrationTableName} ORDER BY run_at DESC LIMIT 1`);
-        return result ? result.version : 0;
-    }
-    async getMigrations() {
-        const files = await fs.readdir(this.pathToMigrations);
-        return files
-            .map((filename) => filename.match(this.filenameRegExp))
-            .filter(notNullOrUndefined)
-            .map(([filename, version, name]) => ({
-            filename: path.join(this.pathToMigrations, filename),
-            version: parseInt(version, 10),
-            name,
-        }))
-            .sort((a, b) => a.version - b.version);
-    }
-    getPreviousMigrations(migrations, currentVersion) {
-        const reversedMigrations = migrations.reverse();
-        return reversedMigrations.filter((migration) => migration.version < currentVersion);
-    }
-    getPendingMigrations(migrations, currentVersion) {
-        return migrations.filter((migration) => migration.version > currentVersion);
-    }
-}
-function notNullOrUndefined(x) {
-    return x != null;
-}

package/dist/postgres-ts-generator.d.ts

@@ -1,11 +0,0 @@
-export interface GenerateDatabaseTypesOptions {
-    outputPath: string;
-    connectionString: string;
-    schema?: string;
-    excludeTables?: string[];
-    includeTables?: string[];
-}
-/**
- * Generates complete TypeScript definitions from database schema
- */
-export declare function generateDatabaseTypes(options: GenerateDatabaseTypesOptions): Promise<void>;

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 {};