@lucaapp/service-utils 1.30.1 → 1.32.0

package/dist/lib/api/api.d.ts

@@ -3,6 +3,7 @@ import 'express-async-errors';
 import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
 import { EndpointHandler, EndpointOptions } from './types/endpoint';
 import { Middleware, EndpointResponseSchema } from './types/middleware';
+import { ZodObjectSchemaOrUndefined } from './types/utils';
 type OpenApiVersion = '3.0.0' | '3.0.1' | '3.0.2' | '3.0.3' | '3.1.0';
 type ApiConstructorOptions = {
     prefixPath?: string;
@@ -11,6 +12,13 @@ type ApiConstructorOptions = {
     apiTitle?: string;
     apiDescription?: string;
     debug?: boolean;
+    tags?: string[];
+    registry?: OpenAPIRegistry;
+    router?: Router;
+};
+type ApiChildOptions = {
+    prefixPath?: string;
+    tags?: string[];
 };
 export declare class Api {
     router: Router;
@@ -21,12 +29,14 @@ export declare class Api {
     apiDescription: string;
     private prefixPath;
     debug: boolean;
+    tags: string[];
     constructor(options?: ApiConstructorOptions);
-    get<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TMiddlewares extends ReadonlyArray<Middleware<any, any, any, any, any, any>> | undefined = undefined>(path: string, summary: string, options: EndpointOptions<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>, handler: EndpointHandler<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>): void;
-    post<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TMiddlewares extends ReadonlyArray<Middleware<any, any, any, any, any, any>> | undefined = undefined>(path: string, summary: string, options: EndpointOptions<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>, handler: EndpointHandler<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>): void;
-    patch<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TMiddlewares extends ReadonlyArray<Middleware<any, any, any, any, any, any>> | undefined = undefined>(path: string, summary: string, options: EndpointOptions<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>, handler: EndpointHandler<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>): void;
-    put<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TMiddlewares extends ReadonlyArray<Middleware<any, any, any, any, any, any>> | undefined = undefined>(path: string, summary: string, options: EndpointOptions<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>, handler: EndpointHandler<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>): void;
-    delete<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TMiddlewares extends ReadonlyArray<Middleware<any, any, any, any, any, any>> | undefined = undefined>(path: string, summary: string, options: EndpointOptions<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>, handler: EndpointHandler<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>): void;
+    child(options: ApiChildOptions): Api;
+    get<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBodySchema extends ZodObjectSchemaOrUndefined = undefined, TRequestParamsSchema extends ZodObjectSchemaOrUndefined = undefined, TRequestQuerySchema extends ZodObjectSchemaOrUndefined = undefined, TRequestHeadersSchema extends ZodObjectSchemaOrUndefined = undefined, TMiddlewares extends ReadonlyArray<Middleware<any, any, any, any, any, any>> | undefined = undefined>(path: string, summary: string, options: EndpointOptions<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares>, handler: EndpointHandler<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares>): void;
+    post<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBodySchema extends ZodObjectSchemaOrUndefined = undefined, TRequestParamsSchema extends ZodObjectSchemaOrUndefined = undefined, TRequestQuerySchema extends ZodObjectSchemaOrUndefined = undefined, TRequestHeadersSchema extends ZodObjectSchemaOrUndefined = undefined, TMiddlewares extends ReadonlyArray<Middleware<any, any, any, any, any, any>> | undefined = undefined>(path: string, summary: string, options: EndpointOptions<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares>, handler: EndpointHandler<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares>): void;
+    patch<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBodySchema extends ZodObjectSchemaOrUndefined = undefined, TRequestParamsSchema extends ZodObjectSchemaOrUndefined = undefined, TRequestQuerySchema extends ZodObjectSchemaOrUndefined = undefined, TRequestHeadersSchema extends ZodObjectSchemaOrUndefined = undefined, TMiddlewares extends ReadonlyArray<Middleware<any, any, any, any, any, any>> | undefined = undefined>(path: string, summary: string, options: EndpointOptions<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares>, handler: EndpointHandler<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares>): void;
+    put<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBodySchema extends ZodObjectSchemaOrUndefined = undefined, TRequestParamsSchema extends ZodObjectSchemaOrUndefined = undefined, TRequestQuerySchema extends ZodObjectSchemaOrUndefined = undefined, TRequestHeadersSchema extends ZodObjectSchemaOrUndefined = undefined, TMiddlewares extends ReadonlyArray<Middleware<any, any, any, any, any, any>> | undefined = undefined>(path: string, summary: string, options: EndpointOptions<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares>, handler: EndpointHandler<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares>): void;
+    delete<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBodySchema extends ZodObjectSchemaOrUndefined = undefined, TRequestParamsSchema extends ZodObjectSchemaOrUndefined = undefined, TRequestQuerySchema extends ZodObjectSchemaOrUndefined = undefined, TRequestHeadersSchema extends ZodObjectSchemaOrUndefined = undefined, TMiddlewares extends ReadonlyArray<Middleware<any, any, any, any, any, any>> | undefined = undefined>(path: string, summary: string, options: EndpointOptions<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares>, handler: EndpointHandler<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares>): void;
     generateOpenAPISpec(): import("openapi3-ts").OpenAPIObject;
     mountSwaggerMiddlewares(): void;
 }

package/dist/lib/api/api.js

@@ -11,35 +11,44 @@ const zod_to_openapi_1 = require("@asteasolutions/zod-to-openapi");
 const endpoint_1 = require("./endpoint");
 class Api {
     constructor(options = {}) {
-        this.router = (0, express_1.Router)();
-        this.registry = new zod_to_openapi_1.OpenAPIRegistry();
+        this.router = options.router || (0, express_1.Router)();
+        this.registry = options.registry || new zod_to_openapi_1.OpenAPIRegistry();
         this.prefixPath = options.prefixPath || '';
         this.openApiVersion = options.openApiVersion || '3.0.0';
         this.apiVersion = options.apiVersion || '1.0.0';
         this.apiTitle = options.apiTitle || 'API';
         this.apiDescription = options.apiDescription || '';
         this.debug = options.debug || false;
-        this.mountSwaggerMiddlewares();
+        this.tags = options.tags || [];
+    }
+    child(options) {
+        return new Api({
+            prefixPath: this.prefixPath + (options.prefixPath || ''),
+            debug: this.debug,
+            tags: [...this.tags, ...(options.tags || [])],
+            registry: this.registry,
+            router: this.router,
+        });
     }
     get(path, summary, options, handler) {
         (0, endpoint_1.mountEndpoint)(this.router, 'get', path, options, handler, this.debug);
-        (0, endpoint_1.registerEndpoint)(this.registry, 'get', this.prefixPath, path, summary, options);
+        (0, endpoint_1.registerEndpoint)(this.registry, 'get', this.prefixPath, path, summary, options, this.tags, this.debug);
     }
     post(path, summary, options, handler) {
         (0, endpoint_1.mountEndpoint)(this.router, 'post', path, options, handler, this.debug);
-        (0, endpoint_1.registerEndpoint)(this.registry, 'post', this.prefixPath, path, summary, options);
+        (0, endpoint_1.registerEndpoint)(this.registry, 'post', this.prefixPath, path, summary, options, this.tags, this.debug);
     }
     patch(path, summary, options, handler) {
         (0, endpoint_1.mountEndpoint)(this.router, 'patch', path, options, handler, this.debug);
-        (0, endpoint_1.registerEndpoint)(this.registry, 'patch', this.prefixPath, path, summary, options);
+        (0, endpoint_1.registerEndpoint)(this.registry, 'patch', this.prefixPath, path, summary, options, this.tags, this.debug);
     }
     put(path, summary, options, handler) {
         (0, endpoint_1.mountEndpoint)(this.router, 'put', path, options, handler, this.debug);
-        (0, endpoint_1.registerEndpoint)(this.registry, 'put', this.prefixPath, path, summary, options);
+        (0, endpoint_1.registerEndpoint)(this.registry, 'put', this.prefixPath, path, summary, options, this.tags, this.debug);
     }
     delete(path, summary, options, handler) {
         (0, endpoint_1.mountEndpoint)(this.router, 'delete', path, options, handler, this.debug);
-        (0, endpoint_1.registerEndpoint)(this.registry, 'delete', this.prefixPath, path, summary, options);
+        (0, endpoint_1.registerEndpoint)(this.registry, 'delete', this.prefixPath, path, summary, options, this.tags, this.debug);
     }
     generateOpenAPISpec() {
         const generator = new zod_to_openapi_1.OpenAPIGenerator(this.registry.definitions, this.openApiVersion);

package/dist/lib/api/endpoint.d.ts

@@ -2,7 +2,8 @@ import { Router } from 'express';
 import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
 import { Middleware, EndpointResponseSchema } from './types/middleware';
 import { EndpointOptions, EndpointHandler } from './types/endpoint';
+import { ZodObjectSchemaOrUndefined } from './types/utils';
 type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch';
-export declare const mountEndpoint: <TResponseSchemas extends readonly EndpointResponseSchema[], TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TMiddlewares extends readonly Middleware<any, any, any, any, any, any>[] | undefined = undefined>(router: Router, method: HttpMethod, path: string, options: EndpointOptions<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>, handler: EndpointHandler<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TMiddlewares>, debug: boolean) => void;
-export declare const registerEndpoint: (registry: OpenAPIRegistry, method: HttpMethod, prefixPath: string, path: string, summary: string, options: EndpointOptions<any, any, any, any, any, any>) => void;
+export declare const mountEndpoint: <TResponseSchemas extends readonly EndpointResponseSchema[], TRequestBodySchema extends ZodObjectSchemaOrUndefined, TRequestParamsSchema extends ZodObjectSchemaOrUndefined, TRequestQuerySchema extends ZodObjectSchemaOrUndefined, TRequestHeadersSchema extends ZodObjectSchemaOrUndefined, TMiddlewares extends readonly Middleware<any, any, any, any, any, any>[] | undefined = undefined>(router: Router, method: HttpMethod, path: string, options: EndpointOptions<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares>, handler: EndpointHandler<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares>, debug: boolean) => void;
+export declare const registerEndpoint: (registry: OpenAPIRegistry, method: HttpMethod, prefixPath: string, path: string, summary: string, options: EndpointOptions<any, any, any, any, any, any>, tags: string[], debug: boolean) => void;
 export {};

package/dist/lib/api/endpoint.js

@@ -6,7 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerEndpoint = exports.mountEndpoint = void 0;
 const zod_1 = require("zod");
 const assert_1 = __importDefault(require("assert"));
-const boom_1 = require("@hapi/boom");
+const http_1 = require("./types/http");
+const mapExpressParamsToOpenAPIParams = (path) => path.replaceAll(/\:([^\:\/]+)/g, '{$1}');
 const buildResponseConfig = (responseOptions) => {
     const responses = {};
     responseOptions.forEach(response => {
@@ -66,6 +67,27 @@ const validateAndSendResponse = async (expressResponse, response, validResponses
     }
     expressResponse.status(response.status).send(validatedResponseBody);
 };
+const sendBadResponseError = (response, error) => {
+    return response.status(500).send({
+        error: http_1.HTTPStatus.INTERNAL_SERVER_ERROR,
+        message: 'Invalid Response',
+        issues: error.issues,
+    });
+};
+const sendKnownErrorResponse = (response, statusCode, error, debug) => {
+    response.status(statusCode).send({
+        error: error.type,
+        message: error.message,
+        ...(debug && { stack: error.stack }),
+    });
+};
+const sendBadRequestError = (response, error) => {
+    return response.status(400).send({
+        error: http_1.HTTPStatus.BAD_REQUEST,
+        message: error.message,
+        issues: error.issues,
+    });
+};
 const handleMiddleware = async (middleware, context, request, response, debug) => new Promise(async (resolve, reject) => {
     try {
         const handlerRequestBody = ((await middleware.options.schemas?.body?.parseAsync(request.body)) ||
@@ -91,10 +113,9 @@ const handleMiddleware = async (middleware, context, request, response, debug) =
                 resolve(false);
             }
             catch (error) {
-                if (error instanceof Error) {
-                    (0, boom_1.boomify)(error, {
-                        statusCode: 500,
-                    });
+                if (error instanceof zod_1.ZodError) {
+                    sendBadResponseError(response, error);
+                    return resolve(false);
                 }
                 reject(error);
             }
@@ -105,27 +126,27 @@ const handleMiddleware = async (middleware, context, request, response, debug) =
                 resolve(true);
             }
             catch (error) {
-                if (error instanceof Error) {
-                    (0, boom_1.boomify)(error, {
-                        statusCode: 500,
-                    });
+                if (error instanceof zod_1.ZodError) {
+                    sendBadResponseError(response, error);
+                    return resolve(false);
                 }
                 reject(error);
             }
         });
     }
     catch (error) {
+        if (error instanceof zod_1.ZodError) {
+            sendBadRequestError(response, error);
+            return resolve(false);
+        }
         if (isTypedError(error) &&
             middleware.options.errors &&
             middleware.options.errors[error.type]) {
             const statusCode = middleware.options.errors[error.type];
-            return response.status(statusCode).send({
-                statusCode,
-                error: error.type,
-                message: error.message,
-                ...(debug && { stack: error.stack }),
-            });
+            sendKnownErrorResponse(response, statusCode, error, debug);
+            return resolve(false);
         }
+        // bubble up unknown errors
         reject(error);
     }
 });
@@ -159,38 +180,41 @@ const mountEndpoint = (router, method, path, options, handler, debug) => {
                     await validateAndSendResponse(response, controllerResponse, options.responses);
                 }
                 catch (error) {
-                    if (error instanceof Error) {
-                        (0, boom_1.boomify)(error, {
-                            statusCode: 500,
-                        });
+                    if (error instanceof zod_1.ZodError) {
+                        return sendBadResponseError(response, error);
                     }
                     next(error);
                 }
             });
         }
         catch (error) {
-            if (error instanceof zod_1.z.ZodError && !(0, boom_1.isBoom)(error)) {
-                return response.status(400).send({ issues: error.issues });
+            if (error instanceof zod_1.ZodError) {
+                return sendBadRequestError(response, error);
             }
             if (isTypedError(error) &&
                 options.errors &&
                 options.errors[error.type]) {
                 const statusCode = options.errors[error.type];
-                return response.status(statusCode).send({
-                    statusCode,
-                    error: error.type,
+                return sendKnownErrorResponse(response, statusCode, error, debug);
+            }
+            if (error instanceof Error) {
+                return response.status(500).send({
+                    error: http_1.HTTPStatus.INTERNAL_SERVER_ERROR,
                     message: error.message,
                     ...(debug && { stack: error.stack }),
                 });
             }
-            next(error);
+            return response.status(500).send({
+                error: http_1.HTTPStatus.INTERNAL_SERVER_ERROR,
+                message: 'Unknown Error',
+            });
         }
     });
 };
 exports.mountEndpoint = mountEndpoint;
 const registerEndpoint = (registry, method, prefixPath, path, summary, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-options) => {
+options, tags, debug) => {
     let bodySchema = options.schemas?.body || undefined;
     let paramsSchema = options.schemas?.params || undefined;
     let querySchema = options.schemas?.query || undefined;
@@ -199,17 +223,14 @@ options) => {
     if (options.errors) {
         for (const errorType of Object.keys(options.errors)) {
             const statusCode = options.errors[errorType];
-            responseSchemas = responseSchemas.concat([
-                {
-                    status: statusCode,
-                    description: errorType,
-                    schema: zod_1.z.object({
-                        statusCode: zod_1.z.literal(statusCode),
-                        error: zod_1.z.literal(errorType),
-                        message: zod_1.z.string(),
-                    }),
-                },
-            ]);
+            responseSchemas.push({
+                status: statusCode,
+                description: errorType,
+                schema: zod_1.z.object({
+                    error: zod_1.z.literal(errorType),
+                    message: zod_1.z.string(),
+                }),
+            });
         }
     }
     for (const middleware of options.middlewares || []) {
@@ -239,25 +260,47 @@ options) => {
         if (middleware.options.errors) {
             for (const errorType of Object.keys(middleware.options.errors)) {
                 const statusCode = middleware.options.errors[errorType];
-                responseSchemas = responseSchemas.concat([
-                    {
-                        status: statusCode,
-                        description: errorType,
-                        schema: zod_1.z.object({
-                            statusCode: zod_1.z.literal(statusCode),
-                            error: zod_1.z.literal(errorType),
-                            message: zod_1.z.string(),
-                        }),
-                    },
-                ]);
+                responseSchemas.push({
+                    status: statusCode,
+                    description: errorType,
+                    schema: zod_1.z.object({
+                        error: zod_1.z.literal(errorType),
+                        message: zod_1.z.string(),
+                    }),
+                });
             }
         }
     }
+    // Add ZodError response
+    responseSchemas.push({
+        status: 400,
+        description: 'Bad Request',
+        schema: zod_1.z.object({
+            error: zod_1.z.literal(http_1.HTTPStatus.BAD_REQUEST),
+            message: zod_1.z.string(),
+            issues: zod_1.z.array(zod_1.z
+                .object({
+                message: zod_1.z.string(),
+            })
+                .openapi({ additionalProperties: true })),
+        }),
+    });
+    // Add UnknownError response
+    responseSchemas.push({
+        status: 500,
+        description: 'Internal Server Error',
+        schema: zod_1.z.object({
+            error: zod_1.z.literal(http_1.HTTPStatus.INTERNAL_SERVER_ERROR),
+            message: zod_1.z.string(),
+            ...(debug && { stack: zod_1.z.string().optional() }),
+        }),
+    });
     const responseMap = buildResponseConfig(responseSchemas);
     registry.registerPath({
         method,
-        path: (prefixPath + path).replaceAll(/\:([^\:\/]+)/g, '{$1}'),
+        path: mapExpressParamsToOpenAPIParams(prefixPath + path),
         summary,
+        tags,
         // description: summary,
         request: {
             ...(bodySchema && {

package/dist/lib/api/response.d.ts

@@ -1,56 +1,45 @@
 import { z } from 'zod';
+import { HTTPStatus } from './types/http';
 declare const noContentSchema: z.ZodVoid;
 declare const badRequestErrorSchema: z.ZodObject<{
-    statusCode: z.ZodLiteral<400>;
-    error: z.ZodString;
+    error: z.ZodLiteral<HTTPStatus.BAD_REQUEST>;
     message: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     message: string;
-    error: string;
-    statusCode: 400;
+    error: HTTPStatus.BAD_REQUEST;
 }, {
     message: string;
-    error: string;
-    statusCode: 400;
+    error: HTTPStatus.BAD_REQUEST;
 }>;
 declare const unauthorizedErrorSchema: z.ZodObject<{
-    statusCode: z.ZodLiteral<401>;
-    error: z.ZodString;
+    error: z.ZodLiteral<HTTPStatus.UNAUTHORIZED>;
     message: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     message: string;
-    error: string;
-    statusCode: 401;
+    error: HTTPStatus.UNAUTHORIZED;
 }, {
     message: string;
-    error: string;
-    statusCode: 401;
+    error: HTTPStatus.UNAUTHORIZED;
 }>;
 declare const forbiddenErrorSchema: z.ZodObject<{
-    statusCode: z.ZodLiteral<403>;
-    error: z.ZodString;
+    error: z.ZodLiteral<HTTPStatus.FORBIDDEN>;
     message: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     message: string;
-    error: string;
-    statusCode: 403;
+    error: HTTPStatus.FORBIDDEN;
 }, {
     message: string;
-    error: string;
-    statusCode: 403;
+    error: HTTPStatus.FORBIDDEN;
 }>;
 declare const notFoundErrorSchema: z.ZodObject<{
-    statusCode: z.ZodLiteral<404>;
-    error: z.ZodString;
+    error: z.ZodLiteral<HTTPStatus.NOT_FOUND>;
     message: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     message: string;
-    error: string;
-    statusCode: 404;
+    error: HTTPStatus.NOT_FOUND;
 }, {
     message: string;
-    error: string;
-    statusCode: 404;
+    error: HTTPStatus.NOT_FOUND;
 }>;
 export declare const okResponse: <T>(schema: z.ZodType<T, z.ZodTypeDef, T>) => {
     status: 200;

package/dist/lib/api/response.js

@@ -3,27 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.notFoundResponse = exports.forbiddenResponse = exports.unauthorizedResponse = exports.badRequestResponse = exports.noContentResponse = exports.okResponse = void 0;
 const zod_to_openapi_1 = require("@asteasolutions/zod-to-openapi");
 const zod_1 = require("zod");
+const http_1 = require("./types/http");
 (0, zod_to_openapi_1.extendZodWithOpenApi)(zod_1.z);
 // response schemas
 const noContentSchema = zod_1.z.void();
 const badRequestErrorSchema = zod_1.z.object({
-    statusCode: zod_1.z.literal(400),
-    error: zod_1.z.string(),
+    error: zod_1.z.literal(http_1.HTTPStatus.BAD_REQUEST),
     message: zod_1.z.string(),
 });
 const unauthorizedErrorSchema = zod_1.z.object({
-    statusCode: zod_1.z.literal(401),
-    error: zod_1.z.string(),
+    error: zod_1.z.literal(http_1.HTTPStatus.UNAUTHORIZED),
     message: zod_1.z.string(),
 });
 const forbiddenErrorSchema = zod_1.z.object({
-    statusCode: zod_1.z.literal(403),
-    error: zod_1.z.string(),
+    error: zod_1.z.literal(http_1.HTTPStatus.FORBIDDEN),
     message: zod_1.z.string(),
 });
 const notFoundErrorSchema = zod_1.z.object({
-    statusCode: zod_1.z.literal(404),
-    error: zod_1.z.string(),
+    error: zod_1.z.literal(http_1.HTTPStatus.NOT_FOUND),
     message: zod_1.z.string(),
 });
 // response functions

package/dist/lib/api/send.d.ts

@@ -1,3 +1,4 @@
+import { HTTPStatus } from './types/http';
 export declare const ok: <T>(body: T) => {
     status: 200;
     body: T;
@@ -9,32 +10,28 @@ export declare const noContent: () => {
 export declare const badRequest: (message?: string) => {
     status: 400;
     body: {
-        statusCode: 400;
-        error: string;
+        error: HTTPStatus.BAD_REQUEST;
         message: string;
     };
 };
 export declare const unauthorized: (message?: string) => {
     status: 401;
     body: {
-        statusCode: 401;
-        error: string;
+        error: HTTPStatus.UNAUTHORIZED;
         message: string;
     };
 };
 export declare const forbidden: (message?: string) => {
     status: 403;
     body: {
-        statusCode: 403;
-        error: string;
+        error: HTTPStatus.FORBIDDEN;
         message: string;
     };
 };
 export declare const notFound: (message?: string) => {
     status: 404;
     body: {
-        statusCode: 404;
-        error: string;
+        error: HTTPStatus.NOT_FOUND;
         message: string;
     };
 };

package/dist/lib/api/send.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.notFound = exports.forbidden = exports.unauthorized = exports.badRequest = exports.noContent = exports.ok = void 0;
+const http_1 = require("./types/http");
 const ok = (body) => ({
     status: 200,
     body,
@@ -14,8 +15,7 @@ exports.noContent = noContent;
 const badRequest = (message) => ({
     status: 400,
     body: {
-        statusCode: 400,
-        error: 'Bad request',
+        error: http_1.HTTPStatus.BAD_REQUEST,
         message: message || 'Bad request',
     },
 });
@@ -23,8 +23,7 @@ exports.badRequest = badRequest;
 const unauthorized = (message) => ({
     status: 401,
     body: {
-        statusCode: 401,
-        error: 'Unauthorized',
+        error: http_1.HTTPStatus.UNAUTHORIZED,
         message: message || 'Unauthorized',
     },
 });
@@ -32,8 +31,7 @@ exports.unauthorized = unauthorized;
 const forbidden = (message) => ({
     status: 403,
     body: {
-        statusCode: 403,
-        error: 'Forbidden',
+        error: http_1.HTTPStatus.FORBIDDEN,
         message: message || 'Forbidden',
     },
 });
@@ -41,8 +39,7 @@ exports.forbidden = forbidden;
 const notFound = (message) => ({
     status: 404,
     body: {
-        statusCode: 404,
-        error: 'Not found',
+        error: http_1.HTTPStatus.NOT_FOUND,
         message: message || 'Not found',
     },
 });

package/dist/lib/api/types/endpoint.d.ts

@@ -1,18 +1,17 @@
-import { z } from 'zod';
 import { Middleware, EndpointResponseSchema } from './middleware';
-import { ArrayToUnion, ExtractZodOutput, ExtractZodOutputFromMiddleware, Always, Merge } from './utils';
-export type EndpointHandler<TResponse, TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TMiddlewares = undefined> = (request: {
-    body: TRequestBody;
-    params: TRequestParams;
-    query: TRequestQuery;
-    headers: TRequestHeaders;
+import { ArrayToUnion, ExtractZodOutput, ExtractZodOutputFromMiddleware, Always, Merge, ZodSchemaOuput } from './utils';
+export type EndpointHandler<TResponse, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares> = (request: {
+    body: ZodSchemaOuput<TRequestBodySchema>;
+    params: ZodSchemaOuput<TRequestParamsSchema>;
+    query: ZodSchemaOuput<TRequestQuerySchema>;
+    headers: ZodSchemaOuput<TRequestHeadersSchema>;
 }, context: Merge<Always<ExtractZodOutputFromMiddleware<ArrayToUnion<TMiddlewares>>>>, send: (response: ExtractZodOutput<ArrayToUnion<TResponse>>) => void) => Promise<void>;
-export type EndpointOptions<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TMiddlewares extends ReadonlyArray<Middleware<any, any, any, any, any, any>> | undefined = undefined> = {
+export type EndpointOptions<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TMiddlewares extends ReadonlyArray<Middleware<any, any, any, any, any, any>> | undefined> = {
     schemas?: {
-        body?: z.ZodObject<z.ZodRawShape, 'strip', z.ZodTypeAny, TRequestBody>;
-        params?: z.ZodObject<z.ZodRawShape, 'strip', z.ZodTypeAny, TRequestParams>;
-        query?: z.ZodObject<z.ZodRawShape, 'strip', z.ZodTypeAny, TRequestQuery>;
-        headers?: z.ZodObject<z.ZodRawShape, 'strip', z.ZodTypeAny, TRequestHeaders>;
+        body?: TRequestBodySchema;
+        params?: TRequestParamsSchema;
+        query?: TRequestQuerySchema;
+        headers?: TRequestHeadersSchema;
     };
     middlewares?: TMiddlewares;
     responses: TResponseSchemas;

package/dist/lib/api/types/http.d.ts

@@ -0,0 +1,17 @@
+export declare enum HTTPStatus {
+    'OK' = "OK",
+    'CREATED' = "CREATED",
+    'ACCEPTED' = "ACCEPTED",
+    'NO_CONTENT' = "NO_CONTENT",
+    'BAD_REQUEST' = "BAD_REQUEST",
+    'UNAUTHORIZED' = "UNAUTHORIZED",
+    'FORBIDDEN' = "FORBIDDEN",
+    'NOT_FOUND' = "NOT_FOUND",
+    'CONFLICT' = "CONFLICT",
+    'GONE' = "GONE",
+    'TOO_MANY_REQUESTS' = "TOO_MANY_REQUESTS",
+    'INTERNAL_SERVER_ERROR' = "INTERNAL_SERVER_ERROR",
+    'NOT_IMPLEMENTED' = "NOT_IMPLEMENTED",
+    'BAD_GATEWAY' = "BAD_GATEWAY",
+    'SERVICE_UNAVAILABLE' = "SERVICE_UNAVAILABLE"
+}

package/dist/lib/api/types/http.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPStatus = void 0;
+var HTTPStatus;
+(function (HTTPStatus) {
+    HTTPStatus["OK"] = "OK";
+    HTTPStatus["CREATED"] = "CREATED";
+    HTTPStatus["ACCEPTED"] = "ACCEPTED";
+    HTTPStatus["NO_CONTENT"] = "NO_CONTENT";
+    HTTPStatus["BAD_REQUEST"] = "BAD_REQUEST";
+    HTTPStatus["UNAUTHORIZED"] = "UNAUTHORIZED";
+    HTTPStatus["FORBIDDEN"] = "FORBIDDEN";
+    HTTPStatus["NOT_FOUND"] = "NOT_FOUND";
+    HTTPStatus["CONFLICT"] = "CONFLICT";
+    HTTPStatus["GONE"] = "GONE";
+    HTTPStatus["TOO_MANY_REQUESTS"] = "TOO_MANY_REQUESTS";
+    HTTPStatus["INTERNAL_SERVER_ERROR"] = "INTERNAL_SERVER_ERROR";
+    HTTPStatus["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
+    HTTPStatus["BAD_GATEWAY"] = "BAD_GATEWAY";
+    HTTPStatus["SERVICE_UNAVAILABLE"] = "SERVICE_UNAVAILABLE";
+})(HTTPStatus = exports.HTTPStatus || (exports.HTTPStatus = {}));

package/dist/lib/api/types/middleware.d.ts

@@ -1,32 +1,32 @@
 import { z } from 'zod';
-import { ArrayToUnion, ExtractZodOutput } from './utils';
+import { ArrayToUnion, ExtractZodOutput, ZodSchemaOuput } from './utils';
 export type EndpointResponseSchema = {
     status: number;
     description: string;
     schema: z.ZodSchema<any> | z.ZodVoid;
 };
-export type MiddlewareHandler<TResponseSchema, TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TContext = undefined> = (request: {
-    body: TRequestBody;
-    params: TRequestParams;
-    query: TRequestQuery;
-    headers: TRequestHeaders;
+export type MiddlewareHandler<TResponseSchema, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TContextSchema> = (request: {
+    body: ZodSchemaOuput<TRequestBodySchema>;
+    params: ZodSchemaOuput<TRequestParamsSchema>;
+    query: ZodSchemaOuput<TRequestQuerySchema>;
+    headers: ZodSchemaOuput<TRequestHeadersSchema>;
     ip: string;
     baseUrl: string;
     path: string;
     method: string;
-}, send: (response: ExtractZodOutput<ArrayToUnion<TResponseSchema>>) => void, next: (context: TContext) => void) => Promise<void>;
-export type MiddlewareOptions<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TContext = undefined> = {
+}, send: (response: ExtractZodOutput<ArrayToUnion<TResponseSchema>>) => void, next: (context: ZodSchemaOuput<TContextSchema>) => void) => Promise<void>;
+export type MiddlewareOptions<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TContextSchema> = {
     schemas?: {
-        body?: z.ZodSchema<TRequestBody>;
-        params?: z.ZodObject<z.ZodRawShape, 'strip', z.ZodTypeAny, TRequestParams>;
-        query?: z.ZodObject<z.ZodRawShape, 'strip', z.ZodTypeAny, TRequestQuery>;
-        headers?: z.ZodObject<z.ZodRawShape, 'strip', z.ZodTypeAny, TRequestHeaders>;
-        context?: z.ZodSchema<TContext>;
+        body?: TRequestBodySchema;
+        params?: TRequestParamsSchema;
+        query?: TRequestQuerySchema;
+        headers?: TRequestHeadersSchema;
+        context?: TContextSchema;
     };
     responses: TResponseSchemas;
     errors?: Record<string, number>;
 };
-export type Middleware<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBody = undefined, TRequestParams = undefined, TRequestQuery = undefined, TRequestHeaders = undefined, TContext = undefined> = {
-    options: MiddlewareOptions<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TContext>;
-    handler: MiddlewareHandler<TResponseSchemas, TRequestBody, TRequestParams, TRequestQuery, TRequestHeaders, TContext>;
+export type Middleware<TResponseSchemas extends ReadonlyArray<EndpointResponseSchema>, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TContextSchema> = {
+    options: MiddlewareOptions<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TContextSchema>;
+    handler: MiddlewareHandler<TResponseSchemas, TRequestBodySchema, TRequestParamsSchema, TRequestQuerySchema, TRequestHeadersSchema, TContextSchema>;
 };

package/dist/lib/api/types/utils.d.ts

@@ -7,6 +7,8 @@ export type ExtractZodOutput<T> = T extends {
     status: Z;
     body: V;
 } : never;
+export type ZodObjectSchemaOrUndefined = z.ZodObject<any> | undefined;
+export type ZodSchemaOuput<T> = T extends z.ZodSchema<any> ? z.infer<T> : undefined;
 export type ExtractZodOutputFromMiddleware<T> = T extends {
     options: {
         schemas?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucaapp/service-utils",
-  "version": "1.30.1",
+  "version": "1.32.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [