@atlantjs/backend 1.0.0 → 1.0.1

package/backend/application/databases/database.config.d.ts

@@ -0,0 +1,23 @@
+import { DataSource, DatabaseType } from "typeorm";
+interface DatabaseConfigProps {
+    type: DatabaseType;
+    host: string;
+    port: number;
+    username: string;
+    password: string;
+    database: string;
+    schema: string;
+    synchronize: boolean;
+    entities: string[];
+    migrations: string[];
+    region?: string;
+    secretArn?: string;
+    resourceArn?: string;
+}
+export declare abstract class DatabaseConfigAbstract {
+    private readonly props;
+    configs: DataSource;
+    private readonly productionOrHomologConfigs;
+    constructor(props: DatabaseConfigProps);
+}
+export {};

package/backend/application/databases/database.config.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseConfigAbstract = void 0;
+const arch_1 = require("@atlantjs/arch");
+const typeorm_1 = require("typeorm");
+class DatabaseConfigAbstract {
+    constructor(props) {
+        this.props = props;
+        this.productionOrHomologConfigs = {
+            ssl: true,
+            extra: {
+                ssl: {
+                    rejectUnauthorized: false,
+                },
+            },
+        };
+        const baseConfig = {
+            type: this.props.type,
+            host: this.props.host,
+            port: this.props.port,
+            username: this.props.username,
+            password: this.props.password,
+            database: this.props.database,
+            synchronize: arch_1.Guardian.isFalsy((0, arch_1.isProdOrHomolog)()),
+            entities: [`${__dirname}/../../**/*.schema{.ts,.js}`],
+            migrations: ["./migrations/*.ts"],
+        };
+        if (arch_1.Guardian.isEqual(this.props.type, "aurora-mysql")) {
+            Object.assign(baseConfig, {
+                region: this.props.region ?? "",
+                secretArn: this.props.secretArn ?? "",
+                resourceArn: this.props.resourceArn ?? "",
+            });
+        }
+        if (new arch_1.UrlAbstract(this.props.host).has("@")) {
+            Object.assign(baseConfig, this.productionOrHomologConfigs);
+        }
+        this.configs = new typeorm_1.DataSource(baseConfig);
+    }
+}
+exports.DatabaseConfigAbstract = DatabaseConfigAbstract;

package/backend/application/databases/database.helper.abstract.commit.failure.d.ts

@@ -0,0 +1,4 @@
+import { FailureAbstract } from "@atlantjs/arch";
+export declare class DatabaseHelperAbstractCommitFailure extends FailureAbstract {
+    constructor(error?: any);
+}

package/backend/application/databases/database.helper.abstract.commit.failure.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseHelperAbstractCommitFailure = void 0;
+const arch_1 = require("@atlantjs/arch");
+class DatabaseHelperAbstractCommitFailure extends arch_1.FailureAbstract {
+    constructor(error) {
+        super({
+            className: DatabaseHelperAbstractCommitFailure.name,
+            message: "Transaction is not open. Run '.openTransaction()' before commit",
+            error,
+        });
+    }
+}
+exports.DatabaseHelperAbstractCommitFailure = DatabaseHelperAbstractCommitFailure;

package/backend/application/databases/database.helper.abstract.d.ts

@@ -0,0 +1,22 @@
+import { DatabaseConfigAbstract } from "./database.config";
+import { EntityAbstract } from "../../domain/entities/entity-backend.abstract";
+import { Optional, Newable, Return, FailureAbstract } from "@atlantjs/arch";
+import { DataSource, ObjectLiteral } from "typeorm";
+import { FindOptionsRelations } from "typeorm";
+export declare abstract class DatabaseHelperAbstract {
+    private database;
+    private queryRunner;
+    connect(db: DatabaseConfigAbstract): Promise<DataSource>;
+    disconnect(): Promise<void>;
+    read<T extends Newable<ObjectLiteral>, E extends ObjectLiteral>(schema: T, condition: {
+        [K in keyof InstanceType<T>]?: InstanceType<T>[K];
+    }, relations: FindOptionsRelations<E>): Promise<Return<Optional<InstanceType<T>[]>, FailureAbstract>>;
+    write<T extends Newable<ObjectLiteral>>(schema: T, sortedEntities: EntityAbstract[]): Promise<Return<undefined, undefined>>;
+    delete<T extends Newable<ObjectLiteral>>(entity: T, condition: {
+        [K in keyof InstanceType<T>]?: InstanceType<T>[K];
+    }): Promise<Return<undefined, undefined>>;
+    private getManager;
+    private openTransaction;
+    private commit;
+    private rollback;
+}

package/backend/application/databases/database.helper.abstract.get-manager.failure.d.ts

@@ -0,0 +1,4 @@
+import { FailureAbstract } from "@atlantjs/arch";
+export declare class DatabaseHelperAbstractGetManagerFailure extends FailureAbstract {
+    constructor(error?: any);
+}

package/backend/application/databases/database.helper.abstract.get-manager.failure.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseHelperAbstractGetManagerFailure = void 0;
+const arch_1 = require("@atlantjs/arch");
+class DatabaseHelperAbstractGetManagerFailure extends arch_1.FailureAbstract {
+    constructor(error) {
+        super({
+            className: DatabaseHelperAbstractGetManagerFailure.name,
+            message: "The database is not connected",
+            error,
+        });
+    }
+}
+exports.DatabaseHelperAbstractGetManagerFailure = DatabaseHelperAbstractGetManagerFailure;

package/backend/application/databases/database.helper.abstract.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseHelperAbstract = void 0;
+const database_helper_abstract_commit_failure_1 = require("./database.helper.abstract.commit.failure");
+const database_helper_abstract_get_manager_failure_1 = require("./database.helper.abstract.get-manager.failure");
+const database_helper_abstract_rollback_failure_1 = require("./database.helper.abstract.rollback.failure");
+const arch_1 = require("@atlantjs/arch");
+class DatabaseHelperAbstract {
+    constructor() {
+        this.database = arch_1.Nothing;
+        this.queryRunner = arch_1.Nothing;
+    }
+    async connect(db) {
+        this.database = (0, arch_1.Optional)(db.configs);
+        await this.database.unpack().initialize();
+        return this.database.unpack();
+    }
+    async disconnect() {
+        await this.database.unpack().destroy();
+        this.database = arch_1.Nothing;
+    }
+    async read(schema, condition, relations) {
+        const clientWrapped = this.getManager();
+        if (clientWrapped.hasFailure())
+            return (0, arch_1.Failure)(clientWrapped.unwrapFail());
+        const client = clientWrapped.unwrap();
+        const repository = client.getRepository(schema);
+        const registryPacked = (0, arch_1.Optional)((await repository.find({
+            where: condition,
+            relations,
+        })));
+        return (0, arch_1.Success)(registryPacked);
+    }
+    async write(schema, sortedEntities) {
+        try {
+            const client = await this.openTransaction();
+            const repository = client.getRepository(schema);
+            sortedEntities.forEach(async (sortedEntity) => {
+                if (arch_1.Guardian.isUndefined(sortedEntity.toPersist) ||
+                    arch_1.Guardian.isUndefined(sortedEntity.id)) {
+                    return (0, arch_1.Failure)();
+                }
+                const registryPacked = (0, arch_1.Optional)(await repository.findOne({
+                    where: { id: sortedEntity.id.toString() },
+                }));
+                if (registryPacked.hasNothing()) {
+                    await repository.save(sortedEntity.toPersist());
+                }
+                else {
+                    await repository.update({ id: sortedEntity.id.toString() }, sortedEntity.toPersist());
+                }
+            });
+            await this.commit();
+            return (0, arch_1.Success)();
+        }
+        catch {
+            await this.rollback();
+            return (0, arch_1.Failure)();
+        }
+    }
+    async delete(entity, condition) {
+        const client = await this.openTransaction();
+        const repository = client.getRepository(entity);
+        const registryPacked = (0, arch_1.Optional)(await repository.find({ where: condition }));
+        if (registryPacked.hasNothing()) {
+            return (0, arch_1.Failure)();
+        }
+        repository.delete(condition);
+        return (0, arch_1.Success)();
+    }
+    getManager() {
+        if (this.database.hasNothing()) {
+            return (0, arch_1.Failure)(new database_helper_abstract_get_manager_failure_1.DatabaseHelperAbstractGetManagerFailure());
+        }
+        return (0, arch_1.Success)(this.database.unpack().manager);
+    }
+    async openTransaction() {
+        if (this.queryRunner.hasNothing()) {
+            this.queryRunner = (0, arch_1.Optional)(this.database.unpack().createQueryRunner());
+            await this.queryRunner.unpack().connect();
+            await this.queryRunner.unpack().startTransaction();
+        }
+        return this.queryRunner.unpack().manager;
+    }
+    async commit() {
+        if (this.queryRunner.hasNothing()) {
+            return (0, arch_1.Failure)(new database_helper_abstract_commit_failure_1.DatabaseHelperAbstractCommitFailure());
+        }
+        await this.queryRunner.unpack().commitTransaction();
+        await this.queryRunner.unpack().release();
+        this.queryRunner = arch_1.Nothing;
+        return (0, arch_1.Success)();
+    }
+    async rollback() {
+        if (this.queryRunner.hasNothing()) {
+            return (0, arch_1.Failure)(new database_helper_abstract_rollback_failure_1.DatabaseHelperAbstractRollbackFailure());
+        }
+        await this.queryRunner.unpack().rollbackTransaction();
+        await this.queryRunner.unpack().release();
+        this.queryRunner = arch_1.Nothing;
+        return (0, arch_1.Success)();
+    }
+}
+exports.DatabaseHelperAbstract = DatabaseHelperAbstract;

package/backend/application/databases/database.helper.abstract.rollback.failure.d.ts

@@ -0,0 +1,4 @@
+import { FailureAbstract } from "@atlantjs/arch";
+export declare class DatabaseHelperAbstractRollbackFailure extends FailureAbstract {
+    constructor(error?: any);
+}

package/backend/application/databases/database.helper.abstract.rollback.failure.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseHelperAbstractRollbackFailure = void 0;
+const arch_1 = require("@atlantjs/arch");
+class DatabaseHelperAbstractRollbackFailure extends arch_1.FailureAbstract {
+    constructor(error) {
+        super({
+            className: DatabaseHelperAbstractRollbackFailure.name,
+            message: "Transaction is not open. Run '.openTransaction()' before commit",
+            error,
+        });
+    }
+}
+exports.DatabaseHelperAbstractRollbackFailure = DatabaseHelperAbstractRollbackFailure;

package/{setup → backend/application}/env/env-vars.d.ts

@@ -1,7 +1,4 @@
-import { NodeEnvs } from "@atlantjs/arch";
-export declare const ENVIRONMENT: NodeEnvs;
 export declare const IAM_MOVINGAPP_REALM_PUBLIC_KEY_RS256: string | undefined;
 export declare const APP_PORT: number;
 export declare const LOAD_MODULES: string[];
 export declare const CORS_ALLOWED_ORIGINS: string;
-export declare const isProdOrHomolog: () => boolean;

package/{setup → backend/application}/env/env-vars.js

@@ -3,18 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isProdOrHomolog = exports.CORS_ALLOWED_ORIGINS = exports.LOAD_MODULES = exports.APP_PORT = exports.IAM_MOVINGAPP_REALM_PUBLIC_KEY_RS256 = exports.ENVIRONMENT = void 0;
-const arch_1 = require("@atlantjs/arch");
+exports.CORS_ALLOWED_ORIGINS = exports.LOAD_MODULES = exports.APP_PORT = exports.IAM_MOVINGAPP_REALM_PUBLIC_KEY_RS256 = void 0;
 const env_var_1 = __importDefault(require("env-var"));
-exports.ENVIRONMENT = env_var_1.default
-    .get("ENVIRONMENT")
-    .required()
-    .asEnum([
-    arch_1.NodeEnvs.test,
-    arch_1.NodeEnvs.development,
-    arch_1.NodeEnvs.production,
-    arch_1.NodeEnvs.homolog,
-]);
 exports.IAM_MOVINGAPP_REALM_PUBLIC_KEY_RS256 = env_var_1.default
     .get("KEYCLOAK_MOVINGAPP_REALM_PUBLIC_KEY_RS256")
     .asString();
@@ -24,5 +14,3 @@ exports.CORS_ALLOWED_ORIGINS = env_var_1.default
     .get("CORS_ALLOWED_ORIGINS")
     .default("*")
     .asString();
-const isProdOrHomolog = () => [arch_1.NodeEnvs.homolog, arch_1.NodeEnvs.production].includes(exports.ENVIRONMENT);
-exports.isProdOrHomolog = isProdOrHomolog;

package/backend/application/injections.abstract.d.ts

@@ -0,0 +1,11 @@
+import { Injections } from "./injections.abstract.type";
+export declare abstract class InjectionsAbstract {
+    protected abstract _injections: Injections;
+    constructor();
+    private injectControllers;
+    private injectMiddlewares;
+    private injectUsecases;
+    private injectServices;
+    private injectRepositories;
+    private injectProviders;
+}

package/backend/application/injections.abstract.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectionsAbstract = void 0;
+const dependency_injections_1 = require("../../setup/dependency-injections");
+class InjectionsAbstract {
+    constructor() {
+        this.injectControllers();
+        this.injectMiddlewares();
+        this.injectUsecases();
+        this.injectServices();
+        this.injectRepositories();
+        this.injectProviders();
+    }
+    injectControllers() {
+        this._injections.controllers?.map((controller) => {
+            dependency_injections_1.diContainer.bind(controller).toSelf();
+        });
+    }
+    injectMiddlewares() {
+        this._injections.middlewares?.map((middleware) => {
+            dependency_injections_1.diContainer.bind(middleware).toSelf();
+        });
+    }
+    injectUsecases() {
+        this._injections.usecases?.map((usecase) => {
+            dependency_injections_1.diContainer.bind(usecase.ref).to(usecase.target);
+        });
+    }
+    injectServices() {
+        this._injections.services?.map((service) => {
+            dependency_injections_1.diContainer.bind(service.ref).to(service.target);
+        });
+    }
+    injectRepositories() {
+        this._injections.repositories?.map((repository) => {
+            dependency_injections_1.diContainer.bind(repository.ref).to(repository.target);
+        });
+    }
+    injectProviders() {
+        this._injections.providers?.map((provider) => {
+            dependency_injections_1.diContainer.bind(provider.ref).to(provider.target);
+        });
+    }
+}
+exports.InjectionsAbstract = InjectionsAbstract;

package/backend/application/injections.abstract.type.d.ts

@@ -0,0 +1,21 @@
+import { Newable } from "@atlantjs/arch";
+import { interfaces } from "inversify";
+import { ControllerAbstract } from "../infrastructure/controllers/controller.abstract";
+import { MiddlewareHandlerAbstract } from "../domain/middlewares/middleware.handler.abstract";
+import { RepositoryAbstract } from "../domain/repositories/repository.abstract";
+import { ServiceAbstract } from "../domain/services/service.abstract";
+import { UsecaseAbstract } from "../domain/usecases/usecase.abstract";
+type ServiceIdentifier<T> = interfaces.ServiceIdentifier<T>;
+interface BindTo<T> {
+    ref: ServiceIdentifier<unknown>;
+    target: Newable<T>;
+}
+export interface Injections {
+    controllers?: ServiceIdentifier<ControllerAbstract>[];
+    middlewares?: ServiceIdentifier<MiddlewareHandlerAbstract>[];
+    usecases?: BindTo<UsecaseAbstract>[];
+    services?: BindTo<ServiceAbstract>[];
+    repositories?: BindTo<RepositoryAbstract>[];
+    providers?: BindTo<RepositoryAbstract>[];
+}
+export {};

package/backend/application/injections.abstract.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/backend/domain/entities/entity-backend.abstract.d.ts

@@ -0,0 +1,9 @@
+import { SchemaAbstract } from "../../infrastructure/repositories/schemas/schema.abstract";
+import { UuidAbstract } from "@atlantjs/arch";
+import { SolidAbstract } from "@atlantjs/arch/arch/modules/domain/entities/solid.abstract";
+export declare abstract class EntityAbstract extends SolidAbstract {
+    protected _id: UuidAbstract;
+    constructor(_id: UuidAbstract);
+    abstract get id(): UuidAbstract;
+    abstract toPersist(): SchemaAbstract;
+}

package/backend/domain/entities/entity-backend.abstract.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityAbstract = void 0;
+const solid_abstract_1 = require("@atlantjs/arch/arch/modules/domain/entities/solid.abstract");
+class EntityAbstract extends solid_abstract_1.SolidAbstract {
+    constructor(_id) {
+        super();
+        this._id = _id;
+    }
+}
+exports.EntityAbstract = EntityAbstract;

package/backend/domain/middlewares/middleware.handler.abstract.d.ts

@@ -0,0 +1,4 @@
+import { Return } from "@atlantjs/arch";
+export declare abstract class MiddlewareHandlerAbstract {
+    protected abstract use(...args: unknown[]): Promise<Return<any, any>>;
+}

package/backend/domain/middlewares/middleware.handler.abstract.js

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

package/backend/domain/providers/provider.abstract.d.ts

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

package/backend/domain/providers/provider.abstract.js

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

package/backend/domain/repositories/repository.abstract.d.ts

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

package/backend/domain/repositories/repository.abstract.js

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

package/backend/domain/services/service.abstract.d.ts

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

package/backend/domain/services/service.abstract.js

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

package/backend/domain/usecases/usecase.abstract.d.ts

@@ -0,0 +1,4 @@
+import { Return } from "@atlantjs/arch";
+export declare abstract class UsecaseAbstract {
+    abstract execute(...args: unknown[]): Promise<Return<unknown, unknown>>;
+}

package/backend/domain/usecases/usecase.abstract.js

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

package/backend/infrastructure/controllers/controller.abstract.d.ts

@@ -0,0 +1,8 @@
+import { ResponseAbstract } from "./responses/response.abstract";
+import { HttpStatusCodes, FailureAbstract } from "@atlantjs/arch";
+import { Response } from "express";
+export declare abstract class ControllerAbstract {
+    abstract handler(response: Response, ...args: unknown[]): Promise<Response>;
+    protected onSuccess<Payload extends ResponseAbstract>(response: Response, payload?: Payload, httpStatusCode?: HttpStatusCodes): Response;
+    protected onFailure(response: Response, failure: FailureAbstract, httpStatusCode?: HttpStatusCodes): Response;
+}

package/backend/infrastructure/controllers/controller.abstract.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControllerAbstract = void 0;
+const arch_1 = require("@atlantjs/arch");
+class ControllerAbstract {
+    onSuccess(response, payload, httpStatusCode = arch_1.HttpStatusCodes.OK) {
+        return response.status(httpStatusCode).send(payload?.toPlain() ?? {});
+    }
+    onFailure(response, failure, httpStatusCode = arch_1.HttpStatusCodes.BAD_REQUEST) {
+        return response.status(httpStatusCode).send(failure.toPlain());
+    }
+}
+exports.ControllerAbstract = ControllerAbstract;

package/backend/infrastructure/controllers/payloads/payload.abstract.d.ts

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

package/backend/infrastructure/controllers/payloads/payload.abstract.js

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

package/backend/infrastructure/controllers/payloads/validators/validator.abstract.d.ts

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

package/backend/infrastructure/controllers/payloads/validators/validator.abstract.js

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

package/backend/infrastructure/controllers/responses/response.abstract.d.ts

@@ -0,0 +1,4 @@
+import { ObjectType } from "@atlantjs/arch";
+export declare abstract class ResponseAbstract {
+    abstract toPlain(): ObjectType;
+}

package/backend/infrastructure/controllers/responses/response.abstract.js

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

package/backend/infrastructure/repositories/schemas/schema.abstract.d.ts

@@ -0,0 +1,7 @@
+import { BaseEntity } from "typeorm";
+export declare abstract class SchemaAbstract extends BaseEntity {
+    createdAt: Date;
+    updatedAt: Date;
+    protected beforeInsert(): void;
+    protected beforeUpdate(): void;
+}

package/backend/infrastructure/repositories/schemas/schema.abstract.js

@@ -0,0 +1,43 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaAbstract = void 0;
+const typeorm_1 = require("typeorm");
+class SchemaAbstract extends typeorm_1.BaseEntity {
+    beforeInsert() {
+        this.createdAt = new Date(Date.now());
+        this.updatedAt = new Date(Date.now());
+    }
+    beforeUpdate() {
+        this.updatedAt = new Date(Date.now());
+    }
+}
+exports.SchemaAbstract = SchemaAbstract;
+__decorate([
+    (0, typeorm_1.Column)({ name: "createdAt", type: "date" }),
+    __metadata("design:type", Date)
+], SchemaAbstract.prototype, "createdAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: "updatedAt", type: "date" }),
+    __metadata("design:type", Date)
+], SchemaAbstract.prototype, "updatedAt", void 0);
+__decorate([
+    (0, typeorm_1.BeforeInsert)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], SchemaAbstract.prototype, "beforeInsert", null);
+__decorate([
+    (0, typeorm_1.BeforeUpdate)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], SchemaAbstract.prototype, "beforeUpdate", null);

package/index.d.ts

@@ -1,3 +1,24 @@
-export { ENVIRONMENT, IAM_MOVINGAPP_REALM_PUBLIC_KEY_RS256, APP_PORT, LOAD_MODULES, CORS_ALLOWED_ORIGINS, isProdOrHomolog, } from "./setup/env/env-vars";
+export { DatabaseConfigAbstract } from "./backend/application/databases/database.config";
+export { DatabaseHelperAbstract } from "./backend/application/databases/database.helper.abstract";
+export { IAM_MOVINGAPP_REALM_PUBLIC_KEY_RS256, APP_PORT, LOAD_MODULES, CORS_ALLOWED_ORIGINS, } from "./backend/application/env/env-vars";
+export { InjectionsAbstract } from "./backend/application/injections.abstract";
+export { EntityAbstract } from "./backend/domain/entities/entity-backend.abstract";
+export { MiddlewareHandlerAbstract } from "./backend/domain/middlewares/middleware.handler.abstract";
+export { ProviderAbstract } from "./backend/domain/providers/provider.abstract";
+export { RepositoryAbstract } from "./backend/domain/repositories/repository.abstract";
+export { ServiceAbstract } from "./backend/domain/services/service.abstract";
+export { UsecaseAbstract } from "./backend/domain/usecases/usecase.abstract";
+export { ControllerAbstract } from "./backend/infrastructure/controllers/controller.abstract";
+export { PayloadAbstract } from "./backend/infrastructure/controllers/payloads/payload.abstract";
+export { ValidatorAbstract } from "./backend/infrastructure/controllers/payloads/validators/validator.abstract";
+export { ResponseAbstract } from "./backend/infrastructure/controllers/responses/response.abstract";
+export { SchemaAbstract } from "./backend/infrastructure/repositories/schemas/schema.abstract";
+export { startContainer, diContainer } from "./setup/dependency-injections";
+export { DefaultContainer } from "./setup/dependency-injections/default-container";
+export { DiContainerAbstract } from "./setup/dependency-injections/di-container.abstract";
+export { BodyParserMiddleware } from "./setup/server/body-parser-middleware";
+export { CorsMiddleware } from "./setup/server/cors-middleware";
+export { DefaultErrorHandlerMiddleware } from "./setup/server/default-error-handler-middleware";
+export { Server } from "http";
+export { Container } from "inversify";
 export { initializeApi, synthesizePaths } from "./setup";
-export { diContainer } from "./setup/dependency-injections";