@aceitadev/adatabase 0.4.5 → 0.5.5

package/dist/Logger.js

@@ -19,30 +19,25 @@ class Logger {
         }
     }
     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})`;
+        const PREFIX = `[aDatabase]`;
+        if (details && details.table && !details.column) {
+            if (details.status === 'started') {
+                process.stdout.write(`${PREFIX} Synchronizing table '${details.table}'...`);
+            }
+            else if (details.status === 'created') {
+                process.stdout.write(` Done.
+`);
             }
         }
-        if (details.column) {
-            logOutput += `
- `;
-            logOutput += `
-  \_ Column '${details.column}'`;
-            if (details.status) {
-                logOutput += ` (${details.status})`;
+        else if (details && details.table && details.column) {
+            if (details.status === 'added') {
+                console.log(`
+${PREFIX} Column '${details.column}' added to table '${details.table}'.`);
             }
         }
-        console.log(`${logOutput}`); // Green for schema logs
+        else {
+            console.log(`${PREFIX} ${message}`);
+        }
     }
 }
 exports.Logger = Logger;

package/dist/SchemaManager.d.ts

@@ -1,7 +1,9 @@
 export declare class SchemaManager {
     private models;
+    private changes;
     constructor(models: Function[]);
     migrate(): Promise<void>;
+    private printMigrationSummary;
     private createTable;
     private updateTable;
     private getSchemaFromModel;

package/dist/SchemaManager.js

@@ -14,21 +14,21 @@ 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) {
+        this.changes = new Map();
         this.models = models;
     }
     migrate() {
         return __awaiter(this, void 0, void 0, function* () {
+            this.changes.clear();
             for (const model of this.models) {
                 const table = (0, Table_1.getTableName)(model);
                 if (!table)
                     continue;
-                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) {
@@ -38,6 +38,28 @@ class SchemaManager {
                     yield this.updateTable(table, columns, indexes, existing);
                 }
             }
+            this.printMigrationSummary();
+        });
+    }
+    printMigrationSummary() {
+        if (this.changes.size === 0) {
+            return;
+        }
+        console.log("Schema atualizado:");
+        const tableEntries = Array.from(this.changes.entries());
+        tableEntries.forEach(([table, changes], tableIndex) => {
+            const isLastTable = tableIndex === tableEntries.length - 1;
+            const tablePrefix = isLastTable ? "└─" : "├─";
+            if (tableIndex > 0) {
+                console.log("│");
+            }
+            console.log(`${tablePrefix} ${table}`);
+            changes.forEach((change, changeIndex) => {
+                const isLastChange = changeIndex === changes.length - 1;
+                const changeLinePrefix = isLastTable ? "  " : "│ ";
+                const changeConnector = isLastChange ? "└─" : "├─";
+                console.log(` ${changeLinePrefix}${changeConnector} ${change}`);
+            });
         });
     }
     createTable(table, columns, indexes) {
@@ -52,7 +74,8 @@ class SchemaManager {
             const conn = yield (0, Database_1.getConnection)();
             try {
                 yield (0, Database_1.execute)(sql, [], conn);
-                Logger_1.Logger.schemaLog("Table created", { table: table, status: "created" });
+                const columnChanges = Object.keys(columns).map(col => `+ ${col} (adicionado)`);
+                this.changes.set(table, columnChanges);
             }
             finally {
                 conn.release();
@@ -74,18 +97,34 @@ class SchemaManager {
     }
     updateTable(table, desired, indexes, existing) {
         return __awaiter(this, void 0, void 0, function* () {
-            for (const [col, type] of Object.entries(desired)) {
-                if (!existing.hasOwnProperty(col)) {
-                    const sql = `ALTER TABLE \`${table}\` ADD COLUMN \`${col}\` ${type};`;
-                    const conn = yield (0, Database_1.getConnection)();
-                    try {
+            const tableChanges = [];
+            const conn = yield (0, Database_1.getConnection)();
+            try {
+                for (const [col, type] of Object.entries(desired)) {
+                    if (!existing.hasOwnProperty(col)) {
+                        const sql = `ALTER TABLE \`${table}\` ADD COLUMN \`${col}\` ${type};`;
                         yield (0, Database_1.execute)(sql, [], conn);
-                        Logger_1.Logger.schemaLog("Column added", { table: table, column: col, status: "added" });
+                        tableChanges.push(`+ ${col} (adicionado)`);
                     }
-                    finally {
-                        conn.release();
+                    else {
+                        const normalize = (t) => t.toLowerCase().replace(/\s/g, '').replace('character varying', 'varchar');
+                        const existingType = normalize(existing[col]);
+                        const desiredType = normalize(type.split(' ')[0]);
+                        if (existingType !== desiredType) {
+                            // NOTE: Type modification is database-specific and can be risky.
+                            // This implementation assumes MySQL's MODIFY COLUMN syntax.
+                            const sql = `ALTER TABLE \`${table}\` MODIFY COLUMN \`${col}\` ${type};`;
+                            yield (0, Database_1.execute)(sql, [], conn);
+                            tableChanges.push(`~ ${col} (tipo alterado: ${existing[col].toUpperCase()} → ${type.split(' ')[0].toUpperCase()})`);
+                        }
                     }
                 }
+                if (tableChanges.length > 0) {
+                    this.changes.set(table, tableChanges);
+                }
+            }
+            finally {
+                conn.release();
             }
         });
     }
@@ -96,15 +135,14 @@ class SchemaManager {
         const nullableMeta = (0, Nullable_1.getNullableMeta)(model);
         const adapter = (0, Database_1.getAdapter)();
         if (!colMeta) {
-            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()) {
-            const colName = opts && opts.name ? opts.name : camelToSnake(prop);
+            const colName = (opts === null || opts === void 0 ? void 0 : opts.name) ? opts.name : camelToSnake(prop);
             if (opts.index) {
                 indexes.push(colName);
             }
-            if (opts && opts.id) {
+            if (opts === null || opts === void 0 ? void 0 : opts.id) {
                 const type = opts.type || Number;
                 if (adapter.type === 'postgres') {
                     columns[colName] = "SERIAL PRIMARY KEY";
@@ -116,7 +154,6 @@ class SchemaManager {
             }
             const type = opts.type;
             if (!type) {
-                Logger_1.Logger.log(`Type not provided for property '${prop}' on model '${model.name}'.`, 'error');
                 continue;
             }
             let sqlType = this.getSqlTypeForClass(type);
@@ -128,7 +165,7 @@ class SchemaManager {
                     sqlType = 'DECIMAL(10, 2)';
                 }
             }
-            if (type === String && opts && opts.limit) {
+            else if (type === String && (opts === null || opts === void 0 ? void 0 : opts.limit)) {
                 sqlType = `VARCHAR(${opts.limit})`;
             }
             const isNullable = nullableMeta === null || nullableMeta === void 0 ? void 0 : nullableMeta.get(prop);
@@ -144,7 +181,7 @@ class SchemaManager {
                     sqlType += " DEFAULT CURRENT_TIMESTAMP";
                 }
             }
-            if (opts && opts.unique)
+            if (opts === null || opts === void 0 ? void 0 : opts.unique)
                 sqlType += " UNIQUE";
             columns[colName] = sqlType;
         }
@@ -177,25 +214,35 @@ class SchemaManager {
             try {
                 let sql;
                 if (adapter.type === 'postgres') {
-                    sql = `SELECT column_name, data_type FROM information_schema.columns WHERE table_schema = current_schema() AND table_name = ?`;
+                    sql = `SELECT column_name, udt_name || COALESCE('(' || character_maximum_length || ')', '') as column_type 
+                       FROM information_schema.columns 
+                       WHERE table_schema = current_schema() AND table_name = $1`;
                 }
                 else { // mysql
-                    sql = `SELECT COLUMN_NAME, DATA_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?`;
+                    sql = `SELECT COLUMN_NAME, COLUMN_TYPE 
+                       FROM INFORMATION_SCHEMA.COLUMNS 
+                       WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?`;
                 }
                 const rows = yield (0, Database_1.query)(sql, [table], conn);
+                if (rows.length === 0)
+                    return {};
                 if (adapter.type === 'postgres') {
                     for (const r of rows) {
-                        columns[r.column_name] = r.data_type;
+                        columns[r.column_name] = r.column_type;
                     }
                 }
                 else {
                     for (const r of rows) {
-                        columns[r.COLUMN_NAME] = r.DATA_TYPE;
+                        columns[r.COLUMN_NAME] = r.COLUMN_TYPE;
                     }
                 }
             }
+            catch (e) {
+                return {}; // Table likely does not exist
+            }
             finally {
-                conn.release();
+                if (conn)
+                    conn.release();
             }
             return columns;
         });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@aceitadev/adatabase",
-    "version": "0.4.5",
+    "version": "0.5.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",