@devmoods/express-extras 0.15.3 → 0.17.0

package/bin/migrate.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node --loader ts-node/esm
+#!/usr/bin/env -S node --loader ts-node/esm
 
 import 'dotenv/config';
 

package/dist/__tests__/__migrations__/1_a.d.ts

@@ -0,0 +1,3 @@
+import { type Connection } from '../../postgres.js';
+export declare function up(query: Connection['query']): Promise<void>;
+export declare function down(query: Connection['query']): Promise<void>;

package/dist/__tests__/__migrations__/1_a.js

@@ -0,0 +1,8 @@
+export async function up(query) {
+    await query('CREATE TABLE baz (id serial primary key)');
+    await query('CREATE TABLE foo (id serial primary key)');
+}
+export async function down(query) {
+    await query('DROP TABLE foo');
+    await query('DROP TABLE baz');
+}

package/dist/email.d.ts

@@ -12,4 +12,5 @@ export interface SendEmailOptions extends nodemailer.SendMailOptions {
 }
 export declare function createEmail({ host, port, user, pass, senderName, senderAddress, }: EmailOptions): {
     send: ({ to, subject, message, ...rest }: SendEmailOptions) => Promise<void>;
+    transporter: nodemailer.Transporter<import("nodemailer/lib/smtp-transport/index.js").SentMessageInfo>;
 };

package/dist/email.js

@@ -17,5 +17,5 @@ export function createEmail({ host, port, user, pass, senderName, senderAddress,
         });
         getLogger('core').info('email-sent', { email: result });
     };
-    return { send };
+    return { send, transporter };
 }

package/dist/logger.d.ts

@@ -1,5 +1,5 @@
 import type { CreateSentry } from './sentry.js';
-export declare type LoggerContext = Record<string, any>;
+export type LoggerContext = Record<string, any>;
 export interface LoggerOptions {
     /**
      * Name of the logger
@@ -16,7 +16,7 @@ export interface LoggerOptions {
 }
 export declare function attachSentryClientToLoggers(sentryClient: CreateSentry['client']): void;
 export declare function setGlobalLoggerContext(getContext: () => LoggerContext): void;
-export declare type Logger = ReturnType<typeof createLogger>;
+export type Logger = ReturnType<typeof createLogger>;
 export declare function createLogger({ name, getContext, silent, }: LoggerOptions): {
     debug(message: string, context?: {
         [key: string]: any;

package/dist/migrate.d.ts

@@ -1,4 +1,4 @@
-import { createPostgres } from './postgres.js';
+import { type Connection, createPostgres } from './postgres.js';
 interface Migration {
     name: string;
     filename: string;
@@ -18,14 +18,14 @@ export declare class Migrator {
     private filenameRegExp;
     private verbose;
     constructor({ postgres, pathToMigrations, migrationTableName, verbose, }?: MigratorOptions);
-    init(): Promise<import("pg").QueryResult<any>>;
+    init(): Promise<import("pg").QueryResult<import("pg").QueryResultRow>>;
     create(name: string | null | undefined): Promise<string>;
-    runMigrations(direction: 'up' | 'down'): Promise<void>;
+    runMigrations(direction: 'up' | 'down'): Promise<number>;
     log(...args: any[]): void;
-    executeMigration(migrations: Migration[], currentVersion: number, direction: 'up' | 'down'): Promise<void>;
-    queryWithLog(sql: string): Promise<import("pg").QueryResult<any>>;
-    migrate(migration: Migration, direction: 'up' | 'down'): Promise<any>;
-    updateCurrentVersion(version: number): Promise<import("pg").QueryResult<any>>;
+    executeMigration(migrations: Migration[], currentVersion: number, direction: 'up' | 'down'): Promise<number>;
+    readMigrationFile(filename: string): Promise<any>;
+    migrate(tx: Connection, migration: Migration, direction: 'up' | 'down'): Promise<void>;
+    updateCurrentVersion(connection: Connection, version: number): Promise<import("pg").QueryResult<import("pg").QueryResultRow>>;
     getCurrentVersion(): Promise<number>;
     getMigrations(): Promise<{
         filename: string;

package/dist/migrate.js

@@ -54,7 +54,7 @@ Usage
 }
 export class Migrator {
     constructor({ postgres = createPostgres(), pathToMigrations = path.resolve(process.cwd(), 'db', 'migrations'), migrationTableName = 'migrations', verbose = true, } = {}) {
-        this.filenameRegExp = /(\d+)_(.*)\.(js|ts|mjs|mts)/;
+        this.filenameRegExp = /(\d+)_(.*)\.(js|ts|mjs|mts|sql)/;
         this.postgres = postgres;
         this.pathToMigrations = pathToMigrations;
         this.migrationTableName = migrationTableName;
@@ -100,46 +100,77 @@ export class Migrator {
             const pendingMigrations = this.getPendingMigrations(migrations, currentVersion);
             if (!pendingMigrations.length) {
                 this.log(chalk.green('No pending migrations'));
-                return;
+                return currentVersion;
             }
             for (const migration of pendingMigrations) {
                 this.log('Running migration', migration.filename);
-                await this.migrate(migration, direction);
-                await this.updateCurrentVersion(migration.version);
+                await this.postgres.transaction(async (tx) => {
+                    await this.migrate(tx, migration, direction);
+                    await this.updateCurrentVersion(tx, migration.version);
+                });
             }
             this.log(chalk.green('Done!'));
+            return await this.getCurrentVersion();
         }
-        else {
+        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;
+                return currentVersion;
             }
             this.log('Rolling back migration', migrationToRollback.filename);
-            await this.migrate(migrationToRollback, 'down');
-            await this.updateCurrentVersion(updatedVersion);
+            await this.postgres.transaction(async (tx) => {
+                await this.migrate(tx, migrationToRollback, 'down');
+                await this.updateCurrentVersion(tx, updatedVersion);
+            });
+            return await this.getCurrentVersion();
         }
+        throw new Error(`Invalid direction ${direction}`);
     }
-    queryWithLog(sql) {
-        this.log(chalk.yellow(sql.toString()));
-        return this.postgres.query(sql);
+    async readMigrationFile(filename) {
+        if (!filename.endsWith('.sql')) {
+            return import(filename);
+        }
+        const content = await fs.readFile(filename, 'utf-8');
+        const [up, down] = content.split('-- ROLLBACK --');
+        return {
+            up() {
+                return up.trim();
+            },
+            down() {
+                return (down || '').trim();
+            },
+        };
     }
-    async migrate(migration, direction) {
-        const migrator = await import(migration.filename);
+    async migrate(tx, migration, direction) {
+        const migrator = await this.readMigrationFile(migration.filename);
         if (!migrator.up || !migrator.down) {
             throw new Error('Migrations must export both an up() and a down() function.');
         }
-        const returnValue = migrator[direction](this.queryWithLog.bind(this));
-        if (typeof returnValue === 'string') {
-            return this.queryWithLog(returnValue);
+        try {
+            const queryWithLog = (sql) => {
+                this.log(chalk.yellow(sql.toString()));
+                return tx.query(sql);
+            };
+            const returnValue = await migrator[direction](queryWithLog.bind(tx));
+            if (typeof returnValue === 'string') {
+                if (returnValue !== '') {
+                    await queryWithLog(returnValue);
+                }
+            }
+            else {
+                await returnValue;
+            }
+        }
+        catch (error) {
+            throw new Error(`Migration failed: ${error.message}`);
         }
-        return returnValue;
     }
-    updateCurrentVersion(version) {
-        return this.postgres.query(`INSERT INTO ${this.migrationTableName} (version, run_at) VALUES ($1, $2)`, [version, new Date()]);
+    updateCurrentVersion(connection, version) {
+        return connection.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`);

package/dist/postgres.d.ts

@@ -1,4 +1,4 @@
-import pg from 'pg';
+import pg, { type PoolClient, type QueryResult, type QueryResultRow } from 'pg';
 import { SQL, type SQLStatement } from 'sql-template-strings';
 export interface PostgresOptions extends pg.PoolConfig {
     onError?: (error: Error, client: any) => void;
@@ -9,6 +9,18 @@ export declare class DoesNotExistError extends Error {
 export declare class MultipleRowsReturnedError extends Error {
     constructor(message: string);
 }
+type Value = null | string | number | Date;
+export declare class Connection {
+    client: PoolClient;
+    constructor(client: PoolClient);
+    query<T extends QueryResultRow>(text: string | SQLStatement, values?: Value[]): Promise<QueryResult<T>>;
+    all<T>(text: string | SQLStatement, values?: Value[]): Promise<T[]>;
+    insert<T extends QueryResultRow>(text: string | SQLStatement, values?: Value[]): Promise<QueryResult<T>>;
+    first<T>(text: string | SQLStatement, values?: Value[]): Promise<T | null>;
+    get<T>(text: string | SQLStatement, values?: Value[]): Promise<T>;
+}
+export declare class Transaction extends Connection {
+}
 /**
  * Create a new Postgres connection pool with
  * conveience methods for executing queries using
@@ -17,171 +29,16 @@ export declare class MultipleRowsReturnedError extends Error {
  * @param config
  */
 export declare function createPostgres({ onError, ...config }?: PostgresOptions): {
-    withConnection: (callback: (query: {
-        query: {
-            <T extends pg.Submittable>(queryStream: T): T;
-            <R extends any[] = any[], I extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I>, values?: I | undefined): Promise<pg.QueryArrayResult<R>>;
-            <R_1 extends pg.QueryResultRow = any, I_1 extends any[] = any[]>(queryConfig: pg.QueryConfig<I_1>): Promise<pg.QueryResult<R_1>>;
-            <R_2 extends pg.QueryResultRow = any, I_2 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_2>, values?: I_2 | undefined): Promise<pg.QueryResult<R_2>>;
-            <R_3 extends any[] = any[], I_3 extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I_3>, callback: (err: Error, result: pg.QueryArrayResult<R_3>) => void): void;
-            <R_4 extends pg.QueryResultRow = any, I_4 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_4>, callback: (err: Error, result: pg.QueryResult<R_4>) => void): void;
-            <R_5 extends pg.QueryResultRow = any, I_5 extends any[] = any[]>(queryText: string, values: I_5, callback: (err: Error, result: pg.QueryResult<R_5>) => void): void;
-        };
-        first: <T_1>(text: string | SQLStatement, values?: (null | string | number | Date)[], options?: {
-            query: {
-                <T extends pg.Submittable>(queryStream: T): T;
-                <R extends any[] = any[], I extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I>, values?: I | undefined): Promise<pg.QueryArrayResult<R>>;
-                <R_1 extends pg.QueryResultRow = any, I_1 extends any[] = any[]>(queryConfig: pg.QueryConfig<I_1>): Promise<pg.QueryResult<R_1>>;
-                <R_2 extends pg.QueryResultRow = any, I_2 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_2>, values?: I_2 | undefined): Promise<pg.QueryResult<R_2>>;
-                <R_3 extends any[] = any[], I_3 extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I_3>, callback: (err: Error, result: pg.QueryArrayResult<R_3>) => void): void;
-                <R_4 extends pg.QueryResultRow = any, I_4 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_4>, callback: (err: Error, result: pg.QueryResult<R_4>) => void): void;
-                <R_5 extends pg.QueryResultRow = any, I_5 extends any[] = any[]>(queryText: string, values: I_5, callback: (err: Error, result: pg.QueryResult<R_5>) => void): void;
-            };
-        }) => Promise<T_1 | null>;
-        all: <T_2>(text: string | SQLStatement, values?: (null | string | number | Date)[], options?: {
-            query: {
-                <T extends pg.Submittable>(queryStream: T): T;
-                <R extends any[] = any[], I extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I>, values?: I | undefined): Promise<pg.QueryArrayResult<R>>;
-                <R_1 extends pg.QueryResultRow = any, I_1 extends any[] = any[]>(queryConfig: pg.QueryConfig<I_1>): Promise<pg.QueryResult<R_1>>;
-                <R_2 extends pg.QueryResultRow = any, I_2 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_2>, values?: I_2 | undefined): Promise<pg.QueryResult<R_2>>;
-                <R_3 extends any[] = any[], I_3 extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I_3>, callback: (err: Error, result: pg.QueryArrayResult<R_3>) => void): void;
-                <R_4 extends pg.QueryResultRow = any, I_4 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_4>, callback: (err: Error, result: pg.QueryResult<R_4>) => void): void;
-                <R_5 extends pg.QueryResultRow = any, I_5 extends any[] = any[]>(queryText: string, values: I_5, callback: (err: Error, result: pg.QueryResult<R_5>) => void): void;
-            };
-        }) => Promise<T_2[]>;
-        get: <T_3>(text: string | SQLStatement, values?: (null | string | number | Date)[], options?: {
-            query: {
-                <T extends pg.Submittable>(queryStream: T): T;
-                <R extends any[] = any[], I extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I>, values?: I | undefined): Promise<pg.QueryArrayResult<R>>;
-                <R_1 extends pg.QueryResultRow = any, I_1 extends any[] = any[]>(queryConfig: pg.QueryConfig<I_1>): Promise<pg.QueryResult<R_1>>;
-                <R_2 extends pg.QueryResultRow = any, I_2 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_2>, values?: I_2 | undefined): Promise<pg.QueryResult<R_2>>;
-                <R_3 extends any[] = any[], I_3 extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I_3>, callback: (err: Error, result: pg.QueryArrayResult<R_3>) => void): void;
-                <R_4 extends pg.QueryResultRow = any, I_4 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_4>, callback: (err: Error, result: pg.QueryResult<R_4>) => void): void;
-                <R_5 extends pg.QueryResultRow = any, I_5 extends any[] = any[]>(queryText: string, values: I_5, callback: (err: Error, result: pg.QueryResult<R_5>) => void): void;
-            };
-        }) => Promise<T_3>;
-        insert: <T_1>(text: string | SQLStatement, values?: (null | string | number | Date)[], options?: {
-            query: {
-                <T extends pg.Submittable>(queryStream: T): T;
-                <R extends any[] = any[], I extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I>, values?: I | undefined): Promise<pg.QueryArrayResult<R>>;
-                <R_1 extends pg.QueryResultRow = any, I_1 extends any[] = any[]>(queryConfig: pg.QueryConfig<I_1>): Promise<pg.QueryResult<R_1>>;
-                <R_2 extends pg.QueryResultRow = any, I_2 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_2>, values?: I_2 | undefined): Promise<pg.QueryResult<R_2>>;
-                <R_3 extends any[] = any[], I_3 extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I_3>, callback: (err: Error, result: pg.QueryArrayResult<R_3>) => void): void;
-                <R_4 extends pg.QueryResultRow = any, I_4 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_4>, callback: (err: Error, result: pg.QueryResult<R_4>) => void): void;
-                <R_5 extends pg.QueryResultRow = any, I_5 extends any[] = any[]>(queryText: string, values: I_5, callback: (err: Error, result: pg.QueryResult<R_5>) => void): void;
-            };
-        }) => Promise<T_1 | null>;
-    }) => Promise<void>) => Promise<void>;
-    transaction: <T_4>(callback: (query: {
-        query: {
-            <T extends pg.Submittable>(queryStream: T): T;
-            <R extends any[] = any[], I extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I>, values?: I | undefined): Promise<pg.QueryArrayResult<R>>;
-            <R_1 extends pg.QueryResultRow = any, I_1 extends any[] = any[]>(queryConfig: pg.QueryConfig<I_1>): Promise<pg.QueryResult<R_1>>;
-            <R_2 extends pg.QueryResultRow = any, I_2 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_2>, values?: I_2 | undefined): Promise<pg.QueryResult<R_2>>;
-            <R_3 extends any[] = any[], I_3 extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I_3>, callback: (err: Error, result: pg.QueryArrayResult<R_3>) => void): void;
-            <R_4 extends pg.QueryResultRow = any, I_4 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_4>, callback: (err: Error, result: pg.QueryResult<R_4>) => void): void;
-            <R_5 extends pg.QueryResultRow = any, I_5 extends any[] = any[]>(queryText: string, values: I_5, callback: (err: Error, result: pg.QueryResult<R_5>) => void): void;
-        };
-        first: <T_1>(text: string | SQLStatement, values?: (null | string | number | Date)[], options?: {
-            query: {
-                <T extends pg.Submittable>(queryStream: T): T;
-                <R extends any[] = any[], I extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I>, values?: I | undefined): Promise<pg.QueryArrayResult<R>>;
-                <R_1 extends pg.QueryResultRow = any, I_1 extends any[] = any[]>(queryConfig: pg.QueryConfig<I_1>): Promise<pg.QueryResult<R_1>>;
-                <R_2 extends pg.QueryResultRow = any, I_2 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_2>, values?: I_2 | undefined): Promise<pg.QueryResult<R_2>>;
-                <R_3 extends any[] = any[], I_3 extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I_3>, callback: (err: Error, result: pg.QueryArrayResult<R_3>) => void): void;
-                <R_4 extends pg.QueryResultRow = any, I_4 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_4>, callback: (err: Error, result: pg.QueryResult<R_4>) => void): void;
-                <R_5 extends pg.QueryResultRow = any, I_5 extends any[] = any[]>(queryText: string, values: I_5, callback: (err: Error, result: pg.QueryResult<R_5>) => void): void;
-            };
-        }) => Promise<T_1 | null>;
-        all: <T_2>(text: string | SQLStatement, values?: (null | string | number | Date)[], options?: {
-            query: {
-                <T extends pg.Submittable>(queryStream: T): T;
-                <R extends any[] = any[], I extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I>, values?: I | undefined): Promise<pg.QueryArrayResult<R>>;
-                <R_1 extends pg.QueryResultRow = any, I_1 extends any[] = any[]>(queryConfig: pg.QueryConfig<I_1>): Promise<pg.QueryResult<R_1>>;
-                <R_2 extends pg.QueryResultRow = any, I_2 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_2>, values?: I_2 | undefined): Promise<pg.QueryResult<R_2>>;
-                <R_3 extends any[] = any[], I_3 extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I_3>, callback: (err: Error, result: pg.QueryArrayResult<R_3>) => void): void;
-                <R_4 extends pg.QueryResultRow = any, I_4 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_4>, callback: (err: Error, result: pg.QueryResult<R_4>) => void): void;
-                <R_5 extends pg.QueryResultRow = any, I_5 extends any[] = any[]>(queryText: string, values: I_5, callback: (err: Error, result: pg.QueryResult<R_5>) => void): void;
-            };
-        }) => Promise<T_2[]>;
-        get: <T_3>(text: string | SQLStatement, values?: (null | string | number | Date)[], options?: {
-            query: {
-                <T extends pg.Submittable>(queryStream: T): T;
-                <R extends any[] = any[], I extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I>, values?: I | undefined): Promise<pg.QueryArrayResult<R>>;
-                <R_1 extends pg.QueryResultRow = any, I_1 extends any[] = any[]>(queryConfig: pg.QueryConfig<I_1>): Promise<pg.QueryResult<R_1>>;
-                <R_2 extends pg.QueryResultRow = any, I_2 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_2>, values?: I_2 | undefined): Promise<pg.QueryResult<R_2>>;
-                <R_3 extends any[] = any[], I_3 extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I_3>, callback: (err: Error, result: pg.QueryArrayResult<R_3>) => void): void;
-                <R_4 extends pg.QueryResultRow = any, I_4 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_4>, callback: (err: Error, result: pg.QueryResult<R_4>) => void): void;
-                <R_5 extends pg.QueryResultRow = any, I_5 extends any[] = any[]>(queryText: string, values: I_5, callback: (err: Error, result: pg.QueryResult<R_5>) => void): void;
-            };
-        }) => Promise<T_3>;
-        insert: <T_1>(text: string | SQLStatement, values?: (null | string | number | Date)[], options?: {
-            query: {
-                <T extends pg.Submittable>(queryStream: T): T;
-                <R extends any[] = any[], I extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I>, values?: I | undefined): Promise<pg.QueryArrayResult<R>>;
-                <R_1 extends pg.QueryResultRow = any, I_1 extends any[] = any[]>(queryConfig: pg.QueryConfig<I_1>): Promise<pg.QueryResult<R_1>>;
-                <R_2 extends pg.QueryResultRow = any, I_2 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_2>, values?: I_2 | undefined): Promise<pg.QueryResult<R_2>>;
-                <R_3 extends any[] = any[], I_3 extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I_3>, callback: (err: Error, result: pg.QueryArrayResult<R_3>) => void): void;
-                <R_4 extends pg.QueryResultRow = any, I_4 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_4>, callback: (err: Error, result: pg.QueryResult<R_4>) => void): void;
-                <R_5 extends pg.QueryResultRow = any, I_5 extends any[] = any[]>(queryText: string, values: I_5, callback: (err: Error, result: pg.QueryResult<R_5>) => void): void;
-            };
-        }) => Promise<T_1 | null>;
-    }) => T_4 | Promise<T_4>) => Promise<T_4>;
+    insert: <T extends pg.QueryResultRow>(text: string | SQLStatement, values?: Value[] | undefined) => Promise<pg.QueryResult<T>>;
+    query: <T_1 extends pg.QueryResultRow>(text: string | SQLStatement, values?: Value[] | undefined) => Promise<pg.QueryResult<T_1>>;
+    first: <T_2>(text: string | SQLStatement, values?: Value[] | undefined) => Promise<T_2 | null>;
+    all: <T_3>(text: string | SQLStatement, values?: Value[] | undefined) => Promise<T_3[]>;
+    get: <T_4>(text: string | SQLStatement, values?: Value[] | undefined) => Promise<T_4>;
+    withConnection: <T_5>(callback: (connection: Connection) => Promise<T_5>) => Promise<T_5>;
+    transaction: <T_6>(callback: (connection: Transaction) => T_6 | Promise<T_6>) => Promise<T_6>;
     instance: pg.Pool;
     clear: (force?: boolean) => Promise<void>;
     end(): Promise<void>;
-    query: {
-        <T extends pg.Submittable>(queryStream: T): T;
-        <R extends any[] = any[], I extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I>, values?: I | undefined): Promise<pg.QueryArrayResult<R>>;
-        <R_1 extends pg.QueryResultRow = any, I_1 extends any[] = any[]>(queryConfig: pg.QueryConfig<I_1>): Promise<pg.QueryResult<R_1>>;
-        <R_2 extends pg.QueryResultRow = any, I_2 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_2>, values?: I_2 | undefined): Promise<pg.QueryResult<R_2>>;
-        <R_3 extends any[] = any[], I_3 extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I_3>, callback: (err: Error, result: pg.QueryArrayResult<R_3>) => void): void;
-        <R_4 extends pg.QueryResultRow = any, I_4 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_4>, callback: (err: Error, result: pg.QueryResult<R_4>) => void): void;
-        <R_5 extends pg.QueryResultRow = any, I_5 extends any[] = any[]>(queryText: string, values: I_5, callback: (err: Error, result: pg.QueryResult<R_5>) => void): void;
-    };
-    first: <T_1>(text: string | SQLStatement, values?: (null | string | number | Date)[], options?: {
-        query: {
-            <T extends pg.Submittable>(queryStream: T): T;
-            <R extends any[] = any[], I extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I>, values?: I | undefined): Promise<pg.QueryArrayResult<R>>;
-            <R_1 extends pg.QueryResultRow = any, I_1 extends any[] = any[]>(queryConfig: pg.QueryConfig<I_1>): Promise<pg.QueryResult<R_1>>;
-            <R_2 extends pg.QueryResultRow = any, I_2 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_2>, values?: I_2 | undefined): Promise<pg.QueryResult<R_2>>;
-            <R_3 extends any[] = any[], I_3 extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I_3>, callback: (err: Error, result: pg.QueryArrayResult<R_3>) => void): void;
-            <R_4 extends pg.QueryResultRow = any, I_4 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_4>, callback: (err: Error, result: pg.QueryResult<R_4>) => void): void;
-            <R_5 extends pg.QueryResultRow = any, I_5 extends any[] = any[]>(queryText: string, values: I_5, callback: (err: Error, result: pg.QueryResult<R_5>) => void): void;
-        };
-    }) => Promise<T_1 | null>;
-    all: <T_2>(text: string | SQLStatement, values?: (null | string | number | Date)[], options?: {
-        query: {
-            <T extends pg.Submittable>(queryStream: T): T;
-            <R extends any[] = any[], I extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I>, values?: I | undefined): Promise<pg.QueryArrayResult<R>>;
-            <R_1 extends pg.QueryResultRow = any, I_1 extends any[] = any[]>(queryConfig: pg.QueryConfig<I_1>): Promise<pg.QueryResult<R_1>>;
-            <R_2 extends pg.QueryResultRow = any, I_2 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_2>, values?: I_2 | undefined): Promise<pg.QueryResult<R_2>>;
-            <R_3 extends any[] = any[], I_3 extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I_3>, callback: (err: Error, result: pg.QueryArrayResult<R_3>) => void): void;
-            <R_4 extends pg.QueryResultRow = any, I_4 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_4>, callback: (err: Error, result: pg.QueryResult<R_4>) => void): void;
-            <R_5 extends pg.QueryResultRow = any, I_5 extends any[] = any[]>(queryText: string, values: I_5, callback: (err: Error, result: pg.QueryResult<R_5>) => void): void;
-        };
-    }) => Promise<T_2[]>;
-    get: <T_3>(text: string | SQLStatement, values?: (null | string | number | Date)[], options?: {
-        query: {
-            <T extends pg.Submittable>(queryStream: T): T;
-            <R extends any[] = any[], I extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I>, values?: I | undefined): Promise<pg.QueryArrayResult<R>>;
-            <R_1 extends pg.QueryResultRow = any, I_1 extends any[] = any[]>(queryConfig: pg.QueryConfig<I_1>): Promise<pg.QueryResult<R_1>>;
-            <R_2 extends pg.QueryResultRow = any, I_2 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_2>, values?: I_2 | undefined): Promise<pg.QueryResult<R_2>>;
-            <R_3 extends any[] = any[], I_3 extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I_3>, callback: (err: Error, result: pg.QueryArrayResult<R_3>) => void): void;
-            <R_4 extends pg.QueryResultRow = any, I_4 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_4>, callback: (err: Error, result: pg.QueryResult<R_4>) => void): void;
-            <R_5 extends pg.QueryResultRow = any, I_5 extends any[] = any[]>(queryText: string, values: I_5, callback: (err: Error, result: pg.QueryResult<R_5>) => void): void;
-        };
-    }) => Promise<T_3>;
-    insert: <T_1>(text: string | SQLStatement, values?: (null | string | number | Date)[], options?: {
-        query: {
-            <T extends pg.Submittable>(queryStream: T): T;
-            <R extends any[] = any[], I extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I>, values?: I | undefined): Promise<pg.QueryArrayResult<R>>;
-            <R_1 extends pg.QueryResultRow = any, I_1 extends any[] = any[]>(queryConfig: pg.QueryConfig<I_1>): Promise<pg.QueryResult<R_1>>;
-            <R_2 extends pg.QueryResultRow = any, I_2 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_2>, values?: I_2 | undefined): Promise<pg.QueryResult<R_2>>;
-            <R_3 extends any[] = any[], I_3 extends any[] = any[]>(queryConfig: pg.QueryArrayConfig<I_3>, callback: (err: Error, result: pg.QueryArrayResult<R_3>) => void): void;
-            <R_4 extends pg.QueryResultRow = any, I_4 extends any[] = any[]>(queryTextOrConfig: string | pg.QueryConfig<I_4>, callback: (err: Error, result: pg.QueryResult<R_4>) => void): void;
-            <R_5 extends pg.QueryResultRow = any, I_5 extends any[] = any[]>(queryText: string, values: I_5, callback: (err: Error, result: pg.QueryResult<R_5>) => void): void;
-        };
-    }) => Promise<T_1 | null>;
 };
 export declare const sql: typeof SQL;
+export {};

package/dist/postgres.js

@@ -12,6 +12,40 @@ export class MultipleRowsReturnedError extends Error {
         this.name = 'MultipleRowsReturnedError';
     }
 }
+export class Connection {
+    constructor(client) {
+        this.client = client;
+    }
+    async query(text, values) {
+        return this.client.query(text, values);
+    }
+    async all(text, values) {
+        const result = await this.client.query(text, values);
+        if (result.rows) {
+            return result.rows;
+        }
+        return [];
+    }
+    async insert(text, values) {
+        return await this.client.query(text, values);
+    }
+    async first(text, values) {
+        const result = await this.client.query(text, values);
+        return result.rows && result.rows.length ? result.rows[0] : null;
+    }
+    async get(text, values) {
+        const result = await this.client.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 {
+}
 /**
  * Create a new Postgres connection pool with
  * conveience methods for executing queries using
@@ -22,50 +56,25 @@ export class MultipleRowsReturnedError extends Error {
 export function createPostgres({ onError = () => { }, ...config } = {}) {
     const pool = new pg.Pool(config);
     pool.on('error', onError);
-    const defaultQuery = pool.query.bind(pool);
     async function withConnection(callback) {
         const client = await pool.connect();
         try {
-            const result = await callback(makeQueryFunctions(client.query.bind(client)));
+            const result = await callback(new Connection(client));
             return result;
         }
         finally {
             client.release();
         }
     }
-    function makeQueryFunctions(defaultQuery) {
-        async function all(text, values, options = { query: defaultQuery }) {
-            const result = await options.query(text, values);
-            if (result.rows) {
-                return result.rows;
-            }
-            return [];
-        }
-        async function first(text, values, options = { query: defaultQuery }) {
-            const result = await options.query(text, values);
-            return result.rows && result.rows.length ? result.rows[0] : null;
-        }
-        async function get(text, values, options = { query: defaultQuery }) {
-            const result = await options.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];
-        }
-        return { query: defaultQuery, first, all, get, insert: first };
-    }
     /**
      * Wipe the database schema
      */
     async function clear(force = false) {
         if (!force)
             return;
-        return withConnection(async ({ query }) => {
-            await query('DROP SCHEMA public CASCADE');
-            await query(`CREATE SCHEMA public`);
+        return withConnection(async (connection) => {
+            await connection.query('DROP SCHEMA public CASCADE');
+            await connection.query(`CREATE SCHEMA public`);
         });
     }
     /**
@@ -75,7 +84,7 @@ export function createPostgres({ onError = () => { }, ...config } = {}) {
         const client = await pool.connect();
         try {
             await client.query('BEGIN');
-            const result = await callback(makeQueryFunctions(client.query.bind(client)));
+            const result = await callback(new Transaction(client));
             await client.query('COMMIT');
             return result;
         }
@@ -87,8 +96,37 @@ export function createPostgres({ onError = () => { }, ...config } = {}) {
             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);
+        });
+    };
     return {
-        ...makeQueryFunctions(defaultQuery),
+        insert,
+        query,
+        first,
+        all,
+        get,
         withConnection,
         transaction,
         instance: pool,

package/dist/redis.d.ts

@@ -1,4 +1,4 @@
-export declare type RedisClient = ReturnType<typeof createRedis>;
+export type RedisClient = ReturnType<typeof createRedis>;
 export interface RedisOptions {
     url?: string;
     onError: (error: Error) => void;
@@ -181,6 +181,8 @@ export declare function createRedis({ url, onError, }: RedisOptions): import("@r
     bf: {
         ADD: typeof import("@redis/bloom/dist/commands/bloom/ADD.js");
         add: typeof import("@redis/bloom/dist/commands/bloom/ADD.js");
+        CARD: typeof import("@redis/bloom/dist/commands/bloom/CARD.js");
+        card: typeof import("@redis/bloom/dist/commands/bloom/CARD.js");
         EXISTS: typeof import("@redis/bloom/dist/commands/bloom/EXISTS.js");
         exists: typeof import("@redis/bloom/dist/commands/bloom/EXISTS.js");
         INFO: typeof import("@redis/bloom/dist/commands/bloom/INFO.js");

package/dist/sentry.d.ts

@@ -3,7 +3,7 @@ import { type Application } from 'express';
 export type { Sentry };
 export interface SentryOptions extends Sentry.NodeOptions {
 }
-export declare type CreateSentry = ReturnType<typeof createSentry>;
+export type CreateSentry = ReturnType<typeof createSentry>;
 /**
  * Create a pre-configured Sentry client
  */
@@ -22,9 +22,9 @@ export declare function createSentryOptions(app: Application | null, options?: S
     release?: string | undefined;
     environment?: string | undefined;
     debug?: boolean | undefined;
-    dsn: string | undefined;
     instrumenter?: import("@sentry/types").Instrumenter | undefined;
     sampleRate?: number | undefined;
+    dsn: string | undefined;
     enabled?: boolean | undefined;
     attachStacktrace?: boolean | undefined;
     autoSessionTracking?: boolean | undefined;
@@ -32,6 +32,7 @@ export declare function createSentryOptions(app: Application | null, options?: S
     dist?: string | undefined;
     transportOptions?: Partial<import("@sentry/node/types/transports/http.js").NodeTransportOptions> | undefined;
     tracesSampleRate: number;
+    enableTracing?: boolean | undefined;
     initialScope?: import("@sentry/types").CaptureContext | undefined;
     maxBreadcrumbs?: number | undefined;
     maxValueLength?: number | undefined;
@@ -39,18 +40,24 @@ export declare function createSentryOptions(app: Application | null, options?: S
     normalizeMaxBreadth?: number | undefined;
     shutdownTimeout?: number | undefined;
     ignoreErrors?: (string | RegExp)[] | undefined;
+    ignoreTransactions?: (string | RegExp)[] | undefined;
     tunnel?: string | undefined;
     sendDefaultPii?: boolean | undefined;
     _metadata?: import("@sentry/types").SdkMetadata | undefined;
     _experiments?: {
         [key: string]: any;
     } | undefined;
+    allowUrls?: (string | RegExp)[] | undefined;
+    denyUrls?: (string | RegExp)[] | undefined;
     tracesSampler?: ((samplingContext: import("@sentry/types").SamplingContext) => number | boolean) | undefined;
-    beforeSend?: ((event: Sentry.Event, hint: Sentry.EventHint) => Sentry.Event | PromiseLike<Sentry.Event | null> | null) | undefined;
-    beforeSendTransaction?: ((event: Sentry.Event, hint: Sentry.EventHint) => Sentry.Event | PromiseLike<Sentry.Event | null> | null) | undefined;
+    beforeSend?: ((event: import("@sentry/types").ErrorEvent, hint: Sentry.EventHint) => Sentry.Event | PromiseLike<Sentry.Event | null> | null) | undefined;
+    beforeSendTransaction?: ((event: import("@sentry/types").TransactionEvent, hint: Sentry.EventHint) => Sentry.Event | PromiseLike<Sentry.Event | null> | null) | undefined;
     beforeBreadcrumb?: ((breadcrumb: Sentry.Breadcrumb, hint?: Sentry.BreadcrumbHint | undefined) => Sentry.Breadcrumb | null) | undefined;
+    profilesSampleRate?: number | undefined;
+    profilesSampler?: ((samplingContext: import("@sentry/types").SamplingContext) => number | boolean) | undefined;
     serverName?: string | undefined;
+    includeLocalVariables?: boolean | undefined;
     tracePropagationTargets?: import("@sentry/types").TracePropagationTargets | undefined;
-    shouldCreateSpanForRequest?(url: string): boolean;
-    onFatalError?(error: Error): void;
+    shouldCreateSpanForRequest?(this: void, url: string): boolean;
+    onFatalError?(this: void, error: Error): void;
 };

package/dist/slack.d.ts

@@ -2,8 +2,8 @@ export interface SlackOptions {
     webhookUrl?: string;
     dryRun?: boolean;
 }
-declare type Message = string;
-declare type Blocks = unknown[];
+type Message = string;
+type Blocks = unknown[];
 /**
  * Send messages to Slack using Incoming Webhooks
  *

package/dist/validate.d.ts

@@ -1,6 +1,6 @@
 import { type Options } from 'ajv';
 import { type RequestHandler } from 'express';
-export declare type ValidationSchema = {
+export type ValidationSchema = {
     type?: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object' | 'null';
     format?: string;
     minimum?: number;
@@ -30,7 +30,7 @@ export declare type ValidationSchema = {
 export declare function validateBody(schema: ValidationSchema): RequestHandler;
 export declare function validateQuery(schema: ValidationSchema): RequestHandler;
 export declare function validateParams(schema: ValidationSchema): RequestHandler;
-export declare type ValidationResult = {
+export type ValidationResult = {
     isValid: true;
     errors: null;
 } | {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devmoods/express-extras",
-  "version": "0.15.3",
+  "version": "0.17.0",
   "description": "Kubernetes-ready utilities for rapid Node.js application development",
   "type": "module",
   "main": "./dist/index.js",
@@ -12,7 +12,7 @@
     "start": "ts-node --esm example/index.ts",
     "clean": "rm -rf dist",
     "lint": "eslint src",
-    "test": "NODE_ENV=test jest",
+    "test": "NODE_ENV=test vitest",
     "build": "npm run clean && tsc --project tsconfig.build.json",
     "prepublishOnly": "npm run clean && npm run build",
     "prettier": "prettier --write '**/*.{js,css,md,ts,tsx}'",
@@ -34,42 +34,41 @@
   ],
   "license": "ISC",
   "devDependencies": {
-    "@devmoods/eslint-config": "^1.0.0",
-    "@types/jest": "29.2.2",
-    "@types/node": "18.11.9",
+    "@devmoods/eslint-config": "^1.1.0",
+    "@types/node": "20.2.5",
     "@types/supertest": "2.0.12",
-    "@typescript-eslint/eslint-plugin": "^5.42.1",
-    "@typescript-eslint/parser": "^5.42.1",
-    "eslint": "^8.27.0",
-    "eslint-plugin-jsx-a11y": "^6.6.1",
+    "@typescript-eslint/eslint-plugin": "^5.59.7",
+    "@typescript-eslint/parser": "^5.59.7",
+    "chalk": "^5.2.0",
+    "eslint": "^8.41.0",
+    "eslint-plugin-jsx-a11y": "^6.7.1",
     "eslint-plugin-prettier": "^4.2.1",
-    "eslint-plugin-react": "^7.31.10",
+    "eslint-plugin-react": "^7.32.2",
     "eslint-plugin-react-hooks": "^4.6.0",
     "import-sort-cli": "6.0.0",
     "import-sort-style-module": "6.0.0",
     "isomorphic-fetch": "3.0.0",
-    "jest": "29.3.1",
-    "prettier": "2.7.1",
-    "supertest": "6.3.1",
-    "ts-jest": "29.0.3",
+    "prettier": "2.8.8",
+    "supertest": "6.3.3",
     "ts-node": "10.9.1",
-    "typescript": "4.8.4"
+    "typescript": "5.0.4",
+    "vitest": "^0.31.1"
   },
   "dependencies": {
     "@devmoods/fetch": "^3.3.0",
-    "@godaddy/terminus": "^4.11.2",
-    "@sentry/node": "^7.19.0",
-    "@sentry/tracing": "^7.19.0",
+    "@godaddy/terminus": "^4.12.0",
+    "@sentry/node": "^7.53.1",
+    "@sentry/tracing": "^7.53.1",
     "@types/bcrypt": "^5.0.0",
     "@types/bunyan": "^1.8.8",
     "@types/cls-hooked": "^4.3.3",
     "@types/cookie-parser": "^1.4.3",
-    "@types/express": "^4.17.14",
-    "@types/jsonwebtoken": "^8.5.9",
-    "@types/nodemailer": "^6.4.6",
-    "@types/pg": "^8.6.5",
-    "@types/uuid": "^8.3.4",
-    "ajv": "^8.11.0",
+    "@types/express": "^4.17.17",
+    "@types/jsonwebtoken": "^9.0.2",
+    "@types/nodemailer": "^6.4.8",
+    "@types/pg": "^8.10.1",
+    "@types/uuid": "^9.0.1",
+    "ajv": "^8.12.0",
     "bcrypt": "^5.1.0",
     "bunyan": "^1.8.15",
     "cls-hooked": "^4.2.2",
@@ -77,12 +76,12 @@
     "cookie-parser": "^1.4.6",
     "dotenv": "^16.0.3",
     "express": "^4.18.2",
-    "helmet": "^6.0.0",
-    "jsonwebtoken": "^8.5.1",
-    "meow": "^11.0.0",
-    "nodemailer": "^6.8.0",
-    "pg": "^8.8.0",
-    "redis": "^4.5.0",
+    "helmet": "^7.0.0",
+    "jsonwebtoken": "^9.0.0",
+    "meow": "^12.0.1",
+    "nodemailer": "^6.9.3",
+    "pg": "^8.11.0",
+    "redis": "^4.6.6",
     "sql-template-strings": "^2.2.2",
     "uuid": "^9.0.0"
   },

package/dist/__tests__/auth.spec.d.ts

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

package/dist/__tests__/auth.spec.jsx

@@ -1,8 +0,0 @@
-import { createAuthToken } from '../auth.js';
-test('createAuthToken', async () => {
-    process.env.APP_JWT_SECRET = 'test';
-    const first = createAuthToken({});
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-    const second = createAuthToken({});
-    expect(first).not.toEqual(second);
-});