@lucaapp/service-utils 1.30.0 → 1.31.0

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export * from './lib/serviceIdentity';
 export * from './lib/urlEncoded';
 export * from './lib/metrics';
 export * from './lib/middleware';
+export * from './lib/money';
 export * from './lib/negotiator';
 export * from './lib/requestTracer';
 export * from './lib/wsEvent';

package/dist/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./lib/serviceIdentity"), exports);
 __exportStar(require("./lib/urlEncoded"), exports);
 __exportStar(require("./lib/metrics"), exports);
 __exportStar(require("./lib/middleware"), exports);
+__exportStar(require("./lib/money"), exports);
 __exportStar(require("./lib/negotiator"), exports);
 __exportStar(require("./lib/requestTracer"), exports);
 __exportStar(require("./lib/wsEvent"), exports);

package/dist/lib/api/api.js

@@ -23,23 +23,23 @@ class Api {
     }
     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.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.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.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.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.debug);
     }
     generateOpenAPISpec() {
         const generator = new zod_to_openapi_1.OpenAPIGenerator(this.registry.definitions, this.openApiVersion);

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

@@ -4,5 +4,5 @@ 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>, 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 registerEndpoint: (registry: OpenAPIRegistry, method: HttpMethod, prefixPath: string, path: string, summary: string, options: EndpointOptions<any, any, any, any, any, any>, debug: boolean) => void;
 export {};

package/dist/lib/api/endpoint.js

@@ -6,7 +6,7 @@ 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 buildResponseConfig = (responseOptions) => {
     const responses = {};
     responseOptions.forEach(response => {
@@ -66,6 +66,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 +112,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 +125,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 +179,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, debug) => {
     let bodySchema = options.schemas?.body || undefined;
     let paramsSchema = options.schemas?.params || undefined;
     let querySchema = options.schemas?.query || undefined;
@@ -199,17 +222,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,20 +259,41 @@ 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,

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/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/money/money.d.ts

@@ -1,3 +1,4 @@
+import { Model } from 'sequelize';
 interface Money {
     getAmount(): number;
     add(addend?: Money): Money;
@@ -26,4 +27,6 @@ declare class Money implements Money {
     min(comparator: Money): Money;
     max(comparator: Money): Money;
 }
-export { Money };
+declare const moneyfiedGet: (model: Model, key: string) => Money | null;
+declare const moneyfiedSet: (model: Model, key: string, value: Money | undefined) => void;
+export { moneyfiedGet, moneyfiedSet, Money };

package/dist/lib/money/money.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Money = void 0;
+exports.Money = exports.moneyfiedSet = exports.moneyfiedGet = void 0;
 const CENTS_PER_EURO = 100;
 const EPSILON = 0.00000000001;
 const roundHalfUp = (value) => {
@@ -87,3 +87,14 @@ class Money {
     }
 }
 exports.Money = Money;
+const moneyfiedGet = (model, key) => {
+    const currentValue = model.getDataValue(key);
+    return currentValue === null || currentValue === undefined
+        ? null
+        : Money.fromAmount(currentValue);
+};
+exports.moneyfiedGet = moneyfiedGet;
+const moneyfiedSet = (model, key, value) => {
+    model.setDataValue(key, value?.getAmount());
+};
+exports.moneyfiedSet = moneyfiedSet;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucaapp/service-utils",
-  "version": "1.30.0",
+  "version": "1.31.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -57,6 +57,7 @@
     "pino-http": "8.2.1",
     "prom-client": "14.1.0",
     "response-time": "^2.3.2",
+    "sequelize": "^6.29.0",
     "swagger-ui-express": "4.5.0",
     "url-value-parser": "^2.2.0",
     "uuid": "^9.0.0",