@devmoods/express-extras 0.13.9 → 0.15.0

package/bin/migrate.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env -S node --loader ts-node/esm
+
+import 'dotenv/config';
+
+async function run() {
+  const { cli } = await import('../dist/migrate.js');
+  cli();
+}
+
+run();

package/dist/__tests__/auth.spec.jsx

@@ -1,10 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const auth_1 = require("../auth");
+import { createAuthToken } from '../auth.js';
 test('createAuthToken', async () => {
     process.env.APP_JWT_SECRET = 'test';
-    const first = (0, auth_1.createAuthToken)({});
+    const first = createAuthToken({});
     await new Promise((resolve) => setTimeout(resolve, 1000));
-    const second = (0, auth_1.createAuthToken)({});
+    const second = createAuthToken({});
     expect(first).not.toEqual(second);
 });

package/dist/auth.d.ts

@@ -1,17 +1,19 @@
-import { Request, RequestHandler, Response } from 'express';
-import { RedisClient } from './redis';
+import { type Request, type RequestHandler, type Response } from 'express';
+import type { RedisClient } from './redis.js';
 export declare function createAuthToken(payload: any, secret?: string): string;
-interface LoginMethods<User = any> {
+export interface AuthLoginMethods<User = any> {
     emailAndPassword?: (email: string, verifyPassword: (realPassword: string) => Promise<boolean>) => Promise<User>;
 }
-interface AuthOptions<UserModel extends Record<string, any>> {
-    getUserByToken: (token: Record<string, any>) => Promise<UserModel>;
-    methods: LoginMethods<UserModel>;
+export interface AuthOptions<UserModel extends Record<string, any>> {
+    getUserByToken(token: Record<string, any>): Promise<UserModel>;
+    methods: AuthLoginMethods<UserModel>;
     redis: RedisClient;
-    filterUser?: (user: UserModel) => Partial<UserModel>;
+    filterUser(user: UserModel): Partial<UserModel>;
     tokenExpiry?: number;
+    onResetRequested?(user: UserModel, temporaryToken: string): void | Promise<void>;
+    onPasswordChanged?(user: UserModel, newPassword: string): Promise<void>;
 }
-export declare function createAuth<UserModel extends Record<string, any>>({ getUserByToken, methods: { emailAndPassword }, filterUser, redis, tokenExpiry, }: AuthOptions<UserModel>): {
+export declare function createAuth<UserModel extends Record<string, any>>({ getUserByToken, methods: { emailAndPassword }, filterUser, redis, tokenExpiry, onResetRequested, onPasswordChanged, }: AuthOptions<UserModel>): {
     createRouter: () => import("express-serve-static-core").Router;
     useCurrentUser: () => UserModel | undefined;
     middleware: (authorize?: boolean) => RequestHandler;
@@ -24,4 +26,3 @@ export declare function parseAuthorizationHeader(req: Request): string | null;
 export declare function setAccessTokenCookie(res: Response, token: string | null): void;
 export declare function checkIfPasswordsMatch(realPassword: string, attemptedPassword: string): Promise<boolean>;
 export declare function hashPassword(password: string): Promise<string>;
-export {};

package/dist/auth.js

@@ -1,40 +1,36 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hashPassword = exports.checkIfPasswordsMatch = exports.setAccessTokenCookie = exports.parseAuthorizationHeader = exports.createAuth = exports.createAuthToken = void 0;
-const bcrypt_1 = __importDefault(require("bcrypt"));
-const express_1 = require("express");
-const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
-const uuid_1 = require("uuid");
-const context_1 = require("./context");
-const errors_1 = require("./errors");
-const logger_1 = require("./logger");
-const middleware_1 = require("./middleware");
-const validate_1 = require("./validate");
+import * as bcrypt from 'bcrypt';
+import { Router, } from 'express';
+import jwt from 'jsonwebtoken';
+import * as crypto from 'node:crypto';
+import { v4 } from 'uuid';
+import { setContext, useContext } from './context.js';
+import { BadRequest, NotFound, Unauthorized } from './errors.js';
+import { getLogger } from './logger.js';
+import { route } from './middleware.js';
+import { validateBody, validateParams, } from './validate.js';
+const logger = getLogger('auth');
 const TOKEN_EXPIRES_IN = 3600 * 48;
-function createAuthToken(payload, secret = process.env.APP_JWT_SECRET) {
-    return jsonwebtoken_1.default.sign(payload, secret, { expiresIn: TOKEN_EXPIRES_IN });
+const TEMP_TOKEN_EXIRES_IN = 3600;
+export function createAuthToken(payload, secret = process.env.APP_JWT_SECRET) {
+    return jwt.sign(payload, secret, { expiresIn: TOKEN_EXPIRES_IN });
 }
-exports.createAuthToken = createAuthToken;
-function createAuth({ getUserByToken, methods: { emailAndPassword }, filterUser = (x) => x, redis, tokenExpiry = TOKEN_EXPIRES_IN, }) {
-    const useCurrentUser = () => (0, context_1.useContext)('currentUser');
+export function createAuth({ getUserByToken, methods: { emailAndPassword }, filterUser = (x) => x, redis, tokenExpiry = TOKEN_EXPIRES_IN, onResetRequested, onPasswordChanged, }) {
+    const useCurrentUser = () => useContext('currentUser');
     const createRouter = () => {
-        const router = (0, express_1.Router)();
-        router.get('/me', middleware(), (0, middleware_1.route)(() => {
+        const router = Router();
+        router.get('/me', middleware(), route(() => {
             const user = useCurrentUser();
             return filterUser(user);
         }));
         if (emailAndPassword) {
-            router.post('/login', (0, validate_1.validateBody)({
+            router.post('/login', validateBody({
                 type: 'object',
                 properties: {
                     email: { type: 'string' },
                     password: { type: 'string' },
                 },
                 required: ['email', 'password'],
-            }), (0, middleware_1.route)(async ({ body: { email, password } }, res) => {
+            }), route(async ({ body: { email, password } }, res) => {
                 try {
                     const user = await emailAndPassword(email, (realPassword) => checkIfPasswordsMatch(realPassword, password));
                     const token = createAuthToken(filterUser(user));
@@ -43,12 +39,12 @@ function createAuth({ getUserByToken, methods: { emailAndPassword }, filterUser
                     return [201, { token }];
                 }
                 catch (error) {
-                    (0, logger_1.getLogger)('core').error(error);
-                    throw (0, errors_1.Unauthorized)(error.message);
+                    getLogger('core').error(error);
+                    throw Unauthorized(error.message);
                 }
             }));
         }
-        router.get('/logout', (0, middleware_1.route)(async (req, res) => {
+        router.get('/logout', route(async (req, res) => {
             const token = extractAccessTokenFromRequest(req);
             if (token) {
                 await redis.del(token);
@@ -56,10 +52,75 @@ function createAuth({ getUserByToken, methods: { emailAndPassword }, filterUser
             setAccessTokenCookie(res, null);
             res.redirect('/');
         }));
-        router.get('/token/refresh', middleware(false), (0, middleware_1.route)(async (req, res) => {
+        const skipPasswordCheck = async () => true;
+        const tokenSchema = {
+            type: 'object',
+            properties: {
+                token: { type: 'string', minLength: 50, maxLength: 64 },
+            },
+        };
+        const emailSchema = {
+            type: 'string',
+            minLength: 4,
+        };
+        router.post('/reset/:token', validateParams(tokenSchema), validateBody({
+            type: 'object',
+            properties: {
+                email: emailSchema,
+                password: { type: 'string' },
+            },
+            required: ['email', 'password'],
+        }), route(async (req) => {
+            const { email, password } = req.body;
+            const { token } = req.params;
+            if (!emailAndPassword) {
+                throw new Error('Not applicable for login method');
+            }
+            const user = await emailAndPassword(email, skipPasswordCheck);
+            const tokenEmail = await redis.get(token);
+            if (!tokenEmail || email !== tokenEmail) {
+                throw BadRequest('invalid email');
+            }
+            await onPasswordChanged?.(user, await hashPassword(password));
+            logger.info('user changed password', { email: tokenEmail });
+            return 200;
+        }));
+        router.get('/reset/:token', validateParams(tokenSchema), route(async (req) => {
+            const token = req.params.token;
+            const email = await redis.get(token);
+            if (!email) {
+                throw NotFound();
+            }
+            return 200;
+        }));
+        router.post('/reset', middleware(false), validateBody({
+            type: 'object',
+            properties: {
+                email: emailSchema,
+            },
+            required: ['email'],
+        }), route(async (req) => {
+            const email = req.body.email;
+            if (!emailAndPassword) {
+                throw new Error('Not applicable for login method');
+            }
+            try {
+                const user = await emailAndPassword(email, skipPasswordCheck);
+                const temporaryToken = crypto.randomBytes(32).toString('hex');
+                await redis.set(temporaryToken, user.email, {
+                    EX: TEMP_TOKEN_EXIRES_IN,
+                });
+                await onResetRequested?.(user, temporaryToken);
+            }
+            catch (error) {
+                logger.error(error, 'auth reset failed');
+            }
+            return 202;
+        }));
+        router.get('/token/refresh', middleware(false), route(async (req, res) => {
             const user = useCurrentUser();
             if (!user) {
-                throw (0, errors_1.Unauthorized)();
+                throw Unauthorized();
             }
             const { exp, iat, ...rest } = user;
             const token = createAuthToken(rest);
@@ -86,17 +147,17 @@ function createAuth({ getUserByToken, methods: { emailAndPassword }, filterUser
                     }
                     throw new InvalidToken('token expired');
                 }
-                const decoded = jsonwebtoken_1.default.verify(token.trim(), process.env.APP_JWT_SECRET);
+                const decoded = jwt.verify(token.trim(), process.env.APP_JWT_SECRET);
                 if (typeof decoded === 'string') {
                     throw new Error('Failed to decode token');
                 }
                 const user = await getUserByToken({ ...decoded });
-                (0, context_1.setContext)('currentUser', user);
+                setContext('currentUser', user);
                 next();
             }
             catch (error) {
-                (0, logger_1.getLogger)('core').error(error);
-                next((0, errors_1.Unauthorized)('Invalid token'));
+                getLogger('core').error(error);
+                next(Unauthorized('Invalid token'));
                 return;
             }
         };
@@ -107,12 +168,11 @@ function createAuth({ getUserByToken, methods: { emailAndPassword }, filterUser
         middleware,
     };
 }
-exports.createAuth = createAuth;
 /**
  * Extract a Bearer token from the HTTP Authorization header
  * of `req`.
  */
-function parseAuthorizationHeader(req) {
+export function parseAuthorizationHeader(req) {
     if (!req.headers.authorization) {
         return null;
     }
@@ -131,7 +191,6 @@ function parseAuthorizationHeader(req) {
     }
     return token;
 }
-exports.parseAuthorizationHeader = parseAuthorizationHeader;
 function extractAccessTokenFromRequest(req) {
     const authorizationHeader = parseAuthorizationHeader(req);
     if (authorizationHeader) {
@@ -142,9 +201,9 @@ function extractAccessTokenFromRequest(req) {
     }
     return null;
 }
-function setAccessTokenCookie(res, token) {
+export function setAccessTokenCookie(res, token) {
     if (token == null) {
-        res.cookie('access_token', (0, uuid_1.v4)(), {
+        res.cookie('access_token', v4(), {
             expires: new Date(1970, 0, 1),
         });
     }
@@ -155,25 +214,22 @@ function setAccessTokenCookie(res, token) {
         });
     }
 }
-exports.setAccessTokenCookie = setAccessTokenCookie;
 class InvalidToken extends Error {
     constructor(message) {
         super(message);
         this.name = 'Invalid Token';
     }
 }
-async function checkIfPasswordsMatch(realPassword, attemptedPassword) {
+export async function checkIfPasswordsMatch(realPassword, attemptedPassword) {
     if (!realPassword) {
         throw new Error('User has no defined password');
     }
-    const validPassword = await bcrypt_1.default.compare(attemptedPassword, realPassword);
+    const validPassword = await bcrypt.compare(attemptedPassword, realPassword);
     if (!validPassword) {
         throw new Error(`Passwords does not match`);
     }
     return true;
 }
-exports.checkIfPasswordsMatch = checkIfPasswordsMatch;
-function hashPassword(password) {
-    return bcrypt_1.default.hash(password, 10);
+export function hashPassword(password) {
+    return bcrypt.hash(password, 10);
 }
-exports.hashPassword = hashPassword;

package/dist/context.d.ts

@@ -1,5 +1,5 @@
-import { Request, RequestHandler } from 'express';
-interface RequestContextOptions {
+import { type Request, type RequestHandler } from 'express';
+export interface RequestContextOptions {
     getRequestId?: (req: Request) => string | undefined;
 }
 /**
@@ -23,4 +23,3 @@ export declare function useRequestId(): string | undefined;
  * @deprecated
  */
 export declare const getRequestId: typeof useRequestId;
-export {};

package/dist/context.js

@@ -1,49 +1,42 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRequestId = exports.useRequestId = exports.setContext = exports.getContext = exports.useContext = exports.withRequestContext = void 0;
-const cls_hooked_1 = require("cls-hooked");
-const uuid_1 = require("uuid");
-const requestContext = (0, cls_hooked_1.createNamespace)('@requestContext');
+import { createNamespace } from 'cls-hooked';
+import { v4 as uuid } from 'uuid';
+const requestContext = createNamespace('@requestContext');
 /**
  * Middleware for setting a `requestId` on the request context.
  */
-function withRequestContext({ getRequestId = (req) => req.headers['X-Request-ID'], } = {}) {
+export function withRequestContext({ getRequestId = (req) => req.headers['X-Request-ID'], } = {}) {
     return (req, res, next) => {
-        const requestId = getRequestId(req) || (0, uuid_1.v4)();
+        const requestId = getRequestId(req) || uuid();
         requestContext.run(() => {
             requestContext.set('requestId', requestId);
             next();
         });
     };
 }
-exports.withRequestContext = withRequestContext;
 /**
  * Return a value from the request context
  */
-function useContext(key) {
+export function useContext(key) {
     if (requestContext && requestContext.active) {
         return requestContext.get(key);
     }
 }
-exports.useContext = useContext;
 /**
  * @deprecated
  */
-exports.getContext = useContext;
+export const getContext = useContext;
 /**
  * Set a value on the request context
  */
-function setContext(key, value) {
+export function setContext(key, value) {
     if (requestContext && requestContext.active) {
         return requestContext.set(key, value);
     }
 }
-exports.setContext = setContext;
-function useRequestId() {
+export function useRequestId() {
     return useContext('requestId');
 }
-exports.useRequestId = useRequestId;
 /**
  * @deprecated
  */
-exports.getRequestId = useRequestId;
+export const getRequestId = useRequestId;

package/dist/email.js

@@ -1,32 +1,6 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEmail = void 0;
-const nodemailer = __importStar(require("nodemailer"));
-const logger_1 = require("./logger");
-function createEmail({ host, port, user, pass, senderName, senderAddress, }) {
+import * as nodemailer from 'nodemailer';
+import { getLogger } from './logger.js';
+export function createEmail({ host, port, user, pass, senderName, senderAddress, }) {
     const transporter = nodemailer.createTransport({
         host,
         port: parseInt(port || '587', 10),
@@ -41,8 +15,7 @@ function createEmail({ host, port, user, pass, senderName, senderAddress, }) {
             text: message,
             ...rest,
         });
-        (0, logger_1.getLogger)('core').info('email-sent', { email: result });
+        getLogger('core').info('email-sent', { email: result });
     };
     return { send };
 }
-exports.createEmail = createEmail;

package/dist/errors.js

@@ -1,58 +1,25 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.errorHandler = exports.mapToProblem = exports.makeError = exports.Conflict = exports.Unauthorized = exports.NotFound = exports.Forbidden = exports.BadRequest = exports.ApiError = void 0;
-const http_1 = require("http");
-const Sentry = __importStar(require("@sentry/node"));
-const compose_middleware_1 = require("compose-middleware");
-class ApiError extends Error {
+import * as Sentry from '@sentry/node';
+import { errors } from 'compose-middleware';
+import { STATUS_CODES } from 'node:http';
+export class ApiError extends Error {
 }
-exports.ApiError = ApiError;
-const BadRequest = (reason) => makeError(400, 'Invalid Params', { reason });
-exports.BadRequest = BadRequest;
-const Forbidden = (detail = '') => makeError(403, detail);
-exports.Forbidden = Forbidden;
-const NotFound = (detail = 'Could not find resource') => makeError(404, detail);
-exports.NotFound = NotFound;
-const Unauthorized = (detail = 'Unauthorized') => makeError(401, detail);
-exports.Unauthorized = Unauthorized;
-const Conflict = (detail = '') => makeError(409, detail);
-exports.Conflict = Conflict;
+export const BadRequest = (reason) => makeError(400, 'Invalid Params', { reason });
+export const Forbidden = (detail = '') => makeError(403, detail);
+export const NotFound = (detail = 'Could not find resource') => makeError(404, detail);
+export const Unauthorized = (detail = 'Unauthorized') => makeError(401, detail);
+export const Conflict = (detail = '') => makeError(409, detail);
 /**
  * Create a new ApiError instance
  */
-function makeError(status, detail, payload) {
-    const error = new ApiError(detail || http_1.STATUS_CODES[status]);
+export function makeError(status, detail, payload) {
+    const error = new ApiError(detail || STATUS_CODES[status]);
     error.status = status;
     error.payload = payload;
     return error;
 }
-exports.makeError = makeError;
-function mapToProblem(error) {
+export function mapToProblem(error) {
     if (error instanceof ApiError) {
-        const statusMessage = http_1.STATUS_CODES[error.status || '500'];
+        const statusMessage = STATUS_CODES[error.status || '500'];
         return {
             type: `/api/problems/${statusMessage
                 .toLocaleLowerCase()
@@ -69,14 +36,13 @@ function mapToProblem(error) {
         status: 500,
     };
 }
-exports.mapToProblem = mapToProblem;
 function _errorHandler({ onError }) {
     return (err, req, res, next // eslint-disable-line
     ) => {
         if (!err) {
             err = makeError(500);
         }
-        onError === null || onError === void 0 ? void 0 : onError(err);
+        onError?.(err);
         const problem = mapToProblem(err);
         res.status(problem.status).json(problem);
     };
@@ -86,8 +52,8 @@ function _errorHandler({ onError }) {
  *
  * Composed together with the Sentry error handler.
  */
-function errorHandler({ onError }) {
-    return (0, compose_middleware_1.errors)([
+export function errorHandler({ onError }) {
+    return errors([
         Sentry.Handlers.errorHandler({
             shouldHandleError(error) {
                 if (error instanceof ApiError && error.status < 500) {
@@ -99,4 +65,3 @@ function errorHandler({ onError }) {
         _errorHandler({ onError }),
     ]);
 }
-exports.errorHandler = errorHandler;

package/dist/index.d.ts

@@ -1,14 +1,14 @@
-export * from './auth';
-export * from './context';
-export * from './email';
-export * from './errors';
-export * from './listen';
-export * from './logger';
-export * from './middleware';
-export * from './postgres';
-export * from './redis';
-export * from './routes';
-export * from './sentry';
-export * from './slack';
-export * from './validate';
+export * from './auth.js';
+export * from './context.js';
+export * from './email.js';
+export * from './errors.js';
+export * from './listen.js';
+export * from './logger.js';
+export * from './middleware.js';
+export * from './postgres.js';
+export * from './redis.js';
+export * from './routes.js';
+export * from './sentry.js';
+export * from './slack.js';
+export * from './validate.js';
 export declare const envPort: (defaultPort?: number) => number;

package/dist/index.js

@@ -1,32 +1,14 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.envPort = void 0;
-__exportStar(require("./auth"), exports);
-__exportStar(require("./context"), exports);
-__exportStar(require("./email"), exports);
-__exportStar(require("./errors"), exports);
-__exportStar(require("./listen"), exports);
-__exportStar(require("./logger"), exports);
-__exportStar(require("./middleware"), exports);
-__exportStar(require("./postgres"), exports);
-__exportStar(require("./redis"), exports);
-__exportStar(require("./routes"), exports);
-__exportStar(require("./sentry"), exports);
-__exportStar(require("./slack"), exports);
-__exportStar(require("./validate"), exports);
-const envPort = (defaultPort = 3000) => parseInt(process.env.PORT, 10) || defaultPort;
-exports.envPort = envPort;
+export * from './auth.js';
+export * from './context.js';
+export * from './email.js';
+export * from './errors.js';
+export * from './listen.js';
+export * from './logger.js';
+export * from './middleware.js';
+export * from './postgres.js';
+export * from './redis.js';
+export * from './routes.js';
+export * from './sentry.js';
+export * from './slack.js';
+export * from './validate.js';
+export const envPort = (defaultPort = 3000) => parseInt(process.env.PORT, 10) || defaultPort;

package/dist/listen.d.ts

@@ -1,6 +1,5 @@
-/// <reference types="node" />
-import http from 'http';
-import { createLogger } from './logger';
+/// <reference types="node" resolution-mode="require"/>
+import type * as http from 'node:http';
 /**
  * Listen on the given port and setup proper signal
  * handlers for terminating the process properly.
@@ -9,7 +8,6 @@ import { createLogger } from './logger';
  */
 export declare function listen(server: http.Server, options: {
     port: number;
-    logger: ReturnType<typeof createLogger>;
     onShutdown?: () => void | Promise<void>;
     healthCheck?: () => Promise<void>;
 }): void;