@seidor-cloud-produtos/orbit-backend-lib 0.0.17 → 0.0.19

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

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

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

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

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

@@ -1,6 +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>;
+  connect(props: unknown): Promise<any>;
+  close(): Promise<void>;
+  createConsumers?<T>(queueName: string, configs: T | any): Promise<void>;
 }

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

@@ -1,6 +1,10 @@
 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>;
+  on(queueName: string, callback: Handler): Promise<void>;
+  publish(
+    exchangeName: string,
+    domainEvent: DomainEvent,
+    configs?: Record<string, any>,
+  ): Promise<void>;
 }

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

@@ -1,8 +1,10 @@
 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;
+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/clean-arch/domain/entities/common-dto.d.ts

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

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

@@ -1,9 +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;
+  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/clean-arch/domain/entities/unique-entity-id.d.ts

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

package/dist/clean-arch/domain/entities/value-object.d.ts

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

package/dist/clean-arch/domain/entities/watched-list.d.ts

@@ -1,25 +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;
+  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/clean-arch/domain/errors/application-error.d.ts

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

package/dist/clean-arch/domain/errors/domain-error.d.ts

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

package/dist/clean-arch/domain/errors/validation-error.d.ts

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

package/dist/clean-arch/domain/events/domain-event.d.ts

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

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

@@ -2,11 +2,11 @@ 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, unknown>;
-    readonly instance: Express;
-    private server;
-    constructor(envs: Record<string, unknown>);
-    on(method: MethodType, url: string, callback: Controller): void;
-    listen(port: number): Promise<void>;
-    close(): Promise<void>;
+  readonly envs: Record<string, unknown>;
+  readonly instance: Express;
+  private server;
+  constructor(envs: Record<string, unknown>);
+  on(method: MethodType, url: string, callback: Controller): void;
+  listen(port: number): Promise<void>;
+  close(): Promise<void>;
 }

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

@@ -2,10 +2,10 @@ 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, unknown>;
-    readonly instance: FastifyInstance;
-    constructor(envs: Record<string, unknown>);
-    on(method: MethodType, url: string, callback: Controller): void;
-    listen(port: number): Promise<void>;
-    close(): Promise<void>;
+  readonly envs: Record<string, unknown>;
+  readonly instance: FastifyInstance;
+  constructor(envs: Record<string, unknown>);
+  on(method: MethodType, url: string, callback: Controller): void;
+  listen(port: number): Promise<void>;
+  close(): Promise<void>;
 }

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

@@ -4,15 +4,18 @@ import AuthValidator from '../../../infra/authorizations/validator/auth-validato
 import { UnauthorizedResponse } from '../../../infra/http/errors/unauthorized-response';
 import { Request, Response } from '../http/controller';
 type AuthorizationMetaData = {
-    handle(input: Request): Promise<Response>;
-    request: Request;
+  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>;
+  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 {};

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

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

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';
 export default class NotAllowedError extends ApiError {
-    constructor(input: UnauthorizedResponse);
+  constructor(input: UnauthorizedResponse);
 }

package/dist/clean-arch/infra/errors/infra-error.d.ts

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

package/dist/clean-arch/infra/http/controller.d.ts

@@ -1,19 +1,19 @@
 export default abstract class Controller {
-    abstract handle(request: Request): Promise<Response>;
-    protected success<T>(dto?: T): Response;
-    protected noContent(): Response;
-    protected created<T>(dto?: T): Response;
-    protected paginated<T>(dto?: T): Response;
-    throw(error: Error): Response;
+  abstract handle(request: Request): Promise<Response>;
+  protected success<T>(dto?: T): Response;
+  protected noContent(): Response;
+  protected created<T>(dto?: T): Response;
+  protected paginated<T>(dto?: T): Response;
+  throw(error: Error): Response;
 }
 export type AnyObject = Record<string, any>;
 export type Request = {
-    body: AnyObject;
-    params: AnyObject;
-    headers: AnyObject;
-    query: AnyObject;
+  body: AnyObject;
+  params: AnyObject;
+  headers: AnyObject;
+  query: AnyObject;
 };
 export type Response = {
-    code: number;
-    data: any;
+  code: number;
+  data: any;
 };

package/dist/clean-arch/infra/http/handle-sort-param-query.d.ts

@@ -1 +1,3 @@
-export declare function handleSortParamQuery(query: string): "createdAt" | "updatedAt" | "isMain";
+export declare function handleSortParamQuery(
+  query: string,
+): 'createdAt' | 'updatedAt' | 'isMain';

package/dist/clean-arch/infra/http/handle-user-headers.d.ts

@@ -1,11 +1,11 @@
 type HeadersProps = {
-    username: string;
-    useremail: string;
+  username: string;
+  useremail: string;
 };
 export declare function handleUserHeaders(headers: HeadersProps): {
-    createdByName: string;
-    createdByEmail: string;
-    updatedByEmail: string;
-    updatedByName: string;
+  createdByName: string;
+  createdByEmail: string;
+  updatedByEmail: string;
+  updatedByName: string;
 };
 export {};

package/dist/clean-arch/infra/http/health-connections.d.ts

@@ -1,15 +1,15 @@
 type HealthCheckOutput = {
-    dbIsOnline: boolean;
+  dbIsOnline: boolean;
 };
 export interface HealthCheck {
-    check(): Promise<HealthCheckOutput>;
+  check(): Promise<HealthCheckOutput>;
 }
 export default class Health implements HealthCheck {
-    private checkDB;
-    constructor(checkDB: CheckDB);
-    check(): Promise<HealthCheckOutput>;
+  private checkDB;
+  constructor(checkDB: CheckDB);
+  check(): Promise<HealthCheckOutput>;
 }
 export interface CheckDB {
-    dbIsOnline(): Promise<boolean>;
+  dbIsOnline(): Promise<boolean>;
 }
 export {};

package/dist/clean-arch/infra/http/http.d.ts

@@ -1,6 +1,6 @@
 export type MethodType = 'get' | 'post' | 'delete' | 'put' | 'patch';
 export default interface Http {
-    on(method: MethodType, url: string, callback: any): void;
-    listen(port: number): Promise<void>;
-    close(): Promise<void>;
+  on(method: MethodType, url: string, callback: any): void;
+  listen(port: number): Promise<void>;
+  close(): Promise<void>;
 }

package/dist/clean-arch/shared/pagination/dto-response.d.ts

@@ -1,8 +1,8 @@
 export type DtoResponsePagination = {
-    count: number;
-    query: {
-        page: string;
-        size: string;
-    };
-    withPagination: boolean;
+  count: number;
+  query: {
+    page: string;
+    size: string;
+  };
+  withPagination: boolean;
 };

package/dist/clean-arch/shared/pagination/get-take-and-skip.d.ts

@@ -1,4 +1,7 @@
-export declare function getTakeAndSkip(size: string, page: string): {
-    take: number;
-    skip: number;
+export declare function getTakeAndSkip(
+  size: string,
+  page: string,
+): {
+  take: number;
+  skip: number;
 };

package/dist/clean-arch/shared/pagination/pagination.d.ts

@@ -1,7 +1,7 @@
 export type Pagination<T> = {
-    data: T[];
-    count?: number;
+  data: T[];
+  count?: number;
 };
 export type NotPagination<T> = {
-    data: T[];
+  data: T[];
 };

package/dist/frameworks/express/authorizations/authorization-express.d.ts

@@ -4,16 +4,21 @@ import { APIAuthValidator } from '../../../infra/authorizations/validator/api/ap
 import AuthValidator from '../../../infra/authorizations/validator/auth-validator';
 import { UnauthorizedResponse } from '../../../infra/http/errors/unauthorized-response';
 export type AuthorizationExpressMetaData = {
-    request: Request;
-    response: Response;
-    next: NextFunction;
+  request: Request;
+  response: Response;
+  next: NextFunction;
 };
 export default class AuthorizationExpress extends APIAuthValidator {
-    controller: AuthorizationExpressMetaData;
-    static create(query: AuthParams, controllerMetaData: AuthorizationExpressMetaData): Promise<AuthValidator>;
-    getAuthorizations(): Promise<string[]>;
-    getRequestId(): string;
-    handleAuthorized(): Promise<boolean | void>;
-    unauthorize(response: UnauthorizedResponse): Promise<Response<any, Record<string, any>>>;
-    private setResponseHeaders;
+  controller: AuthorizationExpressMetaData;
+  static create(
+    query: AuthParams,
+    controllerMetaData: AuthorizationExpressMetaData,
+  ): Promise<AuthValidator>;
+  getAuthorizations(): Promise<string[]>;
+  getRequestId(): string;
+  handleAuthorized(): Promise<boolean | void>;
+  unauthorize(
+    response: UnauthorizedResponse,
+  ): Promise<Response<any, Record<string, any>>>;
+  private setResponseHeaders;
 }

package/dist/frameworks/express/authorizations/midleware-express.d.ts

@@ -1,3 +1,5 @@
 import { NextFunction, Request, Response } from 'express';
 import { AuthParams } from '../../../infra/authorizations/auth-matcher';
-export declare const validateAuthorizations: (query: AuthParams) => (request: Request, response: Response, next: NextFunction) => Promise<any>;
+export declare const validateAuthorizations: (
+  query: AuthParams,
+) => (request: Request, response: Response, next: NextFunction) => Promise<any>;

package/dist/frameworks/nest/authorizations/guard-nest.d.ts

@@ -1,7 +1,7 @@
 import { CanActivate, ExecutionContext } from '@nestjs/common';
 import { AuthParams } from '../../../infra/authorizations/auth-matcher';
 export default class AuthGuardNest implements CanActivate {
-    private readonly authParams;
-    constructor(authParams: AuthParams);
-    canActivate(context: ExecutionContext): Promise<boolean>;
+  private readonly authParams;
+  constructor(authParams: AuthParams);
+  canActivate(context: ExecutionContext): Promise<boolean>;
 }

package/dist/infra/authorizations/auth-matcher.d.ts

@@ -1,10 +1,13 @@
 export type AuthParams = {
-    $and?: string[];
-    $or?: string[];
+  $and?: string[];
+  $or?: string[];
 };
 export default class AuthMatcher {
-    static isMatch(params: AuthParams, authorizationsFromRequest?: string[]): boolean;
-    private static handleOr;
-    private static handleAnd;
-    private static binarySearch;
+  static isMatch(
+    params: AuthParams,
+    authorizationsFromRequest?: string[],
+  ): boolean;
+  private static handleOr;
+  private static handleAnd;
+  private static binarySearch;
 }

package/dist/infra/authorizations/auth-matcher.js

@@ -5,8 +5,9 @@ class AuthMatcher {
         if (!authorizationsFromRequest) {
             return false;
         }
-        const $andResult = this.handleAnd(authorizationsFromRequest, params.$and);
-        const $orResult = this.handleOr(authorizationsFromRequest, params.$or);
+        const orderAuthorizations = authorizationsFromRequest.sort((a, b) => a.localeCompare(b));
+        const $andResult = this.handleAnd(orderAuthorizations, params.$and);
+        const $orResult = this.handleOr(orderAuthorizations, params.$or);
         return $andResult && $orResult;
     }
     static handleOr(authorizationsFromRequest, requiredUserAuthorizations) {

package/dist/infra/authorizations/validator/api/api-validator.d.ts

@@ -2,14 +2,14 @@ import { UnauthorizedResponse } from '../../../http/errors/unauthorized-response
 import { AuthParams } from '../../auth-matcher';
 import AuthValidator, { RequestData } from '../auth-validator';
 export type APIRequestData = RequestData & {
-    request_id: string;
+  request_id: string;
 };
 export declare abstract class APIAuthValidator extends AuthValidator {
-    protected controller: any;
-    requestData: APIRequestData;
-    protected constructor(query: AuthParams, controller: any);
-    protected handleUnauthorized(): any;
-    setup(): Promise<AuthValidator>;
-    protected abstract unauthorize(response: UnauthorizedResponse): any;
-    protected abstract getRequestId(): string;
+  protected controller: any;
+  requestData: APIRequestData;
+  protected constructor(query: AuthParams, controller: any);
+  protected handleUnauthorized(): any;
+  setup(): Promise<AuthValidator>;
+  protected abstract unauthorize(response: UnauthorizedResponse): any;
+  protected abstract getRequestId(): string;
 }

package/dist/infra/authorizations/validator/api/factories/unauthorized-response-factory.d.ts

@@ -3,5 +3,8 @@ import { AuthParams } from '../../../auth-matcher';
 import { RequestData } from '../../auth-validator';
 import { APIRequestData } from '../api-validator';
 export default class UnauthorizedResponseFactory {
-    static create(query: AuthParams, requestData: RequestData & APIRequestData): UnauthorizedResponse;
+  static create(
+    query: AuthParams,
+    requestData: RequestData & APIRequestData,
+  ): UnauthorizedResponse;
 }

package/dist/infra/authorizations/validator/auth-validator.d.ts

@@ -1,14 +1,14 @@
 import { AuthParams } from '../auth-matcher';
 export type RequestData = {
-    authorizations?: string[];
+  authorizations?: string[];
 };
 export default abstract class AuthValidator {
-    protected query: AuthParams;
-    protected requestData: RequestData;
-    protected constructor(query: AuthParams);
-    validate(): Promise<any>;
-    setup(): Promise<AuthValidator>;
-    protected abstract getAuthorizations(): Promise<string[]>;
-    protected abstract handleAuthorized(): any;
-    protected abstract handleUnauthorized(): any;
+  protected query: AuthParams;
+  protected requestData: RequestData;
+  protected constructor(query: AuthParams);
+  validate(): Promise<any>;
+  setup(): Promise<AuthValidator>;
+  protected abstract getAuthorizations(): Promise<string[]>;
+  protected abstract handleAuthorized(): any;
+  protected abstract handleUnauthorized(): any;
 }

package/dist/infra/http/errors/api-common-error.d.ts

@@ -1,25 +1,25 @@
 export type ApiCommonError = {
-    code: number;
-    message: string;
-    timestamp: Date;
-    request_id?: string;
-    errors: [
+  code: number;
+  message: string;
+  timestamp: Date;
+  request_id?: string;
+  errors: [
+    {
+      context_id?: string | number;
+      type?: string;
+      code_error: string;
+      msg: string;
+      location: string;
+      property_errors?: [
         {
-            context_id?: string | number;
-            type?: string;
-            code_error: string;
-            msg: string;
-            location: string;
-            property_errors?: [
-                {
-                    value?: any;
-                    type: string;
-                    code_error: string;
-                    msg: string;
-                    property: string;
-                    path?: string;
-                }
-            ];
-        }
-    ];
+          value?: any;
+          type: string;
+          code_error: string;
+          msg: string;
+          property: string;
+          path?: string;
+        },
+      ];
+    },
+  ];
 };

package/dist/infra/http/errors/api-error.d.ts

@@ -1,7 +1,7 @@
 import { ApiCommonError } from './api-common-error';
 import { UnauthorizedResponse } from './unauthorized-response';
 export declare class ApiError extends Error {
-    code: number;
-    error: ApiCommonError;
-    constructor(input: UnauthorizedResponse);
+  code: number;
+  error: ApiCommonError;
+  constructor(input: UnauthorizedResponse);
 }

package/dist/infra/http/errors/unauthorized-response.d.ts

@@ -1,6 +1,6 @@
 import { ApiCommonError } from './api-common-error';
 export type UnauthorizedResponse = {
-    body: ApiCommonError;
-    headers: Record<string, string>;
-    status: number;
+  body: ApiCommonError;
+  headers: Record<string, string>;
+  status: number;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seidor-cloud-produtos/orbit-backend-lib",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "Internal lib for backend components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,8 +11,8 @@
     "prepare:husky": "husky install",
     "lint-staged": "lint-staged",
     "test": "vitest run --reporter=verbose",
-    "prepare": "npm run build",
-    "version": "npm run prepare && prettier --write dist/**/*.ts && git add --all",
+    "prepare": "npm run build && prettier --write dist/**/*.ts",
+    "version": "npm run prepare && git add --all",
     "postversion": "git push && git push --tags"
   },
   "lint-staged": {