@lucaapp/service-utils 1.26.0 → 1.27.0

package/dist/lib/api/endpoint.js

@@ -6,12 +6,13 @@ 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 buildResponseConfig = (responseOptions) => {
     const responses = {};
     responseOptions.forEach(response => {
         responses[String(response.status)] = {
             description: response.description,
-            ...(!(response.schema instanceof zod_1.ZodVoid) && {
+            ...(!(response.schema instanceof zod_1.z.ZodVoid) && {
                 content: {
                     'application/json': {
                         schema: response.schema,
@@ -22,36 +23,114 @@ const buildResponseConfig = (responseOptions) => {
     });
     return responses;
 };
-const mountEndpoint = (router, method, path, options, handler) => {
-    (0, assert_1.default)(options.responses.length > 0, 'You need to specify at least one response');
-    router[method](path, async (request, response) => {
-        // parse request schemas
-        const handlerRequestBody = ((await options.schemas?.body?.parseAsync(request.body)) || undefined);
-        const handlerRequestParams = ((await options.schemas?.params?.parseAsync(request.params)) || undefined);
-        const handlerRequestQuery = ((await options.schemas?.query?.parseAsync(request.query)) || undefined);
-        const handlerRequestHeaders = ((await options.schemas?.headers?.parseAsync(request.headers)) || undefined);
+const validateAndSendResponse = async (expressResponse, response, validResponses) => {
+    (0, assert_1.default)(typeof response.status === 'number');
+    // get schema respective to status code
+    const responseSchema = validResponses.find(responseSchema => responseSchema.status === response.status);
+    const schema = responseSchema?.schema;
+    const isZodSchema = schema instanceof zod_1.z.ZodSchema;
+    const isZodVoid = schema instanceof zod_1.z.ZodVoid;
+    (0, assert_1.default)(isZodSchema || isZodVoid);
+    // validate response schema
+    const validatedResponseBody = await schema.parseAsync(response.body);
+    if (validatedResponseBody === undefined) {
+        // No Content Response
+        return expressResponse.status(response.status).end();
+    }
+    expressResponse.status(response.status).send(validatedResponseBody);
+};
+const handleMiddleware = async (middleware, context, request, response) => new Promise(async (resolve, reject) => {
+    try {
+        const handlerRequestBody = ((await middleware.options.schemas?.body?.parseAsync(request.body)) ||
+            undefined);
+        const handlerRequestParams = ((await middleware.options.schemas?.params?.parseAsync(request.params)) || undefined);
+        const handlerRequestQuery = ((await middleware.options.schemas?.query?.parseAsync(request.query)) ||
+            undefined);
+        const handlerRequestHeaders = ((await middleware.options.schemas?.headers?.parseAsync(request.headers)) || undefined);
         const handlerRequest = {
             body: handlerRequestBody,
             params: handlerRequestParams,
             query: handlerRequestQuery,
             headers: handlerRequestHeaders,
         };
-        // TODO: handle middlewares and build context object
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const ctx = {};
-        await handler(handlerRequest, ctx, controllerResponse => {
-            // this assertion is necessary due to the type possibly being unknown because of the edge case of an schema array with 0 elements
-            (0, assert_1.default)(typeof controllerResponse.status === 'number');
-            // get schema respective to status code
-            const { schema } = options.responses.find(responseSchema => responseSchema.status === controllerResponse.status);
-            // validate response schema
-            const validatedResponseBody = schema.parse(controllerResponse.body);
-            if (validatedResponseBody === undefined) {
-                // No Content Response
-                return response.status(controllerResponse.status).end();
+        await middleware.handler(handlerRequest, async (middlewareResponse) => {
+            try {
+                await validateAndSendResponse(response, middlewareResponse, middleware.options.responses);
+                resolve(false);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    (0, boom_1.boomify)(error, {
+                        statusCode: 500,
+                    });
+                }
+                reject(error);
+            }
+        }, async (returnedContext) => {
+            try {
+                const validatedContext = await middleware.options.schemas?.context?.parseAsync(returnedContext);
+                Object.assign(context, validatedContext);
+                resolve(true);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    (0, boom_1.boomify)(error, {
+                        statusCode: 500,
+                    });
+                }
+                reject(error);
             }
-            response.status(controllerResponse.status).send(validatedResponseBody);
         });
+    }
+    catch (error) {
+        reject(error);
+    }
+});
+const mountEndpoint = (router, method, path, options, handler) => {
+    (0, assert_1.default)(options.responses.length > 0, 'You need to specify at least one response');
+    router[method](path, async (request, response, next) => {
+        try {
+            // parse request schemas
+            const handlerRequestBody = ((await options.schemas?.body?.parseAsync(request.body)) || undefined);
+            const handlerRequestParams = ((await options.schemas?.params?.parseAsync(request.params)) ||
+                undefined);
+            const handlerRequestQuery = ((await options.schemas?.query?.parseAsync(request.query)) || undefined);
+            const handlerRequestHeaders = ((await options.schemas?.headers?.parseAsync(request.headers)) ||
+                undefined);
+            const handlerRequest = {
+                body: handlerRequestBody,
+                params: handlerRequestParams,
+                query: handlerRequestQuery,
+                headers: handlerRequestHeaders,
+            };
+            const ctx = {};
+            if (options.middlewares instanceof Array) {
+                for (const middleware of options.middlewares) {
+                    const shouldContinue = await handleMiddleware(middleware, ctx, request, response);
+                    if (!shouldContinue)
+                        return;
+                }
+            }
+            await handler(handlerRequest, ctx, async (controllerResponse) => {
+                try {
+                    await validateAndSendResponse(response, controllerResponse, options.responses);
+                }
+                catch (error) {
+                    if (error instanceof Error) {
+                        (0, boom_1.boomify)(error, {
+                            statusCode: 500,
+                        });
+                    }
+                    next(error);
+                }
+            });
+        }
+        catch (error) {
+            if (error instanceof zod_1.z.ZodError && !(0, boom_1.isBoom)(error)) {
+                return response.status(400).send({ issues: error.issues });
+            }
+            next(error);
+        }
     });
 };
 exports.mountEndpoint = mountEndpoint;

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

@@ -5,12 +5,12 @@ declare const badRequestErrorSchema: z.ZodObject<{
     error: z.ZodString;
     message: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    error: string;
     message: string;
+    error: string;
     statusCode: 400;
 }, {
-    error: string;
     message: string;
+    error: string;
     statusCode: 400;
 }>;
 declare const unauthorizedErrorSchema: z.ZodObject<{
@@ -18,12 +18,12 @@ declare const unauthorizedErrorSchema: z.ZodObject<{
     error: z.ZodString;
     message: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    error: string;
     message: string;
+    error: string;
     statusCode: 401;
 }, {
-    error: string;
     message: string;
+    error: string;
     statusCode: 401;
 }>;
 declare const forbiddenErrorSchema: z.ZodObject<{
@@ -31,12 +31,12 @@ declare const forbiddenErrorSchema: z.ZodObject<{
     error: z.ZodString;
     message: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    error: string;
     message: string;
+    error: string;
     statusCode: 403;
 }, {
-    error: string;
     message: string;
+    error: string;
     statusCode: 403;
 }>;
 declare const notFoundErrorSchema: z.ZodObject<{
@@ -44,12 +44,12 @@ declare const notFoundErrorSchema: z.ZodObject<{
     error: z.ZodString;
     message: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    error: string;
     message: string;
+    error: string;
     statusCode: 404;
 }, {
-    error: string;
     message: string;
+    error: string;
     statusCode: 404;
 }>;
 export declare const okResponse: <T>(schema: z.ZodType<T, z.ZodTypeDef, T>) => {

package/package.json

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