@lucaapp/service-utils 1.28.0 → 1.29.0

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

@@ -10,6 +10,7 @@ type ApiConstructorOptions = {
     apiVersion?: string;
     apiTitle?: string;
     apiDescription?: string;
+    debug?: boolean;
 };
 export declare class Api {
     router: Router;
@@ -19,6 +20,7 @@ export declare class Api {
     apiTitle: string;
     apiDescription: string;
     private prefixPath;
+    debug: boolean;
     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;

package/dist/lib/api/api.js

@@ -18,26 +18,27 @@ class Api {
         this.apiVersion = options.apiVersion || '1.0.0';
         this.apiTitle = options.apiTitle || 'API';
         this.apiDescription = options.apiDescription || '';
+        this.debug = options.debug || false;
         this.mountSwaggerMiddlewares();
     }
     get(path, summary, options, handler) {
-        (0, endpoint_1.mountEndpoint)(this.router, 'get', path, 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);
     }
     post(path, summary, options, handler) {
-        (0, endpoint_1.mountEndpoint)(this.router, 'post', path, 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);
     }
     patch(path, summary, options, handler) {
-        (0, endpoint_1.mountEndpoint)(this.router, 'patch', path, 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);
     }
     put(path, summary, options, handler) {
-        (0, endpoint_1.mountEndpoint)(this.router, 'put', path, 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);
     }
     delete(path, summary, options, handler) {
-        (0, endpoint_1.mountEndpoint)(this.router, 'delete', path, 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);
     }
     generateOpenAPISpec() {

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

@@ -3,6 +3,6 @@ import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
 import { Middleware, EndpointResponseSchema } from './types/middleware';
 import { EndpointOptions, EndpointHandler } from './types/endpoint';
 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>) => void;
+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 {};

package/dist/lib/api/endpoint.js

@@ -10,19 +10,46 @@ const boom_1 = require("@hapi/boom");
 const buildResponseConfig = (responseOptions) => {
     const responses = {};
     responseOptions.forEach(response => {
-        responses[String(response.status)] = {
-            description: response.description,
-            ...(!(response.schema instanceof zod_1.z.ZodVoid) && {
-                content: {
-                    'application/json': {
-                        schema: response.schema,
+        const isAlreadyPresent = !!responses[String(response.status)];
+        if (!isAlreadyPresent) {
+            responses[String(response.status)] = {
+                description: response.description,
+                ...(!(response.schema instanceof zod_1.z.ZodVoid) && {
+                    content: {
+                        'application/json': {
+                            schema: response.schema,
+                        },
                     },
-                },
-            }),
-        };
+                }),
+            };
+            return;
+        }
+        const existingResponse = responses[response.status];
+        existingResponse.description =
+            existingResponse.description + ' | ' + response.description;
+        // No Content merge
+        if (!response.schema) {
+            return;
+        }
+        // No Content
+        if (!existingResponse.content ||
+            !existingResponse.content['application/json']) {
+            return;
+        }
+        existingResponse.content['application/json'].schema =
+            existingResponse.content['application/json'].schema.or(response.schema);
     });
     return responses;
 };
+const isTypedError = (error) => {
+    if (!(error instanceof Error))
+        return false;
+    // can't access possibly existing type property without casting to any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (typeof error.type !== 'string')
+        return false;
+    return true;
+};
 const validateAndSendResponse = async (expressResponse, response, validResponses) => {
     (0, assert_1.default)(typeof response.status === 'number');
     // get schema respective to status code
@@ -39,7 +66,7 @@ const validateAndSendResponse = async (expressResponse, response, validResponses
     }
     expressResponse.status(response.status).send(validatedResponseBody);
 };
-const handleMiddleware = async (middleware, context, request, response) => new Promise(async (resolve, reject) => {
+const handleMiddleware = async (middleware, context, request, response, debug) => new Promise(async (resolve, reject) => {
     try {
         const handlerRequestBody = ((await middleware.options.schemas?.body?.parseAsync(request.body)) ||
             undefined);
@@ -47,11 +74,16 @@ const handleMiddleware = async (middleware, context, request, response) => new P
         const handlerRequestQuery = ((await middleware.options.schemas?.query?.parseAsync(request.query)) ||
             undefined);
         const handlerRequestHeaders = ((await middleware.options.schemas?.headers?.parseAsync(request.headers)) || undefined);
+        const { ip, baseUrl, route, method } = request;
         const handlerRequest = {
             body: handlerRequestBody,
             params: handlerRequestParams,
             query: handlerRequestQuery,
             headers: handlerRequestHeaders,
+            ip,
+            baseUrl,
+            method,
+            path: route.path,
         };
         await middleware.handler(handlerRequest, async (middlewareResponse) => {
             try {
@@ -83,10 +115,21 @@ const handleMiddleware = async (middleware, context, request, response) => new P
         });
     }
     catch (error) {
+        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 }),
+            });
+        }
         reject(error);
     }
 });
-const mountEndpoint = (router, method, path, options, handler) => {
+const mountEndpoint = (router, method, path, options, handler, debug) => {
     (0, assert_1.default)(options.responses.length > 0, 'You need to specify at least one response');
     router[method](path, async (request, response, next) => {
         try {
@@ -106,7 +149,7 @@ const mountEndpoint = (router, method, path, options, handler) => {
             const ctx = {};
             if (options.middlewares instanceof Array) {
                 for (const middleware of options.middlewares) {
-                    const shouldContinue = await handleMiddleware(middleware, ctx, request, response);
+                    const shouldContinue = await handleMiddleware(middleware, ctx, request, response, debug);
                     if (!shouldContinue)
                         return;
                 }
@@ -129,6 +172,17 @@ const mountEndpoint = (router, method, path, options, handler) => {
             if (error instanceof zod_1.z.ZodError && !(0, boom_1.isBoom)(error)) {
                 return response.status(400).send({ issues: error.issues });
             }
+            if (isTypedError(error) &&
+                options.errors &&
+                options.errors[error.type]) {
+                const statusCode = options.errors[error.type];
+                return response.status(statusCode).send({
+                    statusCode,
+                    error: error.type,
+                    message: error.message,
+                    ...(debug && { stack: error.stack }),
+                });
+            }
             next(error);
         }
     });
@@ -142,6 +196,22 @@ options) => {
     let querySchema = options.schemas?.query || undefined;
     let headersSchema = options.schemas?.headers || undefined;
     let responseSchemas = options.responses;
+    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(),
+                    }),
+                },
+            ]);
+        }
+    }
     for (const middleware of options.middlewares || []) {
         if (middleware.options.schemas?.body) {
             bodySchema = bodySchema
@@ -166,6 +236,22 @@ options) => {
         if (middleware.options.responses) {
             responseSchemas = responseSchemas.concat(middleware.options.responses);
         }
+        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(),
+                        }),
+                    },
+                ]);
+            }
+        }
     }
     const responseMap = buildResponseConfig(responseSchemas);
     registry.registerPath({

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

@@ -16,4 +16,5 @@ export type EndpointOptions<TResponseSchemas extends ReadonlyArray<EndpointRespo
     };
     middlewares?: TMiddlewares;
     responses: TResponseSchemas;
+    errors?: Record<string, number>;
 };

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

@@ -10,6 +10,10 @@ export type MiddlewareHandler<TResponseSchema, TRequestBody = undefined, TReques
     params: TRequestParams;
     query: TRequestQuery;
     headers: TRequestHeaders;
+    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> = {
     schemas?: {
@@ -20,6 +24,7 @@ export type MiddlewareOptions<TResponseSchemas extends ReadonlyArray<EndpointRes
         context?: z.ZodSchema<TContext>;
     };
     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>;

package/package.json

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