@devmoods/express-extras 0.54.1 → 0.56.0

package/dist/auth/token.d.ts

@@ -19,7 +19,7 @@ export declare function createAccessToken(payload: any, version?: string, secret
  * Decode the given JWT token.
  */
 export declare function decodeAccessToken(token: string, secret?: string): {
-    [x: string]: any;
+    [key: string]: any;
     iss?: string | undefined;
     sub?: string | undefined;
     aud?: string | string[] | undefined;

package/dist/auth.d.ts

@@ -19,8 +19,8 @@ export interface CreateAuth<UserModel extends AnyUser> {
     logout: (req: Request, res: Response) => Promise<void>;
 }
 export declare class RedisTokenStorage extends TokenStorage {
-    private readonly redis;
-    private readonly keyPrefix;
+    redis: RedisClient;
+    keyPrefix: string;
     constructor(redis: RedisClient, keyPrefix?: string);
     set(token: string, userId: string, expiresIn: number): Promise<void>;
     get(token: string): Promise<string | null>;

package/dist/auth.js

@@ -16,6 +16,8 @@ export * from './auth/emailAndPassword.js';
 export * from './auth/passwordless.js';
 export * from './auth/token.js';
 export class RedisTokenStorage extends TokenStorage {
+    redis;
+    keyPrefix;
     constructor(redis, keyPrefix = `${config.value.REDIS_KEY_PREFIX}auth:`) {
         super();
         this.redis = redis;

package/dist/channels.d.ts

@@ -1,8 +1,9 @@
 import { type Request } from 'express';
 import { type RedisClient } from './redis.js';
+import { type ExtractParams, type TypedRequestHandler } from './router.js';
 export declare function createEventStream<Channels extends string>(redis: RedisClient): {
-    sse: ({ channels, }: {
+    sse: <Path extends string>({ channels, }: {
         channels: (req: Request) => string[] | Promise<string[]>;
-    }) => import("express").RequestHandler<Record<string, string>, Record<string, any>, unknown, Record<string, any>, Record<string, any>>;
+    }) => TypedRequestHandler<ExtractParams<Path>, any, any, any>;
     publish: (channel: Channels, message: unknown) => Promise<number>;
 };

package/dist/channels.js

@@ -2,62 +2,67 @@ import {} from 'express';
 import { config } from './config.js';
 import { requestContext } from './context.js';
 import { getLogger } from './logger.js';
-import { route } from './middleware.js';
 import {} from './redis.js';
+import {} from './router.js';
 const logger = getLogger();
 export function createEventStream(redis) {
     const keyPrefix = `${config.value.REDIS_KEY_PREFIX}events:`;
     const withKeyPrefix = (key) => `${keyPrefix}${key}`;
     const sse = ({ channels, }) => {
-        return route(async (req, res) => {
-            const headers = {
-                'Content-Type': 'text/event-stream',
-                'Cache-Control': 'no-cache',
-                Connection: 'keep-alive',
-            };
-            res.writeHead(200, headers);
-            res.write('retry: 15000\n');
-            const heartbeat = setInterval(() => {
-                try {
-                    if (!res.writableEnded) {
-                        res.write('event: heartbeat\n');
-                        res.write('data: ping\n\n');
-                    }
-                }
-                catch (error) {
-                    logger.error(error);
-                }
-            }, 15000);
-            const store = requestContext.getStore();
-            const listener = (value) => {
-                try {
-                    requestContext.run(store, () => {
+        return async (req, res, next) => {
+            try {
+                const headers = {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    Connection: 'keep-alive',
+                };
+                res.writeHead(200, headers);
+                res.write('retry: 15000\n');
+                const heartbeat = setInterval(() => {
+                    try {
                         if (!res.writableEnded) {
-                            res.write('event: data\n');
-                            res.write(`data: ${JSON.stringify(value)}\n\n`);
+                            res.write('event: heartbeat\n');
+                            res.write('data: ping\n\n');
                         }
+                    }
+                    catch (error) {
+                        logger.error(error);
+                    }
+                }, 15000);
+                const store = requestContext.getStore();
+                const listener = (value) => {
+                    try {
+                        requestContext.run(store, () => {
+                            if (!res.writableEnded) {
+                                res.write('event: data\n');
+                                res.write(`data: ${JSON.stringify(value)}\n\n`);
+                            }
+                        });
+                    }
+                    catch (error) {
+                        logger.error(error);
+                    }
+                };
+                const subscriber = redis.duplicate();
+                await subscriber.connect();
+                const _channels = await channels(req);
+                await subscriber.subscribe(_channels.map(withKeyPrefix), (message) => {
+                    listener(JSON.parse(message));
+                });
+                logger.info('event stream subscribe', { channels: _channels });
+                res.on('close', () => {
+                    requestContext.run(store, () => {
+                        logger.info('event stream close');
+                        clearInterval(heartbeat);
+                        subscriber.quit();
+                        res.end();
                     });
-                }
-                catch (error) {
-                    logger.error(error);
-                }
-            };
-            const subscriber = redis.duplicate();
-            await subscriber.connect();
-            const _channels = await channels(req);
-            await subscriber.subscribe(_channels.map(withKeyPrefix), (message) => {
-                listener(JSON.parse(message));
-            });
-            logger.info('event stream subscribe', { channels: _channels });
-            res.on('close', () => {
-                requestContext.run(store, () => {
-                    logger.info('event stream close');
-                    clearInterval(heartbeat);
-                    subscriber.quit();
-                    res.end();
                 });
-            });
-        });
+            }
+            catch (error) {
+                next(error);
+            }
+        };
     };
     const publish = (channel, message) => {
         return redis.publish(withKeyPrefix(channel), JSON.stringify(message));

package/dist/cli.d.ts

@@ -3,7 +3,7 @@ export interface CLIOptions {
     printStackTraces?: boolean;
 }
 export declare class CLI {
-    private options;
+    options: CLIOptions;
     constructor(options?: CLIOptions);
     writeLine(message: string, output?: WriteStream): void;
     greenLine(message: string, output?: WriteStream): void;

package/dist/cli.js

@@ -4,6 +4,7 @@ import {} from 'node:tty';
 import chalk from 'chalk';
 import { startTimer } from './utils.js';
 export class CLI {
+    options;
     constructor(options = {}) {
         this.options = options;
     }

package/dist/errors.d.ts

@@ -1,3 +1,4 @@
+import { type ErrorHandler } from 'compose-middleware';
 type AnyPayload = Record<string, unknown>;
 export declare class ApiError extends Error {
     status: number | null | undefined;
@@ -37,5 +38,5 @@ export interface ErrorHandlerOptions {
  *
  * Composed together with the Sentry error handler.
  */
-export declare function errorHandler({ onError }?: ErrorHandlerOptions): import("compose-middleware").ErrorHandler<unknown, unknown, void>;
+export declare function errorHandler({ onError }?: ErrorHandlerOptions): ErrorHandler<any, any, void>;
 export {};

package/dist/errors.js

@@ -6,6 +6,8 @@ import { InvalidToken } from './auth/errors.js';
 import { getLogger } from './logger.js';
 import { DoesNotExistError, IntegrityError } from './postgres.js';
 export class ApiError extends Error {
+    status;
+    payload;
 }
 export const BadRequest = (reason) => makeError(400, 'Invalid Params', { reason });
 export const Forbidden = (detail = '') => makeError(403, detail);
@@ -88,6 +90,8 @@ export function errorHandler({ onError } = {}) {
                 return process.env.NODE_ENV === 'production';
             },
         }),
-        _errorHandler({ onError: onError || _defaultErrorHandler }),
+        _errorHandler({
+            onError: onError || _defaultErrorHandler,
+        }),
     ]);
 }

package/dist/index.d.ts

@@ -16,6 +16,7 @@ export * from './middleware.js';
 export * from './postgres.js';
 export * from './rate-limit.js';
 export * from './redis.js';
+export * from './router.js';
 export * from './routes.js';
 export * from './sentry.js';
 export * from './slack.js';

package/dist/index.js

@@ -17,6 +17,7 @@ export * from './middleware.js';
 export * from './postgres.js';
 export * from './rate-limit.js';
 export * from './redis.js';
+export * from './router.js';
 export * from './routes.js';
 export * from './sentry.js';
 export * from './slack.js';

package/dist/manage.js

@@ -4,7 +4,7 @@ import { hashPassword } from './auth.js';
 import { CLI } from './cli.js';
 import { config } from './config.js';
 import { asCli } from './migrate.js';
-import { parseRoutes } from './routes.js';
+import { parseRoutes, toOpenAPISpec } from './routes.js';
 export function registerManagementCommand(register) {
     const cli = new CLI({ printStackTraces: process.argv.includes('--verbose') });
     register(program.command.bind(program), cli);
@@ -26,7 +26,8 @@ export function registerDefaultCommands(app) {
             return;
         }
         if (options.openapi) {
-            console.error('Not implemented yet');
+            const routes = toOpenAPISpec(app);
+            console.log(JSON.stringify(routes, null, 2));
             return;
         }
         const routes = parseRoutes(app);

package/dist/middleware.d.ts

@@ -48,7 +48,7 @@ export declare function useCspNonce(): string;
 /**
  * Register middleware that must come before the app routes.
  */
-export declare function before({ cookies, helmet: useHelmet, json: useJson, csrf: useCsrf, urlencoded: useUrlencoded, allowUnsafeInlineScripts, cspDirectives, }?: BeforeMiddlewareOptions): import("compose-middleware").RequestHandler<unknown, unknown, void>;
+export declare function before({ cookies, helmet: useHelmet, json: useJson, csrf: useCsrf, urlencoded: useUrlencoded, allowUnsafeInlineScripts, cspDirectives, }?: BeforeMiddlewareOptions): import("compose-middleware").RequestHandler<any, any, void>;
 /**
  * Middleware that sends a 404
  *
@@ -61,10 +61,10 @@ export declare function notFound(): RequestHandler;
  */
 export declare function after(): RequestHandler;
 type ResponseHeaders = Record<string, string>;
-type AnyResponseBody = Record<string, any> | string;
+type AnyResponseBody = Record<string, any> | Record<string, any>[] | string;
 type HttpResponseCode = number;
 type ResponseWrapper<TResponseBody extends AnyResponseBody> = TResponseBody | TResponseBody[] | HttpResponseCode | [HttpResponseCode, TResponseBody] | [HttpResponseCode, TResponseBody, ResponseHeaders];
 /**
  * Alias of `route()`
  */
-export declare function asyncMiddleware<RequestBody, RequestQuery extends Record<string, any> = Record<string, any>, ResponseBody extends AnyResponseBody = Record<string, any>, ParamKeys extends string = string>(fn: (req: Request<Record<ParamKeys, string>, ResponseBody, RequestBody, RequestQuery, Record<string, any>>, res: Response<ResponseBody, object>, next: NextFunction) => ResponseWrapper<ResponseBody> | Promise<ResponseWrapper<ResponseBody>>): RequestHandler<Record<string, string>, ResponseBody, RequestBody, RequestQuery>;
+export declare function asyncMiddleware<RequestBody, RequestQuery extends Record<string, any> = Record<string, any>, ResponseBody extends AnyResponseBody = Record<string, any>, ParamKeys extends string = string>(fn: (req: Request<Record<ParamKeys, string>, ResponseBody, RequestBody, RequestQuery, Record<string, any>>, res: Response<ResponseBody, object>, next: NextFunction) => ResponseWrapper<ResponseBody> | Promise<ResponseWrapper<ResponseBody>>): RequestHandler<Record<ParamKeys, string>, ResponseBody, RequestBody, RequestQuery>;

package/dist/middleware.js

@@ -151,6 +151,9 @@ export function asyncMiddleware(fn) {
             .then(doubleCsrfProtection(req))
             .then(() => fn(req, res, next))
             .then((result) => {
+            if (typeof result === 'undefined') {
+                return result;
+            }
             if (Array.isArray(result) &&
                 (result.length === 2 || result.length === 3) &&
                 typeof result[0] === 'number') {

package/dist/migrate.js

@@ -55,8 +55,12 @@ export const asCli = (command, cli) => {
     }));
 };
 export class Migrator {
+    postgres;
+    migrationTableName;
+    pathToMigrations;
+    filenameRegExp = /(\d+)_(.*)\.(js|ts|mjs|mts|sql)/;
+    verbose;
     constructor({ postgres = createPostgres({ onLogStatement: () => { } }), pathToMigrations = path.resolve(process.cwd(), 'db', 'migrations'), migrationTableName = 'migrations', verbose = true, } = {}) {
-        this.filenameRegExp = /(\d+)_(.*)\.(js|ts|mjs|mts|sql)/;
         this.postgres = postgres;
         this.pathToMigrations = pathToMigrations;
         this.migrationTableName = migrationTableName;

package/dist/postgres.d.ts

@@ -29,8 +29,8 @@ export interface TransactionContext {
 }
 export declare const transactionStorage: AsyncLocalStorage<TransactionContext>;
 export declare class Connection {
-    private options;
     client: PoolClient;
+    options: ConnectionOptions;
     constructor(client: PoolClient, options: ConnectionOptions);
     private logStatement;
     query<T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]): Promise<QueryResult<T>>;

package/dist/postgres.js

@@ -26,9 +26,11 @@ export class IntegrityError extends Error {
 }
 export const transactionStorage = new AsyncLocalStorage();
 export class Connection {
+    client;
+    options;
     constructor(client, options) {
-        this.options = options;
         this.client = client;
+        this.options = options;
     }
     logStatement(text, values, duration) {
         if (this.options.onLogStatement) {
@@ -80,12 +82,9 @@ export class Connection {
     }
 }
 export class Transaction extends Connection {
-    constructor() {
-        super(...arguments);
-        this.savepoints = [];
-        this.isCommitted = false;
-        this.isRolledBack = false;
-    }
+    savepoints = [];
+    isCommitted = false;
+    isRolledBack = false;
     async createSavepoint() {
         const savepointName = `sp_${this.savepoints.length + 1}`;
         await this.query(`SAVEPOINT ${savepointName}`);

package/dist/router.d.ts

@@ -0,0 +1,40 @@
+import { type StandardSchemaV1 } from '@standard-schema/spec';
+import { type NextFunction, type Request, type RequestHandler, type Response } from 'express';
+import { type ValidationSpec } from './validate.js';
+type ResponseHeaders = Record<string, string>;
+type HttpResponseCode = number;
+type ResponseWrapper<TResponseBody> = TResponseBody | TResponseBody[] | HttpResponseCode | [HttpResponseCode, TResponseBody] | [HttpResponseCode, TResponseBody, ResponseHeaders];
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type ExtractParams<Path extends string> = Prettify<Path extends `${string}:${infer Param}/${infer Rest}` ? {
+    [K in Param extends `${infer P}?` ? P : Param]: 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 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: [
+        ...RequestHandler[],
+        TypedRequestHandler<ExtractParams<Path>, ResponseBodySchema, RequestBodySchema, RequestQuerySchema>
+    ]): void;
+    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: [
+        ...RequestHandler[],
+        TypedRequestHandler<ExtractParams<Path>, ResponseBodySchema, RequestBodySchema, RequestQuerySchema>
+    ]): void;
+    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: [
+        ...RequestHandler[],
+        TypedRequestHandler<ExtractParams<Path>, ResponseBodySchema, RequestBodySchema, RequestQuerySchema>
+    ]): void;
+    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: [
+        ...RequestHandler[],
+        TypedRequestHandler<ExtractParams<Path>, ResponseBodySchema, RequestBodySchema, RequestQuerySchema>
+    ]): void;
+    use(...middleware: RequestHandler[]): this;
+    use(...middleware: [string, ...RequestHandler[]]): this;
+    getRouter(): import("express-serve-static-core").Router;
+}
+export declare function createRouter(): TypedRouter;
+export {};

package/dist/router.js

@@ -0,0 +1,37 @@
+import {} from '@standard-schema/spec';
+import { Router, } from 'express';
+import { asyncMiddleware } from './middleware.js';
+import { validateStandardSchema } from './validate.js';
+export class TypedRouter {
+    router = Router();
+    get(path, validation, ...middleware) {
+        return this.#handle('get', path, validation, ...middleware);
+    }
+    post(path, validation, ...middleware) {
+        return this.#handle('post', path, validation, ...middleware);
+    }
+    put(path, validation, ...middleware) {
+        return this.#handle('put', path, validation, ...middleware);
+    }
+    delete(path, validation, ...middleware) {
+        return this.#handle('delete', path, validation, ...middleware);
+    }
+    #handle(method, path, validation, ...middleware) {
+        const handler = middleware.pop();
+        this.router[method](path, validateStandardSchema({
+            body: validation.request,
+            query: validation.query,
+            response: validation.response,
+        }), ...middleware, asyncMiddleware(handler));
+    }
+    use(...middleware) {
+        this.router.use(...middleware);
+        return this;
+    }
+    getRouter() {
+        return this.router;
+    }
+}
+export function createRouter() {
+    return new TypedRouter();
+}

package/dist/routes.d.ts

@@ -14,9 +14,23 @@ export declare function parseRoutes(app: Express): {
     } | null;
     query: {} | null;
     body: {} | null;
+    response: {} | null;
 }[];
 export interface Key {
     name: string;
     optional: boolean;
     offset: number;
 }
+export declare function toOpenAPISpec(app: Express, info?: {
+    title: string;
+    version: string;
+    description?: string;
+}): {
+    openapi: string;
+    info: {
+        description?: string | undefined;
+        title: string;
+        version: string;
+    };
+    paths: Record<string, any>;
+};

package/dist/routes.js

@@ -4,7 +4,11 @@ export function createDocsRouter(app, extras = {}) {
     return route(async () => {
         return {
             ...extras,
-            routes: parseRoutes(app),
+            ...toOpenAPISpec(app, {
+                title: extras.title || 'API Documentation',
+                version: extras.version || '1.0.0',
+                description: extras.description,
+            }),
         };
     });
 }
@@ -21,6 +25,9 @@ export function parseRoutes(app) {
             body: metadata
                 ?.filter((m) => typeof m === 'object' && m != null && 'bodySchema' in m)
                 .at(-1)?.bodySchema ?? null,
+            response: metadata
+                ?.filter((m) => typeof m === 'object' && m != null && 'responseSchema' in m)
+                .at(-1)?.responseSchema ?? null,
         };
     });
 }
@@ -47,39 +54,11 @@ const buildPathParamsSchema = (pathParams) => {
 };
 // Fork of express-route-parser
 class ExpressPathParser {
+    _appPaths;
     getPaths() {
         return this._appPaths;
     }
     constructor(app) {
-        this.traverse = (path, layer, keys) => {
-            keys = [...keys, ...layer.keys];
-            if (layer.name === 'router' && layer.handle) {
-                for (const l of layer.handle.stack) {
-                    this.traverse(`${path || ''}/${pathRegexParser(layer.regexp, layer.keys)}`, l, keys);
-                }
-            }
-            if (!layer.route || !layer.route.stack.length) {
-                return;
-            }
-            this._appPaths.push(this.parseRouteLayer(layer, keys, path));
-        };
-        this.parseRouteLayer = (layer, keys, basePath) => {
-            const lastRequestHandler = layer.route.stack[layer.route.stack.length - 1];
-            const pathParams = keys.map((key) => {
-                return { name: key.name, in: 'path', required: !key.optional };
-            });
-            const filtered = layer.route.stack.filter((element) => element?.handle?.metadata);
-            const path = (basePath + layer.route.path).replace(/\/{2,}/gi, '/');
-            if (filtered.length === 0) {
-                return { path, pathParams, method: lastRequestHandler.method };
-            }
-            return {
-                path,
-                pathParams,
-                method: lastRequestHandler.method,
-                metadata: filtered.map((f) => f.handle.metadata),
-            };
-        };
         this._appPaths = [];
         const router = app._router;
         if (router) {
@@ -88,6 +67,35 @@ class ExpressPathParser {
             }
         }
     }
+    traverse = (path, layer, keys) => {
+        keys = [...keys, ...layer.keys];
+        if (layer.name === 'router' && layer.handle) {
+            for (const l of layer.handle.stack) {
+                this.traverse(`${path || ''}/${pathRegexParser(layer.regexp, layer.keys)}`, l, keys);
+            }
+        }
+        if (!layer.route || !layer.route.stack.length) {
+            return;
+        }
+        this._appPaths.push(this.parseRouteLayer(layer, keys, path));
+    };
+    parseRouteLayer = (layer, keys, basePath) => {
+        const lastRequestHandler = layer.route.stack[layer.route.stack.length - 1];
+        const pathParams = keys.map((key) => {
+            return { name: key.name, in: 'path', required: !key.optional };
+        });
+        const filtered = layer.route.stack.filter((element) => element?.handle?.metadata);
+        const path = (basePath + layer.route.path).replace(/\/{2,}/gi, '/');
+        if (filtered.length === 0) {
+            return { path, pathParams, method: lastRequestHandler.method };
+        }
+        return {
+            path,
+            pathParams,
+            method: lastRequestHandler.method,
+            metadata: filtered.map((f) => f.handle.metadata),
+        };
+    };
 }
 const pathRegexParser = (layerRegexPath, keys) => {
     if (typeof layerRegexPath === 'string') {
@@ -135,3 +143,95 @@ const mapKeysToPath = (layerRegexPath, keys) => {
         .replace(/\\/gi, '')
         .replace(/\/{2,}/gi, '/');
 };
+export function toOpenAPISpec(app, info = {
+    title: 'API Documentation',
+    version: '1.0.0',
+}) {
+    const routes = parseRoutes(app);
+    const paths = {};
+    for (const routeInfo of routes) {
+        const { method, path, params, query, body, response } = routeInfo;
+        // Convert Express path params to OpenAPI path params
+        const openApiPath = path.replace(/:([^/]+)/g, '{$1}');
+        if (!paths[openApiPath]) {
+            paths[openApiPath] = {};
+        }
+        const parameters = [];
+        // Add path parameters
+        if (params) {
+            parameters.push(...Object.keys(params.properties).map((name) => ({
+                name,
+                in: 'path',
+                required: params.required?.includes(name) ?? true,
+                schema: params.properties[name],
+            })));
+        }
+        // Add query parameters
+        if (query && typeof query === 'object' && 'properties' in query) {
+            const querySchema = query;
+            parameters.push(...Object.keys(querySchema.properties || {}).map((name) => ({
+                name,
+                in: 'query',
+                required: Array.isArray(querySchema.required) &&
+                    querySchema.required.includes(name),
+                schema: (querySchema.properties || {})[name],
+            })));
+        }
+        paths[openApiPath][method.toLowerCase()] = {
+            parameters,
+            ...(body && {
+                requestBody: {
+                    content: {
+                        'application/json': {
+                            schema: body,
+                        },
+                    },
+                },
+            }),
+            responses: {
+                ...(response
+                    ? {
+                        '200': {
+                            description: 'Successful response',
+                            content: {
+                                'application/json': {
+                                    schema: response,
+                                },
+                            },
+                        },
+                    }
+                    : {
+                        '200': {
+                            description: 'Successful response',
+                        },
+                    }),
+                '400': {
+                    description: 'Bad Request',
+                    content: {
+                        'application/json': {
+                            schema: {
+                                type: 'object',
+                                properties: {
+                                    type: { type: 'string' },
+                                    title: { type: 'string' },
+                                    detail: { type: 'string' },
+                                    status: { type: 'number' },
+                                },
+                                required: ['type', 'title', 'status'],
+                            },
+                        },
+                    },
+                },
+            },
+        };
+    }
+    return {
+        openapi: '3.1.0',
+        info: {
+            title: info.title,
+            version: info.version,
+            ...(info.description && { description: info.description }),
+        },
+        paths,
+    };
+}

package/dist/sql.js

@@ -4,6 +4,7 @@ const isRaw = (value) => {
     return (typeof value === 'object' && value !== null && 'raw' in value && !!value.raw);
 };
 export class SqlStatement {
+    stringsAndValues;
     constructor(strings, values) {
         this.stringsAndValues = [];
         this._extract(strings, values);

package/dist/validate.d.ts

@@ -1,6 +1,5 @@
-import { type Options } from 'ajv';
-import { Type } from 'arktype';
-import { type RequestHandler } from 'express';
+import { type StandardSchemaV1 } from '@standard-schema/spec';
+import { type NextFunction, type RequestHandler, type Request, type Response } from 'express';
 export type ValidationSchema = {
     type?: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object' | 'null';
     format?: string;
@@ -28,27 +27,40 @@ export type ValidationSchema = {
     title?: string;
     description?: string;
 } | boolean;
-type AnySchema = Type | ValidationSchema;
-export declare function validateBody(schema: AnySchema): RequestHandler;
-export declare function validateQuery(schema: AnySchema): RequestHandler;
-export declare function validateParams(schema: AnySchema): RequestHandler;
+type LegacyCompatibleSchema = ValidationSchema | StandardSchemaV1;
+export declare function validateBody(schema: LegacyCompatibleSchema): RequestHandler;
+export declare function validateQuery(schema: LegacyCompatibleSchema): RequestHandler;
+export declare function validateParams(schema: LegacyCompatibleSchema): RequestHandler;
+type ValidationErrors<Field extends string = string> = Record<Field, string[]>;
 export type ValidationResult = {
     isValid: true;
     errors: null;
 } | {
     isValid: false;
-    errors: {
-        [key: string]: any;
-    };
+    errors: ValidationErrors;
 };
-export declare function compileValidateSchema(schema: ValidationSchema, options?: Options): (data: unknown) => {
-    readonly isValid: true;
-    readonly errors: null;
-} | {
-    readonly isValid: false;
-    readonly errors: {
-        [key: string]: any[];
+export interface ValidationSpec<RequestBodySchema extends StandardSchemaV1<any> | undefined = undefined, ResponseBodySchema extends StandardSchemaV1<any> | undefined = undefined, RequestQuerySchema extends StandardSchemaV1<any> | undefined = undefined> {
+    request?: RequestBodySchema;
+    response?: ResponseBodySchema;
+    query?: RequestQuerySchema;
+}
+export declare function validateSchema(data: unknown, schema: StandardSchemaV1<any>): Promise<ValidationResult>;
+export declare function validateStandardSchema(schemas: {
+    query?: StandardSchemaV1<any>;
+    body?: StandardSchemaV1<any>;
+    params?: StandardSchemaV1<any>;
+    response?: StandardSchemaV1<any>;
+}): {
+    (req: Request, res: Response, next: NextFunction): Promise<void>;
+    metadata: {
+        bodySchema?: ValidationSchema;
+        querySchema?: ValidationSchema;
+        paramsSchema?: ValidationSchema;
+        responseSchema?: ValidationSchema;
     };
 };
-export declare function validateSchema(data: any, schema: AnySchema, options?: Options): ValidationResult;
+type WithJsonSchema<T> = T & {
+    toJsonSchema: () => ValidationSchema;
+};
+export declare function jsonSchema(schema: ValidationSchema): WithJsonSchema<StandardSchemaV1<Record<string, any>>>;
 export {};

package/dist/validate.js

@@ -1,120 +1,130 @@
+import { standardValidate, ValidationError } from '@devmoods/fetch';
+import {} from '@standard-schema/spec';
 import _Ajv, {} from 'ajv';
-import { Type } from 'arktype';
 import {} from 'express';
 import { BadRequest } from './errors.js';
 const Ajv = _Ajv;
-const toValidationSchema = (schema) => {
-    if (schema instanceof Type) {
-        return schema.toJsonSchema();
+function toStandardSchema(schema) {
+    if (typeof schema === 'boolean' ||
+        (typeof schema === 'object' && schema != null && !('~standard' in schema))) {
+        return jsonSchema(schema);
     }
     return schema;
-};
+}
 export function validateBody(schema) {
-    schema = toValidationSchema(schema);
-    const validate = compileValidateSchema(schema);
-    const middleware = (req, res, next) => {
-        const result = validate(req.body);
-        if (!result.isValid) {
-            return next(BadRequest({ body: result.errors }));
-        }
-        next();
-    };
-    middleware.metadata = { bodySchema: schema };
-    return middleware;
+    return validateStandardSchema({ body: toStandardSchema(schema) });
 }
 export function validateQuery(schema) {
-    schema = toValidationSchema(schema);
-    const validate = compileValidateSchema(schema, { coerceTypes: true });
-    const middleware = (req, res, next) => {
-        const result = validate(req.query);
-        if (!result.isValid) {
-            return next(BadRequest({ query: result.errors }));
-        }
-        next();
-    };
-    middleware.metadata = { querySchema: schema };
-    return middleware;
+    return validateStandardSchema({ query: toStandardSchema(schema) });
 }
 export function validateParams(schema) {
-    schema = toValidationSchema(schema);
-    const validate = compileValidateSchema(schema, { coerceTypes: true });
-    const middleware = (req, res, next) => {
-        const result = validate(req.params);
-        if (!result.isValid) {
-            return next(BadRequest({ params: result.errors }));
-        }
-        next();
-    };
-    middleware.metadata = { paramsSchema: schema };
-    return middleware;
-}
-function createAjv(options) {
-    const ajv = new Ajv({
-        allErrors: true,
-        validateFormats: false,
-        ...options,
-    });
-    ajv.addKeyword('$enumNames');
-    ajv.addKeyword('$bitiforms');
-    ajv.addKeyword('$forms');
-    return ajv;
+    return validateStandardSchema({ params: toStandardSchema(schema) });
 }
-export function compileValidateSchema(schema, options = {}) {
-    const ajv = createAjv(options);
-    const validate = ajv.compile(schema);
-    return (data) => {
-        const valid = validate(data);
-        if (valid) {
-            return {
-                isValid: true,
-                errors: null,
-            };
-        }
-        const errors = transformAjvErrors(validate.errors);
-        validate.errors = null;
+export async function validateSchema(data, schema) {
+    try {
+        await standardValidate(schema, data);
+    }
+    catch (error) {
         return {
             isValid: false,
-            errors,
+            errors: (error instanceof ValidationError
+                ? error.issues.map((issue) => [
+                    String(issue.path ?? '/'),
+                    issue.message,
+                ])
+                : []).reduce((result, item) => {
+                const [key, value] = item;
+                if (Array.isArray(result[key])) {
+                    result[key].push(value);
+                }
+                else {
+                    result[key] = [value];
+                }
+                return result;
+            }, {}),
         };
+    }
+    return { isValid: true, errors: null };
+}
+export function validateStandardSchema(schemas) {
+    const middleware = async (req, res, next) => {
+        try {
+            for (const [key, schema] of Object.entries(schemas)) {
+                if (key === 'response') {
+                    continue;
+                }
+                if (schema) {
+                    const result = await validateSchema(req[key], schema);
+                    if (!result.isValid) {
+                        return next(BadRequest({ [key]: result.errors }));
+                    }
+                }
+            }
+            next();
+        }
+        catch (error) {
+            next(error);
+        }
     };
+    const metadata = {};
+    if (schemas.body) {
+        metadata.bodySchema = toJsonSchema(schemas.body);
+    }
+    if (schemas.query) {
+        metadata.querySchema = toJsonSchema(schemas.query);
+    }
+    if (schemas.params) {
+        metadata.paramsSchema = toJsonSchema(schemas.params);
+    }
+    if (schemas.response) {
+        metadata.responseSchema = toJsonSchema(schemas.response);
+    }
+    middleware.metadata = metadata;
+    return middleware;
 }
-export function validateSchema(data, schema, options = {}) {
-    schema = toValidationSchema(schema);
-    const ajv = createAjv(options);
-    const valid = ajv.validate(schema, data);
-    if (valid) {
-        return {
-            isValid: true,
-            errors: null,
-        };
+function toJsonSchema(standardSchema) {
+    if ('toJsonSchema' in standardSchema &&
+        typeof standardSchema.toJsonSchema === 'function') {
+        return standardSchema.toJsonSchema();
     }
-    const errors = transformAjvErrors(ajv.errors);
-    ajv.errors = null;
-    return {
-        isValid: false,
-        errors,
-    };
+    return {};
 }
 function transformAjvErrors(errors) {
     /* c8 ignore next 3 */
     if (errors == null) {
         return {};
     }
-    return errors
-        .map((error) => {
-        const { instancePath, keyword, params } = error;
+    return errors.map((error) => {
+        const { instancePath, keyword } = error;
         const property = instancePath || '/';
-        const messageWithArgs = { message: `errors.${keyword}`, args: params };
-        return [property, messageWithArgs];
-    })
-        .reduce((result, item) => {
-        const [key, value] = item;
-        if (Array.isArray(result[key])) {
-            result[key].push(value);
-        }
-        else {
-            result[key] = [value];
-        }
-        return result;
-    }, {});
+        return { path: property, message: keyword };
+    });
+}
+export function jsonSchema(schema) {
+    const ajv = new Ajv({
+        allErrors: true,
+        validateFormats: false,
+    });
+    ajv.addKeyword('$enumNames');
+    ajv.addKeyword('$bitiforms');
+    ajv.addKeyword('$forms');
+    const validate = ajv.compile(schema);
+    return {
+        toJsonSchema() {
+            return schema;
+        },
+        '~standard': {
+            version: 1,
+            vendor: 'devmoods-ajv',
+            validate(value) {
+                const valid = validate(value);
+                if (valid) {
+                    return { value };
+                }
+                const issues = transformAjvErrors(validate.errors);
+                validate.errors = null;
+                return { issues };
+            },
+        },
+    };
 }

package/dist/vite/ssr.d.ts

@@ -3,4 +3,4 @@ export interface SsrMiddlewareOptions<InitialData = unknown> {
     getInitialData?: (req: Request) => Promise<InitialData>;
     useDevServer?: boolean;
 }
-export declare function createSsrMiddleware<InitialData = unknown>({ root, getInitialData, useDevServer, }?: SsrMiddlewareOptions<InitialData>): Promise<import("compose-middleware").RequestHandler<unknown, unknown, void>>;
+export declare function createSsrMiddleware<InitialData = unknown>({ root, getInitialData, useDevServer, }?: SsrMiddlewareOptions<InitialData>): Promise<import("compose-middleware").RequestHandler<any, any, void>>;

package/dist/vite/ssr.js

@@ -1,5 +1,6 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import {} from 'compose-middleware';
 import express, {} from 'express';
 import { createServer as createViteServer } from 'vite';
 import {} from './types.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devmoods/express-extras",
-  "version": "0.54.1",
+  "version": "0.56.0",
   "description": "Kubernetes-ready utilities for rapid Node.js application development",
   "type": "module",
   "main": "./dist/index.js",
@@ -46,33 +46,35 @@
   "devDependencies": {
     "@devmoods/eslint-config": "^2.6.0",
     "@types/koa-compose": "^3.2.8",
-    "@types/node": "22.13.5",
+    "@types/node": "22.13.10",
     "@types/supertest": "^6.0.2",
     "@vitejs/plugin-react": "^4.3.4",
-    "@vitest/coverage-v8": "^3.0.7",
-    "arktype": "^2.1.0",
+    "@vitest/coverage-v8": "^3.0.8",
+    "arktype": "^2.1.9",
     "cookiejar": "^2.1.4",
-    "eslint": "^9.21.0",
-    "faktory-worker": "^4.6.0",
-    "prettier": "3.5.2",
+    "eslint": "^9.22.0",
+    "faktory-worker": "^4.7.0",
+    "prettier": "3.5.3",
     "supertest": "7.0.0",
     "ts-node": "10.9.2",
     "tsx": "^4.19.3",
-    "typescript": "5.7.3",
-    "vite": "^6.1.1",
-    "vitest": "^3.0.7",
+    "typescript": "5.8.2",
+    "vite": "^6.2.1",
+    "vitest": "^3.0.8",
     "vitest-fail-on-console": "^0.7.1"
   },
   "dependencies": {
-    "@devmoods/fetch": "^4.0.1",
-    "@sentry/node": "^9.2.0",
-    "@sentry/profiling-node": "^9.2.0",
+    "@devmoods/fetch": "^4.1.0",
+    "@sentry/node": "^9.5.0",
+    "@sentry/profiling-node": "^9.5.0",
+    "@standard-schema/spec": "^1.0.0",
     "@types/bcrypt": "^5.0.2",
     "@types/cookie-parser": "^1.4.8",
     "@types/express": "^5.0.0",
     "@types/jsonwebtoken": "^9.0.9",
     "@types/nodemailer": "^6.4.17",
     "@types/pg": "^8.11.11",
+    "@types/qs": "^6.9.18",
     "@types/superagent": "^8.1.9",
     "@types/uuid": "^10.0.0",
     "ajv": "^8.17.1",
@@ -87,7 +89,7 @@
     "helmet": "^8.0.0",
     "jsonwebtoken": "^9.0.2",
     "nodemailer": "^6.10.0",
-    "pg": "^8.13.3",
+    "pg": "^8.14.0",
     "redis": "^4.7.0",
     "sonda": "^0.7.1",
     "sql-formatter": "^15.4.11",