@devmoods/express-extras 0.31.0 → 0.33.0

package/dist/cache.d.ts

@@ -12,6 +12,6 @@ export declare function createMemoryCacheAdapter(): CacheAdapter;
 export declare function createCache(adapter: CacheAdapter): {
     set: (key: string, value: any, expires?: number | null | undefined) => Promise<void>;
     get: (key: string) => Promise<any>;
-    clear: (key?: string | undefined) => Promise<void>;
+    clear: (key?: string) => Promise<void>;
     wrap: <T>(key: string, expiresMs: number | null | undefined, fn: () => Promise<T>) => Promise<T>;
 };

package/dist/cache.js

@@ -18,8 +18,8 @@ export function createRedisCacheAdapter(redis, options = {}) {
                 await redis.del(createKey(key));
             }
             const keys = await redis.keys(`${keyPrefix}*`);
-            for (const key of keys) {
-                await redis.del(key);
+            for (const existingKey of keys) {
+                await redis.del(existingKey);
             }
         },
     };

package/dist/cli.d.ts

@@ -0,0 +1,13 @@
+import { type WriteStream } from 'node:tty';
+export interface CLIOptions {
+    printStackTraces?: boolean;
+}
+export declare class CLI {
+    private options;
+    constructor(options?: CLIOptions);
+    writeLine(message: string, output?: WriteStream): void;
+    greenLine(message: string, output?: WriteStream): void;
+    redLine(message: string, output?: WriteStream): void;
+    readInput(question: string): Promise<string>;
+    wrap(action: (...args: any[]) => void | Promise<void>): (...args: any[]) => Promise<void>;
+}

package/dist/cli.js

@@ -0,0 +1,45 @@
+import { stdin, stdout, stderr } from 'node:process';
+import * as readline from 'node:readline';
+import {} from 'node:tty';
+import chalk from 'chalk';
+import { startTimer } from './utils.js';
+export class CLI {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    writeLine(message, output = stdout) {
+        output.write(`${message}`);
+    }
+    greenLine(message, output = stdout) {
+        output.write(`${chalk.green(message)}\n`);
+    }
+    redLine(message, output = stderr) {
+        output.write(`${chalk.red(message)}\n`);
+    }
+    /* v8 ignore next 10 */
+    readInput(question) {
+        const rl = readline.createInterface({ input: stdin, output: stderr });
+        return new Promise((resolve) => {
+            rl.question(question, (answer) => {
+                resolve(answer);
+                rl.close();
+            });
+        });
+    }
+    wrap(action) {
+        return async (...args) => {
+            const timer = startTimer();
+            try {
+                await action(...args);
+                this.greenLine(`Command succeeded in ${timer.getDuration().toFixed(4)}s`);
+            }
+            catch (error) {
+                this.redLine(error.message);
+                if (this.options.printStackTraces) {
+                    this.writeLine('\nStack trace:\n', stderr);
+                    this.redLine(error.stack);
+                }
+            }
+        };
+    }
+}

package/dist/email.d.ts

@@ -12,6 +12,6 @@ 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>;
+    transporter: nodemailer.Transporter<import("nodemailer/lib/smtp-transport/index.js").SentMessageInfo, import("nodemailer/lib/smtp-transport/index.js").Options>;
     readonly outbox: Record<string, any>[];
 };

package/dist/errors.js

@@ -64,7 +64,7 @@ function _errorHandler({ onError }) {
  */
 export function errorHandler({ onError }) {
     return errors([
-        Sentry.Handlers.errorHandler({
+        Sentry.expressErrorHandler({
             shouldHandleError(error) {
                 if (error instanceof ApiError && error.status < 500) {
                     return false;

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from './auth.js';
 export * from './cache.js';
+export * from './cli.js';
 export * from './context.js';
 export * from './email.js';
 export * from './errors.js';

package/dist/index.js

@@ -1,5 +1,7 @@
+/* v8 ignore next 100 */
 export * from './auth.js';
 export * from './cache.js';
+export * from './cli.js';
 export * from './context.js';
 export * from './email.js';
 export * from './errors.js';

package/dist/listen.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import { type Server } from 'node:http';
 import { type Application } from 'express';
 interface StoppableServer extends Server {

package/dist/listen.js

@@ -104,7 +104,7 @@ export function createExpressServer(app, options = {}) {
             const meta = await options.healthCheck?.();
             return { status: 'ok', meta, timestamp };
         }
-        catch (error) {
+        catch {
             return [503, { status: 'error', timestamp }];
         }
     }));

package/dist/logger.d.ts

@@ -1,7 +1,7 @@
-/// <reference types="node" resolution-mode="require"/>
-import { type Duplex } from 'node:stream';
-import { type CreateSentry } from './sentry.js';
 export type LoggerContext = Record<string, any>;
+export interface LoggerOutputWriter {
+    write(chunk: any): boolean;
+}
 export interface LoggerOptions {
     /**
      * Name of the logger
@@ -12,9 +12,8 @@ export interface LoggerOptions {
      */
     getContext?: () => LoggerContext;
     level?: string;
-    output?: Duplex;
+    output?: LoggerOutputWriter;
 }
-export declare function attachSentryClientToLoggers(sentryClient: CreateSentry['client']): void;
 export declare function setGlobalLoggerContext(getContext: () => LoggerContext): void;
 export type Logger = ReturnType<typeof createLogger>;
 export declare function createLogger({ name, getContext, level, output, }: LoggerOptions): {
@@ -29,6 +28,6 @@ export declare function getLoggers(): Map<string, {
     debug(message: string, context?: LoggerContext): void;
     info(message: string, context?: LoggerContext): void;
     warn(message: string, context?: LoggerContext): void;
-    error(error: Error | null, message?: string | undefined, context?: LoggerContext): void;
-    fatal(error: Error | null, message?: string | undefined, context?: LoggerContext): void;
+    error(error: Error | null, message?: string, context?: LoggerContext): void;
+    fatal(error: Error | null, message?: string, context?: LoggerContext): void;
 }>;

package/dist/logger.js

@@ -1,7 +1,6 @@
 import * as os from 'node:os';
-import {} from 'node:stream';
+import * as Sentry from '@sentry/node';
 import { useRequestId } from './context.js';
-import {} from './sentry.js';
 import { readEnv } from './utils.js';
 const LEVELS = {
     TRACE: 10,
@@ -13,16 +12,14 @@ const LEVELS = {
 };
 const LEVELS_TO_NAME = Object.fromEntries(Object.entries(LEVELS).map(([name, level]) => [level, name.toLowerCase()]));
 const _loggers = new Map();
-let _sentryClient;
-export function attachSentryClientToLoggers(sentryClient) {
-    _sentryClient = sentryClient;
-}
 let _globalGetContext;
 export function setGlobalLoggerContext(getContext) {
     _globalGetContext = getContext;
 }
 function defaultGetContext() {
+    const nameArgIndex = process.argv.indexOf('--name');
     return {
+        app: nameArgIndex > -1 ? process.argv.at(nameArgIndex + 1) : undefined,
         requestId: useRequestId(),
         ..._globalGetContext?.(),
     };
@@ -45,6 +42,7 @@ export function createLogger({ name, getContext, level = readEnv('LOG_LEVEL', 'I
             ...context,
         };
     }
+    // eslint-disable-next-line @typescript-eslint/no-shadow
     function log(level, message, context) {
         const payload = JSON.stringify({
             level: LEVELS_TO_NAME[level],
@@ -73,8 +71,8 @@ export function createLogger({ name, getContext, level = readEnv('LOG_LEVEL', 'I
         },
         error(error, message, context = {}) {
             const finalContext = getFinalContext(context);
-            if (_sentryClient != null) {
-                _sentryClient.captureException(error, {
+            if (Sentry.isInitialized()) {
+                Sentry.captureException(error, {
                     tags: finalContext,
                 });
             }
@@ -85,8 +83,8 @@ export function createLogger({ name, getContext, level = readEnv('LOG_LEVEL', 'I
         },
         fatal(error, message, context = {}) {
             const finalContext = getFinalContext(context);
-            if (_sentryClient != null) {
-                _sentryClient.captureException(error, {
+            if (Sentry.isInitialized()) {
+                Sentry.captureException(error, {
                     tags: finalContext,
                 });
             }

package/dist/manage.d.ts

@@ -1,5 +1,8 @@
 import { program } from 'commander';
+import { type Express } from 'express';
+import { CLI } from './cli.js';
 type Command = typeof program.command;
-export declare function registerManagementCommand(register: (command: Command) => void): void;
+export declare function registerManagementCommand(register: (command: Command, cli: CLI) => void): void;
 export declare function runManagementCommands(): Promise<void>;
+export declare function registerDefaultCommands(app: Express | null): void;
 export {};

package/dist/manage.js

@@ -1,7 +1,35 @@
 import { program } from 'commander';
+import {} from 'express';
+import { parseExpressApp } from 'express-route-parser';
+import { hashPassword } from './auth.js';
+import { CLI } from './cli.js';
+import { asCli } from './migrate.js';
+program.option('--verbose', 'Verbose mode');
 export function registerManagementCommand(register) {
-    register(program.command.bind(program));
+    const cli = new CLI({ printStackTraces: process.argv.includes('--verbose') });
+    register(program.command.bind(program), cli);
 }
 export async function runManagementCommands() {
     await program.parseAsync(process.argv);
 }
+export function registerDefaultCommands(app) {
+    registerManagementCommand((command, cli) => {
+        const migrate = command('migrate');
+        asCli(migrate, cli);
+    });
+    registerManagementCommand((command, cli) => command('routes').action(cli.wrap(async () => {
+        if (!app)
+            return;
+        const routes = parseExpressApp(app);
+        for (const route of routes) {
+            cli.writeLine(`${route.method.toLocaleUpperCase().padEnd(5)} ${route.path}\n`);
+        }
+    })));
+    registerManagementCommand((command, cli) => {
+        command('password-hash').action(cli.wrap(async () => {
+            const password = await cli.readInput('Type a password: ');
+            const hash = await hashPassword(password);
+            cli.writeLine(`${hash}\n`);
+        }));
+    });
+}

package/dist/middleware.d.ts

@@ -1,5 +1,5 @@
 import bodyParser from 'body-parser';
-import { type RequestHandler } from 'express';
+import { type NextFunction, type RequestHandler, type Request, type Response } from 'express';
 type UrlencodedParser = typeof bodyParser.urlencoded;
 type JsonParser = typeof bodyParser.json;
 export declare const urlencodedParser: UrlencodedParser;
@@ -36,4 +36,4 @@ export declare function after(): RequestHandler;
 /**
  * Alias of `route()`
  */
-export declare function asyncMiddleware<RequestBody, RequestQuery = object>(fn: RequestHandler<Record<string, string>, any, RequestBody, RequestQuery>): RequestHandler<Record<string, string>, any, RequestBody, RequestQuery>;
+export declare function asyncMiddleware<RequestBody, RequestQuery = object, ResponseBody = any>(fn: (req: Request<Record<string, string>, ResponseBody, RequestBody, RequestQuery, object>, res: Response<ResponseBody, object>, next: NextFunction) => ResponseBody | Promise<ResponseBody>): RequestHandler<Record<string, string>, any, RequestBody, RequestQuery>;

package/dist/middleware.js

@@ -1,4 +1,3 @@
-import * as Sentry from '@sentry/node';
 import bodyParser from 'body-parser';
 import { compose } from 'compose-middleware';
 import cookieParser from 'cookie-parser';
@@ -19,8 +18,6 @@ export function before({ cookies = false, helmet: useHelmet = true, json: useJso
     return compose([
         withRequestContext(),
         logRequestDuration(),
-        Sentry.Handlers.requestHandler(),
-        Sentry.Handlers.tracingHandler(),
         useHelmet &&
             helmet({
                 contentSecurityPolicy: {
@@ -97,7 +94,8 @@ function analyticsProxy() {
     return (req, res, next) => {
         if (req.originalUrl === '/analytics.js') {
             res.setHeader('Content-type', 'text/javascript');
-            return res.status(200).end('// no-op analytics proxy');
+            res.status(200).end('// no-op analytics proxy');
+            return;
         }
         next();
     };

package/dist/migrate.d.ts

@@ -1,3 +1,5 @@
+import { type Command } from 'commander';
+import { type CLI } from './cli.js';
 import { type Connection, createPostgres } from './postgres.js';
 interface Migration {
     name: string;
@@ -9,8 +11,7 @@ interface MigrationFileAPI {
     up(fn: any): Promise<void> | Promise<void> | string | undefined;
     down(fn: any): Promise<string> | Promise<void> | string | undefined;
 }
-export declare function cli(): Promise<void>;
-export declare function runCli(input: string[], flags: Record<string, any>, showHelp?: () => void): Promise<number>;
+export declare const asCli: (command: Command, cli: CLI) => void;
 export interface MigratorOptions {
     postgres?: ReturnType<typeof createPostgres>;
     migrationTableName?: string;
@@ -24,6 +25,7 @@ export declare class Migrator {
     private filenameRegExp;
     private verbose;
     constructor({ postgres, pathToMigrations, migrationTableName, verbose, }?: MigratorOptions);
+    end(): Promise<void>;
     init(): Promise<boolean>;
     isInstalled(): Promise<boolean>;
     create(name: string | null | undefined, format?: 'ts' | 'sql'): Promise<string>;

package/dist/migrate.js

@@ -1,85 +1,58 @@
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
 import chalk from 'chalk';
-import meow from 'meow';
+import {} from 'commander';
+import {} from './cli.js';
 import { createPostgres } from './postgres.js';
-export async function cli() {
-    const cli = meow(`
-Usage
-  $ migrate init
-  $ migrate up
-  $ migrate down
-  $ migrate create <name> [--typescript]
-`, {
-        description: 'PostgreSQL migration tool',
-        importMeta: import.meta,
-    });
-    let exitCode = 0;
-    try {
-        exitCode = await runCli(cli.input, cli.flags, 
-        /* c8 ignore next 2 */
-        () => cli.showHelp());
-    }
-    catch (error) {
-        if (error instanceof CliError) {
-            exitCode = error.code;
+export const asCli = (command, cli) => {
+    command.command('up').action(cli.wrap(async () => {
+        const migrator = new Migrator();
+        try {
+            await migrator.runMigrations('up');
         }
-    }
-    finally {
-        process.exit(exitCode);
-    }
-}
-class CliError extends Error {
-    constructor(message, code) {
-        super(message);
-        this.code = code;
-        this.code = code;
-    }
-}
-export async function runCli(input, flags, showHelp) {
-    const verbose = !flags.silent;
-    const args = input.slice();
-    const action = args.shift();
-    function isValidAction(action) {
-        return action != null && ['init', 'up', 'down', 'create'].includes(action);
-    }
-    const migrator = new Migrator({ verbose });
-    async function run(action, ...args) {
+        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 {
-            if (!isValidAction(action)) {
-                showHelp?.();
-                throw new CliError(`Invalid action ${action}`, 2);
+            const created = await migrator.init();
+            if (created) {
+                cli.greenLine('Migrations table was successfully setup.');
             }
-            switch (action) {
-                case 'up':
-                case 'down':
-                    await migrator.runMigrations(action);
-                    break;
-                case 'init': {
-                    const created = await migrator.init();
-                    if (created) {
-                        migrator.log(chalk.green('Migrations table was successfully setup.'));
-                    }
-                    else {
-                        migrator.log(chalk.green('Migrations table already existing.'));
-                    }
-                    break;
-                }
-                case 'create': {
-                    const createdMigration = await migrator.create(args[0], flags.typescript ? 'ts' : 'sql');
-                    migrator.log(chalk.green('Created migration', createdMigration));
-                    break;
-                }
+            else {
+                cli.greenLine('Migrations table already existing.');
             }
-            return 0;
         }
-        catch (error) {
-            console.error(chalk.red(error.message));
-            throw new CliError(error.message, 1);
+        finally {
+            await migrator.end();
         }
-    }
-    return run(action, ...args);
-}
+    }));
+    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 {
     constructor({ postgres = createPostgres(), pathToMigrations = path.resolve(process.cwd(), 'db', 'migrations'), migrationTableName = 'migrations', verbose = true, } = {}) {
         this.filenameRegExp = /(\d+)_(.*)\.(js|ts|mjs|mts|sql)/;
@@ -88,6 +61,9 @@ export class Migrator {
         this.migrationTableName = migrationTableName;
         this.verbose = verbose;
     }
+    end() {
+        return this.postgres.end();
+    }
     async init() {
         if (await this.isInstalled()) {
             return false;
@@ -108,7 +84,7 @@ export class Migrator {
             await fs.stat(this.pathToMigrations);
             return true;
         }
-        catch (error) {
+        catch {
             return false;
         }
     }
@@ -116,6 +92,9 @@ export class Migrator {
         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

package/dist/postgres.d.ts

@@ -33,13 +33,13 @@ export declare class Transaction extends Connection {
  * @param config
  */
 export declare function createPostgres({ onError, url, ...config }?: PostgresOptions): {
-    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>;
+    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>(text: string | SQLStatement, values?: Value[]) => Promise<T | null>;
+    all: <T>(text: string | SQLStatement, values?: Value[]) => Promise<T[]>;
+    get: <T>(text: string | SQLStatement, values?: Value[]) => Promise<T>;
+    withConnection: <T>(callback: (connection: Connection) => Promise<T>) => Promise<T>;
+    transaction: <T>(callback: (connection: Transaction) => Promise<T> | T) => Promise<T>;
     instance: pg.Pool;
     clear: (force?: boolean) => Promise<void>;
     end(): Promise<void>;

package/dist/postgres.js

@@ -71,9 +71,9 @@ export class Transaction extends Connection {
  */
 export function createPostgres({ onError, url = readEnv('POSTGRES_URL'), ...config } = {}) {
     const pool = new pg.Pool({ connectionString: url, ...config });
-    if (onError) {
-        pool.on('error', onError);
-    }
+    pool.on('error', (e, client) => {
+        onError?.(e, client);
+    });
     async function withConnection(callback) {
         const client = await pool.connect();
         try {

package/dist/routes.js

@@ -2,7 +2,7 @@ import {} from 'express';
 import { parseExpressApp } from 'express-route-parser';
 import { route } from './middleware.js';
 export function createDocsRouter(app, extras = {}) {
-    return route(() => {
+    return route(async () => {
         return {
             ...extras,
             routes: parseExpressApp(app),

package/dist/sentry.d.ts

@@ -1,65 +1,5 @@
-import * as Sentry from '@sentry/node';
-import { type Application } from 'express';
+import type * as Sentry from '@sentry/node';
 export type { Sentry };
 export interface SentryOptions extends Sentry.NodeOptions {
 }
-export type CreateSentry = ReturnType<typeof createSentry>;
-/**
- * Create a pre-configured Sentry client
- */
-export declare function createSentry(options?: SentryOptions): {
-    client: typeof Sentry;
-    init(app: Application | null, getOptions?: (defaultOptions: Sentry.NodeOptions) => Sentry.NodeOptions): void;
-};
-/**
- * Construct sensible Sentry default options for an Express-based app.
- */
-export declare function createSentryOptions(app: Application | null, options?: SentryOptions): {
-    defaultIntegrations?: false | import("@sentry/types").Integration[] | undefined;
-    integrations: import("@sentry/types").Integration[] | ((integrations: import("@sentry/types").Integration[]) => import("@sentry/types").Integration[]) | undefined;
-    transport?: ((transportOptions: import("@sentry/node/types/transports/http.js").NodeTransportOptions) => import("@sentry/types").Transport) | undefined;
-    stackParser?: import("@sentry/types").StackParser | import("@sentry/types").StackLineParser[] | undefined;
-    release?: string | undefined;
-    debug?: boolean | undefined;
-    enabled?: boolean | undefined;
-    attachStacktrace?: boolean | undefined;
-    autoSessionTracking?: boolean | undefined;
-    sendClientReports?: boolean | undefined;
-    dsn: string | undefined;
-    environment?: string | undefined;
-    dist?: string | undefined;
-    instrumenter?: import("@sentry/types").Instrumenter | 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;
-    sampleRate?: number | undefined;
-    maxValueLength?: number | undefined;
-    normalizeDepth?: number | undefined;
-    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;
-    tracePropagationTargets?: import("@sentry/types").TracePropagationTargets | undefined;
-    tracesSampler?: ((samplingContext: import("@sentry/types").SamplingContext) => number | boolean) | 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;
-    clientClass?: typeof Sentry.NodeClient | undefined;
-    spotlight?: string | boolean | undefined;
-    shouldCreateSpanForRequest?(this: void, url: string): boolean;
-    onFatalError?(this: void, error: Error): void;
-};
+export declare function sentryOptions(options?: SentryOptions): SentryOptions;

package/dist/sentry.js

@@ -1,31 +1,11 @@
-import * as Sentry from '@sentry/node';
-import {} from 'express';
-import { attachSentryClientToLoggers } from './logger.js';
+import { nodeProfilingIntegration } from '@sentry/profiling-node';
 import { readEnv } from './utils.js';
-/**
- * Create a pre-configured Sentry client
- */
-export function createSentry(options = {}) {
-    const client = Sentry;
-    return {
-        client,
-        init(app, getOptions = (defaultOptions) => defaultOptions) {
-            attachSentryClientToLoggers(client);
-            Sentry.init(getOptions(createSentryOptions(app, options)));
-        },
-    };
-}
-/**
- * Construct sensible Sentry default options for an Express-based app.
- */
-export function createSentryOptions(app, options = {}) {
+export function sentryOptions(options = {}) {
     return {
         dsn: readEnv('SENTRY_DSN'),
-        integrations: [
-            new Sentry.Integrations.Http({ tracing: true }),
-            app && new Sentry.Integrations.Express({ app }),
-        ].filter(Boolean),
         tracesSampleRate: 1.0,
+        profilesSampleRate: 1.0,
+        integrations: [nodeProfilingIntegration()],
         ...options,
     };
 }

package/dist/utils.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import { type EventEmitter } from 'node:events';
 /**
  * Start a high resolution timer

package/package.json

@@ -1,13 +1,10 @@
 {
   "name": "@devmoods/express-extras",
-  "version": "0.31.0",
+  "version": "0.33.0",
   "description": "Kubernetes-ready utilities for rapid Node.js application development",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "bin": {
-    "migrate": "bin/migrate"
-  },
   "author": {
     "name": "hanse",
     "email": "hanse@koren.im"
@@ -17,77 +14,65 @@
     "url": "https://github.com/devmoods/express-extras.git"
   },
   "files": [
-    "bin",
-    "dist",
-    "README.md"
+    "dist"
   ],
   "license": "ISC",
   "devDependencies": {
-    "@devmoods/eslint-config": "^1.13.1",
+    "@devmoods/eslint-config": "^1.14.0",
     "@types/koa-compose": "^3.2.8",
-    "@types/node": "20.14.2",
+    "@types/node": "22.7.5",
     "@types/supertest": "^6.0.2",
-    "@typescript-eslint/eslint-plugin": "^7.12.0",
-    "@typescript-eslint/parser": "^7.12.0",
-    "@vitest/coverage-v8": "^1.3.1",
+    "@typescript-eslint/eslint-plugin": "^8.8.1",
+    "@typescript-eslint/parser": "^8.8.1",
+    "@vitest/coverage-v8": "^2.1.2",
     "chalk": "^5.3.0",
     "eslint": "^8.57.0",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-jsx-a11y": "^6.8.0",
-    "eslint-plugin-prettier": "^5.1.3",
-    "eslint-plugin-react": "^7.34.2",
-    "eslint-plugin-react-hooks": "^4.6.0",
-    "faktory-worker": "^4.5.1",
-    "prettier": "3.3.1",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "faktory-worker": "^4.6.0",
+    "prettier": "3.3.3",
     "supertest": "7.0.0",
     "ts-node": "10.9.2",
-    "typescript": "5.4.5",
-    "vitest": "^1.3.1"
+    "typescript": "5.6.3",
+    "vitest": "^2.1.2"
   },
   "dependencies": {
     "@devmoods/fetch": "^4.0.1",
-    "@sentry/node": "^7.116.0",
+    "@sentry/node": "^8.34.0",
+    "@sentry/profiling-node": "^8.34.0",
     "@types/bcrypt": "^5.0.2",
     "@types/body-parser": "^1.19.5",
     "@types/cookie-parser": "^1.4.7",
-    "@types/express": "^4.17.21",
-    "@types/jsonwebtoken": "^9.0.6",
-    "@types/nodemailer": "^6.4.14",
-    "@types/pg": "^8.11.2",
-    "@types/superagent": "^8.1.4",
-    "@types/uuid": "^9.0.8",
-    "ajv": "^8.16.0",
+    "@types/express": "^5.0.0",
+    "@types/jsonwebtoken": "^9.0.7",
+    "@types/nodemailer": "^6.4.16",
+    "@types/pg": "^8.11.10",
+    "@types/superagent": "^8.1.9",
+    "@types/uuid": "^10.0.0",
+    "ajv": "^8.17.1",
     "bcrypt": "^5.1.1",
-    "body-parser": "^1.20.2",
+    "body-parser": "^1.20.3",
     "commander": "^12.1.0",
     "compose-middleware": "^5.0.1",
-    "cookie-parser": "^1.4.6",
+    "cookie-parser": "^1.4.7",
     "dotenv": "^16.4.5",
-    "express": "^4.18.3",
+    "express": "^4.21.1",
     "express-route-parser": "^1.0.5",
-    "helmet": "^7.1.0",
+    "helmet": "^8.0.0",
     "jsonwebtoken": "^9.0.2",
     "meow": "^13.2.0",
-    "nodemailer": "^6.9.11",
-    "pg": "^8.12.0",
-    "redis": "^4.6.13",
+    "nodemailer": "^6.9.15",
+    "pg": "^8.13.0",
+    "redis": "^4.7.0",
     "sql-template-strings": "^2.2.2",
-    "uuid": "^9.0.1",
-    "vitest-fail-on-console": "^0.7.0"
+    "uuid": "^10.0.0",
+    "vitest-fail-on-console": "^0.7.1"
   },
   "prettier": {
     "singleQuote": true
   },
   "eslintConfig": {
-    "extends": "@devmoods/eslint-config",
-    "parserOptions": {
-      "project": "./tsconfig.json"
-    },
-    "rules": {
-      "@typescript-eslint/consistent-type-imports": "warn",
-      "@typescript-eslint/no-shadow": "off",
-      "react-hooks/rules-of-hooks": "off"
-    }
+    "extends": "@devmoods/eslint-config"
   },
   "peerDependencies": {
     "faktory-worker": "^4.5.1"
@@ -96,11 +81,11 @@
     "node": ">=20.3.0 <23"
   },
   "scripts": {
-    "start": "ts-node --esm example/index.ts",
-    "start:worker": "ts-node --esm example/worker.ts",
+    "start": "node --no-warnings --enable-source-maps --loader ts-node/esm example/src/index.ts --name example",
+    "start:worker": "node --no-warnings --enable-source-maps --loader ts-node/esm example/worker.ts",
     "clean": "rm -rf dist",
-    "lint": "eslint src",
-    "test": "./test.sh src",
+    "lint": "eslint src example",
+    "test": "./test.sh",
     "build": "pnpm run clean && tsc --project tsconfig.build.json",
     "format": "prettier --write '**/*.{js,css,md,ts,tsx}'"
   }

package/bin/migrate

@@ -1,5 +0,0 @@
-#/bin/bash 
-
-set -e
-
-node --no-warnings --loader ts-node/esm node_modules/@devmoods/express-extras/dist/cli/migrate.js ${*:1}

package/bin/routes

@@ -1,5 +0,0 @@
-#/bin/bash 
-
-set -e
-
-node_modules/.bin/ts-node --esm node_modules/@devmoods/express-extras/dist/cli/routes.js ${*:1}

package/dist/cli/migrate.d.ts

@@ -1 +0,0 @@
-import 'dotenv/config';

package/dist/cli/migrate.js

@@ -1,3 +0,0 @@
-import 'dotenv/config';
-import { cli } from '../migrate.js';
-cli();

package/dist/cli/routes.d.ts

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

package/dist/cli/routes.js

@@ -1,10 +0,0 @@
-import { createFetch } from '@devmoods/fetch';
-const port = process.env.PORT ?? 3000;
-const fetch = createFetch({
-    getRootUrl: () => `http://localhost:${port}`,
-    getRequestId: () => 'routes',
-});
-const response = await fetch('/docs');
-for (const route of response.jsonData.routes) {
-    process.stdout.write(`${route.method.toLocaleUpperCase().padEnd(5)} ${route.path}\n`);
-}