@aceitadev/adatabase 0.4.0 → 0.4.5

package/dist/Logger.d.ts

@@ -0,0 +1,9 @@
+export declare class Logger {
+    private static readonly PREFIX;
+    static log(message: string, level?: 'info' | 'warn' | 'error'): void;
+    static schemaLog(message: string, details?: {
+        table?: string;
+        column?: string;
+        status?: string;
+    }): void;
+}

package/dist/Logger.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+class Logger {
+    static log(message, level = 'info') {
+        const timestamp = new Date().toISOString();
+        let formattedMessage = `${Logger.PREFIX} ${message}`;
+        switch (level) {
+            case 'warn':
+                console.warn(`${formattedMessage}`); // Yellow
+                break;
+            case 'error':
+                console.error(`${formattedMessage}`); // Red
+                break;
+            case 'info':
+            default:
+                console.log(`${formattedMessage}`); // Cyan
+                break;
+        }
+    }
+    static schemaLog(message, details) {
+        if (!details) {
+            Logger.log(message);
+            return;
+        }
+        let logOutput = `${Logger.PREFIX} ${message}`;
+        if (details.table) {
+            logOutput += `
+|`;
+            logOutput += `
+|–– Table '${details.table}'`;
+            if (details.status) {
+                logOutput += ` (${details.status})`;
+            }
+        }
+        if (details.column) {
+            logOutput += `
+ `;
+            logOutput += `
+  \_ Column '${details.column}'`;
+            if (details.status) {
+                logOutput += ` (${details.status})`;
+            }
+        }
+        console.log(`${logOutput}`); // Green for schema logs
+    }
+}
+exports.Logger = Logger;
+Logger.PREFIX = "[aDatabase]";

package/dist/SchemaManager.d.ts

@@ -1,7 +1,6 @@
 export declare class SchemaManager {
     private models;
-    private logger;
-    constructor(models: Function[], logger?: Console);
+    constructor(models: Function[]);
     migrate(): Promise<void>;
     private createTable;
     private updateTable;

package/dist/SchemaManager.js

@@ -14,13 +14,13 @@ const Table_1 = require("./decorators/Table");
 const Column_1 = require("./decorators/Column");
 const Nullable_1 = require("./decorators/Nullable");
 const Database_1 = require("./Database");
+const Logger_1 = require("./Logger");
 function camelToSnake(s) {
     return s.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
 }
 class SchemaManager {
-    constructor(models, logger = console) {
+    constructor(models) {
         this.models = models;
-        this.logger = logger;
     }
     migrate() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -28,7 +28,7 @@ class SchemaManager {
                 const table = (0, Table_1.getTableName)(model);
                 if (!table)
                     continue;
-                this.logger.log(`[aMySQL] Syncing model ${model.name} to table ${table}`);
+                Logger_1.Logger.schemaLog("Synchronizing database schema...", { table: table, status: "started" });
                 const { columns, indexes } = this.getSchemaFromModel(model);
                 const existing = yield this.getExistingColumns(table);
                 if (Object.keys(existing).length === 0) {
@@ -52,7 +52,7 @@ class SchemaManager {
             const conn = yield (0, Database_1.getConnection)();
             try {
                 yield (0, Database_1.execute)(sql, [], conn);
-                this.logger.log(`[aMySQL] Created table ${table}`);
+                Logger_1.Logger.schemaLog("Table created", { table: table, status: "created" });
             }
             finally {
                 conn.release();
@@ -80,7 +80,7 @@ class SchemaManager {
                     const conn = yield (0, Database_1.getConnection)();
                     try {
                         yield (0, Database_1.execute)(sql, [], conn);
-                        this.logger.log(`[aMySQL] Added column ${col} to ${table}`);
+                        Logger_1.Logger.schemaLog("Column added", { table: table, column: col, status: "added" });
                     }
                     finally {
                         conn.release();
@@ -96,7 +96,7 @@ class SchemaManager {
         const nullableMeta = (0, Nullable_1.getNullableMeta)(model);
         const adapter = (0, Database_1.getAdapter)();
         if (!colMeta) {
-            this.logger.warn(`[aMySQL] No @Column or @Id decorators found on model ${model.name}.`);
+            Logger_1.Logger.log(`No @Column or @Id decorators found on model ${model.name}.`, 'warn');
             return { columns, indexes };
         }
         for (const [prop, opts] of colMeta.entries()) {
@@ -116,7 +116,7 @@ class SchemaManager {
             }
             const type = opts.type;
             if (!type) {
-                this.logger.error(`[aMySQL] Type not provided for property '${prop}' on model '${model.name}'.`);
+                Logger_1.Logger.log(`Type not provided for property '${prop}' on model '${model.name}'.`, 'error');
                 continue;
             }
             let sqlType = this.getSqlTypeForClass(type);

package/dist/Security.d.ts

@@ -0,0 +1,4 @@
+export declare function validateOperator(operator: string): string;
+export declare function getAndValidateColumnName(prop: string, meta: Map<string, any>, modelName: string): string;
+export declare function sanitizeIntValue(value: any): number;
+export declare function validateDirectionValue(direction: string): 'ASC' | 'DESC';

package/dist/Security.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOperator = validateOperator;
+exports.getAndValidateColumnName = getAndValidateColumnName;
+exports.sanitizeIntValue = sanitizeIntValue;
+exports.validateDirectionValue = validateDirectionValue;
+const PersistenceException_1 = require("./PersistenceException");
+const util_1 = require("./util");
+const ALLOWED_OPERATORS = [
+    '=', '!=', '<>', '>', '<', '>=', '<=', 'LIKE', 'IN', 'IS NULL', 'IS NOT NULL', 'OR'
+];
+function validateOperator(operator) {
+    if (!ALLOWED_OPERATORS.includes(operator.toUpperCase())) {
+        throw new PersistenceException_1.PersistenceException(`Invalid operator used: ${operator}`, null);
+    }
+    return operator;
+}
+function getAndValidateColumnName(prop, meta, modelName) {
+    if (!meta.has(prop)) {
+        throw new PersistenceException_1.PersistenceException(`Property '${prop}' is not a mapped column on model '${modelName}'. It cannot be used in queries.`, null);
+    }
+    const opts = meta.get(prop);
+    return (opts === null || opts === void 0 ? void 0 : opts.name) ? opts.name : (0, util_1.camelToSnake)(prop);
+}
+function sanitizeIntValue(value) {
+    const intValue = parseInt(String(value), 10);
+    if (isNaN(intValue) || intValue < 0) {
+        throw new PersistenceException_1.PersistenceException(`Invalid value for LIMIT or OFFSET: ${value}`, null);
+    }
+    return intValue;
+}
+function validateDirectionValue(direction) {
+    const upperDir = direction.toUpperCase();
+    if (upperDir !== 'ASC' && upperDir !== 'DESC') {
+        throw new PersistenceException_1.PersistenceException(`Invalid ORDER BY direction: ${direction}`, null);
+    }
+    return upperDir;
+}

package/dist/util.d.ts

@@ -0,0 +1 @@
+export declare function camelToSnake(s: string): string;

package/dist/util.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.camelToSnake = camelToSnake;
+function camelToSnake(s) {
+    return s.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@aceitadev/adatabase",
-    "version": "0.4.0",
+    "version": "0.4.5",
     "description": "Uma biblioteca para facilitar a interação com bancos de dados MySQL e PostgreSQL em projetos TypeScript/Node.js.",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",