@devmoods/express-extras 0.14.0 → 0.15.1

package/dist/auth.d.ts

@@ -1,17 +1,19 @@
 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,17 +1,20 @@
 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 { Unauthorized } from './errors.js';
+import { BadRequest, NotFound, Unauthorized } from './errors.js';
 import { getLogger } from './logger.js';
 import { route } from './middleware.js';
-import { validateBody } from './validate.js';
+import { validateBody, validateParams, } from './validate.js';
+const logger = getLogger('auth');
 const TOKEN_EXPIRES_IN = 3600 * 48;
+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 });
 }
-export function createAuth({ getUserByToken, methods: { emailAndPassword }, filterUser = (x) => x, redis, tokenExpiry = TOKEN_EXPIRES_IN, }) {
+export function createAuth({ getUserByToken, methods: { emailAndPassword }, filterUser = (x) => x, redis, tokenExpiry = TOKEN_EXPIRES_IN, onResetRequested, onPasswordChanged, }) {
     const useCurrentUser = () => useContext('currentUser');
     const createRouter = () => {
         const router = Router();
@@ -36,7 +39,7 @@ export function createAuth({ getUserByToken, methods: { emailAndPassword }, filt
                     return [201, { token }];
                 }
                 catch (error) {
-                    getLogger('core').error(error);
+                    logger.error(error);
                     throw Unauthorized(error.message);
                 }
             }));
@@ -49,6 +52,72 @@ export function createAuth({ getUserByToken, methods: { emailAndPassword }, filt
             setAccessTokenCookie(res, null);
             res.redirect('/');
         }));
+        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));
+            await redis.del(token);
+            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) {
@@ -88,7 +157,7 @@ export function createAuth({ getUserByToken, methods: { emailAndPassword }, filt
                 next();
             }
             catch (error) {
-                getLogger('core').error(error);
+                logger.error(error);
                 next(Unauthorized('Invalid token'));
                 return;
             }

package/dist/context.d.ts

@@ -1,5 +1,5 @@
 import { type Request, type RequestHandler } from 'express';
-interface RequestContextOptions {
+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/listen.d.ts

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

package/dist/listen.js

@@ -1,4 +1,6 @@
 import { createTerminus } from '@godaddy/terminus';
+import { getLogger } from './logger.js';
+const logger = getLogger();
 const READINESS_PERIOD_MS = parseInt(process.env.DM_READINESS_PERIOD_MS || '', 10) || 0;
 const FORCE_EXIT_TIMEOUT = parseInt(process.env.DM_FORCE_EXIT_TIMEOUT || '', 10) || 1000;
 /**
@@ -12,7 +14,7 @@ export function listen(server, options) {
         timeout: FORCE_EXIT_TIMEOUT,
         signals: ['SIGTERM', 'SIGINT'],
         async onShutdown() {
-            options.logger.info('app shutting down');
+            logger.info('app shutting down');
         },
         beforeShutdown() {
             return new Promise((resolve) => {
@@ -20,11 +22,11 @@ export function listen(server, options) {
             });
         },
         async onSignal() {
-            options.logger.info('app received shutdown signal');
+            logger.info('app received shutdown signal');
             await options?.onShutdown?.();
         },
         async onSendFailureDuringShutdown() {
-            options.logger.info('app sent service not available message to client');
+            logger.info('app sent service not available message to client');
         },
         healthChecks: {
             '/health': async ({ state }) => {
@@ -35,7 +37,7 @@ export function listen(server, options) {
                     await options?.healthCheck?.();
                 }
                 catch (error) {
-                    options.logger.error(error, 'health check failed');
+                    logger.error(error, 'health check failed');
                     throw error;
                 }
             },
@@ -43,6 +45,6 @@ export function listen(server, options) {
     });
     const port = options.port;
     server.listen(port, () => {
-        options.logger.info('app listening', { port });
+        logger.info('app listening', { port });
     });
 }

package/dist/logger.d.ts

@@ -1,4 +1,5 @@
 import type { CreateSentry } from './sentry.js';
+export declare type LoggerContext = Record<string, any>;
 export interface LoggerOptions {
     /**
      * Name of the logger
@@ -7,15 +8,14 @@ export interface LoggerOptions {
     /**
      * Context to attach to each log line
      */
-    getContext?: () => {
-        [key: string]: any;
-    };
+    getContext?: () => LoggerContext;
     /**
      * Defaults to `process.env.NODE_ENV === 'test'`
      */
     silent?: () => boolean;
 }
 export declare function attachSentryClientToLoggers(sentryClient: CreateSentry['client']): void;
+export declare function setGlobalLoggerContext(getContext: () => LoggerContext): void;
 export declare type Logger = ReturnType<typeof createLogger>;
 export declare function createLogger({ name, getContext, silent, }: LoggerOptions): {
     debug(message: string, context?: {
@@ -30,7 +30,7 @@ export declare function createLogger({ name, getContext, silent, }: LoggerOption
     error(error: Error | null, message?: string): void;
     fatal(error: Error | null, message?: string): void;
 };
-export declare function getLogger(name: string): Logger;
+export declare function getLogger(name?: string): Logger;
 export declare function getLoggers(): Map<string, {
     debug(message: string, context?: {
         [key: string]: any;

package/dist/logger.js

@@ -1,15 +1,20 @@
 import bunyan from 'bunyan';
 import { useRequestId } from './context.js';
-function defaultGetContext() {
-    return {
-        requestId: useRequestId(),
-    };
-}
 const _loggers = new Map();
 let _sentryClient;
 export function attachSentryClientToLoggers(sentryClient) {
     _sentryClient = sentryClient;
 }
+let _globalGetContext;
+export function setGlobalLoggerContext(getContext) {
+    _globalGetContext = getContext;
+}
+function defaultGetContext() {
+    return {
+        requestId: useRequestId(),
+        ..._globalGetContext?.(),
+    };
+}
 export function createLogger({ name, getContext, silent = () => process.env.NODE_ENV === 'test', }) {
     if (_loggers.has(name)) {
         throw new Error(`A logger named ${name} already exists`);
@@ -60,7 +65,7 @@ export function createLogger({ name, getContext, silent = () => process.env.NODE
         },
     };
 }
-export function getLogger(name) {
+export function getLogger(name = 'default') {
     const logger = _loggers.get(name);
     if (!logger) {
         return createLogger({ name });

package/dist/routes.js

@@ -10,7 +10,7 @@ function split(value) {
             .toString()
             .replace('/?', '')
             .replace('(?=/|$)', '$')
-            .match(/^\/\^((?:\\[.*+?^${}()|[\]\\\/]|[^.*+?^${}()|[\]\\\/])*)\$\//);
+            .match(/^\/\^((?:\\[.*+?^${}()|[\]\\/]|[^.*+?^${}()|[\]\\/])*)\$\//);
         return match
             ? match[1].replace(/\\(.)/g, '$1')
             : '<complex:' + value.toString() + '>';

package/dist/sentry.d.ts

@@ -29,6 +29,7 @@ export declare function createSentryOptions(app: Application | null, options?: S
     autoSessionTracking?: boolean | undefined;
     sendClientReports?: boolean | undefined;
     dist?: string | undefined;
+    instrumenter?: import("@sentry/types").Instrumenter | undefined;
     transportOptions?: Partial<import("@sentry/node/types/transports/http.js").NodeTransportOptions> | undefined;
     tracesSampleRate: number;
     initialScope?: import("@sentry/types").CaptureContext | undefined;
@@ -46,8 +47,10 @@ export declare function createSentryOptions(app: Application | null, options?: S
     } | undefined;
     tracesSampler?: ((samplingContext: import("@sentry/types").SamplingContext) => number | boolean) | undefined;
     beforeSend?: ((event: Sentry.Event, hint: Sentry.EventHint) => Sentry.Event | PromiseLike<Sentry.Event | null> | null) | undefined;
+    beforeSendTransaction?: ((event: Sentry.Event, hint: Sentry.EventHint) => Sentry.Event | PromiseLike<Sentry.Event | null> | null) | undefined;
     beforeBreadcrumb?: ((breadcrumb: Sentry.Breadcrumb, hint?: Sentry.BreadcrumbHint | undefined) => Sentry.Breadcrumb | null) | undefined;
     serverName?: string | undefined;
     tracePropagationTargets?: import("@sentry/types").TracePropagationTargets | undefined;
+    shouldCreateSpanForRequest?(url: string): boolean;
     onFatalError?(error: Error): void;
 };

package/dist/slack.js

@@ -1,5 +1,6 @@
 import { createFetch } from '@devmoods/fetch';
 import { getLogger } from './logger.js';
+const logger = getLogger();
 /**
  * Send messages to Slack using Incoming Webhooks
  *
@@ -24,6 +25,7 @@ export function createSlack({ webhookUrl = process.env.SLACK_WEBHOOK_URL, dryRun
      */
     async function postMessage(message, blocks) {
         if (dryRun) {
+            logger.info('slack post message (dry run)', { message });
             return;
         }
         try {
@@ -40,7 +42,7 @@ export function createSlack({ webhookUrl = process.env.SLACK_WEBHOOK_URL, dryRun
             return response.jsonData;
         }
         catch (error) {
-            getLogger('core').error(error);
+            logger.error(error);
             throw error;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devmoods/express-extras",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "description": "Kubernetes-ready utilities for rapid Node.js application development",
   "type": "module",
   "main": "./dist/index.js",
@@ -38,7 +38,7 @@
     "@types/jest": "29.2.2",
     "@types/node": "18.11.9",
     "@types/supertest": "2.0.12",
-    "@typescript-eslint/eslint-plugin": "^5.42.0",
+    "@typescript-eslint/eslint-plugin": "^5.42.1",
     "eslint": "^8.27.0",
     "eslint-plugin-jsx-a11y": "^6.6.1",
     "eslint-plugin-prettier": "^4.2.1",
@@ -47,7 +47,7 @@
     "import-sort-cli": "6.0.0",
     "import-sort-style-module": "6.0.0",
     "isomorphic-fetch": "3.0.0",
-    "jest": "29.2.2",
+    "jest": "29.3.1",
     "prettier": "2.7.1",
     "supertest": "6.3.1",
     "ts-jest": "29.0.3",
@@ -57,8 +57,8 @@
   "dependencies": {
     "@devmoods/fetch": "^3.3.0",
     "@godaddy/terminus": "^4.11.2",
-    "@sentry/node": "^7.17.4",
-    "@sentry/tracing": "^7.17.4",
+    "@sentry/node": "^7.18.0",
+    "@sentry/tracing": "^7.18.0",
     "@types/bcrypt": "^5.0.0",
     "@types/bunyan": "^1.8.8",
     "@types/cls-hooked": "^4.3.3",
@@ -74,7 +74,7 @@
     "cls-hooked": "^4.2.2",
     "compose-middleware": "^5.0.1",
     "cookie-parser": "^1.4.6",
-    "dotenv-safe": "^8.2.0",
+    "dotenv": "^16.0.3",
     "express": "^4.18.2",
     "helmet": "^6.0.0",
     "jsonwebtoken": "^8.5.1",