@devmoods/express-extras 0.73.0 → 0.75.0

package/dist/cache.js

@@ -1,62 +1,116 @@
 import { config } from '@devmoods/config';
 import {} from './redis.js';
-export function createRedisCacheAdapter(redis, options = {}) {
-    const { keyPrefix = `${config.REDIS_KEY_PREFIX}cache:` } = options;
-    const withKeyPrefix = (key) => `${keyPrefix}${key}`;
-    return {
-        async get(key) {
-            const value = await redis.get(withKeyPrefix(key));
-            if (value == null) {
-                return null;
-            }
-            return JSON.parse(value);
-        },
-        async set(key, value, expires) {
-            await redis.set(withKeyPrefix(key), JSON.stringify(value), {
-                PX: expires,
+const MAX_CACHE_KEY_SIZE_BYTES = 256;
+export class CacheAdapter {
+}
+export class RedisCacheAdapter extends CacheAdapter {
+    redis;
+    keyPrefix;
+    constructor(redis, { keyPrefix = `${config.REDIS_KEY_PREFIX}cache:`, } = {}) {
+        super();
+        this.redis = redis;
+        this.keyPrefix = keyPrefix;
+    }
+    async get(key) {
+        const value = await this.redis.get(this.withKeyPrefix(key));
+        if (value == null) {
+            return null;
+        }
+        return JSON.parse(value);
+    }
+    async set(key, value, expires) {
+        const serializedValue = JSON.stringify(value);
+        if (expires == null) {
+            await this.redis.set(this.withKeyPrefix(key), serializedValue);
+            return;
+        }
+        await this.redis.set(this.withKeyPrefix(key), serializedValue, {
+            PX: expires,
+        });
+    }
+    async clear(key) {
+        if (key) {
+            await this.redis.del(this.withKeyPrefix(key));
+            return;
+        }
+        let cursor = '0';
+        const pattern = `${this.keyPrefix}*`;
+        do {
+            const result = await this.redis.scan(cursor, {
+                MATCH: pattern,
+                COUNT: 100,
             });
-        },
-        async clear(key) {
-            if (key) {
-                await redis.del(withKeyPrefix(key));
-            }
-            const keys = await redis.keys(`${keyPrefix}*`);
-            for (const existingKey of keys) {
-                await redis.del(existingKey);
+            cursor = result.cursor;
+            /* v8 ignore next -- @preserve */
+            if (result.keys.length > 0) {
+                await this.redis.unlink(result.keys);
             }
-        },
-    };
+        } while (cursor !== '0');
+    }
+    withKeyPrefix(key) {
+        return `${this.keyPrefix}${key}`;
+    }
 }
-export function createMemoryCacheAdapter() {
-    const cache = new Map();
-    return {
-        async get(key) {
-            const entry = cache.get(key);
-            if (entry == null) {
-                return null;
-            }
-            const [value, expires] = entry;
-            if (expires != null && Date.now() >= expires) {
-                cache.delete(key);
-                return null;
-            }
-            return value;
-        },
-        async set(key, value, expires) {
-            cache.set(key, [value, expires == null ? null : Date.now() + expires]);
-        },
-        async clear(key) {
-            if (key) {
-                cache.delete(key);
-            }
-            else {
-                cache.clear();
+export function createRedisCacheAdapter(redis, options = {}) {
+    return new RedisCacheAdapter(redis, options);
+}
+export class MemoryCacheAdapter extends CacheAdapter {
+    maxSize;
+    #cache = new Map();
+    constructor({ maxSize } = {}) {
+        super();
+        this.maxSize = maxSize;
+    }
+    async get(key) {
+        const entry = this.#cache.get(key);
+        if (entry == null) {
+            return null;
+        }
+        const [value, expires] = entry;
+        if (expires != null && Date.now() >= expires) {
+            this.#cache.delete(key);
+            return null;
+        }
+        // Mark as recently used by deleting the entry and adding it back to the cache
+        this.#cache.delete(key);
+        this.#cache.set(key, entry);
+        return value;
+    }
+    async set(key, value, expires) {
+        this.#cache.delete(key);
+        this.#cache.set(key, [
+            value,
+            expires == null ? null : Date.now() + expires,
+        ]);
+        this.evictLeastRecentlyUsedEntries();
+    }
+    async clear(key) {
+        if (key) {
+            this.#cache.delete(key);
+        }
+        else {
+            this.#cache.clear();
+        }
+    }
+    evictLeastRecentlyUsedEntries() {
+        if (this.maxSize == null) {
+            return;
+        }
+        while (this.#cache.size > this.maxSize) {
+            const oldestKey = this.#cache.keys().next().value;
+            if (oldestKey == null) {
+                return;
             }
-        },
-    };
+            this.#cache.delete(oldestKey);
+        }
+    }
+}
+export function createMemoryCacheAdapter(options = {}) {
+    return new MemoryCacheAdapter(options);
 }
 export function createCache(adapter) {
     async function cached(key, options, fn) {
+        assertCacheKeySize(key);
         const cachedValue = await adapter.get(key);
         if (cachedValue != null) {
             return cachedValue;
@@ -73,7 +127,9 @@ export function createCache(adapter) {
             const baseKey = typeof options === 'object' && options != null
                 ? options.key
                 : undefined;
-            return `${baseKey ?? Buffer.from(fn.toString()).toString('hex')}-${hashKey(args)}`;
+            const cacheKey = `${baseKey ?? Buffer.from(fn.toString()).toString('hex')}-${hashKey(args)}`;
+            assertCacheKeySize(cacheKey);
+            return cacheKey;
         };
         const wrapped = async (...args) => {
             const cacheKey = getCacheKey(...args);
@@ -101,21 +157,28 @@ export function createCache(adapter) {
     };
 }
 function hashKey(obj) {
-    return JSON.stringify(obj, (key, value) => {
-        if (value === null || value === undefined) {
-            return String(value);
-        }
-        if (typeof value === 'object') {
-            if (Array.isArray(value)) {
-                return value;
-            }
-            return Object.keys(value)
-                .sort()
-                .reduce((result, item) => {
-                result[item] = value[item];
-                return result;
-            }, {});
+    return JSON.stringify(obj, (_, value) => {
+        if (!isPlainObject(value)) {
+            return value;
         }
-        return value;
+        return Object.keys(value)
+            .sort()
+            .reduce((result, key) => {
+            result[key] = value[key];
+            return result;
+        }, {});
     });
 }
+function assertCacheKeySize(key) {
+    if (Buffer.byteLength(key, 'utf8') <= MAX_CACHE_KEY_SIZE_BYTES) {
+        return;
+    }
+    throw new Error(`Cache key exceeds ${MAX_CACHE_KEY_SIZE_BYTES} bytes. Provide a shorter explicit key or reduce the size of the cache arguments.`);
+}
+function isPlainObject(value) {
+    if (Object.prototype.toString.call(value) !== '[object Object]') {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === null || prototype === Object.prototype;
+}

package/dist/composeMiddleware.js

@@ -20,14 +20,14 @@ function generate(handlers) {
     const stack = handlers.flat();
     return function middleware(err, req, res, done) {
         let index = -1;
-        // eslint-disable-next-line @typescript-eslint/no-shadow
+        // oxlint-disable-next-line @typescript-eslint/no-shadow
         function dispatch(pos, err) {
             const handler = stack[pos];
             index = pos;
             if (index === stack.length) {
                 return done(err);
             }
-            // eslint-disable-next-line @typescript-eslint/no-shadow
+            // oxlint-disable-next-line @typescript-eslint/no-shadow
             function next(err) {
                 /* v8 ignore next -- @preserve */
                 if (pos < index) {

package/dist/config.d.ts

@@ -2,13 +2,14 @@ declare module '@devmoods/config' {
     interface Config extends ConfigFromDefs<typeof app> {
     }
 }
-declare const app: Defs<{
+declare const app: import("@devmoods/config").Defs<{
     CI: boolean;
     PORT: number;
     PUBLIC_URL: string;
     AUTH_TOKEN_EXPIRES: number;
     AUTH_TEMP_TOKEN_EXPIRES: number;
     AUTH_OTP_EXPIRES: number;
+    AUTH_OTP_MAX_ATTEMPTS: number;
     AUTH_JWT_SECRET: string;
     AUTH_COOKIE_SAME_SITE: string;
     REDIS_URL: string;
@@ -41,6 +42,7 @@ export declare const config: import("@devmoods/config").Defs<{
     AUTH_TOKEN_EXPIRES: number;
     AUTH_TEMP_TOKEN_EXPIRES: number;
     AUTH_OTP_EXPIRES: number;
+    AUTH_OTP_MAX_ATTEMPTS: number;
     AUTH_JWT_SECRET: string;
     AUTH_COOKIE_SAME_SITE: string;
     REDIS_URL: string;

package/dist/config.js

@@ -7,6 +7,7 @@ const app = define({
     AUTH_TOKEN_EXPIRES: t.number(3600 * 24 * 30),
     AUTH_TEMP_TOKEN_EXPIRES: t.number(3600),
     AUTH_OTP_EXPIRES: t.number(5 * 60),
+    AUTH_OTP_MAX_ATTEMPTS: t.number(5),
     AUTH_JWT_SECRET: t.string(),
     AUTH_COOKIE_SAME_SITE: t.enum(['strict', 'lax', 'none'], 'strict'),
     REDIS_URL: t.string(),

package/dist/context.d.ts

@@ -9,7 +9,7 @@ export interface RequestContextOptions {
 /**
  * Middleware for setting a `requestId` on the request context.
  */
-export declare function withRequestContext({ getRequestId }?: RequestContextOptions): RequestHandler;
+export declare function withRequestContext({ getRequestId, }?: RequestContextOptions): RequestHandler;
 /**
  * Return a value from the request context
  */

package/dist/context.js

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
+import { randomUUID } from 'node:crypto';
 import {} from 'express';
-import { v4 as uuid } from 'uuid';
 export const requestContext = new AsyncLocalStorage();
 export const REQUEST_ID_CONTEXT_KEY = 'requestId';
 export const JOB_ID_CONTEXT_KEY = 'jobId';
@@ -9,7 +9,7 @@ export const JOB_ID_CONTEXT_KEY = 'jobId';
  */
 export function withRequestContext({ getRequestId = (req) => req.headers['X-Request-ID'], } = {}) {
     return (req, res, next) => {
-        const requestId = getRequestId(req) || uuid();
+        const requestId = getRequestId(req) || randomUUID();
         requestContext.run(new Map(), () => {
             setRequestContext(REQUEST_ID_CONTEXT_KEY, requestId);
             next();

package/dist/cookie-consent.d.ts

@@ -1,3 +1,3 @@
-export declare function cookieConsent({ onConsent }: {
+export declare function cookieConsent({ onConsent, }: {
     onConsent: (consents: string[]) => Promise<void> | void;
 }): import("express-serve-static-core").Router;

package/dist/csrf.d.ts

@@ -10,7 +10,7 @@ interface CsrfOptions {
     cookieName: string;
     sessionIdentifier: string;
 }
-export declare function csrf({ exempt, sessionIdentifier, cookieName }?: CsrfMiddlewareOptions): RequestHandler;
+export declare function csrf({ exempt, sessionIdentifier, cookieName, }?: CsrfMiddlewareOptions): RequestHandler;
 export declare function setCsrfOptions(options: CsrfOptions): void;
 export declare function useCsrfOptions(): CsrfOptions;
 interface TokenOptions {

package/dist/csrf.js

@@ -43,6 +43,7 @@ export function useCsrfOptions() {
 }
 const generateTokenAndHash = (req, { overwrite = false } = {}) => {
     const secret = getCsrfSecret();
+    // oxlint-disable-next-line eslint-plugin-react-hooks/rules-of-hooks
     const { sessionIdentifier, cookieName } = useCsrfOptions();
     const csrfCookie = req.cookies[cookieName];
     if (typeof csrfCookie === 'string' && !overwrite) {
@@ -66,6 +67,7 @@ const generateTokenAndHash = (req, { overwrite = false } = {}) => {
 export const generateCsrfToken = (req, res, options = {}) => {
     const { csrfToken, csrfTokenHash } = generateTokenAndHash(req, options);
     const cookieContent = `${csrfToken}|${csrfTokenHash}`;
+    // oxlint-disable-next-line eslint-plugin-react-hooks/rules-of-hooks
     const { cookieName } = useCsrfOptions();
     res.cookie(cookieName, cookieContent, {
         sameSite: 'lax',
@@ -85,6 +87,7 @@ const validateTokenHash = ({ csrfToken, csrfTokenHash, secret, sessionIdentifier
     return csrfTokenHash === expectedHash;
 };
 const validateRequest = (req) => {
+    // oxlint-disable-next-line eslint-plugin-react-hooks/rules-of-hooks
     const { cookieName, sessionIdentifier } = useCsrfOptions();
     const csrfCookie = req.cookies[cookieName];
     if (typeof csrfCookie !== 'string') {
@@ -112,6 +115,7 @@ const validateRequest = (req) => {
     }
 };
 export function doubleCsrfProtection(req) {
+    // oxlint-disable-next-line eslint-plugin-react-hooks/rules-of-hooks
     return async () => {
         const { exempt } = useCsrfOptions();
         if (exempt) {

package/dist/email.d.ts

@@ -11,7 +11,7 @@ export interface EmailOptions {
 export interface SendEmailOptions extends nodemailer.SendMailOptions {
     message: string;
 }
-export declare function createEmail({ host, port, user, pass, senderName, senderAddress, onEmailSent }?: 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>;
 };

package/dist/faktory.d.ts

@@ -29,7 +29,7 @@ export interface FaktoryWorkerOptions<GlobalContext> {
     jobContext?: GlobalContext;
 }
 export { createFaktoryWorker as createJobWorker };
-export declare function createFaktoryWorker<GlobalContext>({ queues, jobs, faktory: createFactory, jobContext }: FaktoryWorkerOptions<GlobalContext>): Promise<{
+export declare function createFaktoryWorker<GlobalContext>({ queues, jobs, faktory: createFactory, jobContext, }: FaktoryWorkerOptions<GlobalContext>): Promise<{
     start(workerOptions?: WorkerOptions): Promise<void>;
     stop(): Promise<void>;
 }>;

package/dist/listen.js

@@ -8,7 +8,6 @@ import express, {} from 'express';
 import { BadRequest } from './errors.js';
 import { getLogger } from './logger.js';
 import { before, route } from './middleware.js';
-import { envPort } from './utils.js';
 const logger = getLogger('http');
 const appTimer = startTimer();
 export function stoppable(server, gracePeriodMs = Infinity) {
@@ -175,7 +174,7 @@ export function createExpressServer(app, options = {}) {
         configurable: true,
     });
     enhanced.start = async function start() {
-        const port = app.get('port') ?? envPort(0);
+        const port = config.PORT;
         await options.onStart?.();
         await ctl.start(port);
         logger.info('app listening', {

package/dist/logger.d.ts

@@ -30,7 +30,7 @@ export declare function clearGlobalLoggerContext(): void;
 export type Logger = ReturnType<typeof createLogger>;
 export declare function addDefaultLoggerOutput(output: LoggerAdapter): void;
 export declare function clearDefaultLoggerOutputs(): void;
-export declare function createLogger({ name, getContext, level, outputs }: LoggerOptions): {
+export declare function createLogger({ name, getContext, level, outputs, }: LoggerOptions): {
     debug(message: string, context?: LoggerContext): void;
     info(message: string, context?: LoggerContext): void;
     warn(message: string, context?: LoggerContext): void;

package/dist/logger.js

@@ -7,7 +7,7 @@ export class JsonStreamAdapter {
     constructor(stream) {
         this.#stream = stream;
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    // oxlint-disable-next-line @typescript-eslint/no-unused-vars
     captureError(error, attributes) { }
     write(log) {
         const chunk = `${JSON.stringify(log)}\n`;
@@ -72,7 +72,7 @@ export function createLogger({ name, getContext, level = config.LOG_LEVEL, outpu
     function getFinalContext(context) {
         return Object.assign(baseContext(), getContext?.(), context);
     }
-    // eslint-disable-next-line @typescript-eslint/no-shadow
+    // oxlint-disable-next-line @typescript-eslint/no-shadow
     function log(level, message, context) {
         if (level < logLevel) {
             return;

package/dist/manage.js

@@ -33,13 +33,13 @@ export function registerDefaultCommands(app, program = defaultProgram) {
             }
             if (options.openapi) {
                 const routes = toOpenAPISpec(app);
-                // eslint-disable-next-line no-console
+                // oxlint-disable-next-line no-console
                 console.log(JSON.stringify(routes, null, 2));
                 return;
             }
             const routes = parseRoutes(app);
             if (options.json) {
-                // eslint-disable-next-line no-console
+                // oxlint-disable-next-line no-console
                 console.log(JSON.stringify(routes, null, 2));
                 return;
             }
@@ -60,7 +60,7 @@ export function registerDefaultCommands(app, program = defaultProgram) {
             .option('--json', 'Output JSON')
             .action(cli.wrap(async (options) => {
             if (options.json) {
-                // eslint-disable-next-line no-console
+                // oxlint-disable-next-line no-console
                 console.log(JSON.stringify(config, null, 2));
                 return;
             }

package/dist/middleware.d.ts

@@ -55,7 +55,7 @@ export interface BeforeMiddleware extends RequestHandler {
 /**
  * Register middleware that must come before the app routes.
  */
-export declare function before({ cookies, helmet: useHelmet, json: useJson, csrf: useCsrf, urlencoded: useUrlencoded, allowUnsafeInlineScripts, cspDirectives, auth }?: BeforeMiddlewareOptions): BeforeMiddleware;
+export declare function before({ cookies, helmet: useHelmet, json: useJson, csrf: useCsrf, urlencoded: useUrlencoded, allowUnsafeInlineScripts, cspDirectives, auth, }?: BeforeMiddlewareOptions): BeforeMiddleware;
 /**
  * Middleware that sends a 404
  *

package/dist/middleware.js

@@ -1,13 +1,13 @@
 import * as crypto from 'node:crypto';
 import {} from 'node:http';
 import { config } from '@devmoods/config';
-import { startTimer } from '@devmoods/observability';
+import { metrics, startTimer } from '@devmoods/observability';
 import cookieParser from 'cookie-parser';
 import { json as jsonParser, urlencoded as urlencodedParser, static as staticMiddleware, } from 'express';
 import helmet from 'helmet';
 import {} from './auth.js';
 import { compose } from './composeMiddleware.js';
-import { ANONYMOUS_SESSION_KEY, setRequestContext, useRequestContext, withRequestContext, } from './context.js';
+import { ANONYMOUS_SESSION_KEY, requestContext, setRequestContext, useRequestContext, withRequestContext, } from './context.js';
 import { csrf, doubleCsrfProtection, } from './csrf.js';
 import { NotFound } from './errors.js';
 import { getLogger } from './logger.js';
@@ -26,6 +26,7 @@ export function useCspNonce() {
 export function before({ cookies = true, helmet: useHelmet = true, json: useJson = true, csrf: useCsrf = false, urlencoded: useUrlencoded = false, allowUnsafeInlineScripts = false, cspDirectives = (x) => x, auth, } = {}) {
     const middleware = compose([
         withRequestContext(),
+        startRequestTimer(),
         (cookies || useCsrf) && cookieParser(),
         cookies && setAnonymousCookie(),
         typeof useCsrf === 'object' && useCsrf != null
@@ -76,21 +77,52 @@ export function before({ cookies = true, helmet: useHelmet = true, json: useJson
     });
     return middleware;
 }
+const REQUEST_TIMER_KEY = 'request-timer';
+const LOG_REQUEST_FILTERED_PATHS = [
+    '/src',
+    '/node_modules',
+    '/@fs',
+    '/@vite',
+    '/@react-refresh',
+    '/@id',
+    '/analytics.js',
+];
+function isLogFilteredPath(req) {
+    return LOG_REQUEST_FILTERED_PATHS.some((p) => req.path.startsWith(p));
+}
+/**
+ * Derive a low-cardinality route label (e.g. `/users/:id`) for metrics.
+ * Falls back to `unknown` when no route matched (e.g. 404).
+ */
+function getRouteLabel(req) {
+    const routePath = req.route?.path;
+    if (!routePath) {
+        return 'unknown';
+    }
+    /* c8 ignore next 1 */
+    const pattern = Array.isArray(routePath) ? routePath.join('|') : routePath;
+    return `${req.baseUrl}${pattern}`;
+}
+/**
+ * Start a timer as early as possible in the middleware chain so the
+ * duration reported by `logRequestDuration` includes time spent in
+ * upstream middlewares (cookie parsing, CSRF, auth, etc.).
+ */
+function startRequestTimer() {
+    return function startRequestTimerMiddleware(req, res, next) {
+        if (isLogFilteredPath(req)) {
+            return next();
+        }
+        setRequestContext(REQUEST_TIMER_KEY, startTimer());
+        next();
+    };
+}
 function logRequestDuration() {
-    const FILTERED_PATHS = [
-        '/src',
-        '/node_modules',
-        '/@fs',
-        '/@vite',
-        '/@react-refresh',
-        '/@id',
-        '/analytics.js',
-    ];
     return function logRequestDurationMiddleware(req, res, next) {
-        if (FILTERED_PATHS.some((p) => req.path.startsWith(p))) {
+        const timer = requestContext.getStore()?.get(REQUEST_TIMER_KEY);
+        if (!timer) {
             return next();
         }
-        const timer = startTimer();
         logger.info('http request', {
             method: req.method,
             url: req.originalUrl,
@@ -107,13 +139,20 @@ function logRequestDuration() {
         });
         res.on('finish', () => {
             const duration = timer.getDuration();
+            const route = getRouteLabel(req);
             logger.info('http response', {
                 method: req.method,
                 url: req.originalUrl,
                 path: req.path,
+                route,
                 duration,
                 status: res.statusCode,
             });
+            metrics.distribution('http_request_duration_seconds', duration, {
+                method: req.method,
+                route,
+                status: res.statusCode >= 400 ? 'error' : 'success',
+            });
         });
         next();
     };
@@ -225,14 +264,41 @@ export function withTransaction(wrapper) {
         try {
             await wrapper.transaction(async () => {
                 await new Promise((resolve, reject) => {
-                    res.on('finish', resolve);
-                    res.on('error', reject);
+                    const cleanup = () => {
+                        res.off('finish', onFinish);
+                        res.off('close', onClose);
+                        res.off('error', onError);
+                    };
+                    const onFinish = () => {
+                        cleanup();
+                        if (res.statusCode >= 400) {
+                            reject(new Error(`Request finished with status ${res.statusCode}; rolling back transaction.`));
+                            return;
+                        }
+                        resolve();
+                    };
+                    const onClose = () => {
+                        cleanup();
+                        if (!res.writableFinished) {
+                            reject(new Error('Request closed before the response finished.'));
+                        }
+                    };
+                    const onError = (error) => {
+                        cleanup();
+                        reject(error);
+                    };
+                    res.once('finish', onFinish);
+                    res.once('close', onClose);
+                    res.once('error', onError);
                     next();
                 });
             });
         }
         catch (error) {
             /* v8 ignore next -- @preserve */
+            if (res.headersSent || res.writableEnded) {
+                return;
+            }
             next(error);
         }
     };

package/dist/rate-limit.d.ts

@@ -30,4 +30,4 @@ export interface RateLimitOptions {
 /**
  * Returns a middleware for rate limiting requests.
  */
-export declare function rateLimit(redis: RedisClient, { max, windowSizeInSeconds, getKey }?: RateLimitOptions): RateLimitMiddleware;
+export declare function rateLimit(redis: RedisClient, { max, windowSizeInSeconds, getKey, }?: RateLimitOptions): RateLimitMiddleware;

package/dist/redis.d.ts

@@ -4,4 +4,4 @@ export interface RedisOptions {
     onError?: (error: Error) => void;
 }
 export type RedisClient = ReturnType<typeof createClient>;
-export declare function createRedis({ url, onError }?: RedisOptions): RedisClient;
+export declare function createRedis({ url, onError, }?: RedisOptions): RedisClient;

package/dist/routes.d.ts

@@ -2,9 +2,9 @@ import { type Application } from 'express';
 export declare function createDocsRouter(app: Application, extras?: Record<string, any>): import("express").RequestHandler<Record<string, string>, {
     openapi: string;
     info: {
+        description?: string | undefined;
         title: string;
         version: string;
-        description?: string | undefined;
     };
     tags: {
         name: string;
@@ -42,9 +42,9 @@ export declare function toOpenAPISpec(app: Application, info?: {
 }): {
     openapi: string;
     info: {
+        description?: string | undefined;
         title: string;
         version: string;
-        description?: string | undefined;
     };
     tags: {
         name: string;

package/dist/slack.d.ts

@@ -17,7 +17,7 @@ type Blocks = unknown[];
  *
  * See https://api.slack.com/messaging/webhooks
  */
-export declare function createSlack({ webhookUrl, dryRun }?: SlackOptions): {
+export declare function createSlack({ webhookUrl, dryRun, }?: SlackOptions): {
     postMessage: (message: Message, blocks?: Blocks) => Promise<unknown>;
 };
 export {};

package/dist/utils.d.ts

@@ -4,10 +4,7 @@ export declare function readEnv(key: string): string | undefined;
 export declare function readEnv(key: string, defaultValue: string): string;
 export declare namespace readEnv {
     var number: typeof readEnvNumber;
-}
-export declare namespace readEnv {
     var boolean: typeof readEnvBoolean;
 }
 declare function readEnvNumber(key: string, defaultValue: number): number;
 declare function readEnvBoolean(key: string, defaultValue: boolean): boolean;
-export declare const envPort: (defaultPort?: number) => number;