@schorts/shared-kernel 4.2.1 → 4.2.3

package/__tests__/value-objects/integer-value.test.ts

@@ -1,115 +0,0 @@
-import { expectTypeOf } from "expect-type";
-
-import { ValueObject, IntegerValue } from "../../src/value-objects";
-
-class TestIntegerValue extends IntegerValue {
-  readonly attributeName = "test";
-}
-
-describe("IntegerValue", () => {
-  it('should implement "ValueObject" interface', () => {
-    expectTypeOf<IntegerValue>().toExtend<ValueObject>();
-  });
-
-  it('should have a "valueType" with "Integer" as value', () => {
-    const testIntegerValue = new TestIntegerValue(0);
-
-    expect(testIntegerValue.valueType).toEqual("Integer");
-  });
-
-  it('should have a "value" property of type number', () => {
-    expectTypeOf<IntegerValue["value"]>().toBeNumber();
-  });
-
-  it('should have a "min" property of type number or undefined', () => {
-    expectTypeOf<IntegerValue["min"]>().toEqualTypeOf<number | undefined>();
-  });
-
-  it('should have a "max" property of type number or undefined', () => {
-    expectTypeOf<IntegerValue["max"]>().toEqualTypeOf<number | undefined>()
-  });
-
-  it('should define the "equals" method', () => {
-    expectTypeOf<IntegerValue["equals"]>().toEqualTypeOf<(valueObject: unknown) => boolean>();
-  });
-
-  describe('when "min" is not present', () => {
-    it('should allow any negative integer as valid', () => {
-      const testIntegerValue = new TestIntegerValue(-1);
-
-      expect(testIntegerValue.isValid).toBeTruthy();
-    });
-  });
-
-  describe('when "min" is present', () => {
-    it('should assign the provided value', () => {
-      const min = 1;
-      const testIntegerValue = new TestIntegerValue(0, min);
-
-      expect(testIntegerValue.min).toEqual(min);
-    });
-
-    it('should return false if the value provided is less than the "min"', () => {
-      const min = 1;
-      const testIntegerValue = new TestIntegerValue(-1, min);
-
-      expect(testIntegerValue.isValid).toBeFalsy();
-    });
-
-    it('should return true if the value provided is greather or equal than the "min', () => {
-      const min = 1;
-      const testIntegerValue = new TestIntegerValue(1, min);
-
-      expect(testIntegerValue.isValid).toBeTruthy();
-    });
-  });
-
-  describe('when "max" is not present', () => {
-    it('should assign a default value of undefined', () => {
-      const testIntegerValue = new TestIntegerValue(0);
-
-      expect(testIntegerValue.max).toBeUndefined();
-    });
-  });
-
-  describe('when "max" is present', () => {
-    it('should assign the provided value', () => {
-      const max = 1;
-      const testIntegerValue = new TestIntegerValue(0, undefined, max);
-
-      expect(testIntegerValue.max).toEqual(max);
-    });
-
-    it('should return false if the value provided is greather than the "max"', () => {
-      const max = 1;
-      const testIntegerValue = new TestIntegerValue(2, undefined, max);
-
-      expect(testIntegerValue.isValid).toBeFalsy();
-    });
-
-    it('should return true if the value provided is less or equal than the "max', () => {
-      const max = 1;
-      const testIntegerValue = new TestIntegerValue(1, undefined, max);
-
-      expect(testIntegerValue.isValid).toBeTruthy();
-    });
-  });
-
-  describe('when "min" and "max" is present', () => {
-    it('should return false if the value provided is not between the "min" and "max"', () => {
-      const min = -1;
-      const max = 1;
-      const testIntegerValue = new TestIntegerValue(2, min, max);
-
-      expect(testIntegerValue.isValid).toBeFalsy();
-    });
-
-    it('should return true if the value provided is not between the "min" and "max"', () => {
-      const min = -1;
-      const max = 1;
-      const testIntegerValue = new TestIntegerValue(0, min, max);
-
-      expect(testIntegerValue.isValid).toBeTruthy();
-    });
-  });
-});

package/__tests__/value-objects/phone-value.test.ts

@@ -1,82 +0,0 @@
-import { expectTypeOf } from "expect-type";
-
-import { ValueObject, PhoneValue } from "../../src/value-objects";
-
-class TestPhoneValue extends PhoneValue {
-  readonly attributeName = "test";
-}
-
-describe("PhoneValue", () => {
-  it('should implement "ValueObject" interface', () => {
-    expectTypeOf<PhoneValue>().toExtend<ValueObject>();
-  });
-
-  it('should have a "valueType" with "Phone" as value', () => {
-    const testPhoneValue = new TestPhoneValue("");
-
-    expect(testPhoneValue.valueType).toEqual("Phone");
-  });
-
-  it('should have a "value" property of type string', () => {
-    expectTypeOf<PhoneValue["value"]>().toBeString();
-  });
-
-  it('should have a "countryCode" property of type string', () => {
-    expectTypeOf<PhoneValue["countryCode"]>().toEqualTypeOf<string | null>();
-  });
-
-  it('should have a "phoneNumber" property of type string', () => {
-    expectTypeOf<PhoneValue["phoneNumber"]>().toEqualTypeOf<string | null>();
-  });
-
-  it('should have a "formattedPhone" property of type string', () => {
-    expectTypeOf<PhoneValue["formattedPhone"]>().toEqualTypeOf<string | null>();
-  });
-
-  it('should define the "equals" method', () => {
-    expectTypeOf<PhoneValue["equals"]>().toEqualTypeOf<(valueObject: unknown) => boolean>();
-  });
-
-  describe('when "value" is a phone', () => {
-    const countryCode = "+52";
-    const phoneNumber = "1234567890";
-    const formattedPhone = `${countryCode} (123) 456-7890`;
-    const testPhoneValue = new TestPhoneValue(`${countryCode}${phoneNumber}`);
-
-    it('should return true the "isValid" getter', () => {
-      expect(testPhoneValue.isValid).toBeTruthy();
-    });
-
-    it('should return the "countryCode" property', () => {
-      expect(testPhoneValue.countryCode).toEqual(countryCode);
-    });
-
-    it('should return the "phoneNumber" property', () => {
-      expect(testPhoneValue.phoneNumber).toEqual(phoneNumber);
-    });
-
-    it('should return the "formattedPhone" property', () => {
-      expect(testPhoneValue.formattedPhone).toEqual(formattedPhone);
-    });
-  });
-
-  describe('when "value" is not a phone', () => {
-    const testPhoneValue = new TestPhoneValue("+112345678901241");
-
-    it('should return false the "isValid" getter', () => {
-      expect(testPhoneValue.isValid).toBeFalsy();
-    });
-
-    it('should return null for the "countryCode" property', () => {
-      expect(testPhoneValue.countryCode).toBeNull();
-    });
-
-    it('should return null for the "phoneNumber" property', () => {
-      expect(testPhoneValue.phoneNumber).toBeNull();
-    });
-
-    it('should return null for the "formattedPhone" property', () => {
-      expect(testPhoneValue.formattedPhone).toBeNull();
-    });
-  });
-});

package/__tests__/value-objects/slug-value.test.ts

@@ -1,43 +0,0 @@
-import { expectTypeOf } from "expect-type";
-
-import { ValueObject, SlugValue } from "../../src/value-objects";
-
-class TestSlugValue extends SlugValue {
-  readonly attributeName = "test";
-}
-
-describe("SlugValue", () => {
-  it('should implement "ValueObject" interface', () => {
-    expectTypeOf<TestSlugValue>().toExtend<ValueObject>();
-  });
-
-  it('should have a "valueType" with "Slug" as value', () => {
-    const testSlugValue = new TestSlugValue("");
-
-    expect(testSlugValue.valueType).toEqual("Slug");
-  });
-
-  it('should have a "value" property of type string', () => {
-    expectTypeOf<SlugValue["value"]>().toBeString();
-  });
-
-  it('should define the "equals" method', () => {
-    expectTypeOf<SlugValue["equals"]>().toEqualTypeOf<(valueObject: unknown) => boolean>();
-  });
-
-  describe('when "value" is an slug', () => {
-    it('should return true the "isValid" getter', () => {
-      const testSlugValue = new TestSlugValue("schorts");
-
-      expect(testSlugValue.isValid).toBeTruthy();
-    });
-  });
-
-  describe('when "value" is not an slug', () => {
-    it('should return false the "isValid" getter', () => {
-      const testSlugValue = new TestSlugValue("-schorts");
-
-      expect(testSlugValue.isValid).toBeFalsy();
-    });
-  });
-});

package/__tests__/value-objects/string-value.test.ts

@@ -1,121 +0,0 @@
-import { expectTypeOf } from "expect-type";
-
-import { ValueObject, StringValue } from "../../src/value-objects";
-
-class TestStringalue extends StringValue {
-  readonly attributeName = "test";
-}
-
-describe("StringValue", () => {
-  it('should implement "ValueObject" interface', () => {
-    expectTypeOf<TestStringalue>().toExtend<ValueObject>();
-  });
-
-  it('should have a "valueType" with "String" as value', () => {
-    const testStringValue = new TestStringalue("");
-
-    expect(testStringValue.valueType).toEqual("String");
-  });
-
-  it('should have a "value" property of type string', () => {
-    expectTypeOf<StringValue["value"]>().toBeString();
-  });
-
-  it('should have a "minLength" property of type number', () => {
-    expectTypeOf<StringValue["minLength"]>().toBeNumber();
-  });
-
-  it('should have a "maxLength" property of type number or undefined', () => {
-    expectTypeOf<StringValue["maxLength"]>().toEqualTypeOf<number | undefined>()
-  });
-
-  it('should define the "equals" method', () => {
-    expectTypeOf<StringValue["equals"]>().toEqualTypeOf<(valueObject: unknown) => boolean>();
-  });
-
-  describe('when "minLength" is not present', () => {
-    it('should assign a default value of 0', () => {
-      const testStringValue = new TestStringalue("");
-
-      expect(testStringValue.minLength).toEqual(0);
-    });
-
-    it('should allow an empty string as valid', () => {
-      const testStringValue = new TestStringalue("");
-
-      expect(testStringValue.isValid).toBeTruthy();
-    });
-  });
-
-  describe('when "minLength" is present', () => {
-    it('should assign the provided value', () => {
-      const minLength = 1;
-      const testStringValue = new TestStringalue("", minLength);
-
-      expect(testStringValue.minLength).toEqual(minLength);
-    });
-
-    it('should return false if the value provided length is less than the "minLength"', () => {
-      const minLength = 1;
-      const testStringValue = new TestStringalue("", minLength);
-
-      expect(testStringValue.isValid).toBeFalsy();
-    });
-
-    it('should return true if the value provided length is greather or equal than the "minLength', () => {
-      const minLength = 1;
-      const testStringValue = new TestStringalue("1", minLength);
-
-      expect(testStringValue.isValid).toBeTruthy();
-    });
-  });
-
-  describe('when "maxLength" is not present', () => {
-    it('should assign a default value of undefined', () => {
-      const testStringValue = new TestStringalue("");
-
-      expect(testStringValue.maxLength).toBeUndefined();
-    });
-  });
-
-  describe('when "maxLength" is present', () => {
-    it('should assign the provided value', () => {
-      const maxLength = 1;
-      const testStringValue = new TestStringalue("", 0, maxLength);
-
-      expect(testStringValue.maxLength).toEqual(maxLength);
-    });
-
-    it('should return false if the value provided length is greather than the "maxLength"', () => {
-      const maxLength = 1;
-      const testStringValue = new TestStringalue("12", 0, maxLength);
-
-      expect(testStringValue.isValid).toBeFalsy();
-    });
-
-    it('should return true if the value provided length is less or equal than the "maxLength', () => {
-      const maxLength = 2;
-      const testStringValue = new TestStringalue("1", 0, maxLength);
-
-      expect(testStringValue.isValid).toBeTruthy();
-    });
-  });
-
-  describe('when "minLength" and "maxLength" is present', () => {
-    it('should return false if the value provided length is not between the "minLength" and "maxLength"', () => {
-      const minLength = 1;
-      const maxLength = 2;
-      const testStringValue = new TestStringalue("123", minLength, maxLength);
-
-      expect(testStringValue.isValid).toBeFalsy();
-    });
-
-    it('should return true if the value provided length is not between the "minLength" and "maxLength"', () => {
-      const minLength = 1;
-      const maxLength = 2;
-      const testStringValue = new TestStringalue("12", minLength, maxLength);
-
-      expect(testStringValue.isValid).toBeTruthy();
-    });
-  });
-});

package/__tests__/value-objects/uuid-value.test.ts

@@ -1,67 +0,0 @@
-import { expectTypeOf } from "expect-type";
-
-import { ValueObject, UUIDValue } from "../../src/value-objects";
-
-class TestUUIDValue extends UUIDValue {
-  readonly attributeName = "test";
-}
-
-describe("UUIDValue", () => {
-  it('should implement "ValueObject" interface', () => {
-    expectTypeOf<UUIDValue>().toExtend<ValueObject>();
-  });
-
-  it('should have a "valueType" with "UUID" as value', () => {
-    const testUUIDvalue = new TestUUIDValue();
-
-    expect(testUUIDvalue.valueType).toEqual("UUID");
-  });
-
-  it('should have a "value" property of type string | undefined', () => {
-    expectTypeOf<UUIDValue["value"]>().toEqualTypeOf<string | undefined>();
-  });
-
-  it('should have a "optional" property of type boolean', () => {
-    expectTypeOf<UUIDValue["optional"]>().toBeBoolean();
-  });
-
-  it('should define the "equals" method', () => {
-    expectTypeOf<UUIDValue["equals"]>().toEqualTypeOf<(valueObject: unknown) => boolean>();
-  });
-
-  describe('when "value" is present', () => {
-    describe('when "value" is valid', () => {
-      it('should have a getter "isValid" that returns true', () => {
-        const testUUIDvalue = new TestUUIDValue("87a00bc1-c586-4d23-bfc7-dd637628777c");
-
-        expect(testUUIDvalue.isValid).toBeTruthy();
-      });
-    });
-
-    describe('when "value" is not valid', () => {
-      it('should have a getter "isValid" that returns false', () => {
-        const testUUIDvalue = new TestUUIDValue("dummy-uuid-12346-5734");
-
-        expect(testUUIDvalue.isValid).toBeFalsy();
-      });
-    });
-  });
-
-  describe('when "value" is not present', () => {
-    describe('when "value" is optional', () => {
-      it('should have a getter "isValid" that returns true', () => {
-        const testUUIDvalue = new TestUUIDValue(undefined, true);
-
-        expect(testUUIDvalue.isValid).toBeTruthy();
-      });
-    });
-
-    describe('when "value" is not optional', () => {
-      it('should have a getter "isValid" that runs the validations normally and returns false', () => {
-        const testUUIDvalue = new TestUUIDValue(undefined, false);
-
-        expect(testUUIDvalue.isValid).toBeFalsy();
-      });
-    });
-  });
-});

package/__tests__/value-objects/value-object.test.ts

@@ -1,25 +0,0 @@
-import { expectTypeOf } from "expect-type";
-
-import { ValueObject } from "../../src/value-objects";
-
-describe("ValueObject", () => {
-  it('should have a "value" property of type unknown', () => {
-    expectTypeOf<ValueObject>().toHaveProperty("value");
-    expectTypeOf<ValueObject['value']>().toBeUnknown();
-  });
-
-  it('should have a "isValid" property of type boolean', () => {
-    expectTypeOf<ValueObject>().toHaveProperty("isValid");
-    expectTypeOf<ValueObject['isValid']>().toBeBoolean();
-  });
-
-  it('should have a "valueType" property of type string', () => {
-    expectTypeOf<ValueObject>().toHaveProperty("valueType");
-    expectTypeOf<ValueObject['valueType']>().toBeString();
-  });
-
-  it('should have a "attributeName" property of type string', () => {
-    expectTypeOf<ValueObject>().toHaveProperty("attributeName");
-    expectTypeOf<ValueObject['attributeName']>().toBeString();
-  });
-});

package/jest.config.js

@@ -1,25 +0,0 @@
-// jest.config.js
-const { defaults: tsjPreset } = require("ts-jest/presets");
-const { transform } = require("typescript");
-
-  module.exports = {
-    preset: "ts-jest/presets/default-esm",
-    testEnvironment: "node",
-    extensionsToTreatAsEsm: [".ts"],
-    transform: {
-      '^.+\\.(ts|tsx)$': ['ts-jest', { useESM: true }],
-    },
-    moduleFileExtensions: ["ts", "js", "json", "node"],
-    testMatch: ["**/__tests__/**/*.ts", "**/?(*.)+(spec|test).ts"],
-    collectCoverageFrom: [
-      "src/**/*.ts",
-      "!src/**/*.d.ts",
-      "!src/index.ts",
-    ],
-    coverageDirectory: "coverage",
-    coverageReporters: ["text", "lcov", "html"],
-    moduleNameMapper: {
-      "^@schorts/shared-kernel/(.*)$": "<rootDir>/src/$1",
-    },
-  };
-  

package/src/abac/index.ts

@@ -1 +0,0 @@
-export type { Predicate } from "./predicate";

package/src/abac/predicate.ts

@@ -1,3 +0,0 @@
-import type { BaseResource } from '../rbac/base-resource';
-
-export type Predicate<User extends { id: string }, Resource extends BaseResource> = (user: User, resource: Resource) => boolean;

package/src/auth/auth-provider.ts

@@ -1,11 +0,0 @@
-import { Entity } from "../entities";
-import { BaseModel } from "../models";
-import { ValueObject } from "../value-objects";
-
-export interface AuthProvider<UserEntity extends Entity<ValueObject, BaseModel>> {
-  authenticate(...args: any[]): Promise<string>;
-  logout(): Promise<void>;
-  isAuthenticated(): Promise<boolean>;
-  getCurrentUser(): Promise<UserEntity | null>;
-  onAuthChange(callback: (user: UserEntity | null) => void): () => void;
-}

package/src/auth/exceptions/index.ts

@@ -1,2 +0,0 @@
-export { NotAuthenticated } from "./not-authenticated";
-export { RequireAuthNotImplementedCorrectly } from "./require-auth-not-implemented-correctly";

package/src/auth/exceptions/not-authenticated.ts

@@ -1,11 +0,0 @@
-import { TranslationResolver } from "../../i18n";
-
-export class NotAuthenticated extends Error {
-  constructor(translationResolver?: TranslationResolver) {
-    const message = translationResolver
-      ? translationResolver.resolve("auth.errors.not_authenticated")
-      : "Not Authenticated";
-
-    super(message);
-  }
-}

package/src/auth/exceptions/require-auth-not-implemented-correctly.ts

@@ -1,11 +0,0 @@
-import { TranslationResolver } from "../../i18n";
-
-export class RequireAuthNotImplementedCorrectly extends Error {
-  constructor(translationResolver?: TranslationResolver) {
-    const message = translationResolver
-      ? translationResolver.resolve("auth.errors.require_auth_not_implemented_correctly")
-      : "RequireAuth decorator not implemented correctly";
-
-    super(message);
-  }
-}

package/src/auth/index.ts

@@ -1,3 +0,0 @@
-export type { AuthProvider } from "./auth-provider";
-export { RequireAuth } from "./require-auth.decorator";
-export * from "./exceptions";

package/src/auth/require-auth.decorator.ts

@@ -1,42 +0,0 @@
-import { AuthProvider } from "./auth-provider";
-import { NotAuthenticated, RequireAuthNotImplementedCorrectly } from './exceptions';
-import { TranslationResolver } from "../i18n";
-
-export function RequireAuth(onFail?: () => any) {
-  function wrapper<T extends { authProvider?: AuthProvider<any>, translationResolver?: TranslationResolver }, A extends any[], R>(
-    originalMethod: (this: T, ...args: A) => Promise<R>
-  ): (this: T, ...args: A) => Promise<R> {
-    return async function (this: T, ...args: A): Promise<R> {
-      if (!this.authProvider) {
-        throw new Error("authProvider: AuthProvider is required on this instance");
-      }
-
-      const isAuthenticated = await this.authProvider.isAuthenticated();
-
-      if (!isAuthenticated) {
-        if (onFail) {
-          return onFail();
-        } else {
-          throw new NotAuthenticated(this.translationResolver);
-        }
-      }
-
-      return await originalMethod.apply(this, args);
-    };
-  }
-
-  return function (...args: any[]) {
-    if (args.length === 3 && typeof args[2] === 'object') {
-      const descriptor = args[2] as PropertyDescriptor;
-      descriptor.value = wrapper(descriptor.value);
-      return descriptor;
-    }
-
-    if (args.length === 2 && typeof args[1] === 'object' && 'kind' in args[1]) {
-      const [originalMethod] = args;
-      return wrapper(originalMethod);
-    }
-
-    throw new RequireAuthNotImplementedCorrectly();
-  };
-}

package/src/converters/index.ts

@@ -1 +0,0 @@
-export { RemoteFileToBase64 } from "./remote-file-to-base64";

package/src/converters/remote-file-to-base64.ts

@@ -1,19 +0,0 @@
-import { HTTPProvider } from "../http";
-
-export class RemoteFileToBase64 {
-  constructor(
-    private readonly httpProvider: HTTPProvider,
-  ) {}
-
-  async convert(url: URL): Promise<string> {
-    const blob = await this.httpProvider.get<Blob>(url);
-
-    return new Promise((resolve, reject) => {
-      const reader = new FileReader();
-
-      reader.readAsDataURL(blob);
-      reader.onload = () => resolve(reader.result as string);
-      reader.onerror = (error) => reject(error);
-    });
-  }
-}

package/src/criteria/criteria.ts

@@ -1,46 +0,0 @@
-import { Order } from "./order";
-import { Operator } from "./operator";
-import { Direction } from "./direction";
-import { OffsetNotValid, LimitNotValid } from "./exceptions";
-
-export class Criteria {
-  readonly filters: Array<{ field: string; operator: Operator; value: any }> = [];
-  readonly orders: Array<Order> = [];
-  limit?: number;
-  offset?: number;
-
-  where(field: string, operator: Operator, value: any): Criteria {
-    this.filters.push({ field, operator, value });
-
-    return this;
-  }
-
-  orderBy(
-    field: string,
-    direction: Direction = "ASC",
-  ): Criteria {
-    this.orders.push({ field, direction });
-
-    return this;
-  }
-
-  limitResults(limit: number): Criteria {
-    if (limit < 1) {
-      throw new LimitNotValid(limit);
-    }
-
-    this.limit = limit;
-
-    return this;
-  }
-
-  offsetResults(offset: number): Criteria {
-    if (offset < 1) {
-      throw new OffsetNotValid(offset);
-    }
-
-    this.offset = offset;
-
-    return this;
-  }
-}

package/src/criteria/direction.ts

@@ -1 +0,0 @@
-export type Direction = "ASC" | "DESC";

package/src/criteria/exceptions/index.ts

@@ -1,2 +0,0 @@
-export { OffsetNotValid } from "./offset-not-valid";
-export { LimitNotValid } from "./limit-not-valid";

package/src/criteria/exceptions/limit-not-valid.ts

@@ -1,11 +0,0 @@
-import { TranslationResolver } from "../../i18n";
-
-export class LimitNotValid extends Error {
-  constructor(limit: number, translationResolver?: TranslationResolver) {
-    const message = translationResolver
-      ? translationResolver.resolve("criteria.errors.limit_not_valid", { limit })
-      : `Limit Not Valid: ${limit}`;
-
-    super(message);
-  }
-}