@aceitadev/adatabase 0.7.0 → 0.8.5

package/dist/SchemaManager.d.ts

@@ -6,6 +6,7 @@ export declare class SchemaManager {
     private printMigrationSummary;
     private createTable;
     private updateTable;
+    private getExistingConstraints;
     private getSchemaFromModel;
     private getSqlTypeForClass;
     private getExistingColumns;

package/dist/SchemaManager.js

@@ -13,6 +13,7 @@ exports.SchemaManager = void 0;
 const Table_1 = require("./decorators/Table");
 const Column_1 = require("./decorators/Column");
 const Nullable_1 = require("./decorators/Nullable");
+const BelongsTo_1 = require("./decorators/BelongsTo");
 const Database_1 = require("./Database");
 function camelToSnake(s) {
     return s.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
@@ -29,13 +30,14 @@ class SchemaManager {
                 const table = (0, Table_1.getTableName)(model);
                 if (!table)
                     continue;
-                const { columns, indexes, primaryKey } = this.getSchemaFromModel(model);
+                const { columns, indexes, primaryKey, foreignKeys } = this.getSchemaFromModel(model);
                 const existing = yield this.getExistingColumns(table);
                 if (Object.keys(existing).length === 0) {
-                    yield this.createTable(table, columns, indexes);
+                    yield this.createTable(table, columns, indexes, foreignKeys);
                 }
                 else {
-                    yield this.updateTable(table, columns, indexes, existing, primaryKey);
+                    const existingConstraints = yield this.getExistingConstraints(table);
+                    yield this.updateTable(table, columns, indexes, existing, primaryKey, foreignKeys, existingConstraints);
                 }
             }
             this.printMigrationSummary();
@@ -62,7 +64,7 @@ class SchemaManager {
             });
         });
     }
-    createTable(table, columns, indexes) {
+    createTable(table, columns, indexes, foreignKeys) {
         return __awaiter(this, void 0, void 0, function* () {
             const adapter = (0, Database_1.getAdapter)();
             const colsSql = Object.entries(columns).map(([k, v]) => `\`${k}\` ${v}`).join(", ");
@@ -70,12 +72,17 @@ class SchemaManager {
             if (adapter.type === 'mysql' && indexes.length > 0) {
                 indexSql = ", " + indexes.map(col => `INDEX \`${col}\` (\`${col}\`)`).join(", ");
             }
-            const sql = `CREATE TABLE \`${table}\` (${colsSql}${indexSql});`;
+            let fkSql = "";
+            if (foreignKeys.length > 0) {
+                fkSql = ", " + foreignKeys.map(fk => `CONSTRAINT \`${fk.constraintName}\` FOREIGN KEY (\`${fk.column}\`) REFERENCES \`${fk.referenceTable}\` (\`${fk.referenceColumn}\`)`).join(", ");
+            }
+            const sql = `CREATE TABLE \`${table}\` (${colsSql}${indexSql}${fkSql});`;
             const conn = yield (0, Database_1.getConnection)();
             try {
                 yield (0, Database_1.execute)(sql, [], conn);
-                const columnChanges = Object.keys(columns).map(col => `+ ${col} (adicionado)`);
-                this.changes.set(table, columnChanges);
+                const columnChanges = Object.keys(columns).map(col => `+ ${col} (added)`);
+                const fkChanges = foreignKeys.map(fk => `+ FK ${fk.constraintName} (added)`);
+                this.changes.set(table, [...columnChanges, ...fkChanges]);
             }
             finally {
                 conn.release();
@@ -95,7 +102,7 @@ class SchemaManager {
             }
         });
     }
-    updateTable(table, desired, indexes, existing, primaryKey) {
+    updateTable(table, desired, indexes, existing, primaryKey, foreignKeys, existingConstraints) {
         return __awaiter(this, void 0, void 0, function* () {
             const tableChanges = [];
             const conn = yield (0, Database_1.getConnection)();
@@ -107,7 +114,7 @@ class SchemaManager {
                     if (!existing.hasOwnProperty(col)) {
                         const sql = `ALTER TABLE \`${table}\` ADD COLUMN \`${col}\` ${type};`;
                         yield (0, Database_1.execute)(sql, [], conn);
-                        tableChanges.push(`+ ${col} (adicionado)`);
+                        tableChanges.push(`+ ${col} (added)`);
                     }
                     else {
                         const normalize = (t) => {
@@ -120,7 +127,17 @@ class SchemaManager {
                         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()})`);
+                            tableChanges.push(`~ ${col} (type changed: ${existing[col].toUpperCase()} → ${type.split(' ')[0].toUpperCase()})`);
+                        }
+                    }
+                }
+                // Check for missing foreign keys
+                if (foreignKeys && foreignKeys.length > 0) {
+                    for (const fk of foreignKeys) {
+                        if (!existingConstraints.includes(fk.constraintName)) {
+                            const sql = `ALTER TABLE \`${table}\` ADD CONSTRAINT \`${fk.constraintName}\` FOREIGN KEY (\`${fk.column}\`) REFERENCES \`${fk.referenceTable}\` (\`${fk.referenceColumn}\`);`;
+                            yield (0, Database_1.execute)(sql, [], conn);
+                            tableChanges.push(`+ FK ${fk.constraintName} (added)`);
                         }
                     }
                 }
@@ -133,15 +150,55 @@ class SchemaManager {
             }
         });
     }
+    getExistingConstraints(table) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const conn = yield (0, Database_1.getConnection)();
+            const adapter = (0, Database_1.getAdapter)();
+            const constraints = [];
+            try {
+                let sql;
+                if (adapter.type === 'postgres') {
+                    sql = `SELECT constraint_name 
+                       FROM information_schema.table_constraints 
+                       WHERE table_schema = current_schema() AND table_name = $1 AND constraint_type = 'FOREIGN KEY'`;
+                }
+                else { // mysql
+                    sql = `SELECT CONSTRAINT_NAME 
+                       FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS 
+                       WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ? AND CONSTRAINT_TYPE = 'FOREIGN KEY'`;
+                }
+                const rows = yield (0, Database_1.query)(sql, [table], conn);
+                if (rows.length > 0) {
+                    if (adapter.type === 'postgres') {
+                        rows.forEach((r) => constraints.push(r.constraint_name));
+                    }
+                    else {
+                        rows.forEach((r) => constraints.push(r.CONSTRAINT_NAME));
+                    }
+                }
+            }
+            catch (e) {
+                return [];
+            }
+            finally {
+                if (conn)
+                    conn.release();
+            }
+            return constraints;
+        });
+    }
     getSchemaFromModel(model) {
         const columns = {};
         const indexes = [];
+        const foreignKeys = [];
         let primaryKey = null;
         const colMeta = (0, Column_1.getColumnMeta)(model);
         const nullableMeta = (0, Nullable_1.getNullableMeta)(model);
+        const belongsToMeta = (0, BelongsTo_1.getBelongsToMeta)(model);
         const adapter = (0, Database_1.getAdapter)();
+        const tableName = (0, Table_1.getTableName)(model);
         if (!colMeta) {
-            return { columns, indexes, primaryKey };
+            return { columns, indexes, primaryKey, foreignKeys };
         }
         for (const [prop, opts] of colMeta.entries()) {
             const colName = (opts === null || opts === void 0 ? void 0 : opts.name) ? opts.name : camelToSnake(prop);
@@ -164,13 +221,14 @@ class SchemaManager {
                 continue;
             }
             let sqlType = this.getSqlTypeForClass(type);
-            if (type === Number && opts.decimal) {
+            if (opts === null || opts === void 0 ? void 0 : opts.text) {
+                sqlType = "TEXT";
+            }
+            else if (type === Number && opts.decimal) {
                 if (Array.isArray(opts.decimal) && opts.decimal.length === 2) {
-                    // CORREÇÃO: Removido o espaço após a vírgula
                     sqlType = `DECIMAL(${opts.decimal[0]},${opts.decimal[1]})`;
                 }
                 else {
-                    // CORREÇÃO: Removido o espaço após a vírgula
                     sqlType = 'DECIMAL(10,2)';
                 }
             }
@@ -194,7 +252,37 @@ class SchemaManager {
                 sqlType += " UNIQUE";
             columns[colName] = sqlType;
         }
-        return { columns, indexes, primaryKey };
+        if (belongsToMeta) {
+            for (const [prop, opts] of belongsToMeta.entries()) {
+                const fkProp = opts.foreignKey;
+                const targetModel = opts.model();
+                const targetTable = (0, Table_1.getTableName)(targetModel);
+                if (!targetTable)
+                    continue;
+                // Find the column name for the foreign key property
+                const colOpts = colMeta.get(fkProp);
+                const fkColName = (colOpts === null || colOpts === void 0 ? void 0 : colOpts.name) ? colOpts.name : camelToSnake(fkProp);
+                // Find primary key of target model
+                let targetPk = 'id';
+                const targetColMeta = (0, Column_1.getColumnMeta)(targetModel);
+                if (targetColMeta) {
+                    for (const [tProp, tOpts] of targetColMeta.entries()) {
+                        if (tOpts.id) {
+                            targetPk = tOpts.name ? tOpts.name : camelToSnake(tProp);
+                            break;
+                        }
+                    }
+                }
+                const constraintName = `fk_${tableName}_${fkColName}`;
+                foreignKeys.push({
+                    constraintName,
+                    column: fkColName,
+                    referenceTable: targetTable,
+                    referenceColumn: targetPk
+                });
+            }
+        }
+        return { columns, indexes, primaryKey, foreignKeys };
     }
     getSqlTypeForClass(type) {
         const adapterType = (0, Database_1.getAdapter)().type;

package/dist/decorators/Column.d.ts

@@ -5,6 +5,7 @@ export type ColumnOptions = {
     adapter?: new () => ColumnAdapter;
     unique?: boolean;
     limit?: number;
+    text?: boolean;
     type?: any;
     index?: boolean;
     decimal?: boolean | [number, number];

package/package.json

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