@seidor-cloud-produtos/orbit-backend-lib 0.0.9 → 0.0.11

package/dist/clean-arch/application/queue/handler.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/clean-arch/application/queue/messages-in-memory.d.ts

@@ -1,4 +1,4 @@
-import DomainEvent from '@/clean-arch/domain/events/domain-event';
+import DomainEvent from '../../domain/events/domain-event';
 export type MessagesInMemory = {
     exchangeName: string;
     domainEvent: DomainEvent;

package/dist/clean-arch/application/queue/messages-in-memory.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/clean-arch/application/queue/queue-connection.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/clean-arch/application/queue/queue.d.ts

@@ -1,4 +1,4 @@
-import DomainEvent from '@/clean-arch/domain/events/domain-event';
+import DomainEvent from '../../domain/events/domain-event';
 import Handler from './handler';
 export default interface Queue {
     on(queueName: string, callback: Handler): Promise<void>;

package/dist/clean-arch/application/queue/queue.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/clean-arch/domain/entities/aggregate-root.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateRoot = void 0;
+const entity_1 = require("./entity");
+class AggregateRoot extends entity_1.Entity {
+    get createdAt() {
+        return this.props.createdAt;
+    }
+    set createdAt(date) {
+        this.props.createdAt = date;
+    }
+    get updatedAt() {
+        return this.props.updatedAt;
+    }
+    touch() {
+        this.props.updatedAt = new Date();
+    }
+}
+exports.AggregateRoot = AggregateRoot;

package/dist/clean-arch/domain/entities/common-dto.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/clean-arch/domain/entities/entity.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity = void 0;
+const unique_entity_id_1 = require("./unique-entity-id");
+class Entity {
+    get id() {
+        return this._id;
+    }
+    set id(id) {
+        this._id = id;
+    }
+    constructor(props, id) {
+        this._id = id ?? new unique_entity_id_1.UniqueEntityId(id);
+        this.props = props;
+    }
+    equals(entity) {
+        if (entity === this) {
+            return true;
+        }
+        if (entity.id === this._id) {
+            return true;
+        }
+        return false;
+    }
+}
+exports.Entity = Entity;

package/dist/clean-arch/domain/entities/unique-entity-id.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueEntityId = void 0;
+const node_crypto_1 = require("node:crypto");
+class UniqueEntityId {
+    constructor(value) {
+        this.value = value ?? (0, node_crypto_1.randomUUID)();
+    }
+    toString() {
+        return this.value;
+    }
+    toValue() {
+        return this.value;
+    }
+    equals(id) {
+        return id.toValue() === this.toValue();
+    }
+}
+exports.UniqueEntityId = UniqueEntityId;

package/dist/clean-arch/domain/entities/value-object.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueObject = void 0;
+class ValueObject {
+    constructor(props) {
+        this.props = props;
+    }
+}
+exports.ValueObject = ValueObject;

package/dist/clean-arch/domain/entities/watched-list.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchedList = void 0;
+class WatchedList {
+    constructor(initialItems) {
+        this.currentItems = initialItems || [];
+        this.initial = initialItems || [];
+        this.new = [];
+        this.removed = [];
+        this.updated = [];
+    }
+    getItems() {
+        return this.currentItems;
+    }
+    getNewItems() {
+        return this.new;
+    }
+    getRemovedItems() {
+        return this.removed;
+    }
+    getUpdatedItems() {
+        return this.updated;
+    }
+    addUpdatedItem(item) {
+        return this.updated.push(item);
+    }
+    isCurrentItem(item) {
+        return (this.currentItems.filter((v) => this.compareItems(item, v)).length !==
+            0);
+    }
+    isNewItem(item) {
+        return this.new.filter((v) => this.compareItems(item, v)).length !== 0;
+    }
+    isRemovedItem(item) {
+        return (this.removed.filter((v) => this.compareItems(item, v)).length !== 0);
+    }
+    removeFromNew(item) {
+        this.new = this.new.filter(v => !this.compareItems(v, item));
+    }
+    removeFromCurrent(item) {
+        this.currentItems = this.currentItems.filter(v => !this.compareItems(item, v));
+    }
+    removeFromRemoved(item) {
+        this.removed = this.removed.filter(v => !this.compareItems(item, v));
+    }
+    wasAddedInitially(item) {
+        return (this.initial.filter((v) => this.compareItems(item, v)).length !== 0);
+    }
+    exists(item) {
+        return this.isCurrentItem(item);
+    }
+    add(item) {
+        if (this.isRemovedItem(item)) {
+            this.removeFromRemoved(item);
+        }
+        if (!this.isNewItem(item) && !this.wasAddedInitially(item)) {
+            this.new.push(item);
+        }
+        if (!this.isCurrentItem(item)) {
+            this.currentItems.push(item);
+        }
+    }
+    remove(item) {
+        this.removeFromCurrent(item);
+        if (this.isNewItem(item)) {
+            this.removeFromNew(item);
+            return;
+        }
+        if (!this.isRemovedItem(item)) {
+            this.removed.push(item);
+        }
+    }
+    update(items) {
+        const newItems = items.filter(a => {
+            return !this.getItems().some(b => this.compareItems(a, b));
+        });
+        const removedItems = this.getItems().filter(a => {
+            return !items.some(b => this.compareItems(a, b));
+        });
+        const updatedItems = items.filter(item => !newItems.some(a => this.compareItems(item, a) &&
+            !removedItems.some(b => this.compareItems(item, b))));
+        this.currentItems = items;
+        this.new = newItems;
+        this.removed = removedItems;
+        this.updated = updatedItems;
+    }
+}
+exports.WatchedList = WatchedList;

package/dist/clean-arch/domain/entities/watched-list.spec.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const watched_list_1 = require("./watched-list");
+class NumberWatchedList extends watched_list_1.WatchedList {
+    compareItems(a, b) {
+        return a === b;
+    }
+}
+describe('Watched List', () => {
+    it('should be able to create a watched list with initial items', () => {
+        const list = new NumberWatchedList([1, 2, 3]);
+        expect(list.currentItems).toHaveLength(3);
+    });
+    it('should be able to add new items to the list', () => {
+        const list = new NumberWatchedList([1, 2, 3]);
+        list.add(4);
+        expect(list.currentItems).toHaveLength(4);
+        expect(list.getNewItems()).toEqual([4]);
+    });
+    it('should be able to add remove items from the list', () => {
+        const list = new NumberWatchedList([1, 2, 3]);
+        list.remove(2);
+        expect(list.currentItems).toHaveLength(2);
+        expect(list.getRemovedItems()).toEqual([2]);
+    });
+    it('should be able to add an item even if it was removed before', () => {
+        const list = new NumberWatchedList([1, 2, 3]);
+        list.remove(2);
+        list.add(2);
+        expect(list.currentItems).toHaveLength(3);
+        expect(list.getRemovedItems()).toEqual([]);
+        expect(list.getNewItems()).toEqual([]);
+    });
+    it('should be able to remove an item even if it was added before', () => {
+        const list = new NumberWatchedList([1, 2, 3]);
+        list.add(4);
+        list.remove(4);
+        expect(list.currentItems).toHaveLength(3);
+        expect(list.getRemovedItems()).toEqual([]);
+        expect(list.getNewItems()).toEqual([]);
+    });
+    it('should be able to update watched list items', () => {
+        const list = new NumberWatchedList([1, 2, 3]);
+        list.update([1, 3, 5]);
+        expect(list.getRemovedItems()).toEqual([2]);
+        expect(list.getNewItems()).toEqual([5]);
+        expect(list.getUpdatedItems()).toEqual([1, 3]);
+    });
+});

package/dist/clean-arch/domain/errors/application-error.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ApplicationError extends Error {
+    constructor(message, code = 400) {
+        super(message);
+        this.code = code;
+    }
+}
+exports.default = ApplicationError;

package/dist/clean-arch/domain/errors/domain-error.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DomainError extends Error {
+    constructor(message, code = 400) {
+        super(message);
+        this.code = code;
+    }
+}
+exports.default = DomainError;

package/dist/clean-arch/domain/errors/validation-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ValidationError extends Error {
+    constructor(errors) {
+        super('Validation Error');
+        this.code = 400;
+        this.name = 'Validation Error';
+        this.errors = errors;
+    }
+}
+exports.default = ValidationError;

package/dist/clean-arch/domain/events/domain-event.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/clean-arch/domain/types/optional.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/clean-arch/infra/adapters/express-adapter.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const cors_1 = tslib_1.__importDefault(require("cors"));
+const express_1 = tslib_1.__importDefault(require("express"));
+class ExpressAdapter {
+    constructor(envs) {
+        this.envs = envs;
+        this.instance = (0, express_1.default)();
+        this.instance.use((0, cors_1.default)());
+        this.instance.use(express_1.default.json({ limit: '10mb' }));
+        this.instance.use(express_1.default.urlencoded({ limit: '10mb', extended: false }));
+    }
+    on(method, url, callback) {
+        this.instance[method](url, async (request, response) => {
+            try {
+                const requestData = {
+                    body: request.body,
+                    params: request.params,
+                    headers: request.headers,
+                    query: request.query,
+                };
+                const output = await callback.handle(requestData);
+                return response.status(output.code || 200).json(output.data || {});
+            }
+            catch (err) {
+                const error = callback.throw(err);
+                return response.status(error.code).json(error.data || {});
+            }
+        });
+    }
+    async listen(port) {
+        this.server = this.instance.listen(port, () => {
+            if (this.envs.NODE_ENV !== 'test') {
+                console.log(`🚀  Server is running on PORT ${port}`);
+            }
+        });
+    }
+    async close() {
+        await this.server.close();
+    }
+}
+exports.default = ExpressAdapter;

package/dist/clean-arch/infra/adapters/fastify-adapter.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const cors_1 = tslib_1.__importDefault(require("@fastify/cors"));
+const fastify_1 = tslib_1.__importDefault(require("fastify"));
+const qs_1 = tslib_1.__importDefault(require("qs"));
+class FastifyAdapter {
+    constructor(envs) {
+        this.envs = envs;
+        this.instance = (0, fastify_1.default)({
+            bodyLimit: 10 * 1024 * 1024,
+            querystringParser: str => qs_1.default.parse(str),
+        });
+        this.instance.register(cors_1.default);
+    }
+    on(method, url, callback) {
+        this.instance[method](url, async (request, reply) => {
+            try {
+                const requestData = {
+                    body: request.body,
+                    params: request.params,
+                    headers: request.headers,
+                    query: request.query,
+                };
+                const output = await callback.handle(requestData);
+                return reply.status(output.code || 200).send(output.data || {});
+            }
+            catch (err) {
+                const error = callback.throw(err);
+                return reply.status(error.code || 200).send(error.data || {});
+            }
+        });
+    }
+    async listen(port) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        this.instance.listen({ port }, async (err, _) => {
+            if (err) {
+                console.error(err);
+                process.exit();
+            }
+            await this.instance?.ready();
+            if (this.envs.NODE_ENV !== 'test') {
+                console.log(`🚀  Server is running on PORT ${port}`);
+            }
+        });
+    }
+    async close() {
+        await this.instance.close();
+    }
+}
+exports.default = FastifyAdapter;

package/dist/clean-arch/infra/authorizations/authorization.d.ts

@@ -1,7 +1,7 @@
-import { AuthParams } from '@/infra/authorizations/auth-matcher';
-import { APIAuthValidator } from '@/infra/authorizations/validator/api/api-validator';
-import AuthValidator from '@/infra/authorizations/validator/auth-validator';
-import { UnauthorizedResponse } from '@/infra/http/errors/unauthorized-response';
+import { AuthParams } from '../../../infra/authorizations/auth-matcher';
+import { APIAuthValidator } from '../../../infra/authorizations/validator/api/api-validator';
+import AuthValidator from '../../../infra/authorizations/validator/auth-validator';
+import { UnauthorizedResponse } from '../../../infra/http/errors/unauthorized-response';
 import { Request, Response } from '../http/controller';
 type AuthorizationMetaData = {
     handle(input: Request): Promise<Response>;

package/dist/clean-arch/infra/authorizations/authorization.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const api_validator_1 = require("../../../infra/authorizations/validator/api/api-validator");
+const not_allowed_1 = tslib_1.__importDefault(require("./not-allowed"));
+class Authorization extends api_validator_1.APIAuthValidator {
+    static async create(query, controllerMetaData) {
+        const instance = new Authorization(query, controllerMetaData);
+        return await instance.setup();
+    }
+    unauthorize(response) {
+        throw new not_allowed_1.default(response);
+    }
+    getRequestId() {
+        return this.controller.request.headers['X-Amzn-Requestid'];
+    }
+    async getAuthorizations() {
+        const authorizations = this.controller.request.headers
+            .authorizations;
+        if (typeof authorizations === 'string') {
+            return JSON.parse(authorizations);
+        }
+        return authorizations;
+    }
+    handleAuthorized() {
+        return this.controller.handle(this.controller.request);
+    }
+}
+exports.default = Authorization;

package/dist/clean-arch/infra/authorizations/authorizer.d.ts

@@ -1,4 +1,4 @@
-import { AuthParams } from '@/infra/authorizations/auth-matcher';
+import { AuthParams } from '../../../infra/authorizations/auth-matcher';
 import { Request, Response } from '../http/controller';
 export default function Authorizer(props: AuthParams): <T extends new (..._: any[]) => {
     handle(request: Request): Promise<Response>;

package/dist/clean-arch/infra/authorizations/authorizer.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const authorization_1 = tslib_1.__importDefault(require("./authorization"));
+function Authorizer(props) {
+    return function (constructor) {
+        return class extends constructor {
+            async handle(request) {
+                const authorization = await authorization_1.default.create(props, {
+                    handle: super.handle,
+                    request,
+                });
+                return authorization.validate();
+            }
+        };
+    };
+}
+exports.default = Authorizer;

package/dist/clean-arch/infra/authorizations/authorizer.spec.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const authorizer_1 = tslib_1.__importDefault(require("./authorizer"));
+describe('Authorizer', () => {
+    it('should be able to validate authorizations (AND)', async () => {
+        let Test = class Test {
+            async handle(_) {
+                return {
+                    data: { message: 'ok' },
+                };
+            }
+        };
+        Test = tslib_1.__decorate([
+            (0, authorizer_1.default)({ $and: ['arch.user.create'] })
+        ], Test);
+        const controller = new Test();
+        const response = await controller.handle({
+            headers: {
+                authorizations: [
+                    'arch.user.create',
+                    'arch.user.update',
+                    'arch.user.list',
+                ],
+            },
+            body: {},
+            params: {},
+            query: {},
+        });
+        expect(response.data).toEqual({ message: 'ok' });
+    });
+    it('should be able to validate authorizations (OR)', async () => {
+        let Test = class Test {
+            async handle(_) {
+                return {
+                    data: { message: 'ok' },
+                };
+            }
+        };
+        Test = tslib_1.__decorate([
+            (0, authorizer_1.default)({ $or: ['arch.user.list', 'arch.user.update'] })
+        ], Test);
+        const controller = new Test();
+        const response = await controller.handle({
+            headers: {
+                authorizations: ['arch.user.create', 'arch.user.list'],
+            },
+            body: {},
+            params: {},
+            query: {},
+        });
+        expect(response.data).toEqual({ message: 'ok' });
+    });
+    it('should be able to validate authorizations (THROW)', async () => {
+        let Test = class Test {
+            async handle(_) {
+                return {
+                    data: { message: 'ok' },
+                };
+            }
+        };
+        Test = tslib_1.__decorate([
+            (0, authorizer_1.default)({ $or: ['arch.user.list', 'arch.user.create'] })
+        ], Test);
+        const controller = new Test();
+        await expect(() => controller.handle({
+            headers: {
+                authorizations: ['arch.user.update'],
+            },
+            body: {},
+            params: {},
+            query: {},
+        })).rejects.toBeInstanceOf(Error);
+    });
+    it('should be able to call controller when authorization is not required', async () => {
+        let Test = class Test {
+            async handle(_) {
+                return {
+                    data: { message: 'ok' },
+                };
+            }
+        };
+        Test = tslib_1.__decorate([
+            (0, authorizer_1.default)({})
+        ], Test);
+        const controller = new Test();
+        const response = await controller.handle({
+            headers: {
+                authorizations: [
+                    'arch.user.create',
+                    'arch.user.update',
+                    'arch.user.list',
+                ],
+            },
+            body: {},
+            params: {},
+            query: {},
+        });
+        expect(response.data).toEqual({ message: 'ok' });
+    });
+    it('should be able to return error when not have authorizations on request', async () => {
+        let Test = class Test {
+            async handle(_) {
+                return {
+                    data: { message: 'ok' },
+                };
+            }
+        };
+        Test = tslib_1.__decorate([
+            (0, authorizer_1.default)({ $and: ['arch.user.list', 'arch.user.create'] })
+        ], Test);
+        const controller = new Test();
+        await expect(() => controller.handle({
+            headers: {
+                authorizations: [],
+            },
+            body: {},
+            params: {},
+            query: {},
+        })).rejects.toBeInstanceOf(Error);
+    });
+    it('should be able to convert authorizations string to object JS', async () => {
+        let Test = class Test {
+            async handle(_) {
+                return {
+                    data: { message: 'ok' },
+                };
+            }
+        };
+        Test = tslib_1.__decorate([
+            (0, authorizer_1.default)({ $and: ['arch.user.create'] })
+        ], Test);
+        const controller = new Test();
+        const response = await controller.handle({
+            headers: {
+                authorizations: JSON.stringify(['arch.user.create']),
+            },
+            body: {},
+            params: {},
+            query: {},
+        });
+        expect(response.data).toEqual({ message: 'ok' });
+    });
+});

package/dist/clean-arch/infra/authorizations/not-allowed.d.ts

@@ -1,5 +1,5 @@
-import { ApiError } from '@/infra/http/errors/api-error';
-import { UnauthorizedResponse } from '@/infra/http/errors/unauthorized-response';
+import { ApiError } from '../../../infra/http/errors/api-error';
+import { UnauthorizedResponse } from '../../../infra/http/errors/unauthorized-response';
 export default class NotAllowedError extends ApiError {
     constructor(input: UnauthorizedResponse);
 }

package/dist/clean-arch/infra/authorizations/not-allowed.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_error_1 = require("../../../infra/http/errors/api-error");
+class NotAllowedError extends api_error_1.ApiError {
+    constructor(input) {
+        super(input);
+    }
+}
+exports.default = NotAllowedError;

package/dist/clean-arch/infra/errors/infra-error.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class InfraError extends Error {
+    constructor(message, code = 400) {
+        super(message);
+        this.code = code;
+    }
+}
+exports.default = InfraError;