@aceitadev/adatabase 0.8.0 → 0.9.0

package/dist/ActiveRecord.js

@@ -15,9 +15,7 @@ const Column_1 = require("./decorators/Column");
 const PersistenceException_1 = require("./PersistenceException");
 const QueryBuilder_1 = require("./QueryBuilder");
 const Table_1 = require("./decorators/Table");
-function camelToSnake(s) {
-    return s.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
-}
+const util_1 = require("./util");
 class ActiveRecord {
     static getIdField(ctor) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -55,7 +53,7 @@ class ActiveRecord {
                     if (!this.hasOwnProperty(prop))
                         continue;
                     const value = this[prop];
-                    const colName = (opts === null || opts === void 0 ? void 0 : opts.name) ? opts.name : camelToSnake(prop);
+                    const colName = (opts === null || opts === void 0 ? void 0 : opts.name) ? opts.name : (0, util_1.camelToSnake)(prop);
                     colEntries.push({ colName, value });
                 }
                 const idValue = this[idField];
@@ -74,7 +72,7 @@ ${table}
                 else {
                     const setClause = colEntries.map(c => `\`${c.colName}\` = ?`).join(", ");
                     const params = [...colEntries.map(c => c.value === undefined ? null : c.value), idValue];
-                    const idColName = camelToSnake(idField);
+                    const idColName = (0, util_1.camelToSnake)(idField);
                     const sql = `UPDATE 
 ${table}
  SET ${setClause} WHERE 
@@ -110,7 +108,7 @@ ${idColName}
                 return;
             const conn = tx !== null && tx !== void 0 ? tx : yield (0, Database_1.getConnection)();
             try {
-                const idColName = camelToSnake(idField);
+                const idColName = (0, util_1.camelToSnake)(idField);
                 const sql = `DELETE FROM \`${table}\` WHERE \`${idColName}\` = ?`;
                 yield (0, Database_1.execute)(sql, [idValue], conn);
             }

package/dist/PersistenceException.d.ts

@@ -2,3 +2,18 @@ export declare class PersistenceException extends Error {
     cause?: (Error | null) | undefined;
     constructor(message: string, cause?: (Error | null) | undefined);
 }
+export declare class InvalidColumnException extends PersistenceException {
+    constructor(column: string, model: string);
+}
+export declare class DuplicateEntryException extends PersistenceException {
+    constructor(message: string, cause?: Error | null);
+}
+export declare class ForeignKeyException extends PersistenceException {
+    constructor(message: string, cause?: Error | null);
+}
+export declare class ConnectionException extends PersistenceException {
+    constructor(message: string, cause?: Error | null);
+}
+export declare class TimeoutException extends PersistenceException {
+    constructor(message: string, cause?: Error | null);
+}

package/dist/PersistenceException.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PersistenceException = void 0;
+exports.TimeoutException = exports.ConnectionException = exports.ForeignKeyException = exports.DuplicateEntryException = exports.InvalidColumnException = exports.PersistenceException = void 0;
 class PersistenceException extends Error {
     constructor(message, cause) {
         var _a, _b;
@@ -14,3 +14,38 @@ class PersistenceException extends Error {
     }
 }
 exports.PersistenceException = PersistenceException;
+class InvalidColumnException extends PersistenceException {
+    constructor(column, model) {
+        super(`Property '${column}' is not a mapped column on model '${model}'.`, null);
+        Object.setPrototypeOf(this, InvalidColumnException.prototype);
+    }
+}
+exports.InvalidColumnException = InvalidColumnException;
+class DuplicateEntryException extends PersistenceException {
+    constructor(message, cause) {
+        super(`Duplicate entry violation: ${message}`, cause);
+        Object.setPrototypeOf(this, DuplicateEntryException.prototype);
+    }
+}
+exports.DuplicateEntryException = DuplicateEntryException;
+class ForeignKeyException extends PersistenceException {
+    constructor(message, cause) {
+        super(`Foreign key constraint violation: ${message}`, cause);
+        Object.setPrototypeOf(this, ForeignKeyException.prototype);
+    }
+}
+exports.ForeignKeyException = ForeignKeyException;
+class ConnectionException extends PersistenceException {
+    constructor(message, cause) {
+        super(`Database connection error: ${message}`, cause);
+        Object.setPrototypeOf(this, ConnectionException.prototype);
+    }
+}
+exports.ConnectionException = ConnectionException;
+class TimeoutException extends PersistenceException {
+    constructor(message, cause) {
+        super(`Query timeout: ${message}`, cause);
+        Object.setPrototypeOf(this, TimeoutException.prototype);
+    }
+}
+exports.TimeoutException = TimeoutException;

package/dist/QueryBuilder.d.ts

@@ -18,6 +18,11 @@ export declare class QueryBuilder<T extends ActiveRecord> {
     first(): Promise<T | null>;
     count(): Promise<number>;
     get(): Promise<T[]>;
+    /**
+     * Loads HasMany relations using separate queries with WHERE IN
+     * This avoids the cartesian product problem of JOINs
+     */
+    private loadHasManyRelations;
     private getColumnName;
     private mapRowsToEntities;
 }

package/dist/QueryBuilder.js

@@ -17,9 +17,8 @@ const PersistenceException_1 = require("./PersistenceException");
 const BelongsTo_1 = require("./decorators/BelongsTo");
 const HasMany_1 = require("./decorators/HasMany");
 const HasOne_1 = require("./decorators/HasOne");
-function camelToSnake(s) {
-    return s.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
-}
+const util_1 = require("./util");
+const Security_1 = require("./Security");
 class QueryBuilder {
     constructor(model) {
         this.model = model;
@@ -37,10 +36,14 @@ class QueryBuilder {
         }
     }
     where(field, operator, value) {
+        // Validate operator at call time to fail fast
+        (0, Security_1.validateOperator)(operator);
         this.whereClauses.push({ field: field, operator, value, booleanOp: "AND" });
         return this;
     }
     include(...models) {
+        // HasMany relations are loaded via separate optimized queries (WHERE IN)
+        // BelongsTo and HasOne use efficient JOINs
         this._includes.push(...models);
         return this;
     }
@@ -73,16 +76,13 @@ class QueryBuilder {
             if (!columnsMeta) {
                 throw new PersistenceException_1.PersistenceException("Model has no @Column decorators", null);
             }
-            const allowedOperators = ['=', '!=', '<>', '>', '<', '>=', '<=', 'LIKE', 'IN', 'IS NULL', 'IS NOT NULL'];
             const params = [];
             const baseAlias = 't1';
             let sql = `SELECT COUNT(*) as count FROM \`${table}\` AS ${baseAlias}`;
             if (this.whereClauses.length > 0) {
                 sql += " WHERE ";
                 this.whereClauses.forEach((c, i) => {
-                    if (!allowedOperators.includes(c.operator.toUpperCase())) {
-                        throw new Error(`Invalid operator used: ${c.operator}`);
-                    }
+                    // Operator is already validated in where() method
                     if (i > 0) {
                         sql += ` ${c.booleanOp} `;
                     }
@@ -116,48 +116,67 @@ class QueryBuilder {
             const baseAlias = 't1';
             let selectFields = `${baseAlias}.*`;
             let joinClause = '';
-            const allRelationMetas = [
-                { meta: (0, BelongsTo_1.getBelongsToMeta)(this.model), type: 'BelongsTo' },
-                { meta: (0, HasMany_1.getHasManyMeta)(this.model), type: 'HasMany' },
-                { meta: (0, HasOne_1.getHasOneMeta)(this.model), type: 'HasOne' }
-            ];
+            // Separate relations by type - HasMany will use separate queries
+            const belongsToMeta = (0, BelongsTo_1.getBelongsToMeta)(this.model);
+            const hasOneMeta = (0, HasOne_1.getHasOneMeta)(this.model);
+            const hasManyMeta = (0, HasMany_1.getHasManyMeta)(this.model);
+            // Track which includes are HasMany (will be loaded separately)
+            const hasManyIncludes = [];
+            const joinIncludes = [];
             if (this._includes.length > 0) {
                 this._includes.forEach((includeModel, index) => {
-                    const relationAlias = `t${index + 2}`;
-                    let relationInfo = null;
-                    for (const { meta, type } of allRelationMetas) {
-                        if (meta) {
-                            for (const [prop, opts] of meta.entries()) {
-                                if (opts.model() === includeModel) {
-                                    relationInfo = { prop, opts, type };
-                                    break;
-                                }
+                    // Check if this is a HasMany relation
+                    if (hasManyMeta) {
+                        for (const [prop, opts] of hasManyMeta.entries()) {
+                            if (opts.model() === includeModel) {
+                                hasManyIncludes.push({ model: includeModel, prop, opts });
+                                return; // Don't add to JOIN
                             }
                         }
-                        if (relationInfo)
-                            break;
                     }
-                    if (relationInfo) {
-                        const relatedTable = (0, Table_1.getTableName)(includeModel);
-                        const relatedColumnsMeta = (0, Column_1.getColumnMeta)(includeModel);
-                        if (!relatedTable || !relatedColumnsMeta)
-                            return;
-                        for (const prop of relatedColumnsMeta.keys()) {
-                            const colName = this.getColumnName(prop, relatedColumnsMeta);
-                            selectFields += `, ${relationAlias}.\`${colName}\` AS \`${relationInfo.prop}__${prop}\``;
-                        }
-                        if (relationInfo.type === 'BelongsTo') {
-                            const foreignKey = relationInfo.opts.foreignKey;
-                            const foreignKeyCol = this.getColumnName(foreignKey, columnsMeta);
-                            joinClause += ` LEFT JOIN \`${relatedTable}\` AS ${relationAlias} ON ${baseAlias}.\`${foreignKeyCol}\` = ${relationAlias}.id`;
+                    // Check BelongsTo - use JOIN
+                    if (belongsToMeta) {
+                        for (const [prop, opts] of belongsToMeta.entries()) {
+                            if (opts.model() === includeModel) {
+                                joinIncludes.push({ model: includeModel, prop, opts, type: 'BelongsTo' });
+                                return;
+                            }
                         }
-                        else { // HasOne or HasMany
-                            const foreignKey = relationInfo.opts.foreignKey;
-                            const foreignKeyCol = this.getColumnName(foreignKey, relatedColumnsMeta);
-                            joinClause += ` LEFT JOIN \`${relatedTable}\` AS ${relationAlias} ON ${baseAlias}.id = ${relationAlias}.\`${foreignKeyCol}\``;
+                    }
+                    // Check HasOne - use JOIN
+                    if (hasOneMeta) {
+                        for (const [prop, opts] of hasOneMeta.entries()) {
+                            if (opts.model() === includeModel) {
+                                joinIncludes.push({ model: includeModel, prop, opts, type: 'HasOne' });
+                                return;
+                            }
                         }
                     }
                 });
+                // Build JOINs only for BelongsTo and HasOne
+                joinIncludes.forEach((relation, index) => {
+                    const relationAlias = `t${index + 2}`;
+                    const relatedTable = (0, Table_1.getTableName)(relation.model);
+                    const relatedColumnsMeta = (0, Column_1.getColumnMeta)(relation.model);
+                    if (!relatedTable || !relatedColumnsMeta)
+                        return;
+                    // Add select fields for this relation
+                    for (const prop of relatedColumnsMeta.keys()) {
+                        const colName = this.getColumnName(prop, relatedColumnsMeta);
+                        selectFields += `, ${relationAlias}.\`${colName}\` AS \`${relation.prop}__${prop}\``;
+                    }
+                    // Build JOIN clause
+                    if (relation.type === 'BelongsTo') {
+                        const foreignKey = relation.opts.foreignKey;
+                        const foreignKeyCol = this.getColumnName(foreignKey, columnsMeta);
+                        joinClause += ` LEFT JOIN \`${relatedTable}\` AS ${relationAlias} ON ${baseAlias}.\`${foreignKeyCol}\` = ${relationAlias}.id`;
+                    }
+                    else { // HasOne
+                        const foreignKey = relation.opts.foreignKey;
+                        const foreignKeyCol = this.getColumnName(foreignKey, relatedColumnsMeta);
+                        joinClause += ` LEFT JOIN \`${relatedTable}\` AS ${relationAlias} ON ${baseAlias}.id = ${relationAlias}.\`${foreignKeyCol}\``;
+                    }
+                });
             }
             let sql = `SELECT ${selectFields} FROM \`${table}\` AS ${baseAlias}${joinClause}`;
             if (this.whereClauses.length) {
@@ -181,22 +200,70 @@ class QueryBuilder {
                 sql += ` OFFSET ${this._offset}`;
             }
             sql += ";";
+            // Execute main query
             const rows = yield (0, Database_1.query)(sql, params);
-            return this.mapRowsToEntities(rows);
+            const entities = this.mapRowsToEntities(rows, joinIncludes);
+            // Load HasMany relations with separate optimized queries
+            if (hasManyIncludes.length > 0 && entities.length > 0) {
+                yield this.loadHasManyRelations(entities, hasManyIncludes);
+            }
+            return entities;
+        });
+    }
+    /**
+     * Loads HasMany relations using separate queries with WHERE IN
+     * This avoids the cartesian product problem of JOINs
+     */
+    loadHasManyRelations(entities, hasManyIncludes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get primary key column name
+            const columnsMeta = (0, Column_1.getColumnMeta)(this.model);
+            const pkColName = this.getColumnName(this.primaryKey, columnsMeta);
+            // Collect all entity IDs
+            const entityIds = entities.map(e => e[this.primaryKey]);
+            if (entityIds.length === 0)
+                return;
+            for (const relation of hasManyIncludes) {
+                const relatedTable = (0, Table_1.getTableName)(relation.model);
+                const relatedColumnsMeta = (0, Column_1.getColumnMeta)(relation.model);
+                if (!relatedTable || !relatedColumnsMeta)
+                    continue;
+                // Get foreign key column name in the related table
+                const foreignKeyCol = this.getColumnName(relation.opts.foreignKey, relatedColumnsMeta);
+                // Build optimized query with WHERE IN
+                const placeholders = entityIds.map(() => '?').join(', ');
+                const sql = `SELECT * FROM \`${relatedTable}\` WHERE \`${foreignKeyCol}\` IN (${placeholders});`;
+                const relatedRows = yield (0, Database_1.query)(sql, entityIds);
+                // Initialize arrays for each entity
+                for (const entity of entities) {
+                    entity[relation.prop] = [];
+                }
+                // Map related rows to their parent entities
+                const entityMap = new Map(entities.map(e => [e[this.primaryKey], e]));
+                for (const row of relatedRows) {
+                    const parentId = row[foreignKeyCol];
+                    const parentEntity = entityMap.get(parentId);
+                    if (parentEntity) {
+                        const relatedObj = new relation.model();
+                        for (const [prop] of relatedColumnsMeta.entries()) {
+                            const colName = this.getColumnName(prop, relatedColumnsMeta);
+                            if (row.hasOwnProperty(colName)) {
+                                relatedObj[prop] = row[colName];
+                            }
+                        }
+                        parentEntity[relation.prop].push(relatedObj);
+                    }
+                }
+            }
         });
     }
     getColumnName(prop, meta) {
         const opts = meta.get(prop);
-        return (opts === null || opts === void 0 ? void 0 : opts.name) ? opts.name : camelToSnake(prop);
+        return (opts === null || opts === void 0 ? void 0 : opts.name) ? opts.name : (0, util_1.camelToSnake)(prop);
     }
-    mapRowsToEntities(rows) {
+    mapRowsToEntities(rows, joinIncludes = []) {
         const mainEntityMap = new Map();
         const columnsMeta = (0, Column_1.getColumnMeta)(this.model);
-        const allRelationMetas = [
-            { meta: (0, BelongsTo_1.getBelongsToMeta)(this.model), type: 'BelongsTo' },
-            { meta: (0, HasMany_1.getHasManyMeta)(this.model), type: 'HasMany' },
-            { meta: (0, HasOne_1.getHasOneMeta)(this.model), type: 'HasOne' }
-        ];
         for (const row of rows) {
             const pkValue = row[this.primaryKey];
             if (!mainEntityMap.has(pkValue)) {
@@ -210,28 +277,22 @@ class QueryBuilder {
                 mainEntityMap.set(pkValue, obj);
             }
             const mainEntity = mainEntityMap.get(pkValue);
-            for (const { meta, type } of allRelationMetas) {
-                if (meta) {
-                    for (const [relationProp, opts] of meta.entries()) {
-                        const prefix = `${relationProp}__`;
-                        if (row[`${prefix}id`] === null)
-                            continue;
-                        const relatedModelCtor = opts.model();
-                        const relatedObj = new relatedModelCtor();
-                        const relatedColsMeta = (0, Column_1.getColumnMeta)(relatedModelCtor);
-                        for (const [prop] of relatedColsMeta.entries()) {
-                            relatedObj[prop] = row[`${prefix}${prop}`];
-                        }
-                        if (type === 'HasMany') {
-                            if (!mainEntity[relationProp]) {
-                                mainEntity[relationProp] = [];
-                            }
-                            mainEntity[relationProp].push(relatedObj);
-                        }
-                        else { // BelongsTo or HasOne
-                            mainEntity[relationProp] = relatedObj;
-                        }
+            // Only process BelongsTo and HasOne relations (from JOIN)
+            // HasMany is now handled separately by loadHasManyRelations()
+            for (const relation of joinIncludes) {
+                const prefix = `${relation.prop}__`;
+                if (row[`${prefix}id`] === null)
+                    continue;
+                const relatedModelCtor = relation.opts.model();
+                const relatedColsMeta = (0, Column_1.getColumnMeta)(relatedModelCtor);
+                // For BelongsTo/HasOne, only set if not already set
+                // (no deduplication needed since 1:1 relationship)
+                if (mainEntity[relation.prop] === undefined) {
+                    const relatedObj = new relatedModelCtor();
+                    for (const [prop] of relatedColsMeta.entries()) {
+                        relatedObj[prop] = row[`${prefix}${prop}`];
                     }
+                    mainEntity[relation.prop] = relatedObj;
                 }
             }
         }

package/dist/SchemaManager.d.ts

@@ -1,8 +1,18 @@
+export interface MigrationOptions {
+    /** If true, logs the SQL that would be executed without actually running it */
+    dryRun?: boolean;
+    /** If true, enables the two-phase column drop system */
+    enableDropWarnings?: boolean;
+}
 export declare class SchemaManager {
     private models;
     private changes;
+    private pendingSql;
+    private pendingDropWarnings;
     constructor(models: Function[]);
-    migrate(): Promise<void>;
+    migrate(options?: MigrationOptions): Promise<void>;
+    private printDryRunSummary;
+    private printDropWarnings;
     private printMigrationSummary;
     private createTable;
     private updateTable;

package/dist/SchemaManager.js

@@ -1,4 +1,37 @@
 "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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -15,17 +48,22 @@ 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();
-}
+const util_1 = require("./util");
 class SchemaManager {
     constructor(models) {
         this.changes = new Map();
+        this.pendingSql = [];
+        this.pendingDropWarnings = [];
         this.models = models;
     }
-    migrate() {
+    migrate(options) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const dryRun = (_a = options === null || options === void 0 ? void 0 : options.dryRun) !== null && _a !== void 0 ? _a : false;
+            const enableDropWarnings = (_b = options === null || options === void 0 ? void 0 : options.enableDropWarnings) !== null && _b !== void 0 ? _b : false;
             this.changes.clear();
+            this.pendingSql = [];
+            this.pendingDropWarnings = [];
             for (const model of this.models) {
                 const table = (0, Table_1.getTableName)(model);
                 if (!table)
@@ -33,16 +71,52 @@ class SchemaManager {
                 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, foreignKeys);
+                    yield this.createTable(table, columns, indexes, foreignKeys, dryRun);
                 }
                 else {
                     const existingConstraints = yield this.getExistingConstraints(table);
-                    yield this.updateTable(table, columns, indexes, existing, primaryKey, foreignKeys, existingConstraints);
+                    yield this.updateTable(table, columns, indexes, existing, primaryKey, foreignKeys, existingConstraints, dryRun, enableDropWarnings);
+                }
+            }
+            if (dryRun) {
+                this.printDryRunSummary();
+            }
+            else {
+                this.printMigrationSummary();
+                if (this.pendingDropWarnings.length > 0) {
+                    this.printDropWarnings();
                 }
             }
-            this.printMigrationSummary();
         });
     }
+    printDryRunSummary() {
+        console.log("\n╔══════════════════════════════════════════════════════════════╗");
+        console.log("║                     DRY RUN MODE                              ║");
+        console.log("║           No changes were made to the database               ║");
+        console.log("╚══════════════════════════════════════════════════════════════╝\n");
+        if (this.pendingSql.length === 0) {
+            console.log("✓ No schema changes detected.\n");
+            return;
+        }
+        console.log("The following SQL statements would be executed:\n");
+        this.pendingSql.forEach((sql, i) => {
+            console.log(`  ${i + 1}. ${sql}\n`);
+        });
+    }
+    printDropWarnings() {
+        console.log("\n╔══════════════════════════════════════════════════════════════╗");
+        console.log("║  ⚠️  WARNING: COLUMNS SCHEDULED FOR REMOVAL ⚠️                 ║");
+        console.log("╚══════════════════════════════════════════════════════════════╝\n");
+        console.log("\x1b[33m"); // Yellow color
+        console.log("The following columns exist in the database but NOT in your models.");
+        console.log("They are scheduled for removal on the NEXT migration run.\n");
+        for (const warning of this.pendingDropWarnings) {
+            console.log(`  • Table: ${warning.table}, Column: ${warning.column}`);
+        }
+        console.log("\n  To prevent removal, add these columns back to your models.");
+        console.log("  To confirm removal, run the migration again.\n");
+        console.log("\x1b[0m"); // Reset color
+    }
     printMigrationSummary() {
         if (this.changes.size === 0) {
             return;
@@ -64,8 +138,8 @@ class SchemaManager {
             });
         });
     }
-    createTable(table, columns, indexes, foreignKeys) {
-        return __awaiter(this, void 0, void 0, function* () {
+    createTable(table_1, columns_1, indexes_1, foreignKeys_1) {
+        return __awaiter(this, arguments, void 0, function* (table, columns, indexes, foreignKeys, dryRun = false) {
             const adapter = (0, Database_1.getAdapter)();
             const colsSql = Object.entries(columns).map(([k, v]) => `\`${k}\` ${v}`).join(", ");
             let indexSql = "";
@@ -77,6 +151,13 @@ class SchemaManager {
                 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});`;
+            if (dryRun) {
+                this.pendingSql.push(sql);
+                const columnChanges = Object.keys(columns).map(col => `+ ${col} (would be added)`);
+                const fkChanges = foreignKeys.map(fk => `+ FK ${fk.constraintName} (would be added)`);
+                this.changes.set(table, [...columnChanges, ...fkChanges]);
+                return;
+            }
             const conn = yield (0, Database_1.getConnection)();
             try {
                 yield (0, Database_1.execute)(sql, [], conn);
@@ -91,6 +172,10 @@ class SchemaManager {
                 for (const col of indexes) {
                     const indexName = `idx_${table}_${col}`;
                     const indexCreationSql = `CREATE INDEX \`${indexName}\` ON \`${table}\` (\`${col}\`);`;
+                    if (dryRun) {
+                        this.pendingSql.push(indexCreationSql);
+                        continue;
+                    }
                     const indexConn = yield (0, Database_1.getConnection)();
                     try {
                         yield (0, Database_1.execute)(indexCreationSql, [], indexConn);
@@ -102,9 +187,64 @@ class SchemaManager {
             }
         });
     }
-    updateTable(table, desired, indexes, existing, primaryKey, foreignKeys, existingConstraints) {
-        return __awaiter(this, void 0, void 0, function* () {
+    updateTable(table_1, desired_1, indexes_1, existing_1, primaryKey_1, foreignKeys_1, existingConstraints_1) {
+        return __awaiter(this, arguments, void 0, function* (table, desired, indexes, existing, primaryKey, foreignKeys, existingConstraints, dryRun = false, enableDropWarnings = false) {
             const tableChanges = [];
+            // Improved normalize function for better MySQL/PostgreSQL type comparison
+            const normalize = (t) => {
+                let normalized = t.toLowerCase().replace(/\s/g, '');
+                // PostgreSQL types to MySQL equivalents
+                normalized = normalized.replace('character varying', 'varchar');
+                normalized = normalized.replace('int4', 'integer');
+                normalized = normalized.replace('int8', 'bigint');
+                normalized = normalized.replace('float8', 'double');
+                normalized = normalized.replace('float4', 'real');
+                normalized = normalized.replace('bool', 'boolean');
+                // Remove length from integer types for comparison
+                normalized = normalized.replace(/^(int|integer|tinyint|smallint|mediumint|bigint)\(\d+\)/, '$1');
+                // Normalize int/integer
+                if (normalized === 'int')
+                    normalized = 'integer';
+                // Handle SERIAL -> INTEGER for comparison
+                if (normalized.includes('serial'))
+                    normalized = normalized.replace('serial', 'integer');
+                return normalized;
+            };
+            if (dryRun) {
+                // In dryRun mode, just collect SQL statements without executing
+                for (const [col, type] of Object.entries(desired)) {
+                    if (col === primaryKey)
+                        continue;
+                    if (!existing.hasOwnProperty(col)) {
+                        const sql = `ALTER TABLE \`${table}\` ADD COLUMN \`${col}\` ${type};`;
+                        this.pendingSql.push(sql);
+                        tableChanges.push(`+ ${col} (would be added)`);
+                    }
+                    else {
+                        const existingType = normalize(existing[col]);
+                        const desiredType = normalize(type.split(' ')[0]);
+                        if (existingType !== desiredType) {
+                            const sql = `ALTER TABLE \`${table}\` MODIFY COLUMN \`${col}\` ${type};`;
+                            this.pendingSql.push(sql);
+                            tableChanges.push(`~ ${col} (would be changed: ${existing[col].toUpperCase()} → ${type.split(' ')[0].toUpperCase()})`);
+                        }
+                    }
+                }
+                // Check for 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}\`);`;
+                            this.pendingSql.push(sql);
+                            tableChanges.push(`+ FK ${fk.constraintName} (would be added)`);
+                        }
+                    }
+                }
+                if (tableChanges.length > 0) {
+                    this.changes.set(table, tableChanges);
+                }
+                return;
+            }
             const conn = yield (0, Database_1.getConnection)();
             try {
                 for (const [col, type] of Object.entries(desired)) {
@@ -117,11 +257,6 @@ class SchemaManager {
                         tableChanges.push(`+ ${col} (added)`);
                     }
                     else {
-                        const normalize = (t) => {
-                            let normalized = t.toLowerCase().replace(/\s/g, '').replace('character varying', 'varchar');
-                            normalized = normalized.replace(/^(int|integer|tinyint|smallint|mediumint|bigint)\(\d+\)/, '$1');
-                            return normalized;
-                        };
                         const existingType = normalize(existing[col]);
                         const desiredType = normalize(type.split(' ')[0]);
                         if (existingType !== desiredType) {
@@ -141,6 +276,36 @@ class SchemaManager {
                         }
                     }
                 }
+                // Check for columns that exist in DB but not in model (potential DROP candidates)
+                if (enableDropWarnings) {
+                    const desiredColumns = new Set(Object.keys(desired));
+                    for (const existingCol of Object.keys(existing)) {
+                        if (existingCol === primaryKey)
+                            continue;
+                        if (!desiredColumns.has(existingCol)) {
+                            // Check if this column was already warned about
+                            const warningFile = `.adatabase_drop_warning_${table}_${existingCol}`;
+                            const fs = yield Promise.resolve().then(() => __importStar(require('fs'))).then(m => m.promises);
+                            try {
+                                yield fs.access(warningFile);
+                                // Warning file exists - this is the second run, execute DROP
+                                const sql = `ALTER TABLE \`${table}\` DROP COLUMN \`${existingCol}\`;`;
+                                yield (0, Database_1.execute)(sql, [], conn);
+                                tableChanges.push(`- ${existingCol} (REMOVED)`);
+                                yield fs.unlink(warningFile);
+                            }
+                            catch (_a) {
+                                // Warning file doesn't exist - create it and warn user
+                                yield fs.writeFile(warningFile, `Column ${existingCol} scheduled for removal from table ${table}.\nCreated: ${new Date().toISOString()}`);
+                                this.pendingDropWarnings.push({
+                                    table,
+                                    column: existingCol,
+                                    warningFile
+                                });
+                            }
+                        }
+                    }
+                }
                 if (tableChanges.length > 0) {
                     this.changes.set(table, tableChanges);
                 }
@@ -201,7 +366,7 @@ class SchemaManager {
             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);
+            const colName = (opts === null || opts === void 0 ? void 0 : opts.name) ? opts.name : (0, util_1.camelToSnake)(prop);
             if (opts.index) {
                 indexes.push(colName);
             }
@@ -221,7 +386,10 @@ 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) {
                     sqlType = `DECIMAL(${opts.decimal[0]},${opts.decimal[1]})`;
                 }
@@ -258,14 +426,14 @@ class SchemaManager {
                     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);
+                const fkColName = (colOpts === null || colOpts === void 0 ? void 0 : colOpts.name) ? colOpts.name : (0, util_1.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);
+                            targetPk = tOpts.name ? tOpts.name : (0, util_1.camelToSnake)(tProp);
                             break;
                         }
                     }

package/dist/Security.js

@@ -17,7 +17,7 @@ function validateOperator(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);
+        throw new PersistenceException_1.InvalidColumnException(prop, modelName);
     }
     const opts = meta.get(prop);
     return (opts === null || opts === void 0 ? void 0 : opts.name) ? opts.name : (0, util_1.camelToSnake)(prop);

package/dist/adapters/MySQLAdapter.d.ts

@@ -1,4 +1,6 @@
 import { IDatabaseAdapter, GenericConnection } from './IDatabaseAdapter';
+import { PersistenceException } from '../PersistenceException';
+export declare function mapMySQLError(error: any): PersistenceException;
 export declare class MySQLAdapter implements IDatabaseAdapter {
     readonly type = "mysql";
     private pool;

package/dist/adapters/MySQLAdapter.js

@@ -13,7 +13,34 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MySQLAdapter = void 0;
+exports.mapMySQLError = mapMySQLError;
 const promise_1 = __importDefault(require("mysql2/promise"));
+const PersistenceException_1 = require("../PersistenceException");
+function sanitizeError(error) {
+    const message = error.message || String(error);
+    // Remove connection strings and passwords from error messages
+    return message.replace(/password=([^\s&;]+)/gi, 'password=***')
+        .replace(/:[^:@]+@/g, ':***@')
+        .replace(/host=[^\s&;]+/gi, 'host=***');
+}
+function mapMySQLError(error) {
+    const code = error.code || '';
+    const safeMessage = sanitizeError(error);
+    if (code === 'ER_DUP_ENTRY') {
+        return new PersistenceException_1.DuplicateEntryException(safeMessage, error);
+    }
+    if (code === 'ER_NO_REFERENCED_ROW' || code === 'ER_NO_REFERENCED_ROW_2' ||
+        code === 'ER_ROW_IS_REFERENCED' || code === 'ER_ROW_IS_REFERENCED_2') {
+        return new PersistenceException_1.ForeignKeyException(safeMessage, error);
+    }
+    if (code === 'ECONNREFUSED' || code === 'PROTOCOL_CONNECTION_LOST' || code === 'ENOTFOUND') {
+        return new PersistenceException_1.ConnectionException(safeMessage, error);
+    }
+    if (code === 'ETIMEDOUT' || code === 'ER_LOCK_WAIT_TIMEOUT') {
+        return new PersistenceException_1.TimeoutException(safeMessage, error);
+    }
+    return new PersistenceException_1.PersistenceException(safeMessage, error);
+}
 class MySQLAdapter {
     constructor() {
         this.type = 'mysql';
@@ -30,7 +57,7 @@ class MySQLAdapter {
             console.log("[aDatabase] MySQL connection pool initialized.");
         }
         catch (error) {
-            console.error("[aDatabase] MySQL connection pool initialization failed:", error);
+            console.error("[aDatabase] MySQL connection pool initialization failed:", sanitizeError(error));
             process.exit(1);
         }
     }

package/dist/adapters/PostgresAdapter.d.ts

@@ -1,4 +1,6 @@
 import { IDatabaseAdapter, GenericConnection } from './IDatabaseAdapter';
+import { PersistenceException } from '../PersistenceException';
+export declare function mapPostgresError(error: any): PersistenceException;
 export declare class PostgresAdapter implements IDatabaseAdapter {
     readonly type = "postgres";
     private pool;

package/dist/adapters/PostgresAdapter.js

@@ -10,7 +10,32 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresAdapter = void 0;
+exports.mapPostgresError = mapPostgresError;
 const pg_1 = require("pg");
+const PersistenceException_1 = require("../PersistenceException");
+function sanitizeError(error) {
+    const message = error.message || String(error);
+    return message.replace(/password=([^\s&;]+)/gi, 'password=***')
+        .replace(/:[^:@]+@/g, ':***@')
+        .replace(/host=[^\s&;]+/gi, 'host=***');
+}
+function mapPostgresError(error) {
+    const code = error.code || '';
+    const safeMessage = sanitizeError(error);
+    if (code === '23505') { // unique_violation
+        return new PersistenceException_1.DuplicateEntryException(safeMessage, error);
+    }
+    if (code === '23503') { // foreign_key_violation
+        return new PersistenceException_1.ForeignKeyException(safeMessage, error);
+    }
+    if (code === 'ECONNREFUSED' || code === '08006' || code === '08001') {
+        return new PersistenceException_1.ConnectionException(safeMessage, error);
+    }
+    if (code === '57014' || code === '57P01') { // query_canceled or admin_shutdown
+        return new PersistenceException_1.TimeoutException(safeMessage, error);
+    }
+    return new PersistenceException_1.PersistenceException(safeMessage, error);
+}
 class PostgresAdapter {
     constructor() {
         this.type = 'postgres';
@@ -28,7 +53,7 @@ class PostgresAdapter {
             console.log("[aDatabase] PostgreSQL connection pool initialized.");
         }
         catch (error) {
-            console.error("[aDatabase] PostgreSQL connection pool initialization failed:", error);
+            console.error("[aDatabase] PostgreSQL connection pool initialization failed:", sanitizeError(error));
             process.exit(1);
         }
     }

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/dist/index.d.ts

@@ -11,3 +11,5 @@ export * from "./decorators/HasMany";
 export * from "./decorators/HasOne";
 export * from "./decorators/BelongsTo";
 export * from "./PersistenceException";
+export * from "./util";
+export * from "./Security";

package/dist/index.js

@@ -27,3 +27,5 @@ __exportStar(require("./decorators/HasMany"), exports);
 __exportStar(require("./decorators/HasOne"), exports);
 __exportStar(require("./decorators/BelongsTo"), exports);
 __exportStar(require("./PersistenceException"), exports);
+__exportStar(require("./util"), exports);
+__exportStar(require("./Security"), exports);

package/package.json

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

package/README.md

@@ -1,171 +0,0 @@
-# aDatabase ORM
-
-aDatabase is a lightweight and easy-to-use ORM (Object-Relational Mapping) for TypeScript, inspired by the Active Record pattern. It allows you to interact with your database using object-oriented syntax, abstracting away the need to write raw SQL queries for most common operations.
-
-## Features
-
-*   **Active Record Pattern**: Models represent database tables and instances represent rows.
-*   **Decorator-based Schema**: Define your database schema using simple decorators.
-*   **Multi-database Support**: Supports both MySQL and PostgreSQL.
-*   **Query Builder**: A fluent API for building complex queries.
-*   **Schema Migration**: Keep your database schema in sync with your models.
-*   **Relationships**: Supports `HasOne`, `HasMany`, and `BelongsTo` relationships.
-
-## Installation
-
-```bash
-npm install @aceitadev/adatabase
-```
-
-## Configuration
-
-First, you need to initialize the database connection. This should be done once when your application starts.
-
-```typescript
-import { init } from '@aceitadev/adatabase';
-
-init('mysql', {
-  host: 'localhost',
-  user: 'root',
-  password: 'password',
-  database: 'my_database'
-});
-```
-
-Supported database types are `'mysql'` and `'postgres'`.
-
-## Defining Models
-
-Models are defined as classes that extend `ActiveRecord`. You use decorators to map the class and its properties to a database table and its columns.
-
-```typescript
-import { ActiveRecord, Table, Id, Column } from '@aceitadev/adatabase';
-
-@Table('users')
-export class User extends ActiveRecord {
-  @Id()
-  id: number;
-
-  @Column({ type: String })
-  name: string;
-
-  @Column({ type: String, unique: true })
-  email: string;
-}
-```
-
-## CRUD Operations
-
-### Creating and Saving Records
-
-To create a new record, instantiate a model and call the `save()` method.
-
-```typescript
-const user = new User();
-user.name = 'John Doe';
-user.email = 'john.doe@example.com';
-await user.save();
-```
-
-### Finding Records
-
-Use the static `find()` method to get a `QueryBuilder` instance.
-
-**Find all users:**
-
-```typescript
-const users = await User.find().get();
-```
-
-**Find a single user by ID:**
-
-```typescript
-const user = await User.find().where('id', '=', 1).first();
-```
-
-**Find users with a specific condition:**
-
-```typescript
-const users = await User.find().where('name', 'LIKE', 'John%').get();
-```
-
-### Updating Records
-
-To update a record, modify its properties and call `save()` again.
-
-```typescript
-const user = await User.find().where('id', '=', 1).first();
-if (user) {
-  user.name = 'Jane Doe';
-  await user.save();
-}
-```
-
-### Deleting Records
-
-To delete a record, call the `delete()` method on a model instance.
-
-```typescript
-const user = await User.find().where('id', '=', 1).first();
-if (user) {
-  await user.delete();
-}
-```
-
-## Relationships
-
-You can define relationships between your models using the `@BelongsTo`, `@HasMany`, and `@HasOne` decorators.
-
-```typescript
-import { ActiveRecord, Table, Id, Column, BelongsTo, HasMany } from '@aceitadev/adatabase';
-
-@Table('posts')
-export class Post extends ActiveRecord {
-  @Id()
-  id: number;
-
-  @Column({ type: String })
-  title: string;
-
-  @Column({ type: Number })
-  userId: number;
-
-  @BelongsTo(() => User, { foreignKey: 'userId' })
-  user: User;
-}
-
-@Table('users')
-export class User extends ActiveRecord {
-  @Id()
-  id: number;
-
-  @Column({ type: String })
-  name: string;
-
-  @HasMany(() => Post, { foreignKey: 'userId' })
-  posts: Post[];
-}
-```
-
-To eager-load relationships, use the `include()` method in the `QueryBuilder`.
-
-```typescript
-const userWithPosts = await User.find().where('id', '=', 1).include(Post).first();
-console.log(userWithPosts.posts);
-```
-
-## Schema Migration
-
-The `SchemaManager` helps you keep your database schema in sync with your models.
-
-```typescript
-import { SchemaManager } from '@aceitadev/adatabase';
-import { User, Post } from './models'; // Import your models
-
-const schemaManager = new SchemaManager([User, Post]);
-await schemaManager.migrate();
-```
-
-When you run `migrate()`, the `SchemaManager` will:
-*   Create tables that don't exist.
-*   Add columns that are missing from existing tables.