@devmoods/express-extras 0.41.0 → 0.42.1

package/dist/auth.d.ts

@@ -30,7 +30,10 @@ export interface AuthProviderContext<UserModel extends AnyUser> {
     redis: AuthOptions<UserModel>['redis'];
     setCurrentUser: (user: UserModel) => void;
     createTemporaryToken(user: UserModel): Promise<string>;
-    middleware: (authorize?: boolean) => RequestHandler;
+    middleware: (options?: AuthMiddlewareOptions<UserModel>) => RequestHandler;
+    login: (res: Response, user: UserModel) => Promise<{
+        token: string;
+    }>;
 }
 export type AnyUser = Record<string, any>;
 export interface AuthProvider<UserModel extends AnyUser> {
@@ -45,9 +48,12 @@ export interface AuthOptions<UserModel extends AnyUser> {
 export interface CreateAuth<UserModel extends AnyUser> {
     createRouter: () => Router;
     useCurrentUser: () => UserModel | undefined;
-    middleware: (authorize?: boolean) => RequestHandler;
+    middleware: (options?: AuthMiddlewareOptions<UserModel>) => RequestHandler;
     createTemporaryToken(user: UserModel): Promise<string>;
 }
+export type AuthMiddlewareOptions<UserModel extends AnyUser> = false | {
+    isAuthorized?: (user: UserModel) => Promise<boolean> | boolean;
+};
 export declare function createAuth<UserModel extends AnyUser>({ getUserByToken, filterUser, redis, providers, }: AuthOptions<UserModel>): CreateAuth<UserModel>;
 /**
  * Extract a Bearer token from the HTTP Authorization header

package/dist/auth.js

@@ -4,7 +4,7 @@ import { Router, } from 'express';
 import jwt from 'jsonwebtoken';
 import { v4 } from 'uuid';
 import { setContext, useContext } from './context.js';
-import { BadRequest, NotFound, Unauthorized } from './errors.js';
+import { ApiError, BadRequest, Forbidden, NotFound, Unauthorized, } from './errors.js';
 import { getLogger } from './logger.js';
 import { route } from './middleware.js';
 import {} from './redis.js';
@@ -57,10 +57,7 @@ export function EmailAndPasswordAuthProvider(options) {
             }), route(async ({ body: { email, password } }, res) => {
                 try {
                     const user = await options.login(email, (realPassword) => checkIfPasswordsMatch(realPassword, password));
-                    const token = createAuthToken(context.filterUser(user));
-                    await context.redis.set(token, '1', { EX: TOKEN_EXPIRES_IN });
-                    setAccessTokenCookie(res, token);
-                    context.setCurrentUser(user);
+                    const { token } = await context.login(res, user);
                     logger.info('access token created');
                     return [201, { token }];
                 }
@@ -146,12 +143,20 @@ export function EmailAndPasswordAuthProvider(options) {
 export function createAuth({ getUserByToken, filterUser, redis, providers, }) {
     const useCurrentUser = () => useContext('currentUser');
     const setCurrentUser = (user) => setContext('currentUser', user);
+    const login = async (res, user) => {
+        const token = createAuthToken(filterUser(user));
+        await redis.set(token, '1', { EX: TOKEN_EXPIRES_IN });
+        setAccessTokenCookie(res, token);
+        setCurrentUser(user);
+        return { token };
+    };
     const providerContext = {
         filterUser,
         redis,
         setCurrentUser,
         createTemporaryToken,
         middleware,
+        login,
     };
     const createRouter = () => {
         const router = Router();
@@ -201,19 +206,24 @@ export function createAuth({ getUserByToken, filterUser, redis, providers, }) {
         }
         return router;
     };
-    function middleware(authorize = true) {
+    function middleware(options = {}) {
+        let authenticate = true;
+        if (typeof options === 'boolean') {
+            authenticate = options;
+            options = {};
+        }
         return async (req, res, next) => {
             try {
                 const token = extractAccessTokenFromRequest(req);
                 if (!token) {
-                    if (!authorize) {
+                    if (!authenticate) {
                         return next();
                     }
                     throw new InvalidToken('token missing');
                 }
                 const valid = await redis.get(token);
                 if (!valid) {
-                    if (!authorize) {
+                    if (!authenticate) {
                         logger.warn('request with invalid access token');
                         return next();
                     }
@@ -221,13 +231,20 @@ export function createAuth({ getUserByToken, filterUser, redis, providers, }) {
                 }
                 const decoded = decodeAuthToken(token);
                 const user = await getUserByToken(decoded);
+                if (options.isAuthorized && !(await options.isAuthorized(user))) {
+                    throw Forbidden('Permission denied');
+                }
                 setCurrentUser(user);
                 next();
             }
             catch (error) {
                 logger.error(error);
-                next(Unauthorized('Invalid token'));
-                return;
+                if (error instanceof ApiError) {
+                    next(error);
+                }
+                else {
+                    next(Unauthorized('Invalid token'));
+                }
             }
         };
     }

package/dist/csrf.d.ts

@@ -1,4 +1,5 @@
 import { type RequestHandler, type Request, type Response } from 'express';
+export declare const getCsrfSecret: () => string;
 export interface CsrfMiddlewareOptions {
     excempt?: boolean;
     cookieName?: string;

package/dist/csrf.js

@@ -9,6 +9,13 @@ const defaultCookieName = () => {
         ? '__Host-devmoods.x-csrf-token'
         : 'devmoods.x-csrf-token';
 };
+export const getCsrfSecret = () => {
+    const secret = readEnv('CSRF_SECRET', '');
+    if (!secret) {
+        throw new Error('CSRF_SECRET is not set');
+    }
+    return secret;
+};
 export function csrf({ excempt = false, sessionIdentifier, cookieName, } = {}) {
     return (req, res, next) => {
         const existingOptions = useCsrfOptions();
@@ -34,7 +41,7 @@ function useCsrfOptions() {
     });
 }
 const generateTokenAndHash = (req, { overwrite = false } = {}) => {
-    const secret = readEnv('CSRF_SECRET', '');
+    const secret = getCsrfSecret();
     const { sessionIdentifier, cookieName } = useCsrfOptions();
     const csrfCookie = req.cookies[cookieName];
     if (typeof csrfCookie === 'string' && !overwrite) {
@@ -84,7 +91,7 @@ const validateRequest = (req) => {
     }
     const [csrfToken, csrfTokenHash] = csrfCookie.split('|');
     const csrfTokenFromRequest = req.headers['x-csrf-token'];
-    const secret = readEnv('CSRF_SECRET', '');
+    const secret = getCsrfSecret();
     if (!csrfTokenFromRequest) {
         throw Forbidden('Missing CSRF token');
     }

package/dist/middleware.d.ts

@@ -38,7 +38,7 @@ export declare function after(): RequestHandler;
 type ResponseHeaders = Record<string, string>;
 type AnyResponseBody = Record<string, any> | string;
 type HttpResponseCode = number;
-type ResponseWrapper<TResponseBody extends AnyResponseBody> = TResponseBody | HttpResponseCode | [HttpResponseCode, TResponseBody] | [HttpResponseCode, TResponseBody, ResponseHeaders];
+type ResponseWrapper<TResponseBody extends AnyResponseBody> = TResponseBody | TResponseBody[] | HttpResponseCode | [HttpResponseCode, TResponseBody] | [HttpResponseCode, TResponseBody, ResponseHeaders];
 /**
  * Alias of `route()`
  */

package/dist/postgres.d.ts

@@ -17,12 +17,13 @@ export declare class IntegrityError extends Error {
 }
 type Value = null | string | number | Date;
 export interface ConnectionOptions {
-    onLogStatement?: (statement: SqlStatement | string, values?: unknown[]) => void;
+    onLogStatement?: (statement: SqlStatement | string, values: unknown[] | undefined, duration: number) => void;
 }
 export declare class Connection {
     private options;
     client: PoolClient;
     constructor(client: PoolClient, options: ConnectionOptions);
+    private onLogStatement;
     query<T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]): Promise<QueryResult<T>>;
     all<T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]): Promise<T[]>;
     insert<T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]): Promise<QueryResult<T>>;

package/dist/postgres.js

@@ -1,6 +1,6 @@
 import pg, {} from 'pg';
 import { format } from 'sql-formatter';
-import { readEnv } from './utils.js';
+import { readEnv, startTimer } from './utils.js';
 export const escapePostgresIdentifier = pg.escapeIdentifier;
 export const escapePostgresLiteral = pg.escapeLiteral;
 export const formatSql = (statement) => {
@@ -35,9 +35,17 @@ export class Connection {
         this.options = options;
         this.client = client;
     }
+    onLogStatement(text, values, duration) {
+        if (this.options.onLogStatement) {
+            return this.options.onLogStatement(text, values, duration);
+        }
+        if (readEnv.boolean('LOG_SQL', false)) {
+            console.log(`\n${formatSql(text)}\n\nValues: ${JSON.stringify(values)}\nDuration: ${duration}ms\n`);
+        }
+    }
     async query(text, values) {
+        const timer = startTimer();
         try {
-            this.options.onLogStatement?.(text, values);
             return await this.client.query(text, values);
         }
         catch (error) {
@@ -46,6 +54,9 @@ export class Connection {
             }
             throw error;
         }
+        finally {
+            this.onLogStatement?.(text, values, timer.getDuration());
+        }
     }
     async all(text, values) {
         const result = await this.query(text, values);

package/dist/utils.d.ts

@@ -4,6 +4,7 @@ import { type EventEmitter } from 'node:events';
  *
  */
 export declare function startTimer(): {
+    reset(): void;
     getDuration(): number;
 };
 export declare function readEnv(key: string): string | undefined;

package/dist/utils.js

@@ -4,8 +4,11 @@ import {} from 'node:events';
  *
  */
 export function startTimer() {
-    const start = process.hrtime();
+    let start = process.hrtime();
     return {
+        reset() {
+            start = process.hrtime();
+        },
         getDuration() {
             const elapsed = process.hrtime(start);
             return (elapsed[0] * 1e9 + elapsed[1]) / 1e9;

package/dist/validate.d.ts

@@ -39,12 +39,12 @@ export type ValidationResult = {
         [key: string]: any;
     };
 };
-export declare function compileValidateSchema(schema: ValidationSchema, options?: Options): (data: any) => {
-    isValid: boolean;
-    errors: null;
+export declare function compileValidateSchema(schema: ValidationSchema, options?: Options): (data: unknown) => {
+    readonly isValid: true;
+    readonly errors: null;
 } | {
-    isValid: boolean;
-    errors: {
+    readonly isValid: false;
+    readonly errors: {
         [key: string]: any[];
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devmoods/express-extras",
-  "version": "0.41.0",
+  "version": "0.42.1",
   "description": "Kubernetes-ready utilities for rapid Node.js application development",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,9 +22,9 @@
     "@types/koa-compose": "^3.2.8",
     "@types/node": "22.10.1",
     "@types/supertest": "^6.0.2",
-    "@typescript-eslint/eslint-plugin": "^8.16.0",
-    "@typescript-eslint/parser": "^8.16.0",
-    "@vitest/coverage-v8": "^2.1.6",
+    "@typescript-eslint/eslint-plugin": "^8.17.0",
+    "@typescript-eslint/parser": "^8.17.0",
+    "@vitest/coverage-v8": "^2.1.8",
     "cookiejar": "^2.1.4",
     "eslint": "^8.57.0",
     "eslint-plugin-import": "^2.31.0",
@@ -35,13 +35,13 @@
     "ts-node": "10.9.2",
     "tsx": "^4.19.2",
     "typescript": "5.7.2",
-    "vitest": "^2.1.6",
+    "vitest": "^2.1.8",
     "vitest-fail-on-console": "^0.7.1"
   },
   "dependencies": {
     "@devmoods/fetch": "^4.0.1",
-    "@sentry/node": "^8.41.0",
-    "@sentry/profiling-node": "^8.41.0",
+    "@sentry/node": "^8.42.0",
+    "@sentry/profiling-node": "^8.42.0",
     "@types/bcrypt": "^5.0.2",
     "@types/body-parser": "^1.19.5",
     "@types/cookie-parser": "^1.4.8",
@@ -58,7 +58,7 @@
     "commander": "^12.1.0",
     "compose-middleware": "^5.0.1",
     "cookie-parser": "^1.4.7",
-    "dotenv": "^16.4.5",
+    "dotenv": "^16.4.6",
     "express": "^4.21.1",
     "helmet": "^8.0.0",
     "jsonwebtoken": "^9.0.2",