@devmoods/express-extras 0.59.0 → 0.60.0

package/dist/auth/emailAndPassword.js

@@ -1,12 +1,12 @@
 import argon2 from 'argon2';
 import bcrypt from 'bcrypt';
+import {} from 'express';
 import { createTokenResponse, tokenSchema } from './token.js';
 import {} from './types.js';
 import { Unauthorized } from '../errors.js';
 import { getLogger } from '../logger.js';
-import { route } from '../middleware.js';
 import { startTimer } from '../utils.js';
-import { validateBody } from '../validate.js';
+import { jsonSchema } from '../validate.js';
 const passwordSchema = { type: 'string', minLength: 4 };
 const emailSchema = { type: 'string', minLength: 4 };
 const logger = getLogger('auth');
@@ -14,14 +14,16 @@ export function EmailAndPasswordAuthProvider(options) {
     const skipPasswordCheck = async () => '';
     return {
         setupRoutes(router, context) {
-            router.post('/login', validateBody({
-                type: 'object',
-                properties: {
-                    email: emailSchema,
-                    password: passwordSchema,
-                },
-                required: ['email', 'password'],
-            }), route(async (req, res) => {
+            router.post('/login', {
+                request: jsonSchema({
+                    type: 'object',
+                    properties: {
+                        email: emailSchema,
+                        password: passwordSchema,
+                    },
+                    required: ['email', 'password'],
+                }),
+            }, async (req, res) => {
                 const { email, password } = req.body;
                 const timer = startTimer();
                 try {
@@ -36,12 +38,14 @@ export function EmailAndPasswordAuthProvider(options) {
                     await context.jitter(timer.getDuration());
                     throw Unauthorized(error.message);
                 }
-            }));
-            router.post('/change-password', validateBody({
-                type: 'object',
-                properties: { token: tokenSchema, password: passwordSchema },
-                required: ['token', 'password'],
-            }), route(async (req) => {
+            });
+            router.post('/change-password', {
+                request: jsonSchema({
+                    type: 'object',
+                    properties: { token: tokenSchema, password: passwordSchema },
+                    required: ['token', 'password'],
+                }),
+            }, async (req) => {
                 const { password, token } = req.body;
                 const decoded = context.decodeTemporaryToken(token);
                 const user = await context.getUserById(decoded.payload.uid);
@@ -58,12 +62,14 @@ export function EmailAndPasswordAuthProvider(options) {
                 });
                 logger.info('user changed password');
                 return 200;
-            }));
-            router.post('/verify-email-request', validateBody({
-                type: 'object',
-                properties: { email: emailSchema },
-                required: ['email'],
-            }), route(async (req) => {
+            });
+            router.post('/verify-email-request', {
+                request: jsonSchema({
+                    type: 'object',
+                    properties: { email: emailSchema },
+                    required: ['email'],
+                }),
+            }, async (req) => {
                 const { email } = req.body;
                 const timer = startTimer();
                 const user = await options.login(email, skipPasswordCheck);
@@ -71,12 +77,14 @@ export function EmailAndPasswordAuthProvider(options) {
                 await options.onEmailVerificationRequest?.(user, temporaryToken);
                 await context.jitter(timer.getDuration());
                 return 202;
-            }));
-            router.post('/verify-email', validateBody({
-                type: 'object',
-                properties: { token: tokenSchema, email: emailSchema },
-                required: ['token', 'email'],
-            }), route(async (req) => {
+            });
+            router.post('/verify-email', {
+                request: jsonSchema({
+                    type: 'object',
+                    properties: { token: tokenSchema, email: emailSchema },
+                    required: ['token', 'email'],
+                }),
+            }, async (req) => {
                 const { token, email } = req.body;
                 const user = await options.login(email, skipPasswordCheck);
                 try {
@@ -94,12 +102,14 @@ export function EmailAndPasswordAuthProvider(options) {
                 await options.onEmailVerified?.(user);
                 logger.info('user verified');
                 return 200;
-            }));
-            router.post('/reset', context.middleware(false), validateBody({
-                type: 'object',
-                properties: { email: emailSchema },
-                required: ['email'],
-            }), route(async (req) => {
+            });
+            router.post('/reset', {
+                request: jsonSchema({
+                    type: 'object',
+                    properties: { email: emailSchema },
+                    required: ['email'],
+                }),
+            }, context.middleware(false), async (req) => {
                 const { email } = req.body;
                 const timer = startTimer();
                 try {
@@ -113,7 +123,7 @@ export function EmailAndPasswordAuthProvider(options) {
                     logger.error(error, 'auth reset failed');
                 }
                 return 202;
-            }));
+            });
         },
     };
 }

package/dist/auth/google.d.ts

@@ -0,0 +1,13 @@
+import { type AnyUser, type AuthProvider } from './types.js';
+interface GoogleProfile {
+    email: string;
+    fullName: string;
+}
+interface GoogleAuthProviderOptions<UserModel = AnyUser> {
+    clientId: string;
+    clientSecret: string;
+    redirectUri: string;
+    getOrCreateUserFromUserIdentifier(userIdentifier: string, profile: GoogleProfile): Promise<UserModel>;
+}
+export declare function GoogleAuthProvider<UserModel extends AnyUser>(options: GoogleAuthProviderOptions<UserModel>): AuthProvider<UserModel>;
+export {};

package/dist/auth/google.js

@@ -0,0 +1,94 @@
+import { type } from 'arktype';
+import {} from 'express';
+import { OAuth2Client } from 'google-auth-library';
+import { BadRequest, Unauthorized } from '../errors.js';
+import { getLogger } from '../logger.js';
+import { createTokenResponse } from './token.js';
+import {} from './types.js';
+const logger = getLogger('auth');
+export function GoogleAuthProvider(options) {
+    const client = new OAuth2Client({
+        clientId: options.clientId,
+        clientSecret: options.clientSecret,
+        redirectUri: options.redirectUri,
+    });
+    const verifyAuthorizationCode = async (inputCode) => {
+        try {
+            const { tokens } = await client.getToken(inputCode);
+            return { idToken: tokens.id_token };
+        }
+        catch (e) {
+            logger.error(e);
+            throw Unauthorized('Invalid authorization code');
+        }
+    };
+    const verifyIdToken = async (token) => {
+        const ticket = await client.verifyIdToken({
+            idToken: token,
+            audience: options.clientId,
+        });
+        const payload = ticket.getPayload();
+        if (!payload) {
+            throw Unauthorized('Token from Google contains invalid payload');
+        }
+        return payload;
+    };
+    const requiredScopes = ['openid', 'email', 'profile'];
+    return {
+        setupRoutes(router, context) {
+            const googleUser = { id: 'google' };
+            router.get('/google/login', {}, async (req, res) => {
+                const state = await context.createTemporaryToken(googleUser);
+                const params = new URLSearchParams();
+                params.set('client_id', options.clientId);
+                params.set('redirect_uri', options.redirectUri);
+                params.set('response_type', 'code');
+                params.set('scope', requiredScopes.join(' '));
+                params.set('access_type', 'offline');
+                params.set('prompt', 'select_account');
+                params.set('state', state);
+                res.redirect(`https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}`);
+            });
+            router.get('/google/callback', {
+                query: type({
+                    code: 'string?',
+                    error: 'string?',
+                    scope: 'string?',
+                    state: 'string?',
+                }),
+            }, async (req, res) => {
+                const { code, error, scope, state } = req.query;
+                if (error) {
+                    logger.error(new Error(`Google callback error: ${error}`));
+                    return res.redirect('/');
+                }
+                if (!code || !scope || !state) {
+                    throw BadRequest('Missing code, scope or state');
+                }
+                if (!requiredScopes.every((s) => scope.includes(s))) {
+                    throw BadRequest(`Missing required scopes: ${requiredScopes.join(', ')}`);
+                }
+                try {
+                    await context.verifyTemporaryToken(state, googleUser, true);
+                }
+                catch (e) {
+                    logger.error(e);
+                    throw Unauthorized('Invalid state');
+                }
+                const { idToken } = await verifyAuthorizationCode(code);
+                if (!idToken) {
+                    throw Unauthorized('Invalid id token');
+                }
+                const payload = await verifyIdToken(idToken);
+                logger.info('google payload', { payload });
+                const user = await options.getOrCreateUserFromUserIdentifier(payload?.sub, { email: payload.email, fullName: payload.name });
+                const accessToken = await context.login(req, res, user);
+                logger.info('google-login', { email: user.email });
+                if (req.accepts('html')) {
+                    return res.redirect('/');
+                }
+                return createTokenResponse(accessToken);
+            });
+        },
+    };
+}

package/dist/auth/passwordless.js

@@ -1,9 +1,9 @@
+import {} from 'express';
 import { createTokenResponse } from './token.js';
 import {} from './types.js';
 import { getLogger } from '../logger.js';
-import { route } from '../middleware.js';
 import { DoesNotExistError } from '../postgres.js';
-import { validateBody } from '../validate.js';
+import { jsonSchema } from '../validate.js';
 const logger = getLogger('auth');
 export function PasswordlessAuthProvider(options) {
     const getUserOrNull = async (email) => {
@@ -19,15 +19,17 @@ export function PasswordlessAuthProvider(options) {
     };
     return {
         setupRoutes(router, context) {
-            router.post('/passwordless/login', validateBody({
-                type: 'object',
-                properties: {
-                    type: { type: 'string', enum: ['otp', 'token'] },
-                    otp: { type: 'string' },
-                    token: { type: 'string' },
-                },
-                required: ['type'],
-            }), route(async (req, res) => {
+            router.post('/passwordless/login', {
+                request: jsonSchema({
+                    type: 'object',
+                    properties: {
+                        type: { type: 'string', enum: ['otp', 'token'] },
+                        otp: { type: 'string' },
+                        token: { type: 'string' },
+                    },
+                    required: ['type'],
+                }),
+            }, async (req, res) => {
                 const { token: temporaryToken, otp, type: tokenType } = req.body;
                 const verify = tokenType === 'otp'
                     ? context.verifyOtp
@@ -42,17 +44,19 @@ export function PasswordlessAuthProvider(options) {
                     return res.redirect('/');
                 }
                 return createTokenResponse(accessToken);
-            }));
+            });
             /**
              * Request a one-time password for login.
              */
-            router.post('/passwordless/request-token', validateBody({
-                type: 'object',
-                properties: {
-                    email: { type: 'string' },
-                },
-                required: ['email'],
-            }), route(async (req) => {
+            router.post('/passwordless/request-token', {
+                request: jsonSchema({
+                    type: 'object',
+                    properties: {
+                        email: { type: 'string' },
+                    },
+                    required: ['email'],
+                }),
+            }, async (req) => {
                 const { email } = req.body;
                 const user = await getUserOrNull(email);
                 if (!user) {
@@ -64,7 +68,7 @@ export function PasswordlessAuthProvider(options) {
                 await options.onLoginRequest(user, token, otp);
                 logger.info('passwordless login requested', { email });
                 return 202;
-            }));
+            });
         },
     };
 }

package/dist/auth/types.d.ts

@@ -1,5 +1,6 @@
-import { type RequestHandler, type Router, type Request, type Response } from 'express';
+import { type RequestHandler, type Request, type Response } from 'express';
 import { type AccessToken } from './token.js';
+import { type TypedRouter } from '../router.js';
 export interface AnyUser {
     id: string | number;
     [key: string]: any;
@@ -45,7 +46,7 @@ export interface AuthProviderContext<UserModel extends AnyUser> {
     jitter(duration?: number): Promise<void>;
 }
 export interface AuthProvider<UserModel extends AnyUser> {
-    setupRoutes(router: Router, context: AuthProviderContext<UserModel>): void;
+    setupRoutes(router: TypedRouter, context: AuthProviderContext<UserModel>): void;
 }
 export type AuthMiddlewareOptions<UserModel extends AnyUser> = false | {
     isAuthorized?: (user: UserModel) => Promise<boolean> | boolean;

package/dist/auth/types.js

@@ -1,4 +1,5 @@
 import {} from 'express';
 import {} from './token.js';
+import {} from '../router.js';
 export class TokenStorage {
 }

package/dist/auth.d.ts

@@ -1,10 +1,11 @@
-import { type RequestHandler, type Response, type Request, Router } from 'express';
+import { type RequestHandler, type Response, type Request, type Router } from 'express';
 import { TokenStorage, type AnyUser, type AuthMiddlewareOptions, type AuthOptions, type DecodedTemporaryToken } from './auth/types.js';
 import { type RedisClient } from './redis.js';
 export * from './auth/types.js';
 export * from './auth/emailAndPassword.js';
 export * from './auth/passwordless.js';
 export * from './auth/token.js';
+export * from './auth/google.js';
 export interface CreateAuth<UserModel extends AnyUser> {
     createRouter: () => Router;
     useCurrentUser: () => UserModel | undefined;

package/dist/auth.js

@@ -1,5 +1,5 @@
 import * as crypto from 'node:crypto';
-import { Router, } from 'express';
+import {} from 'express';
 import { InvalidToken, PermissionDenied } from './auth/errors.js';
 import { createAccessToken, decodeAccessToken, extractAccessTokenFromRequest, setAccessTokenCookie, tokenSchema, } from './auth/token.js';
 import { TokenStorage, } from './auth/types.js';
@@ -7,14 +7,15 @@ import { config } from './config.js';
 import { setContext, useContext } from './context.js';
 import { Forbidden, NotFound, Unauthorized } from './errors.js';
 import { getLogger } from './logger.js';
-import { route } from './middleware.js';
 import {} from './redis.js';
-import { validateParams } from './validate.js';
+import { createRouter } from './router.js';
+import { jsonSchema } from './validate.js';
 const logger = getLogger('auth');
 export * from './auth/types.js';
 export * from './auth/emailAndPassword.js';
 export * from './auth/passwordless.js';
 export * from './auth/token.js';
+export * from './auth/google.js';
 export class RedisTokenStorage extends TokenStorage {
     redis;
     keyPrefix;
@@ -80,24 +81,26 @@ export function createAuth({ getUserById, filterUser, tokenStorage, providers, l
         getUserById,
         jitter,
     };
-    const createRouter = () => {
-        const router = Router();
-        router.get('/me', middleware(), route(() => {
+    const createAuthRouter = () => {
+        const router = createRouter();
+        router.get('/me', {}, middleware(), () => {
             const user = useCurrentUser();
             return filterUser(user);
-        }));
-        router.get('/logout', route(async (req, res) => {
+        });
+        router.get('/logout', {}, async (req, res) => {
             await logout(req, res);
             res.redirect(loginUrl);
-        }));
+        });
         /**
          * Check that a reset token is valid.
          */
-        router.get('/reset/:token', validateParams({
-            type: 'object',
-            properties: { token: tokenSchema },
-            required: ['token'],
-        }), route(async (req) => {
+        router.get('/reset/:token', {
+            params: jsonSchema({
+                type: 'object',
+                properties: { token: tokenSchema },
+                required: ['token'],
+            }),
+        }, async (req) => {
             const { token } = req.params;
             const value = await tokenStorage.get(token);
             if (!value) {
@@ -105,8 +108,8 @@ export function createAuth({ getUserById, filterUser, tokenStorage, providers, l
                 throw NotFound();
             }
             return 200;
-        }));
-        router.get('/token/refresh', middleware(false), route(async (req, res) => {
+        });
+        router.get('/token/refresh', {}, middleware(false), async (req, res) => {
             const user = useCurrentUser();
             if (!user) {
                 setAccessTokenCookie(res, null);
@@ -115,7 +118,7 @@ export function createAuth({ getUserById, filterUser, tokenStorage, providers, l
             const { token } = await providerContext.login(req, res, user, true);
             logger.info('refreshed token');
             return { token, user: filterUser(user) };
-        }));
+        });
         for (const provider of providers) {
             provider.setupRoutes(router, providerContext);
         }
@@ -213,18 +216,19 @@ export function createAuth({ getUserById, filterUser, tokenStorage, providers, l
      */
     async function createTemporaryToken(user) {
         try {
+            const uid = user === null ? 'anonymous' : user.id;
             const randomBytes = crypto.randomBytes(32).toString('hex');
-            const payload = { v: '1', uid: user.id, r: randomBytes };
+            const payload = { v: '1', uid: uid, r: randomBytes };
             const signature = crypto
                 .createHmac('sha256', config.value.AUTH_SECRET)
                 .update(JSON.stringify(payload))
                 .digest('base64')
                 .slice(0, 12);
-            const temporaryToken = Buffer.from(JSON.stringify({ payload, signature })).toString('base64url');
-            if (!user.id) {
+            if (!uid) {
                 throw new Error('User ID is required to create a token');
             }
-            await tokenStorage.set(temporaryToken, String(user.id), config.value.AUTH_TEMP_TOKEN_EXPIRES_IN);
+            const temporaryToken = Buffer.from(JSON.stringify({ payload, signature })).toString('base64url');
+            await tokenStorage.set(temporaryToken, String(uid), config.value.AUTH_TEMP_TOKEN_EXPIRES_IN);
             return temporaryToken;
         }
         catch (error) {
@@ -245,14 +249,14 @@ export function createAuth({ getUserById, filterUser, tokenStorage, providers, l
         if (expectedSignature !== decoded.signature) {
             throw new InvalidToken('Invalid signature');
         }
-        if (user && decoded.payload.uid !== user.id) {
+        if (user !== null && decoded.payload.uid !== user.id) {
             throw new InvalidToken(`Invalid user ${user.id}`);
         }
         const storedUid = await tokenStorage.get(token);
         if (!storedUid) {
             throw new InvalidToken('Invalid token not found');
         }
-        if (user && storedUid !== user.id) {
+        if (user !== null && storedUid !== user.id) {
             throw new InvalidToken(`Invalid user ${user.id}`);
         }
         if (consume) {
@@ -263,7 +267,7 @@ export function createAuth({ getUserById, filterUser, tokenStorage, providers, l
     return {
         before: () => middleware(false),
         isAuthorized: (fn) => middleware({ isAuthorized: fn || (() => true) }),
-        createRouter,
+        createRouter: () => createAuthRouter().getRouter(),
         useCurrentUser,
         middleware,
         createTemporaryToken,

package/dist/cookie-consent.js

@@ -1,24 +1,25 @@
-import { Router } from 'express';
 import { getLogger } from './logger.js';
-import { route } from './middleware.js';
-import { validateBody } from './validate.js';
+import { createRouter } from './router.js';
+import { jsonSchema } from './validate.js';
 const logger = getLogger();
 export function cookieConsent({ onConsent, }) {
-    const router = Router();
-    router.get('/', route(() => {
+    const router = createRouter();
+    router.get('/', {}, async () => {
         return {
             consents: [],
         };
-    }));
-    router.post('/', validateBody({
-        type: 'object',
-        properties: {
-            consents: {
-                type: 'array',
-                items: { type: 'string' },
+    });
+    router.post('/', {
+        request: jsonSchema({
+            type: 'object',
+            properties: {
+                consents: {
+                    type: 'array',
+                    items: { type: 'string' },
+                },
             },
-        },
-    }), route(async (req, res) => {
+        }),
+    }, async (req, res) => {
         const { consents } = req.body;
         res.cookie('cookie_consent', consents.join(',') || '1', {
             expires: new Date(Date.now() + 365 * 24 * 60 * 60 * 1000),
@@ -28,6 +29,6 @@ export function cookieConsent({ onConsent, }) {
         await onConsent?.(consents);
         logger.info('cookie consent');
         return { consents };
-    }));
-    return router;
+    });
+    return router.getRouter();
 }

package/dist/manage.js

@@ -1,3 +1,5 @@
+import { resolve } from 'node:path';
+import { createClient } from '@hey-api/openapi-ts';
 import { program } from 'commander';
 import {} from 'express';
 import { hashPassword } from './auth.js';
@@ -59,4 +61,34 @@ export function registerDefaultCommands(app) {
             }
         }));
     });
+    registerManagementCommand((command, cli) => {
+        command('generate-api')
+            .option('--output <string>', 'Output directory', 'src/types/api-gen')
+            .action(cli.wrap(async (options) => {
+            const openApiFile = resolve('./openapi.json');
+            await createClient({
+                input: {
+                    path: openApiFile,
+                },
+                output: {
+                    format: 'prettier',
+                    path: options.output,
+                    lint: 'eslint',
+                    tsConfigPath: resolve('./tsconfig.json'),
+                },
+                plugins: [
+                    {
+                        enums: 'javascript',
+                        name: '@hey-api/typescript',
+                    },
+                    {
+                        asClass: true,
+                        classStructure: 'off',
+                        classNameBuilder: (name) => `${name}Service`,
+                        name: '@hey-api/sdk',
+                    },
+                ],
+            });
+        }));
+    });
 }

package/dist/router.d.ts

@@ -12,25 +12,25 @@ export type ExtractParams<Path extends string> = Prettify<Path extends `${string
 } & ExtractParams<`/${Rest}`> : Path extends `${string}:${infer Param}` ? {
     [K in Param extends `${infer P}?` ? P : Param]: string;
 } : {}>;
-export type TypedRequestHandler<Params, ResponseBodySchema extends StandardSchemaV1 | undefined, RequestBodySchema extends StandardSchemaV1 | undefined, RequestQuery extends StandardSchemaV1 | undefined> = (req: Request<Params, never, RequestBodySchema extends StandardSchemaV1<any> ? StandardSchemaV1.InferOutput<RequestBodySchema> : unknown, RequestQuery extends StandardSchemaV1<any> ? StandardSchemaV1.InferOutput<RequestQuery> : Record<string, string | string[]>>, res: Response<ResponseBodySchema extends StandardSchemaV1<any> ? StandardSchemaV1.InferOutput<ResponseBodySchema> : unknown>, next: NextFunction) => ResponseWrapper<ResponseBodySchema extends StandardSchemaV1<any> ? StandardSchemaV1.InferOutput<ResponseBodySchema> : unknown> | Promise<ResponseWrapper<ResponseBodySchema extends StandardSchemaV1<any> ? StandardSchemaV1.InferOutput<ResponseBodySchema> : unknown>>;
+export type TypedRequestHandler<Params, ResponseBodySchema extends StandardSchemaV1 | undefined, RequestBodySchema extends StandardSchemaV1 | undefined, RequestQuery extends StandardSchemaV1 | undefined, RequestParamsSchema extends StandardSchemaV1 | undefined = undefined> = (req: Request<Params, never, RequestBodySchema extends StandardSchemaV1<any> ? StandardSchemaV1.InferOutput<RequestBodySchema> : unknown, RequestQuery extends StandardSchemaV1<any> ? StandardSchemaV1.InferOutput<RequestQuery> : Record<string, string | string[]>>, res: Response<ResponseBodySchema extends StandardSchemaV1<any> ? StandardSchemaV1.InferOutput<ResponseBodySchema> : unknown>, next: NextFunction) => ResponseWrapper<ResponseBodySchema extends StandardSchemaV1<any> ? StandardSchemaV1.InferOutput<ResponseBodySchema> : unknown> | Promise<ResponseWrapper<ResponseBodySchema extends StandardSchemaV1<any> ? StandardSchemaV1.InferOutput<ResponseBodySchema> : unknown>>;
 export declare class TypedRouter {
     #private;
     router: import("express-serve-static-core").Router;
-    get<Path extends string, RequestBodySchema extends StandardSchemaV1<any> | undefined = undefined, ResponseBodySchema extends StandardSchemaV1<any> | undefined = undefined, RequestQuerySchema extends StandardSchemaV1<any> | undefined = undefined>(path: Path, validation: ValidationSpec<RequestBodySchema, ResponseBodySchema, RequestQuerySchema>, ...middleware: [
+    get<Path extends string, RequestBodySchema extends StandardSchemaV1<any> | undefined = undefined, ResponseBodySchema extends StandardSchemaV1<any> | undefined = undefined, RequestQuerySchema extends StandardSchemaV1<any> | undefined = undefined, RequestParamsSchema extends StandardSchemaV1<any> | undefined = undefined>(path: Path, validation: ValidationSpec<RequestBodySchema, ResponseBodySchema, RequestQuerySchema, RequestParamsSchema>, ...middleware: [
         ...RequestHandler[],
-        TypedRequestHandler<ExtractParams<Path>, ResponseBodySchema, RequestBodySchema, RequestQuerySchema>
+        TypedRequestHandler<ExtractParams<Path>, ResponseBodySchema, RequestBodySchema, RequestQuerySchema, RequestParamsSchema>
     ]): this;
-    post<Path extends string, RequestBodySchema extends StandardSchemaV1<any> | undefined = undefined, ResponseBodySchema extends StandardSchemaV1<any> | undefined = undefined, RequestQuerySchema extends StandardSchemaV1<any> | undefined = undefined>(path: Path, validation: ValidationSpec<RequestBodySchema, ResponseBodySchema, RequestQuerySchema>, ...middleware: [
+    post<Path extends string, RequestBodySchema extends StandardSchemaV1<any> | undefined = undefined, ResponseBodySchema extends StandardSchemaV1<any> | undefined = undefined, RequestQuerySchema extends StandardSchemaV1<any> | undefined = undefined, RequestParamsSchema extends StandardSchemaV1<any> | undefined = undefined>(path: Path, validation: ValidationSpec<RequestBodySchema, ResponseBodySchema, RequestQuerySchema, RequestParamsSchema>, ...middleware: [
         ...RequestHandler[],
-        TypedRequestHandler<ExtractParams<Path>, ResponseBodySchema, RequestBodySchema, RequestQuerySchema>
+        TypedRequestHandler<ExtractParams<Path>, ResponseBodySchema, RequestBodySchema, RequestQuerySchema, RequestParamsSchema>
     ]): this;
-    put<Path extends string, RequestBodySchema extends StandardSchemaV1<any> | undefined = undefined, ResponseBodySchema extends StandardSchemaV1<any> | undefined = undefined, RequestQuerySchema extends StandardSchemaV1<any> | undefined = undefined>(path: Path, validation: ValidationSpec<RequestBodySchema, ResponseBodySchema, RequestQuerySchema>, ...middleware: [
+    put<Path extends string, RequestBodySchema extends StandardSchemaV1<any> | undefined = undefined, ResponseBodySchema extends StandardSchemaV1<any> | undefined = undefined, RequestQuerySchema extends StandardSchemaV1<any> | undefined = undefined, RequestParamsSchema extends StandardSchemaV1<any> | undefined = undefined>(path: Path, validation: ValidationSpec<RequestBodySchema, ResponseBodySchema, RequestQuerySchema, RequestParamsSchema>, ...middleware: [
         ...RequestHandler[],
         TypedRequestHandler<ExtractParams<Path>, ResponseBodySchema, RequestBodySchema, RequestQuerySchema>
     ]): this;
-    delete<Path extends string, RequestBodySchema extends StandardSchemaV1<any> | undefined = undefined, ResponseBodySchema extends StandardSchemaV1<any> | undefined = undefined, RequestQuerySchema extends StandardSchemaV1<any> | undefined = undefined>(path: Path, validation: ValidationSpec<RequestBodySchema, ResponseBodySchema, RequestQuerySchema>, ...middleware: [
+    delete<Path extends string, RequestBodySchema extends StandardSchemaV1<any> | undefined = undefined, ResponseBodySchema extends StandardSchemaV1<any> | undefined = undefined, RequestQuerySchema extends StandardSchemaV1<any> | undefined = undefined, RequestParamsSchema extends StandardSchemaV1<any> | undefined = undefined>(path: Path, validation: ValidationSpec<RequestBodySchema, ResponseBodySchema, RequestQuerySchema>, ...middleware: [
         ...RequestHandler[],
-        TypedRequestHandler<ExtractParams<Path>, ResponseBodySchema, RequestBodySchema, RequestQuerySchema>
+        TypedRequestHandler<ExtractParams<Path>, ResponseBodySchema, RequestBodySchema, RequestQuerySchema, RequestParamsSchema>
     ]): this;
     use(...middleware: RequestHandler[]): this;
     use(...middleware: [string, ...RequestHandler[]]): this;

package/dist/routes.d.ts

@@ -32,5 +32,8 @@ export declare function toOpenAPISpec(app: Express, info?: {
         title: string;
         version: string;
     };
+    tags: {
+        name: string;
+    }[];
     paths: Record<string, any>;
 };

package/dist/routes.js

@@ -143,14 +143,54 @@ const mapKeysToPath = (layerRegexPath, keys) => {
         .replace(/\\/gi, '')
         .replace(/\/{2,}/gi, '/');
 };
+function extractTagsFromPath(path) {
+    const segments = path
+        .replace(/^\/api\/v\d+\//, '') // Remove /api/v1, /api/v2, etc.
+        .split('/')
+        .filter(Boolean);
+    if (segments.length === 0) {
+        return ['Default'];
+    }
+    // Use the first segment as the primary tag
+    const primaryTag = segments[0].charAt(0).toUpperCase() + segments[0].slice(1);
+    return [primaryTag];
+}
+function convertPathToOperationId(method, path) {
+    // Clean the path and split into segments
+    const segments = path
+        .replace(/[{}]/g, '') // Remove OpenAPI parameter braces
+        .replace(/[^a-zA-Z0-9/-]/g, '') // Keep hyphens, remove other non-alphanumeric chars
+        .replace(/^\/api\/v\d+\//, '') // Remove /api/v1, /api/v2, etc. prefixes
+        .split('/') // Split by slashes
+        .filter(Boolean) // Remove empty strings
+        .map((segment) => {
+        // Handle kebab-case segments by splitting on hyphens and camelizing
+        return segment
+            .split('-')
+            .map((word, index) => index === 0
+            ? word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+            : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join('');
+    }); // Capitalize each segment
+    const camelizedPath = segments.join('');
+    return `${method.toLowerCase()}${camelizedPath}`;
+}
 export function toOpenAPISpec(app, info = {
     title: 'API Documentation',
     version: '1.0.0',
 }) {
     const routes = parseRoutes(app);
     const paths = {};
+    const allTags = new Set();
     for (const routeInfo of routes) {
         const { method, path, params, query, body, response } = routeInfo;
+        if (!path.startsWith('/api/')) {
+            continue;
+        }
+        const tags = extractTagsFromPath(path);
+        for (const tag of tags) {
+            allTags.add(tag);
+        }
         // Convert Express path params to OpenAPI path params
         const openApiPath = path.replace(/:([^/]+)/g, '{$1}');
         if (!paths[openApiPath]) {
@@ -178,6 +218,8 @@ export function toOpenAPISpec(app, info = {
             })));
         }
         paths[openApiPath][method.toLowerCase()] = {
+            operationId: convertPathToOperationId(method, path), // Use original path, not openApiPath
+            tags,
             parameters,
             ...(body && {
                 requestBody: {
@@ -232,6 +274,7 @@ export function toOpenAPISpec(app, info = {
             version: info.version,
             ...(info.description && { description: info.description }),
         },
+        tags: Array.from(allTags).map((tag) => ({ name: tag })),
         paths,
     };
 }

package/dist/validate.d.ts

@@ -39,10 +39,11 @@ export type ValidationResult = {
     isValid: false;
     errors: ValidationErrors;
 };
-export interface ValidationSpec<RequestBodySchema extends StandardSchemaV1<any> | undefined = undefined, ResponseBodySchema extends StandardSchemaV1<any> | undefined = undefined, RequestQuerySchema extends StandardSchemaV1<any> | undefined = undefined> {
+export interface ValidationSpec<RequestBodySchema extends StandardSchemaV1<any> | undefined = undefined, ResponseBodySchema extends StandardSchemaV1<any> | undefined = undefined, RequestQuerySchema extends StandardSchemaV1<any> | undefined = undefined, RequestParamsSchema extends StandardSchemaV1<any> | undefined = undefined> {
     request?: RequestBodySchema;
     response?: ResponseBodySchema;
     query?: RequestQuerySchema;
+    params?: RequestParamsSchema;
 }
 export declare function validateSchema(data: unknown, schema: StandardSchemaV1<any>): Promise<ValidationResult>;
 export declare function validateStandardSchema(schemas: {

package/dist/vite/defineViteConfig.js

@@ -5,6 +5,13 @@ import Sonda from 'sonda/vite';
 import { defineConfig } from 'vite';
 import { readEnv } from '../utils.js';
 export function defineViteConfig({ base = '', reactCompiler = false, ssr = false, analyze = readEnv.boolean('VITE_ANALYZE', false), }) {
+    const allowedHosts = [
+        'localhost',
+        '127.0.0.1',
+        // Support puma-dev by default
+        `${process.cwd().split('/').pop()}.local`,
+        `${process.cwd().split('/').pop()}.test`,
+    ];
     const port = readEnv.number('VITE_PORT', 5173);
     return defineConfig({
         plugins: [
@@ -53,14 +60,9 @@ export function defineViteConfig({ base = '', reactCompiler = false, ssr = false
                     '/api': `http://localhost:${readEnv.number('PORT', 4000)}`,
                     '/analytics.js': `http://localhost:${readEnv.number('PORT', 4000)}`,
                 },
-                allowedHosts: [
-                    'localhost',
-                    '127.0.0.1',
-                    // Support puma-dev by default
-                    `${process.cwd().split('/').pop()}.local`,
-                ],
+                allowedHosts,
             }
-            : {},
+            : { allowedHosts },
         ssr: ssr
             ? {
                 noExternal: ['react-helmet-async'],

package/dist/vite/vitest.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/vite/vitest.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devmoods/express-extras",
-  "version": "0.59.0",
+  "version": "0.60.0",
   "description": "Kubernetes-ready utilities for rapid Node.js application development",
   "type": "module",
   "main": "./dist/index.js",
@@ -44,35 +44,36 @@
   ],
   "license": "ISC",
   "devDependencies": {
-    "@devmoods/eslint-config": "^2.10.0",
+    "@devmoods/eslint-config": "^2.12.0",
     "@types/koa-compose": "^3.2.8",
     "@types/node": "24.3.0",
     "@types/supertest": "^6.0.3",
-    "@vitejs/plugin-react": "^5.0.0",
+    "@vitejs/plugin-react": "^5.0.2",
     "@vitest/coverage-v8": "^3.2.4",
     "arktype": "^2.1.20",
     "cookiejar": "^2.1.4",
-    "eslint": "^9.33.0",
+    "eslint": "^9.34.0",
     "faktory-worker": "^4.7.1",
     "prettier": "3.6.2",
     "supertest": "7.1.4",
     "ts-node": "10.9.2",
-    "tsx": "^4.20.4",
+    "tsx": "^4.20.5",
     "typescript": "5.9.2",
-    "vite": "^7.1.2",
+    "vite": "^7.1.3",
     "vitest": "^3.2.4",
     "vitest-fail-on-console": "^0.9.0"
   },
   "dependencies": {
     "@devmoods/fetch": "^4.1.0",
-    "@sentry/node": "^10.5.0",
-    "@sentry/profiling-node": "^10.5.0",
+    "@hey-api/openapi-ts": "^0.82.1",
+    "@sentry/node": "^10.8.0",
+    "@sentry/profiling-node": "^10.8.0",
     "@standard-schema/spec": "^1.0.0",
     "@types/bcrypt": "^6.0.0",
     "@types/cookie-parser": "^1.4.9",
     "@types/express": "^5.0.3",
     "@types/jsonwebtoken": "^9.0.10",
-    "@types/nodemailer": "^7.0.0",
+    "@types/nodemailer": "^7.0.1",
     "@types/pg": "^8.15.5",
     "@types/qs": "^6.14.0",
     "@types/superagent": "^8.1.9",
@@ -80,17 +81,18 @@
     "ajv": "^8.17.1",
     "argon2": "^0.44.0",
     "bcrypt": "^6.0.0",
-    "chalk": "^5.5.0",
+    "chalk": "^5.6.0",
     "commander": "^14.0.0",
     "compose-middleware": "^5.0.1",
     "cookie-parser": "^1.4.7",
     "dotenv": "^17.2.1",
     "express": "^4.21.2",
+    "google-auth-library": "^10.3.0",
     "helmet": "^8.1.0",
     "jsonwebtoken": "^9.0.2",
-    "nodemailer": "^7.0.5",
+    "nodemailer": "^7.0.6",
     "pg": "^8.16.3",
-    "redis": "^5.8.1",
+    "redis": "^5.8.2",
     "sonda": "^0.9.0",
     "sql-formatter": "^15.6.6",
     "uuid": "^11.1.0"