@seidor-cloud-produtos/orbit-backend-lib 0.0.2 → 0.0.3

package/.eslintrc.json

@@ -21,22 +21,18 @@
       "no-useless-constructor": "off",
       "no-console": "off",
       "@typescript-eslint/ban-types": "off",
+      "@typescript-eslint/no-explicit-any": "off",
       "import-helpers/order-imports": [
         "warn",
         {
             "newlinesBetween": "always",
             "groups": [
-                "/^node/",
-                "/^aws-sdk/",
-                "/^supertest/",
-                "/^@prisma/",
-                "/^@faker/",
-                "/^test/",
-                "/^@/infra/",
-                "/^@/shared/",
-                "/^@/application/",
-                "/^@/domain/",
-                ["parent", "sibling", "index"]
+              "/^node/",
+              "module",
+              "/^@/infra/",
+              "/^@/frameworks/",
+              "/^@/clean-arch/",
+              ["parent", "sibling", "index"]
             ],
             "alphabetize": { "order": "asc", "ignoreCase": true }
         }

package/.husky/commit-msg

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npx --no -- commitlint --edit ${1}

package/.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npm run lint-staged

package/.husky/pre-push

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npm run test

package/README.md

@@ -1 +1,4 @@
-# orbit-backend-lib
+# orbit-backend-lib
+
+Repositorio do Orbit para bibliotecas de uso interno
+

package/dist/commitlint.config.d.ts

@@ -0,0 +1,2 @@
+declare let _extends: string[];
+export { _extends as extends };

package/dist/commitlint.config.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = { extends: ['@commitlint/config-conventional'] };

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

@@ -0,0 +1,3 @@
+export default interface Handler {
+    handle(message: any): Promise<void>;
+}

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

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

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

@@ -0,0 +1,6 @@
+import DomainEvent from '@/clean-arch/domain/events/domain-event';
+export type MessagesInMemory = {
+    exchangeName: string;
+    domainEvent: DomainEvent;
+    configs?: Record<string, unknown>;
+};

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

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

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

@@ -0,0 +1,6 @@
+import Queue from './queue';
+export default interface QueueConnection extends Queue {
+    connect(props: unknown): Promise<any>;
+    close(): Promise<void>;
+    createConsumers?<T>(queueName: string, configs: T | any): Promise<void>;
+}

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

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

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

@@ -0,0 +1,6 @@
+import DomainEvent from '@/clean-arch/domain/events/domain-event';
+import Handler from './handler';
+export default interface Queue {
+    on(queueName: string, callback: Handler): Promise<void>;
+    publish(exchangeName: string, domainEvent: DomainEvent, configs?: Record<string, any>): Promise<void>;
+}

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

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

package/dist/lib/clean-arch/domain/entities/aggregate-root.d.ts

@@ -0,0 +1,8 @@
+import { CommonDTO } from './common-dto';
+import { Entity } from './entity';
+export declare abstract class AggregateRoot<Props extends CommonDTO> extends Entity<Props> {
+    get createdAt(): Date;
+    set createdAt(date: Date);
+    get updatedAt(): Date | undefined;
+    touch(): void;
+}

package/dist/lib/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/lib/clean-arch/domain/entities/common-dto.d.ts

@@ -0,0 +1,14 @@
+export type CommonDTO = {
+    createdAt: Date;
+    updatedAt?: Date;
+};
+export type CreateCommonDTO = {
+    createdAt?: Date;
+    updatedAt?: Date;
+};
+export type UserRequestDTO = {
+    createdByName: string;
+    createdByEmail: string;
+    updatedByName: string;
+    updatedByEmail: string;
+};

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

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

package/dist/lib/clean-arch/domain/entities/entity.d.ts

@@ -0,0 +1,9 @@
+import { UniqueEntityId } from './unique-entity-id';
+export declare abstract class Entity<Props> {
+    private _id;
+    protected props: Props;
+    get id(): UniqueEntityId;
+    set id(id: UniqueEntityId);
+    protected constructor(props: Props, id?: UniqueEntityId);
+    equals(entity: Entity<any>): boolean;
+}

package/dist/lib/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/lib/clean-arch/domain/entities/unique-entity-id.d.ts

@@ -0,0 +1,7 @@
+export declare class UniqueEntityId {
+    private value;
+    constructor(value?: string);
+    toString(): string;
+    toValue(): string;
+    equals(id: UniqueEntityId): boolean;
+}

package/dist/lib/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/lib/clean-arch/domain/entities/value-object.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class ValueObject<Props> {
+    protected props: Props;
+    protected constructor(props: Props);
+}

package/dist/lib/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/lib/clean-arch/domain/entities/watched-list.d.ts

@@ -0,0 +1,25 @@
+export declare abstract class WatchedList<T> {
+    currentItems: T[];
+    private initial;
+    private new;
+    private removed;
+    private updated;
+    constructor(initialItems?: T[]);
+    abstract compareItems(a: T, b: T): boolean;
+    getItems(): T[];
+    getNewItems(): T[];
+    getRemovedItems(): T[];
+    getUpdatedItems(): T[];
+    addUpdatedItem(item: T): number;
+    private isCurrentItem;
+    private isNewItem;
+    private isRemovedItem;
+    private removeFromNew;
+    private removeFromCurrent;
+    private removeFromRemoved;
+    private wasAddedInitially;
+    exists(item: T): boolean;
+    add(item: T): void;
+    remove(item: T): void;
+    update(items: T[]): void;
+}

package/dist/lib/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/lib/clean-arch/domain/entities/watched-list.spec.d.ts

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

package/dist/lib/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/lib/clean-arch/domain/errors/application-error.d.ts

@@ -0,0 +1,4 @@
+export default class ApplicationError extends Error {
+    code: number;
+    constructor(message: string, code?: number);
+}

package/dist/lib/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/lib/clean-arch/domain/errors/domain-error.d.ts

@@ -0,0 +1,4 @@
+export default class DomainError extends Error {
+    code: number;
+    constructor(message: string, code?: number);
+}

package/dist/lib/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/lib/clean-arch/domain/errors/validation-error.d.ts

@@ -0,0 +1,10 @@
+type Errors = {
+    property: string;
+    message: string;
+};
+export default class ValidationError extends Error {
+    code: number;
+    errors: Errors[];
+    constructor(errors: Errors[]);
+}
+export {};

package/dist/lib/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/lib/clean-arch/domain/events/domain-event.d.ts

@@ -0,0 +1,4 @@
+export default interface DomainEvent {
+    name: string;
+    eventDate: Date;
+}

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

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

package/dist/lib/clean-arch/domain/types/optional.d.ts

@@ -0,0 +1 @@
+export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;

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

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

package/dist/lib/clean-arch/infra/adapters/express-adapter.d.ts

@@ -0,0 +1,12 @@
+import { Express } from 'express';
+import Controller from '../http/controller';
+import Http, { MethodType } from '../http/http';
+export default class ExpressAdapter implements Http {
+    readonly envs: Record<string, string>;
+    readonly instance: Express;
+    private server;
+    constructor(envs: Record<string, string>);
+    on(method: MethodType, url: string, callback: Controller): void;
+    listen(port: number): Promise<void>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cors_1 = __importDefault(require("cors"));
+const express_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/lib/clean-arch/infra/adapters/fastify-adapter.d.ts

@@ -0,0 +1,11 @@
+import { FastifyInstance } from 'fastify';
+import Controller from '../http/controller';
+import Http, { MethodType } from '../http/http';
+export default class FastifyAdapter implements Http {
+    readonly envs: Record<string, string>;
+    readonly instance: FastifyInstance;
+    constructor(envs: Record<string, string>);
+    on(method: MethodType, url: string, callback: Controller): void;
+    listen(port: number): Promise<void>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cors_1 = __importDefault(require("@fastify/cors"));
+const fastify_1 = __importDefault(require("fastify"));
+const qs_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) {
+        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/lib/clean-arch/infra/authorizations/authorization.d.ts

@@ -0,0 +1,18 @@
+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>;
+    request: Request;
+};
+export default class Authorization extends APIAuthValidator {
+    controller: AuthorizationMetaData;
+    static create(query: AuthParams, controllerMetaData: AuthorizationMetaData): Promise<AuthValidator>;
+    protected unauthorize(response: UnauthorizedResponse): void;
+    protected getRequestId(): string;
+    protected getAuthorizations(): Promise<string[]>;
+    protected handleAuthorized(): Promise<Response>;
+}
+export {};