@atlantjs/arch 1.0.0

package/objects/datatypes/entities/$string.abstract.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$string = void 0;
+class $string {
+    constructor(value) {
+        this.value = value;
+        this.sanitize();
+        this.validate();
+    }
+    toString() {
+        return this.value;
+    }
+    has(value) {
+        return !this.value.indexOf(value);
+    }
+    extract(start, end) {
+        const indexStartValue = this.value.indexOf(start);
+        const indexEndValue = this.value.lastIndexOf(end) + 1;
+        return this.value.substring(indexStartValue, indexEndValue);
+    }
+    remove(substrings) {
+        const regex = new RegExp(`[${substrings.join("")}]`, "g");
+        return this.value.replace(regex, "");
+    }
+    sanitize() {
+        this.value = this.value.trim();
+    }
+    validate() {
+        if (this.value.length <= 0) {
+            throw Error(`${this.constructor.name} should not be empty.`);
+        }
+    }
+}
+exports.$string = $string;

package/objects/datatypes/entities/uuid.abstract.d.ts

@@ -0,0 +1,7 @@
+export declare abstract class UuidAbstract {
+    private readonly value;
+    private static readonly pattern;
+    constructor(value?: string);
+    equals(uuid: UuidAbstract): boolean;
+    toString(): string;
+}

package/objects/datatypes/entities/uuid.abstract.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UuidAbstract = void 0;
+const uuid_1 = require("uuid");
+class UuidAbstract {
+    constructor(value = (0, uuid_1.v7)()) {
+        this.value = value;
+        if (!UuidAbstract.pattern.test(value)) {
+            throw new TypeError("The provided UUID is invalid. Please ensure it is in the correct format");
+        }
+    }
+    equals(uuid) {
+        return this.toString() === uuid.toString();
+    }
+    toString() {
+        return this.value;
+    }
+}
+exports.UuidAbstract = UuidAbstract;
+UuidAbstract.pattern = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;

package/package.json

@@ -0,0 +1,66 @@
+{
+	"name": "@atlantjs/arch",
+	"version": "1.0.0",
+	"main": "index.js",
+	"license": "UNLICENSED",
+	"publishConfig": {
+		"registry": "https://registry.npmjs.org/"
+	},
+	"directories": {
+		"src": "src",
+		"test": "tests"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+ssh://git@github.com/MovingApp/lib-atlantjs-guardian.git"
+	},
+	"author": "movingapp",
+	"bugs": {
+		"url": "https://github.com/MovingApp/lib-atlantjs-guardian/issues"
+	},
+	"homepage": "https://github.com/MovingApp/lib-atlantjs-guardian#readme",
+	"scripts": {
+		"build": "rm -rf dist && tsc --project tsconfig.json && tscpaths -p tsconfig.json -s ./src -o ./dist",
+		"lint": "npx biome check src --indent-style=tab ",
+		"lint:fix": "yarn lint --fix --unsafe --organize-imports-enabled=true",
+		"test": "yarn cross-env ENVIRONMENT=test jest --passWithNoTests --silent --noStackTrace  --detectOpenHandles --bail",
+		"test:verbose": "yarn cross-env ENVIRONMENT=test jest --passWithNoTests --runInBand",
+		"test:unit": "yarn test -c jest-unit.config.js",
+		"test:unit:watch": "yarn test:unit --watch",
+		"test:unit:watch:staged": "yarn test:unit --watch --findRelatedTests",
+		"test:unit:watch:changed": "yarn test:unit --watch --onlyChanged",
+		"test:unit:cov": "yarn test:unit --coverage --runInBand"
+	},
+	"dependencies": {
+		"@faker-js/faker": "^9.0.3",
+		"class-transformer": "^0.5.1",
+		"dotenv": "^16.4.5",
+		"env-var": "^7.5.0",
+		"express": "^4.21.1",
+		"jsonwebtoken": "^9.0.2",
+		"jwk-to-pem": "^2.0.6",
+		"module-alias": "^2.2.3",
+		"reflect-metadata": "^0.2.2",
+		"uuid": "^10.0.0"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "1.8.3",
+		"@types/express": "^5.0.0",
+		"@types/jest": "^29.5.12",
+		"@types/jsonwebtoken": "^9.0.7",
+		"@types/jwk-to-pem": "^2.0.3",
+		"@types/uuid": "^10.0.0",
+		"copyfiles": "^2.4.1",
+		"cross-env": "^7.0.3",
+		"faker": "^5.5.3",
+		"jest": "^29.7.0",
+		"ts-jest": "^29.2.5",
+		"ts-node": "^10.9.1",
+		"ts-node-dev": "^2.0.0",
+		"ts-prune": "^0.10.3",
+		"tsconfig-paths": "^4.2.0",
+		"tscpaths": "^0.0.9",
+		"tslib": "^2.7.0",
+		"typescript": "^5.2.2"
+	}
+}

package/tests/builders/auth/access-token-signature.builder.d.ts

@@ -0,0 +1,6 @@
+import { AccessTokenSignature } from "../../../objects/auth/entities/token/access-token-signature";
+import { EntityBuilder } from "../../entity-builder.util";
+export declare class AccessTokenSignatureBuilder extends EntityBuilder<AccessTokenSignature, AccessTokenSignatureBuilder> {
+    constructor();
+    protected buildDefault(): AccessTokenSignature;
+}

package/tests/builders/auth/access-token-signature.builder.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessTokenSignatureBuilder = void 0;
+const access_token_signature_1 = require("../../../objects/auth/entities/token/access-token-signature");
+const entity_builder_util_1 = require("../../entity-builder.util");
+const _1 = require("@faker-js/faker/.");
+class AccessTokenSignatureBuilder extends entity_builder_util_1.EntityBuilder {
+    constructor() {
+        super(AccessTokenSignatureBuilder);
+    }
+    buildDefault() {
+        return new access_token_signature_1.AccessTokenSignature({
+            realmUrl: _1.faker.internet.url(),
+            minTimeBetweenJwksRequests: _1.faker.number.int(),
+            publicKey: _1.faker.string.uuid(),
+        });
+    }
+}
+exports.AccessTokenSignatureBuilder = AccessTokenSignatureBuilder;

package/tests/builders/auth/access-token.builder.d.ts

@@ -0,0 +1,6 @@
+import { AccessTokenDummy } from "./value-objects/dummies/access-token.dummy";
+import { EntityBuilder } from "../../entity-builder.util";
+export declare class AccessTokenBuilder extends EntityBuilder<AccessTokenDummy, AccessTokenBuilder> {
+    constructor();
+    protected buildDefault(): AccessTokenDummy;
+}

package/tests/builders/auth/access-token.builder.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessTokenBuilder = void 0;
+const access_token_dummy_1 = require("./value-objects/dummies/access-token.dummy");
+const entity_builder_util_1 = require("../../entity-builder.util");
+const _1 = require("@faker-js/faker/.");
+class AccessTokenBuilder extends entity_builder_util_1.EntityBuilder {
+    constructor() {
+        super(AccessTokenBuilder);
+    }
+    buildDefault() {
+        return new access_token_dummy_1.AccessTokenDummy(_1.faker.string.uuid());
+    }
+}
+exports.AccessTokenBuilder = AccessTokenBuilder;

package/tests/builders/auth/rotation.builder.d.ts

@@ -0,0 +1,6 @@
+import { Rotation } from "../../../objects/auth/entities/token/rotation";
+import { EntityBuilder } from "../../entity-builder.util";
+export declare class RotationBuilder extends EntityBuilder<Rotation, RotationBuilder> {
+    constructor();
+    protected buildDefault(): Rotation;
+}

package/tests/builders/auth/rotation.builder.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RotationBuilder = void 0;
+const rotation_1 = require("../../../objects/auth/entities/token/rotation");
+const entity_builder_util_1 = require("../../entity-builder.util");
+const _1 = require("@faker-js/faker/.");
+class RotationBuilder extends entity_builder_util_1.EntityBuilder {
+    constructor() {
+        super(RotationBuilder);
+    }
+    buildDefault() {
+        return new rotation_1.Rotation({
+            realmUrl: _1.faker.internet.url(),
+            minTimeBetweenJwksRequests: _1.faker.number.int(),
+            publicKey: _1.faker.string.uuid(),
+        });
+    }
+}
+exports.RotationBuilder = RotationBuilder;

package/tests/builders/auth/token.builder.d.ts

@@ -0,0 +1,7 @@
+import { Token } from "../../../objects/auth/entities/token/token";
+import { EntityBuilder } from "../../entity-builder.util";
+import { JwtPayload } from "jsonwebtoken";
+export declare class TokenBuilder<T extends JwtPayload> extends EntityBuilder<Token<T>, TokenBuilder<T>> {
+    constructor();
+    protected buildDefault(): Token<T>;
+}

package/tests/builders/auth/token.builder.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenBuilder = void 0;
+const token_1 = require("../../../objects/auth/entities/token/token");
+const entity_builder_util_1 = require("../../entity-builder.util");
+const faker_1 = require("@faker-js/faker");
+class TokenBuilder extends entity_builder_util_1.EntityBuilder {
+    constructor() {
+        super(TokenBuilder);
+    }
+    buildDefault() {
+        return new token_1.Token(faker_1.faker.string.uuid());
+    }
+}
+exports.TokenBuilder = TokenBuilder;

package/tests/builders/auth/value-objects/client-credentials.builder.d.ts

@@ -0,0 +1,6 @@
+import { ClientCredentialsDummy } from "./dummies/client-credentials.dummy";
+import { EntityBuilder } from "../../../entity-builder.util";
+export declare class ClientCredentialsBuilder extends EntityBuilder<ClientCredentialsDummy, ClientCredentialsBuilder> {
+    constructor();
+    protected buildDefault(): ClientCredentialsDummy;
+}

package/tests/builders/auth/value-objects/client-credentials.builder.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientCredentialsBuilder = void 0;
+const faker_1 = require("@faker-js/faker");
+const client_credentials_dummy_1 = require("./dummies/client-credentials.dummy");
+const entity_builder_util_1 = require("../../../entity-builder.util");
+const random_enum_value_1 = require("../../../../utils/randoms/random-enum-value");
+const client_enum_1 = require("../../../../objects/auth/enums/client.enum");
+const realm_enum_1 = require("../../../../objects/auth/enums/realm.enum");
+class ClientCredentialsBuilder extends entity_builder_util_1.EntityBuilder {
+    constructor() {
+        super(ClientCredentialsBuilder);
+    }
+    buildDefault() {
+        return new client_credentials_dummy_1.ClientCredentialsDummy((0, random_enum_value_1.randomEnumValue)(client_enum_1.ClientEnum), faker_1.faker.string.uuid(), (0, random_enum_value_1.randomEnumValue)(realm_enum_1.RealmEnum));
+    }
+}
+exports.ClientCredentialsBuilder = ClientCredentialsBuilder;

package/tests/builders/auth/value-objects/dummies/access-token.dummy.d.ts

@@ -0,0 +1,3 @@
+import { AccessTokenAbstract } from "../../../../../objects/auth/entities/token/access-token.abstract";
+export declare class AccessTokenDummy extends AccessTokenAbstract {
+}

package/tests/builders/auth/value-objects/dummies/access-token.dummy.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessTokenDummy = void 0;
+const access_token_abstract_1 = require("../../../../../objects/auth/entities/token/access-token.abstract");
+class AccessTokenDummy extends access_token_abstract_1.AccessTokenAbstract {
+}
+exports.AccessTokenDummy = AccessTokenDummy;

package/tests/builders/auth/value-objects/dummies/client-credentials.dummy.d.ts

@@ -0,0 +1,3 @@
+import { ClientCredentialsAbstract } from "../../../../../objects/auth/entities/client/client-credentials.abstract";
+export declare class ClientCredentialsDummy extends ClientCredentialsAbstract {
+}

package/tests/builders/auth/value-objects/dummies/client-credentials.dummy.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientCredentialsDummy = void 0;
+const client_credentials_abstract_1 = require("../../../../../objects/auth/entities/client/client-credentials.abstract");
+class ClientCredentialsDummy extends client_credentials_abstract_1.ClientCredentialsAbstract {
+}
+exports.ClientCredentialsDummy = ClientCredentialsDummy;

package/tests/builders/auth/value-objects/dummies/realm-credentials.dummy.d.ts

@@ -0,0 +1,6 @@
+import { RealmCredentialsAbstract } from "../../../../../objects/auth/entities/client/realm-credentials.abstract";
+import { ClientCredentialsDummy } from "./client-credentials.dummy";
+import { Optional } from "../../../../../utils/ducts/optional-type";
+export declare class RealmCredentialsDummy extends RealmCredentialsAbstract {
+    clientWrapped: Optional<ClientCredentialsDummy>;
+}

package/tests/builders/auth/value-objects/dummies/realm-credentials.dummy.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealmCredentialsDummy = void 0;
+const realm_credentials_abstract_1 = require("../../../../../objects/auth/entities/client/realm-credentials.abstract");
+const optional_type_1 = require("../../../../../utils/ducts/optional-type");
+class RealmCredentialsDummy extends realm_credentials_abstract_1.RealmCredentialsAbstract {
+    constructor() {
+        super(...arguments);
+        this.clientWrapped = optional_type_1.Nothing;
+    }
+}
+exports.RealmCredentialsDummy = RealmCredentialsDummy;

package/tests/builders/auth/value-objects/dummies/user-tokens.dummy.d.ts

@@ -0,0 +1,3 @@
+import { UserTokensAbstract } from "../../../../../objects/auth/entities/user/user-tokens.abstract";
+export declare class UserTokensDummy extends UserTokensAbstract {
+}

package/tests/builders/auth/value-objects/dummies/user-tokens.dummy.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserTokensDummy = void 0;
+const user_tokens_abstract_1 = require("../../../../../objects/auth/entities/user/user-tokens.abstract");
+class UserTokensDummy extends user_tokens_abstract_1.UserTokensAbstract {
+}
+exports.UserTokensDummy = UserTokensDummy;

package/tests/builders/auth/value-objects/realm-credentials.builder.d.ts

@@ -0,0 +1,6 @@
+import { RealmCredentialsDummy } from "./dummies/realm-credentials.dummy";
+import { EntityBuilder } from "../../../entity-builder.util";
+export declare class RealmCredentialsBuilder extends EntityBuilder<RealmCredentialsDummy, RealmCredentialsBuilder> {
+    constructor();
+    protected buildDefault(): RealmCredentialsDummy;
+}

package/tests/builders/auth/value-objects/realm-credentials.builder.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealmCredentialsBuilder = void 0;
+const realm_enum_1 = require("../../../../objects/auth/enums/realm.enum");
+const realm_credentials_dummy_1 = require("./dummies/realm-credentials.dummy");
+const entity_builder_util_1 = require("../../../entity-builder.util");
+const random_enum_value_1 = require("../../../../utils/randoms/random-enum-value");
+const _1 = require("@faker-js/faker/.");
+class RealmCredentialsBuilder extends entity_builder_util_1.EntityBuilder {
+    constructor() {
+        super(RealmCredentialsBuilder);
+    }
+    buildDefault() {
+        return new realm_credentials_dummy_1.RealmCredentialsDummy((0, random_enum_value_1.randomEnumValue)(realm_enum_1.RealmEnum), _1.faker.word.noun(), _1.faker.string.hexadecimal());
+    }
+}
+exports.RealmCredentialsBuilder = RealmCredentialsBuilder;

package/tests/builders/auth/value-objects/user-tokens.builder.d.ts

@@ -0,0 +1,7 @@
+import { UserTokensAbstract } from "../../../../objects/auth/entities/user/user-tokens.abstract";
+import { EntityBuilder } from "../../../entity-builder.util";
+export declare class UserTokensBuilder<T extends UserTokensAbstract> extends EntityBuilder<UserTokensAbstract, UserTokensBuilder<T>> {
+    private instance;
+    constructor(entityClass: new (...args: any[]) => T);
+    protected buildDefault(): T;
+}

package/tests/builders/auth/value-objects/user-tokens.builder.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserTokensBuilder = void 0;
+const token_builder_1 = require("../token.builder");
+const user_tokens_dummy_1 = require("./dummies/user-tokens.dummy");
+const entity_builder_util_1 = require("../../../entity-builder.util");
+class UserTokensBuilder extends entity_builder_util_1.EntityBuilder {
+    constructor(entityClass) {
+        super(UserTokensBuilder);
+        this.instance = entityClass;
+    }
+    buildDefault() {
+        const dummy = new user_tokens_dummy_1.UserTokensDummy(new token_builder_1.TokenBuilder().build(), new token_builder_1.TokenBuilder().build(), new Date(Date.now()));
+        Object.assign(dummy, this.instance);
+        return dummy;
+    }
+}
+exports.UserTokensBuilder = UserTokensBuilder;

package/tests/builders/errors/application-error.builder.d.ts

@@ -0,0 +1,6 @@
+import { EntityBuilder } from "../../entity-builder.util";
+export declare class ApplicationErrorBuilder<T> extends EntityBuilder<T, ApplicationErrorBuilder<T>> {
+    private instance;
+    constructor(entityClass: new (...args: any[]) => T);
+    protected buildDefault(): T;
+}

package/tests/builders/errors/application-error.builder.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationErrorBuilder = void 0;
+const faker_1 = require("@faker-js/faker");
+const application_error_dummy_1 = require("./dummies/application-error.dummy");
+const entity_builder_util_1 = require("../../entity-builder.util");
+class ApplicationErrorBuilder extends entity_builder_util_1.EntityBuilder {
+    constructor(entityClass) {
+        super(ApplicationErrorBuilder);
+        this.instance = entityClass;
+    }
+    buildDefault() {
+        const dummy = new application_error_dummy_1.ApplicationErrorDummy({
+            className: faker_1.faker.string.alphanumeric(),
+            message: faker_1.faker.lorem.words(),
+        });
+        Object.assign(dummy, this.instance);
+        return dummy;
+    }
+}
+exports.ApplicationErrorBuilder = ApplicationErrorBuilder;

package/tests/builders/errors/dummies/application-error.dummy.d.ts

@@ -0,0 +1,3 @@
+import { ApplicationErrorAbstract } from "../../../../objects/arch/application/errors/application-error.abstract";
+export declare class ApplicationErrorDummy extends ApplicationErrorAbstract {
+}

package/tests/builders/errors/dummies/application-error.dummy.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationErrorDummy = void 0;
+const application_error_abstract_1 = require("../../../../objects/arch/application/errors/application-error.abstract");
+class ApplicationErrorDummy extends application_error_abstract_1.ApplicationErrorAbstract {
+}
+exports.ApplicationErrorDummy = ApplicationErrorDummy;

package/tests/builders/generic/dummies/uuid.dummy.d.ts

@@ -0,0 +1,3 @@
+import { UuidAbstract } from "../../../../objects/datatypes/entities/uuid.abstract";
+export declare class UuidDummy extends UuidAbstract {
+}

package/tests/builders/generic/dummies/uuid.dummy.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UuidDummy = void 0;
+const uuid_abstract_1 = require("../../../../objects/datatypes/entities/uuid.abstract");
+class UuidDummy extends uuid_abstract_1.UuidAbstract {
+}
+exports.UuidDummy = UuidDummy;

package/tests/builders/generic/uuid.builder.d.ts

@@ -0,0 +1,6 @@
+import { UuidDummy } from "./dummies/uuid.dummy";
+import { EntityBuilder } from "../../entity-builder.util";
+export declare class UuidBuilder extends EntityBuilder<UuidDummy, UuidBuilder> {
+    constructor();
+    protected buildDefault(): UuidDummy;
+}

package/tests/builders/generic/uuid.builder.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UuidBuilder = void 0;
+const uuid_dummy_1 = require("./dummies/uuid.dummy");
+const entity_builder_util_1 = require("../../entity-builder.util");
+class UuidBuilder extends entity_builder_util_1.EntityBuilder {
+    constructor() {
+        super(UuidBuilder);
+    }
+    buildDefault() {
+        return new uuid_dummy_1.UuidDummy();
+    }
+}
+exports.UuidBuilder = UuidBuilder;

package/tests/builders/user/user-id.builder.d.ts

@@ -0,0 +1,6 @@
+import { UserId } from "../../../objects/auth/entities/user/value-objects/user-id";
+import { EntityBuilder } from "../../entity-builder.util";
+export declare class UserIdBuilder extends EntityBuilder<UserId, UserIdBuilder> {
+    constructor();
+    protected buildDefault(): UserId;
+}

package/tests/builders/user/user-id.builder.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserIdBuilder = void 0;
+const user_id_1 = require("../../../objects/auth/entities/user/value-objects/user-id");
+const uuid_builder_1 = require("../generic/uuid.builder");
+const entity_builder_util_1 = require("../../entity-builder.util");
+class UserIdBuilder extends entity_builder_util_1.EntityBuilder {
+    constructor() {
+        super(UserIdBuilder);
+    }
+    buildDefault() {
+        return new user_id_1.UserId(new uuid_builder_1.UuidBuilder().build().toString());
+    }
+}
+exports.UserIdBuilder = UserIdBuilder;

package/tests/create-fake-stub.d.ts

@@ -0,0 +1,8 @@
+import { Return } from "../utils/ducts/return-type";
+export declare class CreateFakeUsecase {
+    private _response;
+    static new<UsecaseStub>(): UsecaseStub & CreateFakeUsecase;
+    protected execute(): Promise<Return<unknown, unknown>>;
+    withSuccess(response: unknown): this;
+    withError(response?: unknown): this;
+}

package/tests/create-fake-stub.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateFakeUsecase = void 0;
+const application_error_builder_1 = require("./builders/errors/application-error.builder");
+const application_error_dummy_1 = require("./builders/errors/dummies/application-error.dummy");
+const return_type_1 = require("../utils/ducts/return-type");
+class CreateFakeUsecase {
+    static new() {
+        const instance = new CreateFakeUsecase();
+        return instance;
+    }
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._response.isFailure())
+                return (0, return_type_1.Failure)(this._response.unwrapErr());
+            return (0, return_type_1.Success)(this._response.unwrap());
+        });
+    }
+    withSuccess(response) {
+        this._response = (0, return_type_1.Success)(response);
+        return this;
+    }
+    withError(response) {
+        this._response = (0, return_type_1.Failure)(response !== null && response !== void 0 ? response : new application_error_builder_1.ApplicationErrorBuilder(application_error_dummy_1.ApplicationErrorDummy).build());
+        return this;
+    }
+}
+exports.CreateFakeUsecase = CreateFakeUsecase;

package/tests/entity-builder.util.d.ts

@@ -0,0 +1,13 @@
+type ModifierCallback<T> = (dataToModify: T) => void;
+export declare abstract class EntityBuilder<T, TBuilder extends EntityBuilder<T, TBuilder>> {
+    private readonly innerType;
+    protected modifiers: Array<ModifierCallback<T>>;
+    protected constructor(innerType: new (...args: any[]) => TBuilder);
+    build(): T;
+    with<K extends keyof T>(key: K, value: T[K]): TBuilder;
+    buildMany(quantity?: number): T[];
+    protected applyModifiers(instance: T): void;
+    protected newBuilder(modifier: ModifierCallback<T>): TBuilder;
+    protected abstract buildDefault(): T;
+}
+export {};

package/tests/entity-builder.util.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityBuilder = void 0;
+class EntityBuilder {
+    constructor(innerType) {
+        this.innerType = innerType;
+        this.modifiers = [];
+    }
+    build() {
+        const instance = this.buildDefault();
+        this.applyModifiers(instance);
+        return instance;
+    }
+    with(key, value) {
+        return this.newBuilder((entity) => {
+            entity[key] = value;
+        });
+    }
+    buildMany(quantity) {
+        let calculatedQuantity = quantity;
+        if (calculatedQuantity === undefined) {
+            const min = 2;
+            const max = 6;
+            calculatedQuantity = Math.floor(Math.random() * (max - min + 1) + min);
+        }
+        return Array.from({ length: calculatedQuantity }, () => this.build());
+    }
+    applyModifiers(instance) {
+        for (const modifier of this.modifiers) {
+            modifier(instance);
+        }
+    }
+    newBuilder(modifier) {
+        const newBuilder = new this.innerType();
+        newBuilder.modifiers = [...this.modifiers, modifier];
+        return newBuilder;
+    }
+}
+exports.EntityBuilder = EntityBuilder;

package/tests/faker/faker.d.ts

@@ -0,0 +1,2 @@
+export declare class Faker {
+}

package/tests/faker/faker.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Faker = void 0;
+class Faker {
+}
+exports.Faker = Faker;

package/utils/arrays/extended-map.d.ts

@@ -0,0 +1,5 @@
+export declare class ExtendedMap<K, V> extends Map<K, V> {
+    getOrDefault(key: K, defaultValue: V): V;
+    getOrThrow(key: K, errorMessage?: string): V;
+    invert(): ExtendedMap<V, K>;
+}

package/utils/arrays/extended-map.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendedMap = void 0;
+const guardian_1 = require("../type-guard/guardian");
+class ExtendedMap extends Map {
+    getOrDefault(key, defaultValue) {
+        var _a;
+        return (_a = this.get(key)) !== null && _a !== void 0 ? _a : defaultValue;
+    }
+    getOrThrow(key, errorMessage = "Key not mapped") {
+        const value = this.get(key);
+        if (guardian_1.Guardian.isUndefined(value)) {
+            throw Error(errorMessage);
+        }
+        return value;
+    }
+    invert() {
+        const inverted = new ExtendedMap();
+        this.forEach((value, key) => inverted.set(value, key));
+        return inverted;
+    }
+}
+exports.ExtendedMap = ExtendedMap;