@expressots/core 3.0.0-beta.1 → 3.0.0-beta.3

package/lib/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [3.0.0-beta.3](https://github.com/expressots/expressots/compare/3.0.0-beta.1...3.0.0) (2024-11-28)
+
+### Features
+
+- implement in-memory data provider and repository interfaces ([09561fa](https://github.com/expressots/expressots/commit/09561fa1385e040bc235ba0d699f654f269c0a21))
+
+### Tests
+
+- add unit tests for insert, update, delete, and find methods in InMemoryDataTable ([a96f4a6](https://github.com/expressots/expressots/commit/a96f4a6076ca7aebbac853317006f67de5daf9d2))
+
 ## [3.0.0-beta.1](https://github.com/expressots/expressots/compare/2.16.2...2.17.0) (2024-11-17)
 
 ### Features

package/lib/cjs/di/annotation/injectable.js

@@ -32,6 +32,7 @@ const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
  * @public API
  */
 function injectable() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return function (target) {
         if (Reflect.hasOwnMetadata(METADATA_KEY.PARAM_TYPES, target)) {
             throw new Error(ERRORS_MSGS.DUPLICATED_INJECTABLE_DECORATOR);

package/lib/cjs/provider/db-in-memory/base-repo.repository.js

@@ -8,102 +8,48 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseRepository = void 0;
 const inversify_1 = require("../../di/inversify");
-const db_in_memory_provider_1 = require("./db-in-memory.provider");
 /**
- * Base Repository Class
- *
- * This class provides the basic functionalities to interact with an in-memory database.
- *
- * @decorator @provide(BaseRepository)
+ * Base repository class using the repository pattern.
+ * @template T - The type of entity to be stored in the repository.
+ * @public API
  */
-class BaseRepository {
-    /**
-     * Constructor
-     * @param tableName - The name of the table to interact with.
-     *
-     */
-    constructor(tableName) {
-        this.tableName = tableName;
+let BaseRepository = class BaseRepository {
+    constructor(dataProvider, tableName) {
+        this.dataTable = dataProvider.getTable(tableName);
+        this.entityName = tableName;
+    }
+    async create(item) {
+        return this.dataTable.insert(item);
     }
-    /**
-     * Getter for the table
-     * @returns {T[]} - An array of entities.
-     */
-    get table() {
-        return [...this.inMemoryDB.getTable(this.tableName)];
+    async update(item) {
+        return this.dataTable.update(item);
     }
-    /**
-     * create Method
-     * @param item - The entity to be created.
-     * @returns {T | null} - The created entity or null if the entity already exists.
-     * @throws {Error} - If the entity already exists.
-     */
-    create(item) {
-        const existingItem = this.table.find((i) => i.id === item.id);
-        if (existingItem) {
-            throw new Error(`Object with id ${item.id} already exists`);
-        }
-        this.inMemoryDB.getTable(this.tableName).push(item);
-        this.inMemoryDB.printTable(this.tableName);
-        return item;
+    async delete(id) {
+        return this.dataTable.delete(id);
     }
-    /**
-     * delete Method
-     * @param id - The id of the entity to be deleted.
-     * @returns {boolean} - True if the entity was deleted, false otherwise.
-     * @throws {Error} - If the entity does not exist.
-     */
-    delete(id) {
-        const db = this.inMemoryDB.getTable(this.tableName);
-        const index = db.findIndex((item) => item.id === id);
-        if (index !== -1) {
-            db.splice(index, 1);
-            this.inMemoryDB.printTable(this.tableName);
-            return true;
-        }
-        return false;
+    async find(id) {
+        return this.dataTable.find(id);
     }
-    /**
-     * update Method
-     * @param item - The entity to be updated.
-     * @returns {T | null} - The updated entity or null if the entity does not exist
-     * @throws {Error} - If the entity does not exist.
-     */
-    update(item) {
-        const db = this.inMemoryDB.getTable(this.tableName);
-        const index = db.findIndex((i) => i.id === item.id);
-        if (index !== -1) {
-            db[index] = item;
-            this.inMemoryDB.printTable(this.tableName);
-            return item;
-        }
-        return null;
+    async findAll() {
+        return this.dataTable.findAll();
     }
-    /**
-     * find Method
-     * @param id - The id of the entity to find.
-     * @returns {T | null} - The entity if it exists, null otherwise
-     * @throws {Error} - If the entity does not exist.
-     */
-    find(id) {
-        const item = this.table.find((item) => item.id === id);
-        this.inMemoryDB.printTable(this.tableName);
-        return item || null;
+    async query(predicate) {
+        return this.dataTable.query(predicate);
     }
-    /**
-     * findAll Method
-     * @returns {T[] | null} - An array of entities or null if the table is empty.
-     */
-    findAll() {
-        this.inMemoryDB.printTable(this.tableName);
-        return this.table;
+    async transaction(actions) {
+        await this.dataTable.transaction(actions);
     }
-}
+};
 exports.BaseRepository = BaseRepository;
-__decorate([
-    (0, inversify_1.inject)(db_in_memory_provider_1.InMemoryDB),
-    __metadata("design:type", db_in_memory_provider_1.InMemoryDB)
-], BaseRepository.prototype, "inMemoryDB", void 0);
+exports.BaseRepository = BaseRepository = __decorate([
+    (0, inversify_1.injectable)(),
+    __param(0, (0, inversify_1.inject)("IDataProvider")),
+    __param(1, (0, inversify_1.unmanaged)()),
+    __metadata("design:paramtypes", [Object, String])
+], BaseRepository);

package/lib/cjs/provider/db-in-memory/db-in-memory.interface.js

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

package/lib/cjs/provider/db-in-memory/db-in-memory.provider.js

@@ -6,80 +6,109 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InMemoryDB = void 0;
+exports.InMemoryDataTable = exports.InMemoryDataProvider = void 0;
 const inversify_1 = require("../../di/inversify");
+const db_in_memory_types_1 = require("./db-in-memory.types");
 /**
- * InMemoryDB Class
- *
- * This class and its methods offer functionalities to simulate an in-memory database.
- * It is particularly useful for developers starting with ExpressoTS without any database connection.
- *
- * @decorator @provideSingleton(InMemoryDB)
+ * In-memory data provider implementation.
  * @public API
  */
-let InMemoryDB = class InMemoryDB {
+let InMemoryDataProvider = class InMemoryDataProvider {
     constructor() {
         this.name = "In Memory DB Provider";
         this.version = "3.0.0";
         this.author = "Richard Zampieri";
         this.repo = "https://github.com/expressots/expressots";
-        this.tables = {};
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.tables = new Map();
     }
-    /**
-     * getTable Method
-     *
-     * Retrieves a table by its name from the in-memory database.
-     *
-     * @param tableName - The name of the table to retrieve.
-     * @returns {IEntity[]} - An array of entities.
-     * @public API
-     */
     getTable(tableName) {
-        if (!this.tables[tableName]) {
-            this.tables[tableName] = [];
+        if (!this.tables.has(tableName)) {
+            this.tables.set(tableName, new InMemoryDataTable(tableName));
         }
-        return this.tables[tableName];
+        return this.tables.get(tableName);
     }
-    /**
-     * showTables Method
-     *
-     * Prints a list of all tables in the in-memory database to the standard output.
-     * @public API
-     */
-    showTables() {
-        if (!this.tables) {
-            process.stdout.write("No tables exist.");
-            return;
+};
+exports.InMemoryDataProvider = InMemoryDataProvider;
+exports.InMemoryDataProvider = InMemoryDataProvider = __decorate([
+    (0, inversify_1.injectable)()
+], InMemoryDataProvider);
+/**
+ * In-memory data table implementation.
+ */
+class InMemoryDataTable {
+    constructor(tableName) {
+        this.items = new Map();
+        this.transactionStack = [];
+        this.tableName = tableName;
+    }
+    async insert(item) {
+        if (this.items.has(item.id)) {
+            throw new db_in_memory_types_1.EntityAlreadyExistsError(this.tableName, item.id);
         }
-        process.stdout.write("List of tables:");
-        for (const tableName in this.tables) {
-            process.stdout.write(`\n- ${tableName}`);
+        this.items.set(item.id, item);
+        return item;
+    }
+    async insertMany(items) {
+        const insertedItems = [];
+        for (const item of items) {
+            const insertedItem = await this.insert(item);
+            insertedItems.push(insertedItem);
         }
+        return insertedItems;
     }
-    /**
-     * printTable Method
-     *
-     * Prints all records in a specific table to the console.
-     * If the table doesn't exist or is empty, it notifies the user.
-     *
-     * @param tableName - The name of the table to print.
-     * @public API
-     */
-    printTable(tableName) {
-        if (!this.tables) {
-            process.stdout.write("No tables exist.");
-            return;
+    async update(item) {
+        if (!this.items.has(item.id)) {
+            throw new db_in_memory_types_1.EntityNotFoundError(this.tableName, item.id);
         }
-        const table = this.getTable(tableName);
-        if (table.length === 0) {
-            process.stdout.write(`Table '${tableName}' is empty.`);
-            return;
+        this.items.set(item.id, item);
+        return item;
+    }
+    async delete(id) {
+        if (!this.items.has(id)) {
+            throw new db_in_memory_types_1.EntityNotFoundError(this.tableName, id);
         }
-        process.stdout.write(`\nRecords in table '${tableName}':\n`);
-        console.table(table);
+        return this.items.delete(id);
     }
-};
-exports.InMemoryDB = InMemoryDB;
-exports.InMemoryDB = InMemoryDB = __decorate([
-    (0, inversify_1.injectable)()
-], InMemoryDB);
+    async find(id) {
+        const item = this.items.get(id);
+        if (!item) {
+            throw new db_in_memory_types_1.EntityNotFoundError(this.tableName, id);
+        }
+        return item;
+    }
+    async findAll() {
+        return Array.from(this.items.values());
+    }
+    async query(predicate) {
+        return Array.from(this.items.values()).filter(predicate);
+    }
+    async transaction(actions) {
+        this.beginTransaction();
+        try {
+            await actions();
+            this.commitTransaction();
+        }
+        catch (error) {
+            this.rollbackTransaction();
+            throw error;
+        }
+    }
+    beginTransaction() {
+        const snapshot = new Map(this.items);
+        this.transactionStack.push(snapshot);
+    }
+    commitTransaction() {
+        this.transactionStack.pop();
+    }
+    rollbackTransaction() {
+        const snapshot = this.transactionStack.pop();
+        if (snapshot) {
+            this.items = snapshot;
+        }
+        else {
+            throw new Error("No transaction to rollback.");
+        }
+    }
+}
+exports.InMemoryDataTable = InMemoryDataTable;

package/lib/cjs/provider/db-in-memory/db-in-memory.types.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityAlreadyExistsError = exports.EntityNotFoundError = void 0;
+/**
+ * Error thrown when an entity is not found.
+ * @public API
+ */
+class EntityNotFoundError extends Error {
+    constructor(entityName, id) {
+        super(`${entityName} with ID ${id} not found.`);
+        this.name = "EntityNotFoundError";
+    }
+}
+exports.EntityNotFoundError = EntityNotFoundError;
+/**
+ * Error thrown when an entity already exists.
+ * @public API
+ */
+class EntityAlreadyExistsError extends Error {
+    constructor(entityName, id) {
+        super(`${entityName} with ID ${id} already exists.`);
+        this.name = "EntityAlreadyExistsError";
+    }
+}
+exports.EntityAlreadyExistsError = EntityAlreadyExistsError;

package/lib/cjs/provider/db-in-memory/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseRepository = exports.EntityAlreadyExistsError = exports.EntityNotFoundError = exports.InMemoryDataTable = exports.InMemoryDataProvider = void 0;
+var db_in_memory_provider_1 = require("./db-in-memory.provider");
+Object.defineProperty(exports, "InMemoryDataProvider", { enumerable: true, get: function () { return db_in_memory_provider_1.InMemoryDataProvider; } });
+Object.defineProperty(exports, "InMemoryDataTable", { enumerable: true, get: function () { return db_in_memory_provider_1.InMemoryDataTable; } });
+var db_in_memory_types_1 = require("./db-in-memory.types");
+Object.defineProperty(exports, "EntityNotFoundError", { enumerable: true, get: function () { return db_in_memory_types_1.EntityNotFoundError; } });
+Object.defineProperty(exports, "EntityAlreadyExistsError", { enumerable: true, get: function () { return db_in_memory_types_1.EntityAlreadyExistsError; } });
+var base_repo_repository_1 = require("./base-repo.repository");
+Object.defineProperty(exports, "BaseRepository", { enumerable: true, get: function () { return base_repo_repository_1.BaseRepository; } });

package/lib/cjs/provider/index.js

@@ -1,6 +1,20 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseRepository = exports.InMemoryDB = exports.ValidateDTO = exports.Env = exports.Logger = exports.ProviderManager = void 0;
+exports.ValidateDTO = exports.Env = exports.Logger = exports.ProviderManager = void 0;
 var provider_manager_1 = require("./provider-manager");
 Object.defineProperty(exports, "ProviderManager", { enumerable: true, get: function () { return provider_manager_1.ProviderManager; } });
 var logger_provider_1 = require("./logger/logger.provider");
@@ -9,7 +23,4 @@ var env_validator_provider_1 = require("./environment/env-validator.provider");
 Object.defineProperty(exports, "Env", { enumerable: true, get: function () { return env_validator_provider_1.EnvValidatorProvider; } });
 var dto_validator_provider_1 = require("./dto-validator/dto-validator.provider");
 Object.defineProperty(exports, "ValidateDTO", { enumerable: true, get: function () { return dto_validator_provider_1.ValidateDTO; } });
-var db_in_memory_provider_1 = require("./db-in-memory/db-in-memory.provider");
-Object.defineProperty(exports, "InMemoryDB", { enumerable: true, get: function () { return db_in_memory_provider_1.InMemoryDB; } });
-var base_repo_repository_1 = require("./db-in-memory/base-repo.repository");
-Object.defineProperty(exports, "BaseRepository", { enumerable: true, get: function () { return base_repo_repository_1.BaseRepository; } });
+__exportStar(require("./db-in-memory"), exports);

package/lib/cjs/provider/provider-manager.js

@@ -14,40 +14,79 @@ class ProviderManager {
     }
     /**
      * Register a provider with the container.
-     * @param serviceIdentifier - The service identifier for the provider.
-     * @param scope - The binding scope for the provider.
      * @public API
      */
-    register(serviceIdentifier, scope = inversify_1.BindingScopeEnum.Request) {
+    register(serviceIdentifier, constructorOrScope, scope = inversify_1.BindingScopeEnum.Request) {
         if (this.container.isBound(serviceIdentifier)) {
             this.logger.warn(`${serviceIdentifier.name} already registered`, "provider-manager");
             return;
         }
+        let binding;
+        if (typeof constructorOrScope === "function") {
+            // Overload where constructor is provided
+            const constructor = constructorOrScope;
+            const scopeDefinition = scope || inversify_1.BindingScopeEnum.Transient;
+            binding = this.container.bind(serviceIdentifier).to(constructor);
+            this.applyScope(binding, scopeDefinition);
+        }
+        else {
+            const scopeDefinition = constructorOrScope ||
+                inversify_1.BindingScopeEnum.Transient;
+            binding = this.container.bind(serviceIdentifier).toSelf();
+            this.applyScope(binding, scopeDefinition);
+        }
+    }
+    /**
+     * Get a provider from the container.
+     * @param serviceIdentifier - The service identifier to get from the container.
+     * @returns An instance of the provider.
+     * @public API
+     */
+    get(serviceIdentifier) {
+        if (!this.container.isBound(serviceIdentifier)) {
+            this.logger.error(`${this.getServiceIdentifierName(serviceIdentifier)} not registered`, "ProviderManager");
+            throw new Error(`Provider ${this.getServiceIdentifierName(serviceIdentifier)} not registered`);
+        }
+        return this.container.get(serviceIdentifier);
+    }
+    /**
+     * Apply the scope to the binding.
+     * @param binding - The binding to apply the scope to.
+     * @param scope - The scope to apply.
+     * @private
+     */
+    applyScope(binding, scope) {
         switch (scope) {
             case inversify_1.BindingScopeEnum.Singleton:
-                this.container.bind(serviceIdentifier).toSelf().inSingletonScope();
-                break;
-            case inversify_1.BindingScopeEnum.Transient:
-                this.container.bind(serviceIdentifier).toSelf().inTransientScope();
+                binding.inSingletonScope();
                 break;
             case inversify_1.BindingScopeEnum.Request:
-                this.container.bind(serviceIdentifier).toSelf().inRequestScope();
+                binding.inRequestScope();
+                break;
+            case inversify_1.BindingScopeEnum.Transient:
+            default:
+                binding.inTransientScope();
                 break;
         }
     }
     /**
-     * Get a provider from the container.
-     * @param provider - The provider class to get from the container.
-     * @returns An instance of the provider.
-     * @public API
+     * Get the name of the service identifier for logging purposes.
+     * @param serviceIdentifier - The service identifier.
+     * @returns The name of the service identifier.
+     * @private
      */
-    get(provider) {
-        const serviceIdentifier = this.container.get(provider);
-        if (!serviceIdentifier) {
-            this.logger.error(`${provider.name} not registered`, "provider-manager");
-            throw new Error(`Provider ${provider.name} not registered`);
+    getServiceIdentifierName(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    serviceIdentifier) {
+        if (typeof serviceIdentifier === "function") {
+            return serviceIdentifier.name;
+        }
+        else if (typeof serviceIdentifier === "symbol") {
+            return serviceIdentifier.toString();
+        }
+        else {
+            return serviceIdentifier;
         }
-        return serviceIdentifier;
     }
 }
 exports.ProviderManager = ProviderManager;

package/lib/cjs/types/di/annotation/injectable.d.ts

@@ -3,5 +3,5 @@
  * @returns A decorator function
  * @public API
  */
-declare function injectable(): <T extends abstract new (...args: Array<unknown>) => unknown>(target: T) => T;
+declare function injectable(): <T extends abstract new (...args: any) => unknown>(target: T) => T;
 export { injectable };

package/lib/cjs/types/provider/db-in-memory/base-repo.repository.d.ts

@@ -1,63 +1,18 @@
-import { IMemoryDBEntity } from "./db-in-memory.provider";
-export interface IBaseRepository<T extends IMemoryDBEntity> {
-    create(item: T): T | null;
-    update(item: T): T | null;
-    delete(id: string): boolean;
-    find(id: string): T | null;
-    findAll(): Array<T> | null;
-}
+import { IDataProvider, IDataTable, IEntity, IRepository } from "./db-in-memory.interface";
 /**
- * Base Repository Class
- *
- * This class provides the basic functionalities to interact with an in-memory database.
- *
- * @decorator @provide(BaseRepository)
+ * Base repository class using the repository pattern.
+ * @template T - The type of entity to be stored in the repository.
+ * @public API
  */
-export declare class BaseRepository<T extends IMemoryDBEntity> implements IBaseRepository<T> {
-    private inMemoryDB;
-    private tableName;
-    /**
-     * Constructor
-     * @param tableName - The name of the table to interact with.
-     *
-     */
-    constructor(tableName: string);
-    /**
-     * Getter for the table
-     * @returns {T[]} - An array of entities.
-     */
-    protected get table(): Array<T>;
-    /**
-     * create Method
-     * @param item - The entity to be created.
-     * @returns {T | null} - The created entity or null if the entity already exists.
-     * @throws {Error} - If the entity already exists.
-     */
-    create(item: T): T | null;
-    /**
-     * delete Method
-     * @param id - The id of the entity to be deleted.
-     * @returns {boolean} - True if the entity was deleted, false otherwise.
-     * @throws {Error} - If the entity does not exist.
-     */
-    delete(id: string): boolean;
-    /**
-     * update Method
-     * @param item - The entity to be updated.
-     * @returns {T | null} - The updated entity or null if the entity does not exist
-     * @throws {Error} - If the entity does not exist.
-     */
-    update(item: T): T | null;
-    /**
-     * find Method
-     * @param id - The id of the entity to find.
-     * @returns {T | null} - The entity if it exists, null otherwise
-     * @throws {Error} - If the entity does not exist.
-     */
-    find(id: string): T | null;
-    /**
-     * findAll Method
-     * @returns {T[] | null} - An array of entities or null if the table is empty.
-     */
-    findAll(): Array<T> | null;
+export declare class BaseRepository<T extends IEntity> implements IRepository<T> {
+    protected dataTable: IDataTable<T>;
+    protected entityName: string;
+    constructor(dataProvider: IDataProvider, tableName: string);
+    create(item: T): Promise<T>;
+    update(item: T): Promise<T>;
+    delete(id: string): Promise<boolean>;
+    find(id: string): Promise<T>;
+    findAll(): Promise<Array<T>>;
+    query(predicate: (item: T) => boolean): Promise<Array<T>>;
+    transaction(actions: () => Promise<void>): Promise<void>;
 }

package/lib/cjs/types/provider/db-in-memory/db-in-memory.interface.d.ts

@@ -0,0 +1,43 @@
+import { IProvider } from "../provider-manager";
+export interface IEntity {
+    id?: string;
+}
+/**
+ * IRepository Interface
+ * Generic interface that defines the structure of a repository.
+ * @template T - The type of entity to be stored in the repository.
+ * @public API
+ */
+export interface IRepository<T extends IEntity> {
+    create(item: T): Promise<T>;
+    update(item: T): Promise<T>;
+    delete(id: string): Promise<boolean>;
+    find(id: string): Promise<T>;
+    findAll(): Promise<Array<T>>;
+    query(predicate: (item: T) => boolean): Promise<Array<T>>;
+    transaction(actions: () => Promise<void>): Promise<void>;
+}
+/**
+ * IDataTable Interface for CRUD operations
+ * Generic interface that defines the structure of a data table.
+ * @template T - The type of entity to be stored in the data table.
+ * @public API
+ */
+export interface IDataTable<T extends IEntity> {
+    insert(item: T): Promise<T>;
+    insertMany(items: Array<T>): Promise<Array<T>>;
+    update(item: T): Promise<T>;
+    delete(id: string): Promise<boolean>;
+    find(id: string): Promise<T>;
+    findAll(): Promise<Array<T>>;
+    query(predicate: (item: T) => boolean): Promise<Array<T>>;
+    transaction(actions: () => Promise<void>): Promise<void>;
+}
+/**
+ * IDataProvider Interface for obtaining data tables
+ * Generic interface that defines the structure of a data provider.
+ * @public API
+ */
+export interface IDataProvider extends IProvider {
+    getTable<T extends IEntity>(tableName: string): IDataTable<T>;
+}

package/lib/cjs/types/provider/db-in-memory/db-in-memory.provider.d.ts

@@ -1,47 +1,33 @@
-import { IProvider } from "../provider-manager";
-export interface IMemoryDBEntity {
-    id: string;
-}
+import { IDataProvider, IEntity, IDataTable } from "./db-in-memory.interface";
 /**
- * InMemoryDB Class
- *
- * This class and its methods offer functionalities to simulate an in-memory database.
- * It is particularly useful for developers starting with ExpressoTS without any database connection.
- *
- * @decorator @provideSingleton(InMemoryDB)
+ * In-memory data provider implementation.
  * @public API
  */
-export declare class InMemoryDB implements IProvider {
+export declare class InMemoryDataProvider implements IDataProvider {
     name: string;
     version: string;
     author: string;
     repo: string;
     private tables;
-    /**
-     * getTable Method
-     *
-     * Retrieves a table by its name from the in-memory database.
-     *
-     * @param tableName - The name of the table to retrieve.
-     * @returns {IEntity[]} - An array of entities.
-     * @public API
-     */
-    getTable(tableName: string): Array<IMemoryDBEntity>;
-    /**
-     * showTables Method
-     *
-     * Prints a list of all tables in the in-memory database to the standard output.
-     * @public API
-     */
-    showTables(): void;
-    /**
-     * printTable Method
-     *
-     * Prints all records in a specific table to the console.
-     * If the table doesn't exist or is empty, it notifies the user.
-     *
-     * @param tableName - The name of the table to print.
-     * @public API
-     */
-    printTable(tableName: string): void;
+    getTable<T extends IEntity>(tableName: string): IDataTable<T>;
+}
+/**
+ * In-memory data table implementation.
+ */
+export declare class InMemoryDataTable<T extends IEntity> implements IDataTable<T> {
+    private items;
+    private tableName;
+    private transactionStack;
+    constructor(tableName: string);
+    insert(item: T): Promise<T>;
+    insertMany(items: Array<T>): Promise<Array<T>>;
+    update(item: T): Promise<T>;
+    delete(id: string): Promise<boolean>;
+    find(id: string): Promise<T>;
+    findAll(): Promise<Array<T>>;
+    query(predicate: (item: T) => boolean): Promise<Array<T>>;
+    transaction(actions: () => Promise<void>): Promise<void>;
+    private beginTransaction;
+    private commitTransaction;
+    private rollbackTransaction;
 }

package/lib/cjs/types/provider/db-in-memory/db-in-memory.types.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Error thrown when an entity is not found.
+ * @public API
+ */
+export declare class EntityNotFoundError extends Error {
+    constructor(entityName: string, id: string);
+}
+/**
+ * Error thrown when an entity already exists.
+ * @public API
+ */
+export declare class EntityAlreadyExistsError extends Error {
+    constructor(entityName: string, id: string);
+}

package/lib/cjs/types/provider/db-in-memory/index.d.ts

@@ -0,0 +1,4 @@
+export { InMemoryDataProvider, InMemoryDataTable, } from "./db-in-memory.provider";
+export { EntityNotFoundError, EntityAlreadyExistsError, } from "./db-in-memory.types";
+export { BaseRepository } from "./base-repo.repository";
+export { IEntity, IRepository, IDataTable, IDataProvider, } from "./db-in-memory.interface";

package/lib/cjs/types/provider/index.d.ts

@@ -2,5 +2,4 @@ export { IProvider, ProviderManager } from "./provider-manager";
 export { Logger } from "./logger/logger.provider";
 export { EnvValidatorProvider as Env } from "./environment/env-validator.provider";
 export { ValidateDTO } from "./dto-validator/dto-validator.provider";
-export { InMemoryDB, IMemoryDBEntity, } from "./db-in-memory/db-in-memory.provider";
-export { BaseRepository, IBaseRepository, } from "./db-in-memory/base-repo.repository";
+export * from "./db-in-memory";

package/lib/cjs/types/provider/provider-manager.d.ts

@@ -9,7 +9,6 @@ export interface IProvider {
     author: string;
     repo: string;
 }
-type ClassType<T> = new () => T;
 /**
  * ProviderManager Class - A class for managing dependency injection providers.
  * @public API
@@ -19,18 +18,39 @@ export declare class ProviderManager {
     private logger;
     constructor(container: interfaces.Container);
     /**
-     * Register a provider with the container.
+     * Register a provider by binding it to itself with optional scope.
      * @param serviceIdentifier - The service identifier for the provider.
-     * @param scope - The binding scope for the provider.
+     * @param scope - The binding scope.
      * @public API
      */
-    register(serviceIdentifier: interfaces.ServiceIdentifier<unknown>, scope?: interfaces.BindingScope): void;
+    register<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, scope?: interfaces.BindingScope): void;
+    /**
+     * Overload: Register a provider by binding a service identifier to a specific implementation with optional scope.
+     * @param serviceIdentifier - The service identifier for the provider.
+     * @param constructor - The implementation class.
+     * @param scope - The binding scope.
+     * @public API
+     */
+    register<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, constructor: interfaces.Newable<T>, scope?: interfaces.BindingScope): void;
     /**
      * Get a provider from the container.
-     * @param provider - The provider class to get from the container.
+     * @param serviceIdentifier - The service identifier to get from the container.
      * @returns An instance of the provider.
      * @public API
      */
-    get<P>(provider: ClassType<P>): P;
+    get<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): T;
+    /**
+     * Apply the scope to the binding.
+     * @param binding - The binding to apply the scope to.
+     * @param scope - The scope to apply.
+     * @private
+     */
+    private applyScope;
+    /**
+     * Get the name of the service identifier for logging purposes.
+     * @param serviceIdentifier - The service identifier.
+     * @returns The name of the service identifier.
+     * @private
+     */
+    private getServiceIdentifierName;
 }
-export {};

package/lib/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expressots/core",
-  "version": "3.0.0-beta.1",
+  "version": "3.0.0-beta.3",
   "description": "Expressots - modern, fast, lightweight nodejs web framework (@core)",
   "author": "Richard Zampieri",
   "main": "./lib/cjs/index.js",
@@ -71,7 +71,7 @@
     "@codecov/vite-plugin": "^0.0.1-beta.5",
     "@commitlint/cli": "19.2.1",
     "@commitlint/config-conventional": "19.1.0",
-    "@expressots/shared": "0.2.0",
+    "@expressots/shared": "3.0.0-beta.3",
     "@release-it/conventional-changelog": "8.0.1",
     "@types/express": "4.17.21",
     "@types/jest": "^29.5.14",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expressots/core",
-  "version": "3.0.0-beta.1",
+  "version": "3.0.0-beta.3",
   "description": "Expressots - modern, fast, lightweight nodejs web framework (@core)",
   "author": "Richard Zampieri",
   "main": "./lib/cjs/index.js",
@@ -71,7 +71,7 @@
     "@codecov/vite-plugin": "^0.0.1-beta.5",
     "@commitlint/cli": "19.2.1",
     "@commitlint/config-conventional": "19.1.0",
-    "@expressots/shared": "0.2.0",
+    "@expressots/shared": "3.0.0-beta.3",
     "@release-it/conventional-changelog": "8.0.1",
     "@types/express": "4.17.21",
     "@types/jest": "^29.5.14",