@devmoods/express-extras 0.36.0 → 0.38.0

package/dist/cache.d.ts

@@ -1,4 +1,8 @@
 import { type RedisClient } from './redis.js';
+export interface CacheOptions {
+    key?: string;
+    expiresMs?: number | null;
+}
 export interface CacheAdapter {
     get(key: string): Promise<any>;
     set(key: string, value: any, expires?: number | null | undefined): Promise<void>;
@@ -13,5 +17,6 @@ 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) => Promise<void>;
-    wrap: <T>(key: string, expiresMs: number | null | undefined, fn: () => Promise<T>) => Promise<T>;
+    wrap: <T>(key: string, options: CacheOptions | number | null, fn: () => Promise<T>) => Promise<T>;
+    decorate: <T, Arguments extends any[]>(options: CacheOptions | number | null, fn: (...args: Arguments) => T | Promise<T>) => (...args: Arguments) => Promise<T>;
 };

package/dist/cache.js

@@ -53,19 +53,42 @@ export function createMemoryCacheAdapter() {
     };
 }
 export function createCache(adapter) {
-    async function cached(key, expiresMs, fn) {
+    async function cached(key, options, fn) {
         const cachedValue = await adapter.get(key);
         if (cachedValue != null) {
             return cachedValue;
         }
+        const expiresMs = typeof options === 'number' || options == null
+            ? options
+            : options.expiresMs;
         const result = await fn();
         await adapter.set(key, result, expiresMs);
         return result;
     }
+    function cachedFn(options, fn) {
+        return async (...args) => {
+            const baseKey = typeof options === 'object' && options != null
+                ? options.key
+                : undefined;
+            const cacheKey = `${baseKey ?? Buffer.from(fn.toString()).toString('hex')}-${JSON.stringify(args)}`;
+            const cachedValue = await adapter.get(cacheKey);
+            if (cachedValue != null) {
+                return cachedValue;
+            }
+            const expiresMs = typeof options === 'number' || options == null
+                ? options
+                : options.expiresMs;
+            console.log({ expiresMs });
+            const result = await fn(...args);
+            await adapter.set(cacheKey, result, expiresMs);
+            return result;
+        };
+    }
     return {
         set: adapter.set.bind(adapter),
         get: adapter.get.bind(adapter),
         clear: adapter.clear.bind(adapter),
         wrap: cached,
+        decorate: cachedFn,
     };
 }

package/dist/cli.js

@@ -16,7 +16,7 @@ export class CLI {
     redLine(message, output = stderr) {
         output.write(`${chalk.red(message)}\n`);
     }
-    /* v8 ignore next 10 */
+    /* c8 ignore next 10 */
     readInput(question) {
         const rl = readline.createInterface({ input: stdin, output: stderr });
         return new Promise((resolve) => {
@@ -31,7 +31,7 @@ export class CLI {
             const timer = startTimer();
             try {
                 await action(...args);
-                this.greenLine(`Command succeeded in ${timer.getDuration().toFixed(4)}s`);
+                this.greenLine(`Command succeeded in ${timer.getDuration().toFixed(4)}s`, stderr);
             }
             catch (error) {
                 this.redLine(error.message);

package/dist/csrf.d.ts

@@ -0,0 +1,15 @@
+import { type RequestHandler, type Request, type Response } from 'express';
+export interface CsrfMiddlewareOptions {
+    excempt?: boolean;
+}
+export declare function csrf({ excempt, }?: CsrfMiddlewareOptions): RequestHandler;
+export declare function setCsrfIdentifier(identifier: string): void;
+export declare function useCsrfIdentifier(): string;
+export declare function setCsrfProtectionEnabled(enabled: boolean): void;
+export declare function useCsrfProtectionEnabled(): boolean | undefined;
+interface TokenOptions {
+    overwrite?: boolean;
+}
+export declare const generateCsrfToken: (req: Request<any, any, any, any>, res: Response, options?: TokenOptions) => string;
+export declare function doubleCsrfProtection(req: Request<any, any, any, any>): () => Promise<void>;
+export {};

package/dist/csrf.js

@@ -0,0 +1,104 @@
+import { createHash, randomBytes } from 'node:crypto';
+import {} from 'express';
+import { setContext, useContext } from './context.js';
+import { Forbidden } from './errors.js';
+import { readEnv } from './utils.js';
+export function csrf({ excempt = false, } = {}) {
+    return (req, res, next) => {
+        setCsrfProtectionEnabled(!excempt);
+        next();
+    };
+}
+const CSRF_IDENTIFIER_CONTEXT_KEY = '@csrfRequestIdentifier';
+export function setCsrfIdentifier(identifier) {
+    setContext(CSRF_IDENTIFIER_CONTEXT_KEY, identifier);
+}
+export function useCsrfIdentifier() {
+    return useContext(CSRF_IDENTIFIER_CONTEXT_KEY) ?? '';
+}
+const CSRF_REQUIRED = '@csrfProtectionEnabled';
+export function setCsrfProtectionEnabled(enabled) {
+    setContext(CSRF_REQUIRED, enabled);
+}
+export function useCsrfProtectionEnabled() {
+    return useContext(CSRF_REQUIRED);
+}
+const ignoredMethods = new Set(['GET', 'HEAD', 'OPTIONS']);
+const cookieName = '__Host-devmoods.x-csrf-token';
+const generateTokenAndHash = (req, { overwrite = false } = {}) => {
+    const secret = readEnv('CSRF_SECRET', '');
+    const sessionIdentifier = useCsrfIdentifier();
+    const csrfCookie = req.cookies[cookieName];
+    if (typeof csrfCookie === 'string' && !overwrite) {
+        const [csrfToken, csrfTokenHash] = csrfCookie.split('|');
+        if (validateTokenHash({
+            csrfToken,
+            csrfTokenHash,
+            secret,
+            sessionIdentifier,
+        })) {
+            return { csrfToken, csrfTokenHash };
+        }
+        throw Forbidden('Invalid CSRF token');
+    }
+    const csrfToken = randomBytes(64).toString('hex');
+    const csrfTokenHash = createHash('sha256')
+        .update(`${sessionIdentifier}${csrfToken}${secret}`)
+        .digest('hex');
+    return { csrfToken, csrfTokenHash };
+};
+export const generateCsrfToken = (req, res, options = {}) => {
+    const { csrfToken, csrfTokenHash } = generateTokenAndHash(req, options);
+    const cookieContent = `${csrfToken}|${csrfTokenHash}`;
+    res.cookie(cookieName, cookieContent, {
+        sameSite: 'lax',
+        path: '/',
+        secure: process.env.NODE_ENV === 'production',
+        httpOnly: true,
+    });
+    return csrfToken;
+};
+const validateTokenHash = ({ csrfToken, csrfTokenHash, secret, sessionIdentifier, }) => {
+    if (typeof csrfToken !== 'string' || typeof csrfTokenHash !== 'string') {
+        return false;
+    }
+    const expectedHash = createHash('sha256')
+        .update(`${sessionIdentifier}${csrfToken}${secret}`)
+        .digest('hex');
+    return csrfTokenHash === expectedHash;
+};
+const validateRequest = (req) => {
+    const csrfCookie = req.cookies[cookieName];
+    if (typeof csrfCookie !== 'string') {
+        throw Forbidden('Missing CSRF cookie');
+    }
+    const [csrfToken, csrfTokenHash] = csrfCookie.split('|');
+    const csrfTokenFromRequest = req.headers['x-csrf-token'];
+    const secret = readEnv('CSRF_SECRET', '');
+    if (!csrfTokenFromRequest) {
+        throw Forbidden('Missing CSRF token');
+    }
+    if (csrfToken !== csrfTokenFromRequest) {
+        throw Forbidden('CSRF token mismatch');
+    }
+    if (!validateTokenHash({
+        csrfToken: csrfTokenFromRequest,
+        csrfTokenHash,
+        secret,
+        sessionIdentifier: useCsrfIdentifier(),
+    })) {
+        throw Forbidden('Invalid CSRF token');
+    }
+};
+export function doubleCsrfProtection(req) {
+    return async () => {
+        const isCsrfProtectionEnabled = useCsrfProtectionEnabled();
+        if (!isCsrfProtectionEnabled) {
+            return;
+        }
+        if (ignoredMethods.has(req.method)) {
+            return;
+        }
+        validateRequest(req);
+    };
+}

package/dist/email.d.ts

@@ -6,12 +6,12 @@ export interface EmailOptions {
     pass?: string;
     senderName: string;
     senderAddress: string;
+    onEmailSent?: (payload: Record<string, any>) => void | Promise<void>;
 }
 export interface SendEmailOptions extends nodemailer.SendMailOptions {
     message: string;
 }
-export declare function createEmail({ host, port, user, pass, senderName, senderAddress, }: EmailOptions): {
+export declare function createEmail({ host, port, user, pass, senderName, senderAddress, onEmailSent, }: EmailOptions): {
     send: ({ to, subject, message, ...rest }: SendEmailOptions) => Promise<void>;
     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/email.js

@@ -1,14 +1,13 @@
 import * as nodemailer from 'nodemailer';
 import { getLogger } from './logger.js';
 const logger = getLogger('email');
-export function createEmail({ host, port, user, pass, senderName, senderAddress, }) {
+export function createEmail({ host, port, user, pass, senderName, senderAddress, onEmailSent, }) {
     const transporter = nodemailer.createTransport({
         host,
         port: parseInt(port || '587', 10),
         secure: false,
         auth: { user, pass },
     });
-    const outbox = [];
     const send = async ({ to, subject, message, ...rest }) => {
         const payload = {
             from: `${senderName} <${senderAddress}>`,
@@ -18,17 +17,11 @@ export function createEmail({ host, port, user, pass, senderName, senderAddress,
             ...rest,
         };
         const result = await transporter.sendMail(payload);
-        outbox.push(payload);
-        if (outbox.length > 5) {
-            outbox.shift();
-        }
+        await onEmailSent?.(payload);
         logger.info('email-sent', { email: result });
     };
     return {
         send,
         transporter,
-        get outbox() {
-            return outbox;
-        },
     };
 }

package/dist/faktory.d.ts

@@ -3,14 +3,20 @@ export interface JobsOptions {
     queueName: string;
     faktory?: typeof create;
 }
-export type JobContext = Record<string, any>;
-export declare function createJobs<GlobalContext extends JobContext>({ queueName, faktory: createFactory, }: JobsOptions): {
-    job: <K extends Record<string, any>, T extends (input: K, ctx: GlobalContext) => undefined | Promise<any>>(fn: T) => {
+export type AnyJobContext = Record<string, any>;
+export interface JobOptions {
+    retry?: number;
+    priority?: number;
+    at?: Date | string;
+}
+export declare function createJobs<GlobalContext extends AnyJobContext>({ queueName, faktory: createFactory, }: JobsOptions): {
+    job: <Arguments extends Record<string, any>, Fn extends (input: Arguments, ctx: GlobalContext) => undefined | Promise<any>>(optionsOrFn: JobOptions | Fn, fnOrUndefined?: Fn) => {
         $job: boolean;
         jobName: string;
+        options: JobOptions;
         readonly executionCount: number;
-        delay(args?: Parameters<T>[0]): Promise<`${string}-${string}-${string}-${string}-${string}`>;
-        execute(args: Parameters<T>[0], context: GlobalContext): Promise<any>;
+        delay(args?: Parameters<Fn>[0]): Promise<`${string}-${string}-${string}-${string}-${string}`>;
+        execute(args: Parameters<Fn>[0], context: GlobalContext): Promise<any>;
     };
     queueName: string;
 };

package/dist/faktory.js

@@ -7,7 +7,12 @@ const logger = getLogger('faktory');
 const JOB_ID = 'jobId';
 export function createJobs({ queueName, faktory: createFactory = create, }) {
     const faktory = createFactory();
-    function job(fn) {
+    function job(optionsOrFn, fnOrUndefined) {
+        const fn = typeof optionsOrFn === 'function' ? optionsOrFn : fnOrUndefined;
+        const options = typeof optionsOrFn === 'function' ? {} : optionsOrFn;
+        if (!fn) {
+            throw new Error('job() must get a function as the first or second argument');
+        }
         const jobName = fn.name;
         let executionCount = 0;
         if (!jobName) {
@@ -16,6 +21,7 @@ export function createJobs({ queueName, faktory: createFactory = create, }) {
         return {
             $job: true,
             jobName,
+            options,
             get executionCount() {
                 return executionCount;
             },
@@ -26,6 +32,7 @@ export function createJobs({ queueName, faktory: createFactory = create, }) {
                     const j = client.job(jobName, args);
                     j.jid = jid;
                     j.queue = queueName;
+                    Object.assign(j, options);
                     await j.push();
                     await client.close();
                 }

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export * from './auth.js';
 export * from './cache.js';
 export * from './cli.js';
 export * from './context.js';
+export * from './csrf.js';
 export * from './email.js';
 export * from './errors.js';
 export * from './faktory.js';

package/dist/index.js

@@ -1,8 +1,9 @@
-/* v8 ignore next 100 */
+/* c8 ignore next 100 */
 export * from './auth.js';
 export * from './cache.js';
 export * from './cli.js';
 export * from './context.js';
+export * from './csrf.js';
 export * from './email.js';
 export * from './errors.js';
 export * from './faktory.js';

package/dist/manage.js

@@ -1,9 +1,9 @@
 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';
+import { parseRoutes } from './routes.js';
 export function registerManagementCommand(register) {
     const cli = new CLI({ printStackTraces: process.argv.includes('--verbose') });
     register(program.command.bind(program), cli);
@@ -17,12 +17,23 @@ export function registerDefaultCommands(app) {
         const migrate = command('migrate');
         asCli(migrate, cli);
     });
-    registerManagementCommand((command, cli) => command('routes').action(cli.wrap(async () => {
+    registerManagementCommand((command, cli) => command('routes')
+        .option('--openapi', 'Output OpenAPI schema')
+        .option('--json', 'Output JSON')
+        .action(cli.wrap(async (options) => {
         if (!app)
             return;
-        const routes = parseExpressApp(app);
+        if (options.openapi) {
+            console.error('Not implemented yet');
+            return;
+        }
+        const routes = parseRoutes(app);
+        if (options.json) {
+            console.log(JSON.stringify(routes, null, 2));
+            return;
+        }
         for (const route of routes) {
-            cli.writeLine(`${route.method.toLocaleUpperCase().padEnd(5)} ${route.path}\n`);
+            cli.writeLine(`${route.method.padEnd(7)} ${route.path}\n`);
         }
     })));
     registerManagementCommand((command, cli) => {

package/dist/middleware.d.ts

@@ -15,13 +15,14 @@ export interface BeforeMiddlewareOptions {
     cookies?: boolean;
     helmet?: boolean;
     json?: boolean;
+    csrf?: boolean;
     allowUnsafeInlineScripts?: boolean;
     cspDirectives?: (defaults: BeforeMiddlewareCSPDirectives) => BeforeMiddlewareCSPDirectives;
 }
 /**
  * Register middleware that must come before the app routes.
  */
-export declare function before({ cookies, helmet: useHelmet, json: useJson, allowUnsafeInlineScripts, cspDirectives, }?: BeforeMiddlewareOptions): import("compose-middleware").RequestHandler<unknown, unknown, void>;
+export declare function before({ cookies, helmet: useHelmet, json: useJson, csrf: useCsrf, allowUnsafeInlineScripts, cspDirectives, }?: BeforeMiddlewareOptions): import("compose-middleware").RequestHandler<unknown, unknown, void>;
 /**
  * Middleware that sends a 404
  *

package/dist/middleware.js

@@ -4,6 +4,7 @@ import cookieParser from 'cookie-parser';
 import {} from 'express';
 import helmet from 'helmet';
 import { withRequestContext } from './context.js';
+import { csrf, doubleCsrfProtection } from './csrf.js';
 import { NotFound } from './errors.js';
 import { getLogger } from './logger.js';
 import { startTimer } from './utils.js';
@@ -14,9 +15,10 @@ export { asyncMiddleware as route };
 /**
  * Register middleware that must come before the app routes.
  */
-export function before({ cookies = false, helmet: useHelmet = true, json: useJson = true, allowUnsafeInlineScripts = false, cspDirectives = (x) => x, } = {}) {
+export function before({ cookies = false, helmet: useHelmet = true, json: useJson = true, csrf: useCsrf = false, allowUnsafeInlineScripts = false, cspDirectives = (x) => x, } = {}) {
     return compose([
         withRequestContext(),
+        useCsrf && csrf(),
         logRequestDuration(),
         useHelmet &&
             helmet({
@@ -48,7 +50,7 @@ export function before({ cookies = false, helmet: useHelmet = true, json: useJso
                 },
             }),
         useJson && jsonParser(),
-        cookies && cookieParser(),
+        (cookies || useCsrf) && cookieParser(),
         analyticsProxy(),
     ].filter(Boolean));
 }
@@ -111,7 +113,9 @@ export function after() {
  */
 export function asyncMiddleware(fn) {
     const handler = (req, res, next) => {
-        return Promise.resolve(fn(req, res, next))
+        return Promise.resolve()
+            .then(doubleCsrfProtection(req))
+            .then(() => fn(req, res, next))
             .then((result) => {
             if (Array.isArray(result) &&
                 (result.length === 2 || result.length === 3) &&

package/dist/routes.d.ts

@@ -1,2 +1,22 @@
 import { type Express, type RequestHandler } from 'express';
 export declare function createDocsRouter(app: Express, extras?: Record<string, any>): RequestHandler;
+export declare function parseRoutes(app: Express): {
+    method: string;
+    path: string;
+    params: {
+        type: string;
+        properties: {
+            [k: string]: {
+                type: string;
+            };
+        };
+        required: string[];
+    } | null;
+    query: {} | null;
+    body: {} | null;
+}[];
+export interface Key {
+    name: string;
+    optional: boolean;
+    offset: number;
+}

package/dist/routes.js

@@ -1,11 +1,137 @@
 import {} from 'express';
-import { parseExpressApp } from 'express-route-parser';
 import { route } from './middleware.js';
 export function createDocsRouter(app, extras = {}) {
     return route(async () => {
         return {
             ...extras,
-            routes: parseExpressApp(app),
+            routes: parseRoutes(app),
         };
     });
 }
+export function parseRoutes(app) {
+    return new ExpressPathParser(app).getPaths().map((routeMetadata) => {
+        const { method, path, pathParams, metadata } = routeMetadata;
+        return {
+            method: method.toLocaleUpperCase(),
+            path,
+            params: buildPathParamsSchema(pathParams),
+            query: metadata
+                ?.filter((m) => typeof m === 'object' && m != null && 'querySchema' in m)
+                .at(-1)?.querySchema ?? null,
+            body: metadata
+                ?.filter((m) => typeof m === 'object' && m != null && 'bodySchema' in m)
+                .at(-1)?.bodySchema ?? null,
+        };
+    });
+}
+const buildPathParamsSchema = (pathParams) => {
+    const required = [];
+    const params = [];
+    for (const param of pathParams) {
+        if (param.in !== 'path') {
+            continue;
+        }
+        params.push(param.name);
+        if (param.required) {
+            required.push(param.name);
+        }
+    }
+    if (params.length === 0) {
+        return null;
+    }
+    return {
+        type: 'object',
+        properties: Object.fromEntries(params.map((p) => [p, { type: 'string' }])),
+        required,
+    };
+};
+// Fork of express-route-parser
+class ExpressPathParser {
+    getPaths() {
+        return this._appPaths;
+    }
+    constructor(app) {
+        this.traverse = (path, layer, keys) => {
+            keys = [...keys, ...layer.keys];
+            if (layer.name === 'router' && layer.handle) {
+                for (const l of layer.handle.stack) {
+                    this.traverse(`${path || ''}/${pathRegexParser(layer.regexp, layer.keys)}`, l, keys);
+                }
+            }
+            if (!layer.route || !layer.route.stack.length) {
+                return;
+            }
+            this._appPaths.push(this.parseRouteLayer(layer, keys, path));
+        };
+        this.parseRouteLayer = (layer, keys, basePath) => {
+            const lastRequestHandler = layer.route.stack[layer.route.stack.length - 1];
+            const pathParams = keys.map((key) => {
+                return { name: key.name, in: 'path', required: !key.optional };
+            });
+            const filtered = layer.route.stack.filter((element) => element?.handle?.metadata);
+            const path = (basePath + layer.route.path).replace(/\/{2,}/gi, '/');
+            if (filtered.length === 0) {
+                return { path, pathParams, method: lastRequestHandler.method };
+            }
+            return {
+                path,
+                pathParams,
+                method: lastRequestHandler.method,
+                metadata: filtered.map((f) => f.handle.metadata),
+            };
+        };
+        this._appPaths = [];
+        const router = app._router;
+        if (router) {
+            for (const layer of router.stack) {
+                this.traverse('', layer, []);
+            }
+        }
+    }
+}
+const pathRegexParser = (layerRegexPath, keys) => {
+    if (typeof layerRegexPath === 'string') {
+        return layerRegexPath;
+    }
+    if (layerRegexPath.fast_slash) {
+        return '';
+    }
+    if (layerRegexPath.fast_star) {
+        return '*';
+    }
+    let mappedPath = '';
+    if (keys && keys.length) {
+        mappedPath = mapKeysToPath(layerRegexPath, keys);
+    }
+    const match = layerRegexPath
+        .toString()
+        .replace('\\/?', '')
+        .replace('(?=\\/|$)', '$')
+        .match(/^\/\^((?:\\[.*+?^${}()|[\]\\/]|[^.*+?^${}()|[\]\\/])*)\$\//);
+    if (match) {
+        return match[1].replace(/\\(.)/g, '$1').slice(1);
+    }
+    if (mappedPath) {
+        return mappedPath.slice(1);
+    }
+    return layerRegexPath.toString();
+};
+const mapKeysToPath = (layerRegexPath, keys) => {
+    if (!keys || keys.length === 0) {
+        throw Error('must include atleast one key to map');
+    }
+    let convertedSubPath = layerRegexPath.toString();
+    for (const key of keys) {
+        if (key.optional) {
+            convertedSubPath = convertedSubPath.replace('(?:\\/([^\\/]+?))?\\', `/:${key.name}?`);
+        }
+        else {
+            convertedSubPath = convertedSubPath.replace('(?:([^\\/]+?))', `:${key.name}`);
+        }
+    }
+    return convertedSubPath
+        .replace('/?(?=\\/|$)/i', '')
+        .replace('/^', '')
+        .replace(/\\/gi, '')
+        .replace(/\/{2,}/gi, '/');
+};

package/dist/setupTests.js

@@ -1,3 +1,5 @@
 import 'dotenv/config';
+import EventEmitter from 'node:events';
 import failOnConsole from 'vitest-fail-on-console';
+EventEmitter.setMaxListeners(20);
 failOnConsole();

package/dist/validate.js

@@ -4,33 +4,39 @@ import { BadRequest } from './errors.js';
 const Ajv = _Ajv;
 export function validateBody(schema) {
     const validate = compileValidateSchema(schema);
-    return (req, res, next) => {
+    const middleware = (req, res, next) => {
         const result = validate(req.body);
         if (!result.isValid) {
             return next(BadRequest({ body: result.errors }));
         }
         next();
     };
+    middleware.metadata = { bodySchema: schema };
+    return middleware;
 }
 export function validateQuery(schema) {
     const validate = compileValidateSchema(schema, { coerceTypes: true });
-    return (req, res, next) => {
+    const middleware = (req, res, next) => {
         const result = validate(req.query);
         if (!result.isValid) {
             return next(BadRequest({ query: result.errors }));
         }
         next();
     };
+    middleware.metadata = { querySchema: schema };
+    return middleware;
 }
 export function validateParams(schema) {
     const validate = compileValidateSchema(schema, { coerceTypes: true });
-    return (req, res, next) => {
+    const middleware = (req, res, next) => {
         const result = validate(req.params);
         if (!result.isValid) {
             return next(BadRequest({ params: result.errors }));
         }
         next();
     };
+    middleware.metadata = { paramsSchema: schema };
+    return middleware;
 }
 function createAjv(options) {
     const ajv = new Ajv({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devmoods/express-extras",
-  "version": "0.36.0",
+  "version": "0.38.0",
   "description": "Kubernetes-ready utilities for rapid Node.js application development",
   "type": "module",
   "main": "./dist/index.js",
@@ -20,12 +20,12 @@
   "devDependencies": {
     "@devmoods/eslint-config": "^1.14.0",
     "@types/koa-compose": "^3.2.8",
-    "@types/node": "22.7.5",
+    "@types/node": "22.8.6",
     "@types/supertest": "^6.0.2",
-    "@typescript-eslint/eslint-plugin": "^8.8.1",
-    "@typescript-eslint/parser": "^8.8.1",
-    "@vitest/coverage-v8": "^2.1.2",
-    "chalk": "^5.3.0",
+    "@typescript-eslint/eslint-plugin": "^8.12.2",
+    "@typescript-eslint/parser": "^8.12.2",
+    "@vitest/coverage-v8": "^2.1.4",
+    "cookiejar": "^2.1.4",
     "eslint": "^8.57.0",
     "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-prettier": "^5.2.1",
@@ -33,15 +33,15 @@
     "prettier": "3.3.3",
     "supertest": "7.0.0",
     "ts-node": "10.9.2",
-    "tsx": "^4.19.1",
+    "tsx": "^4.19.2",
     "typescript": "5.6.3",
-    "vitest": "^2.1.2",
+    "vitest": "^2.1.4",
     "vitest-fail-on-console": "^0.7.1"
   },
   "dependencies": {
     "@devmoods/fetch": "^4.0.1",
-    "@sentry/node": "^8.34.0",
-    "@sentry/profiling-node": "^8.34.0",
+    "@sentry/node": "^8.36.0",
+    "@sentry/profiling-node": "^8.36.0",
     "@types/bcrypt": "^5.0.2",
     "@types/body-parser": "^1.19.5",
     "@types/cookie-parser": "^1.4.7",
@@ -54,19 +54,19 @@
     "ajv": "^8.17.1",
     "bcrypt": "^5.1.1",
     "body-parser": "^1.20.3",
+    "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "compose-middleware": "^5.0.1",
     "cookie-parser": "^1.4.7",
     "dotenv": "^16.4.5",
     "express": "^4.21.1",
-    "express-route-parser": "^1.0.5",
     "helmet": "^8.0.0",
     "jsonwebtoken": "^9.0.2",
-    "nodemailer": "^6.9.15",
-    "pg": "^8.13.0",
+    "nodemailer": "^6.9.16",
+    "pg": "^8.13.1",
     "redis": "^4.7.0",
     "sql-template-strings": "^2.2.2",
-    "uuid": "^10.0.0"
+    "uuid": "^11.0.2"
   },
   "prettier": {
     "singleQuote": true