@aceitadev/adatabase 0.5.0 → 0.5.6

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,31 +14,52 @@ 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* () {
-            Logger_1.Logger.schemaLog("Synchronizing database schema...");
+            this.changes.clear();
             for (const model of this.models) {
                 const table = (0, Table_1.getTableName)(model);
                 if (!table)
                     continue;
-                Logger_1.Logger.schemaLog("", { table: table, status: "started" });
-                const { columns, indexes } = this.getSchemaFromModel(model);
+                const { columns, indexes, primaryKey } = this.getSchemaFromModel(model);
                 const existing = yield this.getExistingColumns(table);
                 if (Object.keys(existing).length === 0) {
                     yield this.createTable(table, columns, indexes);
                 }
                 else {
-                    yield this.updateTable(table, columns, indexes, existing);
+                    yield this.updateTable(table, columns, indexes, existing, primaryKey);
                 }
             }
+            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) {
@@ -53,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: table, status: "created" });
+                const columnChanges = Object.keys(columns).map(col => `+ ${col} (adicionado)`);
+                this.changes.set(table, columnChanges);
             }
             finally {
                 conn.release();
@@ -73,39 +95,59 @@ class SchemaManager {
             }
         });
     }
-    updateTable(table, desired, indexes, existing) {
+    updateTable(table, desired, indexes, existing, primaryKey) {
         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)) {
+                    // Se a coluna for a chave primária, pule a verificação para evitar o erro.
+                    if (col === primaryKey) {
+                        continue;
+                    }
+                    if (!existing.hasOwnProperty(col)) {
+                        const sql = `ALTER TABLE \`${table}\` ADD COLUMN \`${col}\` ${type};`;
                         yield (0, Database_1.execute)(sql, [], conn);
-                        Logger_1.Logger.schemaLog("", { 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]);
+                        // Compara apenas o tipo base, ignorando extras como NOT NULL
+                        const desiredType = normalize(type.split(' ')[0]);
+                        if (existingType !== desiredType) {
+                            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();
             }
         });
     }
     getSchemaFromModel(model) {
         const columns = {};
         const indexes = [];
+        let primaryKey = null;
         const colMeta = (0, Column_1.getColumnMeta)(model);
         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 };
+            return { columns, indexes, primaryKey };
         }
         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) {
+                primaryKey = colName;
                 const type = opts.type || Number;
                 if (adapter.type === 'postgres') {
                     columns[colName] = "SERIAL PRIMARY KEY";
@@ -117,7 +159,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);
@@ -129,7 +170,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);
@@ -145,11 +186,11 @@ 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;
         }
-        return { columns, indexes };
+        return { columns, indexes, primaryKey };
     }
     getSqlTypeForClass(type) {
         const adapterType = (0, Database_1.getAdapter)().type;
@@ -178,25 +219,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.5.0",
+    "version": "0.5.6",
     "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",