@expressots/core 2.16.2 → 3.0.0-beta.3

package/lib/cjs/error/report.js

@@ -5,13 +5,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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.Report = void 0;
-const inversify_binding_decorators_1 = require("inversify-binding-decorators");
-const logger_provider_1 = require("../provider/logger/logger.provider");
+const inversify_1 = require("../di/inversify");
 const app_error_1 = require("./app-error");
 /**
  * Report class is a utility class to manage and log errors within the application.
@@ -20,7 +16,10 @@ const app_error_1 = require("./app-error");
  */
 let Report = class Report {
     constructor() {
-        this.logger = new logger_provider_1.Logger();
+        this.name = "Report Provider";
+        this.version = "3.0.0";
+        this.author = "Richard Zampieri";
+        this.repo = "https://github.com/expressots/expressots";
     }
     /**
      * The Error method is responsible for generating a standardized error object,
@@ -34,20 +33,30 @@ let Report = class Report {
      *
      * @throws An object of the custom type AppError, which includes details about the error.
      */
-    error(error, statusCode, service) {
-        let appError = {};
-        if (error instanceof Error) {
-            appError = new app_error_1.AppError(error.message, statusCode, service);
+    error(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    error, statusCode, service) {
+        let message = "";
+        if (error == null) {
+            // error is null or undefined
+            message = "";
+        }
+        else if (typeof error === "string") {
+            message = error;
+        }
+        else if (error instanceof Error) {
+            message = error.message;
+        }
+        else if (typeof error === "object" && "message" in error) {
+            message = error.message;
         }
         else {
-            appError = new app_error_1.AppError(error, statusCode, service);
+            message = String(error);
         }
-        this.logger.error(appError.message, appError.service || "service-undefined");
-        return appError;
+        return new app_error_1.AppError(message, statusCode, service);
     }
 };
 exports.Report = Report;
 exports.Report = Report = __decorate([
-    (0, inversify_binding_decorators_1.provide)(Report),
-    __metadata("design:paramtypes", [])
+    (0, inversify_1.injectable)()
 ], Report);

package/lib/cjs/index.js

@@ -15,11 +15,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./application"), exports);
-__exportStar(require("./common"), exports);
 __exportStar(require("./console"), exports);
 __exportStar(require("./container-module"), exports);
-__exportStar(require("./controller"), exports);
 __exportStar(require("./decorator"), exports);
 __exportStar(require("./error"), exports);
 __exportStar(require("./middleware"), exports);
 __exportStar(require("./provider"), exports);
+__exportStar(require("./di/inversify"), exports);

package/lib/cjs/middleware/middleware-interface.js

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

package/lib/cjs/middleware/middleware-service.js

@@ -1,35 +1,24 @@
 "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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Middleware = exports.ExpressoMiddleware = void 0;
-const express_1 = __importDefault(require("express"));
-const index_1 = require("../decorator/index");
+const express_1 = require("express");
 const error_handler_middleware_1 = __importDefault(require("../error/error-handler-middleware"));
 const logger_provider_1 = require("../provider/logger/logger.provider");
 const middleware_resolver_1 = require("./middleware-resolver");
-const inversify_binding_decorators_1 = require("inversify-binding-decorators");
 /**
  * Abstract class for creating custom Expresso middleware.
  * Custom middleware classes should extend this class and implement the use method.
  *
  */
-let ExpressoMiddleware = class ExpressoMiddleware {
+class ExpressoMiddleware {
     get name() {
         return this.constructor.name;
     }
-};
+}
 exports.ExpressoMiddleware = ExpressoMiddleware;
-exports.ExpressoMiddleware = ExpressoMiddleware = __decorate([
-    (0, inversify_binding_decorators_1.provide)(ExpressoMiddleware)
-], ExpressoMiddleware);
 /**
  * MiddlewareType Enum
  *
@@ -50,8 +39,9 @@ var MiddlewareType;
  * including adding Body Parser and retrieving all configured middlewares.
  *
  * @see IConfigure
+ * @public API
  */
-let Middleware = class Middleware {
+class Middleware {
     constructor() {
         this.middlewarePipeline = [];
         this.logger = new logger_provider_1.Logger();
@@ -60,7 +50,6 @@ let Middleware = class Middleware {
      * Retrieves the type of the middleware.
      *
      * @param middleware - The middleware to be checked.
-     *
      * @returns The type of the middleware.
      */
     getMiddlewareType(middleware) {
@@ -79,7 +68,6 @@ let Middleware = class Middleware {
      * Checks if a middleware with the given name exists in the middleware collection.
      *
      * @param middlewareName - The name of the middleware to be checked.
-     *
      * @returns A boolean value indicating whether the middleware exists or not.
      */
     middlewareExists(middlewareName) {
@@ -107,7 +95,7 @@ let Middleware = class Middleware {
         else {
             this.middlewarePipeline.push({
                 timestamp: new Date(),
-                middleware: express_1.default.urlencoded(options),
+                middleware: (0, express_1.urlencoded)(options),
             });
         }
     }
@@ -134,7 +122,7 @@ let Middleware = class Middleware {
         else {
             this.middlewarePipeline.push({
                 timestamp: new Date(),
-                middleware: express_1.default.json(options),
+                middleware: (0, express_1.json)(options),
             });
         }
     }
@@ -305,7 +293,7 @@ let Middleware = class Middleware {
         else {
             this.middlewarePipeline.push({
                 timestamp: new Date(),
-                middleware: express_1.default.static(root, options),
+                middleware: (0, express_1.static)(root, options),
             });
         }
     }
@@ -496,8 +484,5 @@ let Middleware = class Middleware {
     getErrorHandler() {
         return this.errorHandler;
     }
-};
+}
 exports.Middleware = Middleware;
-exports.Middleware = Middleware = __decorate([
-    (0, index_1.provideSingleton)(Middleware)
-], Middleware);

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

@@ -8,107 +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_binding_decorators_1 = require("inversify-binding-decorators");
-const db_in_memory_provider_1 = require("./db-in-memory.provider");
-const inversify_1 = require("inversify");
+const inversify_1 = require("../../di/inversify");
 /**
- * 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
  */
 let BaseRepository = class BaseRepository {
-    /**
-     * Constructor
-     * @param tableName - The name of the table to interact with.
-     *
-     */
-    constructor(tableName) {
-        this.tableName = tableName;
+    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_binding_decorators_1.provide)(BaseRepository),
-    __metadata("design:paramtypes", [String])
+    (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,77 +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;
-const inversify_1 = require("inversify");
+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
  */
-//@provideSingleton(InMemoryDB)
-let InMemoryDB = class InMemoryDB {
+let InMemoryDataProvider = class InMemoryDataProvider {
     constructor() {
-        this.name = "InMemoryDB";
-        this.version = "0.0.1";
+        this.name = "In Memory DB Provider";
+        this.version = "3.0.0";
         this.author = "Richard Zampieri";
-        this.repo = "internal";
-        this.tables = {};
+        this.repo = "https://github.com/expressots/expressots";
+        // 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.
-     */
     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.
-     */
-    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.
-     */
-    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/dto-validator/dto-validator.provider.js

@@ -3,20 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValidateDTO = ValidateDTO;
 require("reflect-metadata");
 const status_code_1 = require("../../error/status-code");
-const package_resolver_1 = require("../../common/package-resolver");
+const package_resolver_1 = require("./package-resolver");
 const logger_provider_1 = require("../logger/logger.provider");
 /**
  * Validate the DTO using class-validator and class-transformer.
  * @param type - The type of the DTO to validate.
  * @returns A RequestHandler function.
  * @throws An exception if the DTO is invalid.
- *
+ * @public API
  */
 function ValidateDTO(type) {
     return async (req, res, next) => {
         const logger = new logger_provider_1.Logger();
-        const classValidator = (0, package_resolver_1.packageResolver)("class-validator");
-        const classTransformer = (0, package_resolver_1.packageResolver)("class-transformer");
+        const classValidator = await (0, package_resolver_1.packageResolver)("class-validator");
+        const classTransformer = await (0, package_resolver_1.packageResolver)("class-transformer");
         if (!classValidator || !classTransformer) {
             return next();
         }

package/lib/cjs/provider/dto-validator/package-resolver.js

@@ -0,0 +1,56 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageResolver = packageResolver;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const logger_provider_1 = require("../logger/logger.provider");
+/**
+ * Resolve package from the current working directory.
+ * @param packageName
+ * @param options
+ * @returns
+ */
+async function packageResolver(packageName, ...options) {
+    const logger = new logger_provider_1.Logger();
+    try {
+        const hasPackage = require.resolve(packageName, {
+            paths: [process.cwd()],
+        });
+        if (hasPackage) {
+            const packageResolved = await Promise.resolve(`${hasPackage}`).then(s => __importStar(require(s)));
+            if (typeof packageResolved === "function") {
+                return packageResolved(...options);
+            }
+            if (packageResolved.default &&
+                typeof packageResolved.default === "function") {
+                return packageResolved.default(...options);
+            }
+            return packageResolved;
+        }
+    }
+    catch (error) {
+        logger.warn(`Package [${packageName}] not installed. Please install it using your package manager.`, "package-resolver");
+    }
+}