@seidor-cloud-produtos/orbit-backend-lib 2.0.110 → 2.0.111

package/dist/coverage/sorter.d.ts

@@ -0,0 +1 @@
+declare function addSorting(): void;

package/dist/coverage/sorter.js

@@ -0,0 +1,178 @@
+'use strict';
+/* eslint-disable */
+var addSorting = (function () {
+  'use strict';
+  var cols,
+    currentSort = {
+      index: 0,
+      desc: false,
+    };
+  // returns the summary table element
+  function getTable() {
+    return document.querySelector('.coverage-summary');
+  }
+  // returns the thead element of the summary table
+  function getTableHeader() {
+    return getTable().querySelector('thead tr');
+  }
+  // returns the tbody element of the summary table
+  function getTableBody() {
+    return getTable().querySelector('tbody');
+  }
+  // returns the th element for nth column
+  function getNthColumn(n) {
+    return getTableHeader().querySelectorAll('th')[n];
+  }
+  function onFilterInput() {
+    const searchValue = document.getElementById('fileSearch').value;
+    const rows = document.getElementsByTagName('tbody')[0].children;
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i];
+      if (row.textContent.toLowerCase().includes(searchValue.toLowerCase())) {
+        row.style.display = '';
+      } else {
+        row.style.display = 'none';
+      }
+    }
+  }
+  // loads the search box
+  function addSearchBox() {
+    var template = document.getElementById('filterTemplate');
+    var templateClone = template.content.cloneNode(true);
+    templateClone.getElementById('fileSearch').oninput = onFilterInput;
+    template.parentElement.appendChild(templateClone);
+  }
+  // loads all columns
+  function loadColumns() {
+    var colNodes = getTableHeader().querySelectorAll('th'),
+      colNode,
+      cols = [],
+      col,
+      i;
+    for (i = 0; i < colNodes.length; i += 1) {
+      colNode = colNodes[i];
+      col = {
+        key: colNode.getAttribute('data-col'),
+        sortable: !colNode.getAttribute('data-nosort'),
+        type: colNode.getAttribute('data-type') || 'string',
+      };
+      cols.push(col);
+      if (col.sortable) {
+        col.defaultDescSort = col.type === 'number';
+        colNode.innerHTML = colNode.innerHTML + '<span class="sorter"></span>';
+      }
+    }
+    return cols;
+  }
+  // attaches a data attribute to every tr element with an object
+  // of data values keyed by column name
+  function loadRowData(tableRow) {
+    var tableCols = tableRow.querySelectorAll('td'),
+      colNode,
+      col,
+      data = {},
+      i,
+      val;
+    for (i = 0; i < tableCols.length; i += 1) {
+      colNode = tableCols[i];
+      col = cols[i];
+      val = colNode.getAttribute('data-value');
+      if (col.type === 'number') {
+        val = Number(val);
+      }
+      data[col.key] = val;
+    }
+    return data;
+  }
+  // loads all row data
+  function loadData() {
+    var rows = getTableBody().querySelectorAll('tr'),
+      i;
+    for (i = 0; i < rows.length; i += 1) {
+      rows[i].data = loadRowData(rows[i]);
+    }
+  }
+  // sorts the table using the data for the ith column
+  function sortByIndex(index, desc) {
+    var key = cols[index].key,
+      sorter = function (a, b) {
+        a = a.data[key];
+        b = b.data[key];
+        return a < b ? -1 : a > b ? 1 : 0;
+      },
+      finalSorter = sorter,
+      tableBody = document.querySelector('.coverage-summary tbody'),
+      rowNodes = tableBody.querySelectorAll('tr'),
+      rows = [],
+      i;
+    if (desc) {
+      finalSorter = function (a, b) {
+        return -1 * sorter(a, b);
+      };
+    }
+    for (i = 0; i < rowNodes.length; i += 1) {
+      rows.push(rowNodes[i]);
+      tableBody.removeChild(rowNodes[i]);
+    }
+    rows.sort(finalSorter);
+    for (i = 0; i < rows.length; i += 1) {
+      tableBody.appendChild(rows[i]);
+    }
+  }
+  // removes sort indicators for current column being sorted
+  function removeSortIndicators() {
+    var col = getNthColumn(currentSort.index),
+      cls = col.className;
+    cls = cls.replace(/ sorted$/, '').replace(/ sorted-desc$/, '');
+    col.className = cls;
+  }
+  // adds sort indicators for current column being sorted
+  function addSortIndicators() {
+    getNthColumn(currentSort.index).className += currentSort.desc
+      ? ' sorted-desc'
+      : ' sorted';
+  }
+  // adds event listeners for all sorter widgets
+  function enableUI() {
+    var i,
+      el,
+      ithSorter = function ithSorter(i) {
+        var col = cols[i];
+        return function () {
+          var desc = col.defaultDescSort;
+          if (currentSort.index === i) {
+            desc = !currentSort.desc;
+          }
+          sortByIndex(i, desc);
+          removeSortIndicators();
+          currentSort.index = i;
+          currentSort.desc = desc;
+          addSortIndicators();
+        };
+      };
+    for (i = 0; i < cols.length; i += 1) {
+      if (cols[i].sortable) {
+        // add the click event handler on the th so users
+        // dont have to click on those tiny arrows
+        el = getNthColumn(i).querySelector('.sorter').parentElement;
+        if (el.addEventListener) {
+          el.addEventListener('click', ithSorter(i));
+        } else {
+          el.attachEvent('onclick', ithSorter(i));
+        }
+      }
+    }
+  }
+  // adds sorting functionality to the UI
+  return function () {
+    if (!getTable()) {
+      return;
+    }
+    cols = loadColumns();
+    loadData();
+    addSearchBox();
+    addSortIndicators();
+    enableUI();
+  };
+})();
+window.addEventListener('load', addSorting);

package/dist/frameworks/express/api-gateway/mapping-model.spec.js

@@ -40,6 +40,17 @@ describe('ExpressMappingModel', () => {
         });
     });
     describe('setHeader', () => {
+        it('should ignore empty header keys', () => {
+            const instance = new mapping_model_2.ExpressMappingModel({
+                request: {
+                    headers: { existing: 'existing_value' },
+                },
+            });
+            expect(instance['setHeader']('', 'new_value')).toBe(instance);
+            expect(instance['getHeaders']()).toStrictEqual({
+                existing: 'existing_value',
+            });
+        });
         it('should set a existing header value', () => {
             const result = new mapping_model_2.ExpressMappingModel({
                 request: {
@@ -136,4 +147,51 @@ describe('ExpressMappingModel', () => {
             expect(result).toBe('next func');
         });
     });
+    describe('setBody', () => {
+        it('should replace the body with body-json when present', () => {
+            const instance = new mapping_model_2.ExpressMappingModel({
+                request: {
+                    body: {
+                        ['body-json']: { id: '1' },
+                    },
+                },
+            });
+            instance['setBody']();
+            expect(instance['getBody']()).toStrictEqual({ id: '1' });
+        });
+        it('should keep the original body when body-json is missing', () => {
+            const body = { id: '1' };
+            const instance = new mapping_model_2.ExpressMappingModel({
+                request: {
+                    body,
+                },
+            });
+            instance['setBody']();
+            expect(instance['getBody']()).toBe(body);
+        });
+    });
+    describe('setMethod', () => {
+        it('should override request method from header', () => {
+            const instance = new mapping_model_2.ExpressMappingModel({
+                request: {
+                    method: 'POST',
+                    headers: {
+                        'x-http-method-override': 'PATCH',
+                    },
+                },
+            });
+            instance['setMethod']();
+            expect(instance['controller'].request.method).toBe('PATCH');
+        });
+        it('should keep request method when override header is missing', () => {
+            const instance = new mapping_model_2.ExpressMappingModel({
+                request: {
+                    method: 'POST',
+                    headers: {},
+                },
+            });
+            instance['setMethod']();
+            expect(instance['controller'].request.method).toBe('POST');
+        });
+    });
 });

package/dist/frameworks/express/authorizations/authorization-express.spec.js

@@ -36,6 +36,15 @@ describe('Express', () => {
         const authorizations = await expressInstance['getAuthorizations']();
         expect(authorizations).toEqual(['auth1', 'auth2']);
     });
+    it('should get authorizations from auths header when needed', async () => {
+        request.headers = {
+            auths: '["auth1","auth2"]',
+            ['X-Amzn-Requestid']: 'request-id',
+        };
+        const expressInstance = (await authorization_express_1.default.create(query, controllerMetaData));
+        expect(expressInstance['getAuthsHeader']()).toBe('["auth1","auth2"]');
+        expect(expressInstance.getRequestId()).toBe('request-id');
+    });
     it('should call next function when authorized', async () => {
         const expressInstance = await authorization_express_1.default.create(query, controllerMetaData);
         expressInstance['handleAuthorized']();

package/dist/frameworks/express/middleware-express.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/frameworks/express/middleware-express.spec.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const vitest_1 = require("vitest");
+vitest_1.vi.mock('compression', () => ({
+    default: vitest_1.vi.fn(options => options),
+}));
+const compression_1 = tslib_1.__importDefault(require("compression"));
+const mapping_model_1 = require("./api-gateway/mapping-model");
+const middleware_express_1 = require("./api-gateway/middleware-express");
+const authorization_express_1 = tslib_1.__importDefault(require("./authorizations/authorization-express"));
+const middleware_express_2 = require("./authorizations/middleware-express");
+const middleware_express_3 = require("./compression/middleware-express");
+describe('Express middlewares', () => {
+    it('should map API Gateway requests through the mapping model', () => {
+        const parseSpy = vitest_1.vi
+            .spyOn(mapping_model_1.ExpressMappingModel.prototype, 'parse')
+            .mockReturnValue('mapped');
+        const request = {};
+        const response = {};
+        const next = vitest_1.vi.fn();
+        expect((0, middleware_express_1.mapRequestMiddleware)(request, response, next)).toBe('mapped');
+        expect(parseSpy).toHaveBeenCalledTimes(1);
+    });
+    it('should build the authorizer middleware and validate the request', async () => {
+        const validate = vitest_1.vi.fn().mockResolvedValue(true);
+        const createSpy = vitest_1.vi
+            .spyOn(authorization_express_1.default, 'create')
+            .mockResolvedValue({ validate });
+        const request = {};
+        const response = {};
+        const next = vitest_1.vi.fn();
+        const query = { $and: ['auth.read'] };
+        const middleware = (0, middleware_express_2.authorizer)(query);
+        await expect(middleware(request, response, next)).resolves.toBe(true);
+        expect(createSpy).toHaveBeenCalledWith(query, {
+            request,
+            response,
+            next,
+        });
+        expect(validate).toHaveBeenCalledTimes(1);
+    });
+    it('should create a compression middleware with the expected filter', () => {
+        expect(compression_1.default).toHaveBeenCalledWith({
+            filter: expect.any(Function),
+        });
+        const filter = middleware_express_3.compressionMiddleware.filter;
+        expect(filter({ headers: { 'accept-encoding': 'identity' } })).toBe(true);
+        expect(filter({ headers: { 'accept-encoding': 'gzip' } })).toBe(false);
+    });
+});

package/dist/frameworks/nest/nest.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/frameworks/nest/nest.spec.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const authorization_nest_1 = tslib_1.__importDefault(require("./authorizations/authorization-nest"));
+const guard_nest_1 = tslib_1.__importDefault(require("./authorizations/guard-nest"));
+const not_allowed_nest_1 = require("./authorizations/not-allowed-nest");
+const orbit_error_1 = require("./errors/orbit-error");
+const orbit_exception_filter_1 = require("./exception-filters/orbit-exception-filter");
+describe('Nest integrations', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should expose orbit errors as HTTP exceptions', () => {
+        const error = new orbit_error_1.OrbitError('Forbidden', 403);
+        expect(error.getStatus()).toBe(403);
+        expect(error.message).toBe('Forbidden');
+    });
+    it('should expose the not allowed payload for Nest', () => {
+        const timestamp = new Date('2024-01-01T00:00:00.000Z');
+        const error = new not_allowed_nest_1.NestNotAllowedError({
+            status: 401,
+            body: {
+                code: 401,
+                message: 'Unauthorized',
+                timestamp,
+                errors: [
+                    {
+                        code_error: '401',
+                        location: 'authorization',
+                        msg: 'Unauthorized',
+                    },
+                ],
+            },
+            headers: {},
+        });
+        expect(error.getStatus()).toBe(403);
+        expect(error.getResponse()).toEqual({
+            code: 401,
+            message: 'Unauthorized',
+            timestamp,
+            errors: [
+                {
+                    code_error: '401',
+                    location: 'authorization',
+                    msg: 'Unauthorized',
+                },
+            ],
+        });
+        expect(error.message).toBe('Unauthorized');
+    });
+    it('should translate orbit errors in the exception filter', () => {
+        const response = {
+            status: vi.fn().mockReturnThis(),
+            json: vi.fn().mockReturnThis(),
+        };
+        const host = {
+            switchToHttp: () => ({
+                getResponse: () => response,
+            }),
+        };
+        const exception = new not_allowed_nest_1.NestNotAllowedError({
+            status: 403,
+            body: {
+                code: 403,
+                message: 'Forbidden',
+                timestamp: new Date('2024-01-01T00:00:00.000Z'),
+                errors: [],
+            },
+            headers: {},
+        });
+        const filter = new orbit_exception_filter_1.OrbitExceptionFilter();
+        filter.catch(exception, host);
+        expect(response.status).toHaveBeenCalledWith(403);
+        expect(response.json).toHaveBeenCalledWith(exception.getResponse());
+    });
+    it('should authorize or throw on Nest authorization wrappers', async () => {
+        const query = { $and: ['auth.read'] };
+        const request = {
+            headers: {
+                authorizations: '["auth.read"]',
+            },
+        };
+        const response = {};
+        const next = vi.fn();
+        const instance = (await authorization_nest_1.default.create(query, {
+            request,
+            response,
+            next,
+        }));
+        await expect(instance['handleAuthorized']()).resolves.toBe(true);
+        await expect(instance['unauthorize']({
+            status: 403,
+            body: {
+                code: 403,
+                message: 'Forbidden',
+                timestamp: new Date('2024-01-01T00:00:00.000Z'),
+                errors: [],
+            },
+            headers: {},
+        })).rejects.toBeInstanceOf(not_allowed_nest_1.NestNotAllowedError);
+    });
+    it('should validate requests through the Nest guard', async () => {
+        const validate = vi.fn().mockResolvedValue(true);
+        const createSpy = vi
+            .spyOn(authorization_nest_1.default, 'create')
+            .mockResolvedValue({ validate });
+        const request = {};
+        const response = {};
+        const next = vi.fn();
+        const guard = new guard_nest_1.default({ $or: ['auth.read'] });
+        const context = {
+            switchToHttp: () => ({
+                getRequest: () => request,
+                getResponse: () => response,
+                getNext: () => next,
+            }),
+        };
+        await expect(guard.canActivate(context)).resolves.toBe(true);
+        expect(createSpy).toHaveBeenCalledWith({ $or: ['auth.read'] }, { request, response, next });
+        expect(validate).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/infra/http/api-gateway/mapping-model.spec.js

@@ -132,5 +132,47 @@ describe('MappingModel', () => {
             expect(instance['deleteParams'].mock.calls.length).toBe(1);
             expect(instance['next'].mock.calls.length).toBe(1);
         });
+        it('should create an empty context when it is missing', () => {
+            const instance = new MockMappingModel(undefined);
+            instance['getBody'] = vi.fn().mockReturnValue({
+                ['api-gateway-params']: {
+                    header: {},
+                    querystring: {},
+                    path: {},
+                },
+            });
+            instance['next'] = vi.fn().mockReturnValue('next func');
+            instance['setHeader'] = vi.fn().mockReturnThis();
+            instance['deleteParams'] = vi.fn().mockReturnThis();
+            expect(instance.parse()).toBe('next func');
+            expect(instance['setHeader'].mock.calls).toStrictEqual([
+                ['authorizations', undefined],
+                ['fiscalidsfromtenant', '[]'],
+                ['accept-encoding', 'identity'],
+            ]);
+        });
+        it('should map fiscal ids from tenant into headers', () => {
+            const instance = new MockMappingModel(undefined);
+            instance['getBody'] = vi.fn().mockReturnValue({
+                ['api-gateway-params']: {
+                    context: {
+                        authorizations: ['test'],
+                        fiscalIdsFromTenant: ['123', '456'],
+                    },
+                    header: {},
+                    querystring: {},
+                    path: {},
+                },
+            });
+            instance['next'] = vi.fn().mockReturnValue('next func');
+            instance['setHeader'] = vi.fn().mockReturnThis();
+            instance['deleteParams'] = vi.fn().mockReturnThis();
+            expect(instance.parse()).toBe('next func');
+            expect(instance['setHeader'].mock.calls).toStrictEqual([
+                ['authorizations', ['test']],
+                ['fiscalidsfromtenant', '["123","456"]'],
+                ['accept-encoding', 'identity'],
+            ]);
+        });
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seidor-cloud-produtos/orbit-backend-lib",
-  "version": "2.0.110",
+  "version": "2.0.111",
   "description": "Internal lib for backend components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -81,6 +81,10 @@
     "@aws-sdk/client-sqs": "3.940.0",
     "@fastify/cors": "8.3.0",
     "@nestjs/common": "8.4.7",
+    "@opentelemetry/auto-instrumentations-node": "^0.69.0",
+    "@opentelemetry/resources": "^2.5.0",
+    "@opentelemetry/sdk-node": "^0.211.0",
+    "@opentelemetry/semantic-conventions": "^1.39.0",
     "amqplib": "0.10.9",
     "axios": "1.8.2",
     "compression": "1.7.4",