@atlantjs/backend 1.2.13 → 1.3.1

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

@@ -2,6 +2,7 @@ import { DataSource, DatabaseType } from "typeorm";
 interface DatabaseLiteConfigProps {
     type: DatabaseType;
     binaryFilePath: string;
+    accessKey: string;
     synchronize?: boolean;
     entities?: string[];
     migrations?: string[];

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

@@ -11,6 +11,10 @@ class DatabaseLiteConfigAbstract {
             type: this.props.type,
             database: this.props.binaryFilePath,
             synchronize: arch_1.Guardian.isFalsy((0, env_vars_1.isProdOrHomolog)()),
+            extra: {
+                cipher: "aes-256-cbc",
+                key: props.accessKey,
+            },
             entities: [`${__dirname}/../../../../../../**/*.schema{.ts,.js}`],
             migrations: ["./migrations/*.ts"],
         };

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

@@ -4,7 +4,7 @@ export declare abstract class InjectionsAbstract {
     constructor(_injections: Injections);
     private injectControllers;
     private injectMiddlewares;
-    private injectUsecases;
+    private injectCommands;
     private injectServices;
     private injectRepositories;
     private injectProviders;

package/backend/application/injections.abstract.js

@@ -7,7 +7,7 @@ class InjectionsAbstract {
         this._injections = _injections;
         this.injectControllers();
         this.injectMiddlewares();
-        this.injectUsecases();
+        this.injectCommands();
         this.injectServices();
         this.injectRepositories();
         this.injectProviders();
@@ -22,24 +22,24 @@ class InjectionsAbstract {
             dependency_injections_1.diContainer.bind(middleware).toSelf();
         });
     }
-    injectUsecases() {
-        this._injections.usecases?.map((usecase) => {
-            dependency_injections_1.diContainer.bind(usecase.ref).to(usecase.target);
+    injectCommands() {
+        this._injections.commands?.map((command) => {
+            dependency_injections_1.diContainer.bind(command.token).to(command.target);
         });
     }
     injectServices() {
         this._injections.services?.map((service) => {
-            dependency_injections_1.diContainer.bind(service.ref).to(service.target);
+            dependency_injections_1.diContainer.bind(service.token).to(service.target);
         });
     }
     injectRepositories() {
         this._injections.repositories?.map((repository) => {
-            dependency_injections_1.diContainer.bind(repository.ref).to(repository.target);
+            dependency_injections_1.diContainer.bind(repository.token).to(repository.target);
         });
     }
     injectProviders() {
         this._injections.providers?.map((provider) => {
-            dependency_injections_1.diContainer.bind(provider.ref).to(provider.target);
+            dependency_injections_1.diContainer.bind(provider.token).to(provider.target);
         });
     }
 }

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

@@ -7,13 +7,13 @@ import { ServiceAbstract } from "../domain/services/service.abstract";
 import { CommandAbstract } from "../domain/commands/command.abstract";
 type ServiceIdentifier<T> = interfaces.ServiceIdentifier<T>;
 interface BindTo<T> {
-    ref: ServiceIdentifier<unknown>;
+    token: ServiceIdentifier<unknown>;
     target: Newable<T>;
 }
 export interface Injections {
     controllers?: ServiceIdentifier<ControllerAbstract>[];
     middlewares?: ServiceIdentifier<MiddlewareHandlerAbstract>[];
-    usecases?: BindTo<CommandAbstract>[];
+    commands?: BindTo<CommandAbstract>[];
     services?: BindTo<ServiceAbstract>[];
     repositories?: BindTo<RepositoryAbstract>[];
     providers?: BindTo<RepositoryAbstract>[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlantjs/backend",
-	"version": "1.2.13",
+	"version": "1.3.1",
 	"main": "index.js",
 	"license": "UNLICENSED",
 	"publishConfig": {

package/setup/dependency-injections/di-container.abstract.d.ts

@@ -6,13 +6,13 @@ import { CommandAbstract } from "../../backend/domain/commands/command.abstract"
 import { ControllerAbstract } from "../../backend/infrastructure/controllers/controller.abstract";
 import { Newable } from "@atlantjs/arch";
 interface BindTo<T> {
-    ref: Symbol;
+    token: Symbol;
     target: Newable<T>;
 }
 interface Dependencies {
     controllers: ControllerAbstract[];
     middlewares: MiddlewareHandlerAbstract[];
-    usecases: BindTo<CommandAbstract>[];
+    commands: BindTo<CommandAbstract>[];
     repositories: BindTo<RepositoryAbstract>[];
     providers: BindTo<ProviderAbstract>[];
     services: BindTo<ServiceAbstract>[];
@@ -23,7 +23,7 @@ export declare abstract class DiContainerAbstract {
     private injectProviders;
     private injectServices;
     private injectRepositories;
-    private injectUsecases;
+    private injectCommands;
     private injectMiddlewares;
     private injectControllers;
 }

package/setup/dependency-injections/di-container.abstract.js

@@ -6,29 +6,29 @@ class DiContainerAbstract {
     constructor() {
         this.injectControllers();
         this.injectMiddlewares();
-        this.injectUsecases();
+        this.injectCommands();
         this.injectRepositories();
         this.injectServices();
         this.injectProviders();
     }
     injectProviders() {
         this.dependencies.providers.map((dependency) => {
-            di_container_1.diContainer.bind(dependency.ref.valueOf).to(dependency.target);
+            di_container_1.diContainer.bind(dependency.token.valueOf).to(dependency.target);
         });
     }
     injectServices() {
         this.dependencies.services.map((dependency) => {
-            di_container_1.diContainer.bind(dependency.ref.valueOf).to(dependency.target);
+            di_container_1.diContainer.bind(dependency.token.valueOf).to(dependency.target);
         });
     }
     injectRepositories() {
         this.dependencies.repositories.map((dependency) => {
-            di_container_1.diContainer.bind(dependency.ref.valueOf).to(dependency.target);
+            di_container_1.diContainer.bind(dependency.token.valueOf).to(dependency.target);
         });
     }
-    injectUsecases() {
-        this.dependencies.usecases.map((dependency) => {
-            di_container_1.diContainer.bind(dependency.ref.valueOf).to(dependency.target);
+    injectCommands() {
+        this.dependencies.commands.map((dependency) => {
+            di_container_1.diContainer.bind(dependency.token.valueOf).to(dependency.target);
         });
     }
     injectMiddlewares() {

package/setup/index.d.ts

@@ -6,7 +6,7 @@ import { DatabaseLiteConfigAbstract } from "../backend/application/databases/dat
 interface ServerProps {
     databases?: [
         {
-            ref: interfaces.ServiceIdentifier<unknown>;
+            token: interfaces.ServiceIdentifier<unknown>;
             target: InstanceType<typeof DatabaseHelperAbstract>;
             configs: Newable<DatabaseConfigAbstract | DatabaseLiteConfigAbstract>;
         }

package/setup/index.js

@@ -15,7 +15,7 @@ function initializeApi(props) {
         if (arch_1.Guardian.isNotUndefined(props.databases)) {
             Promise.all([
                 props.databases.map((database) => {
-                    dependency_injections_1.diContainer.bind(database.ref).toConstantValue(database.target);
+                    dependency_injections_1.diContainer.bind(database.token).toConstantValue(database.target);
                     database.target.connect(new database.configs());
                 }),
             ]);