@lucaapp/service-utils 1.28.1 → 1.30.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);
@@ -58,9 +85,7 @@ const handleMiddleware = async (middleware, context, request, response) => new P
             method,
             path: route.path,
         };
-        await middleware.handler(handlerRequest, 
-        // { ip, baseUrl, route, method } = request,
-        async (middlewareResponse) => {
+        await middleware.handler(handlerRequest, async (middlewareResponse) => {
             try {
                 await validateAndSendResponse(response, middlewareResponse, middleware.options.responses);
                 resolve(false);
@@ -90,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 {
@@ -113,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;
                 }
@@ -136,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);
         }
     });
@@ -149,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
@@ -173,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

@@ -24,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/dist/lib/money/index.d.ts

@@ -0,0 +1 @@
+export * from './money';

package/dist/lib/money/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./money"), exports);

package/dist/lib/money/money.d.ts

@@ -0,0 +1,29 @@
+interface Money {
+    getAmount(): number;
+    add(addend?: Money): Money;
+    subtract(subtrahend?: Money): Money;
+    multiply(multiplier: number): Money;
+    divide(divisor: number): Money;
+    equalsTo(comparator: Money): boolean;
+    lessThan(comparator: Money): boolean;
+    lessThanOrEqual(comparator: Money): boolean;
+    greaterThan(comparator: Money): boolean;
+    greaterThanOrEqual(comparator: Money): boolean;
+    isZero(): boolean;
+    isPositive(): boolean;
+    isNegative(): boolean;
+}
+declare class Money implements Money {
+    private readonly value;
+    static fromAmount(value: number): Money;
+    static fromFloat(value: number): Money;
+    static zero(): Money;
+    private constructor();
+    clone(): Money;
+    getEuroAmount(): number;
+    getEuroString(): string;
+    percentage(percentage: number): Money;
+    min(comparator: Money): Money;
+    max(comparator: Money): Money;
+}
+export { Money };

package/dist/lib/money/money.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Money = void 0;
+const CENTS_PER_EURO = 100;
+const EPSILON = 0.00000000001;
+const roundHalfUp = (value) => {
+    const rounded = Math.sign(value) * Math.round(Math.abs(value) + EPSILON);
+    return rounded === 0 ? 0 : rounded;
+};
+const euroToAmount = (amountInEuros) => roundHalfUp(amountInEuros * CENTS_PER_EURO);
+const amountToEuro = (value) => value / CENTS_PER_EURO;
+class Money {
+    static fromAmount(value) {
+        if (!Number.isInteger(value)) {
+            throw new TypeError('Integer required.');
+        }
+        return new Money(value);
+    }
+    static fromFloat(value) {
+        return new Money(euroToAmount(value));
+    }
+    static zero() {
+        return Money.fromAmount(0);
+    }
+    constructor(amount) {
+        this.value = amount;
+    }
+    clone() {
+        return Money.fromAmount(this.value);
+    }
+    getAmount() {
+        return this.value;
+    }
+    getEuroAmount() {
+        return amountToEuro(this.value);
+    }
+    getEuroString() {
+        return this.getEuroAmount().toFixed(2);
+    }
+    add(addend) {
+        return Money.fromAmount(this.value + (addend?.value || 0));
+    }
+    subtract(subtrahend) {
+        return Money.fromAmount(this.value - (subtrahend?.value || 0));
+    }
+    multiply(multiplier) {
+        return Money.fromAmount(roundHalfUp(this.value * multiplier));
+    }
+    divide(divisor) {
+        return Money.fromAmount(roundHalfUp(this.value / divisor));
+    }
+    percentage(percentage) {
+        if (Number.isNaN(percentage) || percentage < 0 || percentage > 100) {
+            throw new TypeError('Expected number between 0 and 100');
+        }
+        return Money.fromAmount(roundHalfUp((this.value / 100) * percentage));
+    }
+    equalsTo(comparator) {
+        return this.value === comparator.value;
+    }
+    lessThan(comparator) {
+        return this.value < comparator.value;
+    }
+    lessThanOrEqual(comparator) {
+        return this.value <= comparator.value;
+    }
+    greaterThan(comparator) {
+        return this.value > comparator.value;
+    }
+    greaterThanOrEqual(comparator) {
+        return this.value >= comparator.value;
+    }
+    isZero() {
+        return this.value === 0;
+    }
+    isPositive() {
+        return this.value > 0;
+    }
+    isNegative() {
+        return this.value < 0;
+    }
+    min(comparator) {
+        return this.value < comparator.value ? this.clone() : comparator.clone();
+    }
+    max(comparator) {
+        return this.value > comparator.value ? this.clone() : comparator.clone();
+    }
+}
+exports.Money = Money;

package/package.json

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