@seidor-cloud-produtos/orbit-backend-lib 0.0.12 → 0.0.14

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

@@ -10,6 +10,7 @@ function Authorizer(props) {
                     handle: super.handle,
                     request,
                 });
+                console.log(authorization);
                 return authorization.validate();
             }
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seidor-cloud-produtos/orbit-backend-lib",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "Internal lib for backend components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -22,8 +22,7 @@
     ]
   },
   "files": [
-    "dist",
-    "lib"
+    "dist"
   ],
   "repository": {
     "type": "git",

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

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

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

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

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

@@ -1,7 +0,0 @@
-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/lib/clean-arch/application/queue/queue.ts

@@ -1,11 +0,0 @@
-import DomainEvent from '../../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/lib/clean-arch/domain/entities/aggregate-root.ts

@@ -1,22 +0,0 @@
-import { CommonDTO } from './common-dto';
-import { Entity } from './entity';
-
-export abstract class AggregateRoot<
-  Props extends CommonDTO,
-> extends Entity<Props> {
-  get createdAt() {
-    return this.props.createdAt;
-  }
-
-  set createdAt(date: Date) {
-    this.props.createdAt = date;
-  }
-
-  get updatedAt(): Date | undefined {
-    return this.props.updatedAt;
-  }
-
-  public touch() {
-    this.props.updatedAt = new Date();
-  }
-}

package/lib/clean-arch/domain/entities/common-dto.ts

@@ -1,16 +0,0 @@
-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/lib/clean-arch/domain/entities/entity.ts

@@ -1,31 +0,0 @@
-import { UniqueEntityId } from './unique-entity-id';
-
-export abstract class Entity<Props> {
-  private _id: UniqueEntityId;
-  protected props: Props;
-
-  get id() {
-    return this._id;
-  }
-
-  set id(id: UniqueEntityId) {
-    this._id = id;
-  }
-
-  protected constructor(props: Props, id?: UniqueEntityId) {
-    this._id = id ?? new UniqueEntityId(id);
-    this.props = props;
-  }
-
-  public equals(entity: Entity<any>) {
-    if (entity === this) {
-      return true;
-    }
-
-    if (entity.id === this._id) {
-      return true;
-    }
-
-    return false;
-  }
-}

package/lib/clean-arch/domain/entities/unique-entity-id.ts

@@ -1,21 +0,0 @@
-import { randomUUID } from 'node:crypto';
-
-export class UniqueEntityId {
-  private value: string;
-
-  constructor(value?: string) {
-    this.value = value ?? randomUUID();
-  }
-
-  toString() {
-    return this.value;
-  }
-
-  toValue() {
-    return this.value;
-  }
-
-  public equals(id: UniqueEntityId) {
-    return id.toValue() === this.toValue();
-  }
-}

package/lib/clean-arch/domain/entities/value-object.ts

@@ -1,7 +0,0 @@
-export abstract class ValueObject<Props> {
-  protected props: Props;
-
-  protected constructor(props: Props) {
-    this.props = props;
-  }
-}

package/lib/clean-arch/domain/entities/watched-list.spec.ts

@@ -1,65 +0,0 @@
-import { WatchedList } from './watched-list';
-
-class NumberWatchedList extends WatchedList<number> {
-  compareItems(a: number, b: number): boolean {
-    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/lib/clean-arch/domain/entities/watched-list.ts

@@ -1,130 +0,0 @@
-export abstract class WatchedList<T> {
-  public currentItems: T[];
-  private initial: T[];
-  private new: T[];
-  private removed: T[];
-  private updated: T[];
-
-  constructor(initialItems?: T[]) {
-    this.currentItems = initialItems || [];
-    this.initial = initialItems || [];
-    this.new = [];
-    this.removed = [];
-    this.updated = [];
-  }
-
-  abstract compareItems(a: T, b: T): boolean;
-
-  public getItems(): T[] {
-    return this.currentItems;
-  }
-
-  public getNewItems(): T[] {
-    return this.new;
-  }
-
-  public getRemovedItems(): T[] {
-    return this.removed;
-  }
-
-  public getUpdatedItems(): T[] {
-    return this.updated;
-  }
-
-  public addUpdatedItem(item: T) {
-    return this.updated.push(item);
-  }
-
-  private isCurrentItem(item: T): boolean {
-    return (
-      this.currentItems.filter((v: T) => this.compareItems(item, v)).length !==
-      0
-    );
-  }
-
-  private isNewItem(item: T): boolean {
-    return this.new.filter((v: T) => this.compareItems(item, v)).length !== 0;
-  }
-
-  private isRemovedItem(item: T): boolean {
-    return (
-      this.removed.filter((v: T) => this.compareItems(item, v)).length !== 0
-    );
-  }
-
-  private removeFromNew(item: T): void {
-    this.new = this.new.filter(v => !this.compareItems(v, item));
-  }
-
-  private removeFromCurrent(item: T): void {
-    this.currentItems = this.currentItems.filter(
-      v => !this.compareItems(item, v),
-    );
-  }
-
-  private removeFromRemoved(item: T): void {
-    this.removed = this.removed.filter(v => !this.compareItems(item, v));
-  }
-
-  private wasAddedInitially(item: T): boolean {
-    return (
-      this.initial.filter((v: T) => this.compareItems(item, v)).length !== 0
-    );
-  }
-
-  public exists(item: T): boolean {
-    return this.isCurrentItem(item);
-  }
-
-  public add(item: T): void {
-    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);
-    }
-  }
-
-  public remove(item: T): void {
-    this.removeFromCurrent(item);
-
-    if (this.isNewItem(item)) {
-      this.removeFromNew(item);
-
-      return;
-    }
-
-    if (!this.isRemovedItem(item)) {
-      this.removed.push(item);
-    }
-  }
-
-  public update(items: T[]): void {
-    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;
-  }
-}

package/lib/clean-arch/domain/errors/application-error.ts

@@ -1,8 +0,0 @@
-export default class ApplicationError extends Error {
-  code: number;
-
-  constructor(message: string, code = 400) {
-    super(message);
-    this.code = code;
-  }
-}

package/lib/clean-arch/domain/errors/domain-error.ts

@@ -1,8 +0,0 @@
-export default class DomainError extends Error {
-  code: number;
-
-  constructor(message: string, code = 400) {
-    super(message);
-    this.code = code;
-  }
-}

package/lib/clean-arch/domain/errors/validation-error.ts

@@ -1,17 +0,0 @@
-type Errors = {
-  property: string;
-  message: string;
-};
-
-export default class ValidationError extends Error {
-  code: number;
-
-  errors: Errors[];
-
-  constructor(errors: Errors[]) {
-    super('Validation Error');
-    this.code = 400;
-    this.name = 'Validation Error';
-    this.errors = errors;
-  }
-}

package/lib/clean-arch/domain/events/domain-event.ts

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

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

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

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

@@ -1,49 +0,0 @@
-import cors from 'cors';
-import express, { Request, Response, Express } from 'express';
-
-import Controller from '../http/controller';
-import Http, { MethodType } from '../http/http';
-
-export default class ExpressAdapter implements Http {
-  readonly instance: Express;
-  private server: any;
-
-  constructor(readonly envs: Record<string, unknown>) {
-    this.instance = express();
-    this.instance.use(cors());
-    this.instance.use(express.json({ limit: '10mb' }));
-    this.instance.use(express.urlencoded({ limit: '10mb', extended: false }));
-  }
-
-  on(method: MethodType, url: string, callback: Controller): void {
-    this.instance[method](url, async (request: Request, response: 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: any) {
-        const error = callback.throw(err);
-        return response.status(error.code).json(error.data || {});
-      }
-    });
-  }
-
-  async listen(port: number): Promise<void> {
-    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();
-  }
-}

package/lib/clean-arch/infra/adapters/fastify-adapter.ts

@@ -1,66 +0,0 @@
-import cors from '@fastify/cors';
-import fastify, {
-  FastifyInstance,
-  FastifyRequest,
-  FastifyReply,
-} from 'fastify';
-import qs from 'qs';
-
-import Controller, { Request } from '../http/controller';
-import Http, { MethodType } from '../http/http';
-
-export default class FastifyAdapter implements Http {
-  readonly instance: FastifyInstance;
-
-  constructor(readonly envs: Record<string, unknown>) {
-    this.instance = fastify({
-      bodyLimit: 10 * 1024 * 1024,
-      querystringParser: str => qs.parse(str),
-    });
-
-    this.instance.register(cors);
-  }
-
-  on(method: MethodType, url: string, callback: Controller): void {
-    this.instance[method](
-      url,
-      async (request: FastifyRequest, reply: FastifyReply) => {
-        try {
-          const requestData = {
-            body: request.body,
-            params: request.params,
-            headers: request.headers,
-            query: request.query,
-          } as Request;
-
-          const output = await callback.handle(requestData);
-
-          return reply.status(output.code || 200).send(output.data || {});
-        } catch (err: any) {
-          const error = callback.throw(err);
-          return reply.status(error.code || 200).send(error.data || {});
-        }
-      },
-    );
-  }
-
-  async listen(port: number): Promise<void> {
-    // 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();
-  }
-}

package/lib/clean-arch/infra/authorizations/authorization.ts

@@ -1,47 +0,0 @@
-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';
-import NotAllowedError from './not-allowed';
-
-type AuthorizationMetaData = {
-  handle(input: Request): Promise<Response>;
-  request: Request;
-};
-
-export default class Authorization extends APIAuthValidator {
-  declare controller: AuthorizationMetaData;
-
-  public static async create(
-    query: AuthParams,
-    controllerMetaData: AuthorizationMetaData,
-  ): Promise<AuthValidator> {
-    const instance = new Authorization(query, controllerMetaData);
-
-    return await instance.setup();
-  }
-
-  protected unauthorize(response: UnauthorizedResponse) {
-    throw new NotAllowedError(response);
-  }
-
-  protected getRequestId(): string {
-    return this.controller.request.headers['X-Amzn-Requestid'] as string;
-  }
-
-  protected async getAuthorizations(): Promise<string[]> {
-    const authorizations = this.controller.request.headers
-      .authorizations as string;
-
-    if (typeof authorizations === 'string') {
-      return JSON.parse(authorizations);
-    }
-
-    return authorizations;
-  }
-
-  protected handleAuthorized() {
-    return this.controller.handle(this.controller.request);
-  }
-}