@seidor-cloud-produtos/orbit-backend-lib 0.0.24 → 0.0.26

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

@@ -0,0 +1,4 @@
+import DomainError from './domain-error';
+export default class InvalidPasswordAlgorithmError extends DomainError {
+  constructor();
+}

package/dist/clean-arch/domain/errors/invalid-password-algorithm-error.js

@@ -0,0 +1,11 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+const tslib_1 = require('tslib');
+const domain_error_1 = tslib_1.__importDefault(require('./domain-error'));
+class InvalidPasswordAlgorithmError extends domain_error_1.default {
+  constructor() {
+    super('Invalid password algorithm.', 400);
+    this.name = 'InvalidPasswordAlgorithmError';
+  }
+}
+exports.default = InvalidPasswordAlgorithmError;

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

@@ -0,0 +1,4 @@
+import DomainError from './domain-error';
+export default class InvalidPasswordLengthError extends DomainError {
+  constructor();
+}

package/dist/clean-arch/domain/errors/invalid-password-length-error.js

@@ -0,0 +1,14 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+const tslib_1 = require('tslib');
+const domain_error_1 = tslib_1.__importDefault(require('./domain-error'));
+class InvalidPasswordLengthError extends domain_error_1.default {
+  constructor() {
+    super(
+      'Invalid length password. Password must be at least 8 characters long.',
+      400,
+    );
+    this.name = 'InvalidPasswordLengthError';
+  }
+}
+exports.default = InvalidPasswordLengthError;

package/dist/clean-arch/domain/factories/create-password-factory.d.ts

@@ -0,0 +1,13 @@
+import { PasswordAlgorithm } from '../value-objects/password';
+import PBKDF2Password from '../value-objects/pbkdf2-password';
+import SHA1Password from '../value-objects/sha1-password';
+export type CreatePasswordDomainProps = {
+  value: string;
+  algorithm: PasswordAlgorithm;
+  salt: string | null;
+};
+export default class CreatePasswordFactory {
+  static create(
+    password?: CreatePasswordDomainProps,
+  ): PBKDF2Password | SHA1Password;
+}

package/dist/clean-arch/domain/factories/create-password-factory.js

@@ -0,0 +1,32 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+const tslib_1 = require('tslib');
+const invalid_password_algorithm_error_1 = tslib_1.__importDefault(
+  require('../errors/invalid-password-algorithm-error'),
+);
+const pbkdf2_password_1 = tslib_1.__importDefault(
+  require('../value-objects/pbkdf2-password'),
+);
+const sha1_password_1 = tslib_1.__importDefault(
+  require('../value-objects/sha1-password'),
+);
+const random_password_temporary_factory_1 = tslib_1.__importDefault(
+  require('./random-password-temporary-factory'),
+);
+class CreatePasswordFactory {
+  static create(password) {
+    if (!password) {
+      return sha1_password_1.default.create(
+        random_password_temporary_factory_1.default.create(),
+      );
+    }
+    if (password && password.algorithm === 'sha1') {
+      return sha1_password_1.default.restore(password.value, password.salt);
+    }
+    if (password && password.algorithm === 'pbkdf2') {
+      return pbkdf2_password_1.default.restore(password.value, password.salt);
+    }
+    throw new invalid_password_algorithm_error_1.default();
+  }
+}
+exports.default = CreatePasswordFactory;

package/dist/clean-arch/domain/factories/random-password-temporary-factory.d.ts

@@ -0,0 +1,8 @@
+export default class CreateRandomPasswordTemporaryFactory {
+  static create(password?: string): string;
+  static isValid(str: string): boolean;
+  private static hasSpecialCharacter;
+  private static hasUpperCaseLetter;
+  private static hasNumber;
+  private static getRandomCharacter;
+}

package/dist/clean-arch/domain/factories/random-password-temporary-factory.js

@@ -0,0 +1,55 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+class CreateRandomPasswordTemporaryFactory {
+  static create(password) {
+    if (password) {
+      return password;
+    }
+    const specials = '!@#$%^&*()_+-=[]{}|;:,.<>?';
+    const upperCaseLetters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    const allChars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    let randomString = '';
+    randomString += this.getRandomCharacter(specials);
+    randomString += this.getRandomCharacter(upperCaseLetters);
+    randomString += this.getRandomCharacter('0123456789');
+    for (let i = 0; i < 5; i++) {
+      randomString += this.getRandomCharacter(allChars);
+    }
+    randomString = randomString
+      .split('')
+      .sort(() => Math.random() - 0.5)
+      .join('');
+    return randomString;
+  }
+  static isValid(str) {
+    const minLength = 8;
+    if (str.length < minLength) {
+      return false;
+    }
+    if (!this.hasSpecialCharacter(str)) {
+      return false;
+    }
+    if (!this.hasUpperCaseLetter(str)) {
+      return false;
+    }
+    if (!this.hasNumber(str)) {
+      return false;
+    }
+    return true;
+  }
+  static hasSpecialCharacter(str) {
+    const specials = '!@#$%^&*()_+-=[]{}|;:,.<>?';
+    return [...str].some(char => specials.includes(char));
+  }
+  static hasUpperCaseLetter(str) {
+    return [...str].some(char => char >= 'A' && char <= 'Z');
+  }
+  static hasNumber(str) {
+    return [...str].some(char => char >= '0' && char <= '9');
+  }
+  static getRandomCharacter(characters) {
+    const index = Math.floor(Math.random() * characters.length);
+    return characters[index];
+  }
+}
+exports.default = CreateRandomPasswordTemporaryFactory;

package/dist/clean-arch/domain/value-objects/password.d.ts

@@ -0,0 +1,19 @@
+export declare enum PasswordAlgorithm {
+  SHA1 = 'sha1',
+  PBKDF2 = 'pbkdf2',
+}
+type PasswordProps = {
+  algorithm: PasswordAlgorithm;
+  isTemporary: boolean;
+};
+export default abstract class Password {
+  value: string;
+  salt: string | null;
+  notEncryptedValue?: string;
+  algorithm: string;
+  isTemporary: boolean;
+  abstract isEqual(password: string): boolean;
+  protected static isValid(password: string): boolean;
+  protected constructor(props: PasswordProps);
+}
+export {};

package/dist/clean-arch/domain/value-objects/password.js

@@ -0,0 +1,18 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.PasswordAlgorithm = void 0;
+var PasswordAlgorithm;
+(function (PasswordAlgorithm) {
+  PasswordAlgorithm['SHA1'] = 'sha1';
+  PasswordAlgorithm['PBKDF2'] = 'pbkdf2';
+})(PasswordAlgorithm || (exports.PasswordAlgorithm = PasswordAlgorithm = {}));
+class Password {
+  static isValid(password) {
+    return password.length >= 8;
+  }
+  constructor(props) {
+    this.algorithm = props.algorithm;
+    this.isTemporary = props.isTemporary;
+  }
+}
+exports.default = Password;

package/dist/clean-arch/domain/value-objects/pbkdf2-password.d.ts

@@ -0,0 +1,10 @@
+import Password from './password';
+export default class PBKDF2Password extends Password {
+  readonly value: string;
+  readonly salt: string;
+  readonly notEncryptedValue?: string | undefined;
+  private constructor();
+  static create(password: string): PBKDF2Password;
+  static restore(password: string, salt: string): PBKDF2Password;
+  isEqual(password: string): boolean;
+}

package/dist/clean-arch/domain/value-objects/pbkdf2-password.js

@@ -0,0 +1,47 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+const tslib_1 = require('tslib');
+const node_crypto_1 = require('node:crypto');
+const invalid_password_length_error_1 = tslib_1.__importDefault(
+  require('../errors/invalid-password-length-error'),
+);
+const password_1 = tslib_1.__importStar(require('./password'));
+class PBKDF2Password extends password_1.default {
+  constructor(value, salt, notEncryptedValue) {
+    super({
+      algorithm: password_1.PasswordAlgorithm.PBKDF2,
+      isTemporary: false,
+    });
+    this.value = value;
+    this.salt = salt;
+    this.notEncryptedValue = notEncryptedValue;
+  }
+  static create(password) {
+    if (!this.isValid(password)) {
+      throw new invalid_password_length_error_1.default();
+    }
+    const salt = (0, node_crypto_1.randomBytes)(20).toString('hex');
+    const value = (0, node_crypto_1.pbkdf2Sync)(
+      password,
+      salt,
+      100,
+      64,
+      'sha512',
+    ).toString('hex');
+    return new PBKDF2Password(value, salt, password);
+  }
+  static restore(password, salt) {
+    return new PBKDF2Password(password, salt);
+  }
+  isEqual(password) {
+    const value = (0, node_crypto_1.pbkdf2Sync)(
+      password,
+      this.salt,
+      100,
+      64,
+      'sha512',
+    ).toString('hex');
+    return this.value === value;
+  }
+}
+exports.default = PBKDF2Password;

package/dist/clean-arch/domain/value-objects/sha1-password.d.ts

@@ -0,0 +1,10 @@
+import Password from './password';
+export default class SHA1Password extends Password {
+  readonly value: string;
+  readonly salt: string | null;
+  readonly notEncryptedValue?: string | undefined;
+  private constructor();
+  static create(password: string): SHA1Password;
+  static restore(password: string, salt: string | null): SHA1Password;
+  isEqual(password: string): boolean;
+}

package/dist/clean-arch/domain/value-objects/sha1-password.js

@@ -0,0 +1,35 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+const tslib_1 = require('tslib');
+const node_crypto_1 = require('node:crypto');
+const invalid_password_length_error_1 = tslib_1.__importDefault(
+  require('../errors/invalid-password-length-error'),
+);
+const password_1 = tslib_1.__importStar(require('./password'));
+class SHA1Password extends password_1.default {
+  constructor(value, salt, notEncryptedValue) {
+    super({ algorithm: password_1.PasswordAlgorithm.SHA1, isTemporary: true });
+    this.value = value;
+    this.salt = salt;
+    this.notEncryptedValue = notEncryptedValue;
+  }
+  static create(password) {
+    if (!this.isValid(password)) {
+      throw new invalid_password_length_error_1.default();
+    }
+    const value = (0, node_crypto_1.createHash)('sha1')
+      .update(password)
+      .digest('hex');
+    return new SHA1Password(value, null, password);
+  }
+  static restore(password, salt) {
+    return new SHA1Password(password, salt, undefined);
+  }
+  isEqual(password) {
+    const value = (0, node_crypto_1.createHash)('sha1')
+      .update(password)
+      .digest('hex');
+    return this.value === value;
+  }
+}
+exports.default = SHA1Password;

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

@@ -15,7 +15,7 @@ export default class Authorization extends APIAuthValidator {
   ): Promise<AuthValidator>;
   protected unauthorize(response: UnauthorizedResponse): void;
   protected getRequestId(): string;
-  protected getAuthorizations(): Promise<string[]>;
   protected handleAuthorized(): Promise<Response>;
+  protected getAuthorizationsHeader(): string;
 }
 export {};

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

@@ -14,15 +14,11 @@ class Authorization extends api_validator_1.APIAuthValidator {
   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);
   }
+  getAuthorizationsHeader() {
+    return this.controller.request.headers.authorizations;
+  }
 }
 exports.default = Authorization;

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

@@ -10,11 +10,11 @@ export default class AuthorizationExpress extends APIAuthValidator {
     query: AuthParams,
     controllerMetaData: ExpressMidlewareProperties,
   ): Promise<AuthValidator>;
-  getAuthorizations(): Promise<string[]>;
   getRequestId(): string;
   handleAuthorized(): Promise<boolean | void>;
   unauthorize(
     response: UnauthorizedResponse,
   ): Promise<Response<any, Record<string, any>>>;
   private setResponseHeaders;
+  protected getAuthorizationsHeader(): string;
 }

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

@@ -6,10 +6,6 @@ class AuthorizationExpress extends api_validator_1.APIAuthValidator {
     const instance = new AuthorizationExpress(query, controllerMetaData);
     return await instance.setup();
   }
-  async getAuthorizations() {
-    const authorizationsHeader = this.controller.request.headers.authorizations;
-    return authorizationsHeader?.split(',') || [];
-  }
   getRequestId() {
     return this.controller.request.headers['X-Amzn-Requestid'];
   }
@@ -27,5 +23,8 @@ class AuthorizationExpress extends api_validator_1.APIAuthValidator {
     }
     return this.controller.response;
   }
+  getAuthorizationsHeader() {
+    return this.controller.request.headers.authorizations;
+  }
 }
 exports.default = AuthorizationExpress;

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

@@ -10,6 +10,8 @@ export declare abstract class APIAuthValidator extends AuthValidator {
   protected constructor(query: AuthParams, controller: any);
   protected handleUnauthorized(): any;
   setup(): Promise<AuthValidator>;
+  protected getAuthorizations(): Promise<string[]>;
   protected abstract unauthorize(response: UnauthorizedResponse): any;
   protected abstract getRequestId(): string;
+  protected abstract getAuthorizationsHeader(): string;
 }

package/dist/infra/authorizations/validator/api/api-validator.js

@@ -19,11 +19,16 @@ class APIAuthValidator extends auth_validator_1.default {
     return this.unauthorize(response);
   }
   async setup() {
-    this.requestData = {
-      authorizations: await this.getAuthorizations(),
-      request_id: this.getRequestId(),
-    };
+    await super.setup();
+    this.requestData.request_id = this.getRequestId();
     return this;
   }
+  async getAuthorizations() {
+    const authorizations = this.getAuthorizationsHeader();
+    if (typeof authorizations === 'string') {
+      return JSON.parse(authorizations);
+    }
+    return authorizations;
+  }
 }
 exports.APIAuthValidator = APIAuthValidator;

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

@@ -14,16 +14,16 @@ class MockMappingModel extends mapping_model_1.MappingModel {
   getPathParams() {
     throw new Error('Method not implemented.');
   }
-  setHeader(key, value) {
+  setHeader() {
     throw new Error('Method not implemented.');
   }
-  setQuery(key, value) {
+  setQuery() {
     throw new Error('Method not implemented.');
   }
   deleteParams() {
     throw new Error('Method not implemented.');
   }
-  setPathParams(key, value) {
+  setPathParams() {
     throw new Error('Method not implemented.');
   }
   next() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seidor-cloud-produtos/orbit-backend-lib",
-  "version": "0.0.24",
+  "version": "0.0.26",
   "description": "Internal lib for backend components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",