@carno.js/orm 1.0.7 → 1.0.8

package/dist/SqlBuilder.d.ts

@@ -15,6 +15,8 @@ export declare class SqlBuilder<T> {
     private _modelTransformer?;
     private _joinManager?;
     private readonly boundGetAlias;
+    private quoteId;
+    private qualifyTable;
     constructor(model: new () => T);
     private get modelTransformer();
     private get joinManager();
@@ -37,7 +39,6 @@ export declare class SqlBuilder<T> {
     cache(cache: boolean | number | Date | undefined): SqlBuilder<T>;
     load(load: string[]): SqlBuilder<T>;
     count(): SqlBuilder<T>;
-    private getPrimaryKeyColumnName;
     private shouldUseCache;
     private getCacheTtl;
     private getCachedResult;
@@ -63,7 +64,6 @@ export declare class SqlBuilder<T> {
     private attachOneToManyRelations;
     private removeDuplicatesByPrimaryKey;
     private getPrimaryKeyName;
-    private getPrimaryKeyNameForEntity;
     executeCount(): Promise<number>;
     private logExecution;
     inTransaction<T>(callback: (builder: SqlBuilder<T>) => Promise<T>): Promise<T>;

package/dist/SqlBuilder.js

@@ -10,6 +10,16 @@ const model_transformer_1 = require("./query/model-transformer");
 const sql_column_manager_1 = require("./query/sql-column-manager");
 const sql_join_manager_1 = require("./query/sql-join-manager");
 class SqlBuilder {
+    quoteId(identifier) {
+        const q = this.driver.getIdentifierQuote();
+        return `${q}${identifier}${q}`;
+    }
+    qualifyTable(schema, tableName) {
+        if (this.driver.dbType === 'mysql') {
+            return this.quoteId(tableName);
+        }
+        return `${this.quoteId(schema)}.${this.quoteId(tableName)}`;
+    }
     constructor(model) {
         this.statements = {};
         this.aliases = new Set();
@@ -24,12 +34,12 @@ class SqlBuilder {
         this.statements.hooks = this.entity.hooks;
         // Pre-bind once
         this.boundGetAlias = this.getAlias.bind(this);
-        this.columnManager = new sql_column_manager_1.SqlColumnManager(this.entityStorage, this.statements, this.entity);
+        this.columnManager = new sql_column_manager_1.SqlColumnManager(this.entityStorage, this.statements, this.entity, this.driver);
         const applyJoinWrapper = (relationship, value, alias) => {
             return this.joinManager.applyJoin(relationship, value, alias);
         };
-        this.conditionBuilder = new sql_condition_builder_1.SqlConditionBuilder(this.entityStorage, applyJoinWrapper, this.statements);
-        const subqueryBuilder = new sql_subquery_builder_1.SqlSubqueryBuilder(this.entityStorage, () => this.conditionBuilder);
+        this.conditionBuilder = new sql_condition_builder_1.SqlConditionBuilder(this.entityStorage, applyJoinWrapper, this.statements, this.driver);
+        const subqueryBuilder = new sql_subquery_builder_1.SqlSubqueryBuilder(this.entityStorage, () => this.conditionBuilder, this.driver);
         this.conditionBuilder.setSubqueryBuilder(subqueryBuilder);
     }
     // Lazy getter for modelTransformer - only created when transform is needed
@@ -53,7 +63,7 @@ class SqlBuilder {
         this.statements.columns = columns;
         this.originalColumns = columns || [];
         this.statements.alias = this.getAlias(tableName);
-        this.statements.table = `"${schema}"."${tableName}"`;
+        this.statements.table = this.qualifyTable(schema, tableName);
         return this;
     }
     setStrategy(strategy = 'joined') {
@@ -70,7 +80,7 @@ class SqlBuilder {
         this.statements.statement = 'insert';
         this.statements.instance = value_processor_1.ValueProcessor.createInstance(processedValues, this.model, 'insert');
         this.statements.alias = this.getAlias(tableName);
-        this.statements.table = `"${schema}"."${tableName}"`;
+        this.statements.table = this.qualifyTable(schema, tableName);
         this.statements.values = this.withUpdatedValues(this.withDefaultValues(processedValues, this.entity), this.entity);
         this.reflectToValues();
         return this;
@@ -80,7 +90,7 @@ class SqlBuilder {
         const processedValues = value_processor_1.ValueProcessor.processForUpdate(values, this.entity);
         this.statements.statement = 'update';
         this.statements.alias = this.getAlias(tableName);
-        this.statements.table = `${schema}.${tableName}`;
+        this.statements.table = this.qualifyTable(schema, tableName);
         this.statements.values = this.withUpdatedValues(processedValues, this.entity);
         this.statements.instance = value_processor_1.ValueProcessor.createInstance(processedValues, this.model, 'update');
         return this;
@@ -89,7 +99,7 @@ class SqlBuilder {
         const { tableName, schema } = this.getTableName();
         this.statements.statement = 'delete';
         this.statements.alias = this.getAlias(tableName);
-        this.statements.table = `${schema}.${tableName}`;
+        this.statements.table = this.qualifyTable(schema, tableName);
         return this;
     }
     where(where) {
@@ -143,20 +153,16 @@ class SqlBuilder {
         const { tableName, schema } = this.getTableName();
         this.statements.statement = 'count';
         this.statements.alias = this.getAlias(tableName);
-        this.statements.table = `"${schema}"."${tableName}"`;
+        this.statements.table = this.qualifyTable(schema, tableName);
         return this;
     }
-    getPrimaryKeyColumnName(entity) {
-        // Logic to resolve the entity primary key column name
-        // Replace this with your own logic based on your project structure
-        // For example, if the primary key is always 'id', you can return 'id'.
-        // If the logic becomes more complex, add a method on Options to resolve the primary key.
-        return 'id';
-    }
     shouldUseCache() {
         if (this.statements.statement !== 'select') {
             return false;
         }
+        if (this.statements.cache === false) {
+            return false;
+        }
         if (this.statements.cache instanceof Date) {
             return this.statements.cache.getTime() > Date.now();
         }
@@ -203,6 +209,9 @@ class SqlBuilder {
         if (this.shouldUseCache()) {
             await this.setCachedResult(result);
         }
+        if (this.isWriteOperation()) {
+            await this.invalidateCache();
+        }
         return result;
     }
     isWriteOperation() {
@@ -213,6 +222,11 @@ class SqlBuilder {
         if (!this.cacheManager) {
             return;
         }
+        const cacheConfig = orm_1.Orm.getInstance().connection.cache;
+        const shouldInvalidate = cacheConfig?.invalidateCacheOnWrite ?? true;
+        if (!shouldInvalidate) {
+            return;
+        }
         await this.cacheManager.invalidate(this.statements);
     }
     prepareColumns() {
@@ -299,9 +313,9 @@ class SqlBuilder {
         for (const row of rows) {
             const models = this.modelTransformer.transform(this.model, this.statements, row);
             this.afterHooks(models);
-            await this.joinManager.handleSelectJoin(row, models);
             results.push(models);
         }
+        await this.joinManager.handleSelectJoinBatch(rows, results);
         return results;
     }
     hasOneToManyJoinedJoin() {
@@ -404,7 +418,7 @@ class SqlBuilder {
         if (!entity) {
             return models;
         }
-        const primaryKey = this.getPrimaryKeyNameForEntity(entity);
+        const primaryKey = entity._primaryKeyPropertyName || 'id';
         const seen = new Set();
         const unique = [];
         for (const model of models) {
@@ -417,15 +431,7 @@ class SqlBuilder {
         return unique;
     }
     getPrimaryKeyName() {
-        return this.getPrimaryKeyNameForEntity(this.entity);
-    }
-    getPrimaryKeyNameForEntity(entity) {
-        for (const prop in entity.properties) {
-            if (entity.properties[prop].options.isPrimary) {
-                return prop;
-            }
-        }
-        return 'id';
+        return this.entity._primaryKeyPropertyName || 'id';
     }
     async executeCount() {
         const result = await this.execute();
@@ -570,7 +576,9 @@ class SqlBuilder {
     applyOnInsert(values, key, property) {
         const columnName = property.options.columnName;
         values[columnName] = property.options.onInsert();
-        this.updatedColumns.push(`${this.statements.alias}."${columnName}" as "${this.statements.alias}_${columnName}"`);
+        const col = this.quoteId(columnName);
+        const aliasedCol = this.quoteId(`${this.statements.alias}_${columnName}`);
+        this.updatedColumns.push(`${this.statements.alias}.${col} as ${aliasedCol}`);
     }
     withUpdatedValues(values, entityOptions) {
         const properties = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.onUpdate);
@@ -580,7 +588,9 @@ class SqlBuilder {
     applyOnUpdate(values, property) {
         const columnName = property.options.columnName;
         values[columnName] = property.options.onUpdate();
-        this.updatedColumns.push(`${this.statements.alias}."${columnName}" as "${this.statements.alias}_${columnName}"`);
+        const col = this.quoteId(columnName);
+        const aliasedCol = this.quoteId(`${this.statements.alias}_${columnName}`);
+        this.updatedColumns.push(`${this.statements.alias}.${col} as ${aliasedCol}`);
     }
     callHook(type, model) {
         const hooks = this.statements.hooks?.filter(hook => hook.type === type) || [];

package/dist/domain/base-entity.d.ts

@@ -49,6 +49,11 @@ export declare abstract class BaseEntity {
      * @return {boolean} Returns true if the object has been persisted, otherwise false.
      */
     isPersisted(): boolean;
+    /**
+     * Removes this entity from the database.
+     * Uses cached primary key property name instead of hardcoded 'id'.
+     */
+    remove(): Promise<void>;
     toJSON(): Record<string, any>;
     private serializeWithEntity;
     private serializeWithMetadata;

package/dist/domain/base-entity.js

@@ -111,8 +111,12 @@ class BaseEntity {
         if (this.$_isPersisted) {
             qb.update(this._changedValues);
             qb.setInstance(this);
+            // Use cached primary key property name instead of hardcoded 'id'
+            const storage = entities_1.EntityStorage.getInstance();
+            const options = storage.get(this.constructor);
+            const pkName = options?._primaryKeyPropertyName || 'id';
             // @ts-ignore
-            qb.where({ id: this._oldValues.id });
+            qb.where({ [pkName]: this._oldValues[pkName] });
         }
         else {
             qb.insert(this._oldValues);
@@ -134,6 +138,19 @@ class BaseEntity {
     isPersisted() {
         return this.$_isPersisted;
     }
+    /**
+     * Removes this entity from the database.
+     * Uses cached primary key property name instead of hardcoded 'id'.
+     */
+    async remove() {
+        const qb = this.createQueryBuilder();
+        const storage = entities_1.EntityStorage.getInstance();
+        const options = storage.get(this.constructor);
+        const pkName = options?._primaryKeyPropertyName || 'id';
+        // @ts-ignore
+        qb.delete().where({ [pkName]: this._oldValues[pkName] });
+        await qb.execute();
+    }
     toJSON() {
         const storage = entities_1.EntityStorage.getInstance();
         const entity = storage.get(this.constructor);

package/dist/domain/entities.d.ts

@@ -18,6 +18,8 @@ export type Options = {
         propertyName: string;
     }[];
     schema?: string;
+    _primaryKeyPropertyName?: string;
+    _primaryKeyColumnName?: string;
 };
 export declare class EntityStorage {
     static instance: EntityStorage;
@@ -34,6 +36,12 @@ export declare class EntityStorage {
     }[]): void;
     get(entity: Function): Options;
     entries(): MapIterator<[Function, Options]>;
+    /**
+     * Computa metadados da primary key a partir das propriedades da entidade.
+     * Chamado uma vez durante o registro da entidade para lookups O(1).
+     * @private
+     */
+    private computePrimaryKeyInfo;
     static getInstance(): EntityStorage;
     snapshot(values: Options): Promise<SnapshotTable>;
     private snapshotColumns;

package/dist/domain/entities.js

@@ -112,6 +112,8 @@ let EntityStorage = EntityStorage_1 = class EntityStorage {
         const indexes = core_1.Metadata.get("indexes", entity.target) || [];
         const uniques = core_1.Metadata.get("uniques", entity.target) || [];
         const columnMap = buildIndexColumnMap(properties, relations);
+        // Compute primary key cache once during registration
+        const pkInfo = this.computePrimaryKeyInfo(properties);
         this.entities.set(entity.target, {
             properties: properties,
             hideProperties: Object.entries(properties)
@@ -123,6 +125,8 @@ let EntityStorage = EntityStorage_1 = class EntityStorage {
             hooks,
             tableName: entityName,
             ...entity.options,
+            _primaryKeyPropertyName: pkInfo.propertyName,
+            _primaryKeyColumnName: pkInfo.columnName,
         });
     }
     get(entity) {
@@ -131,6 +135,26 @@ let EntityStorage = EntityStorage_1 = class EntityStorage {
     entries() {
         return this.entities.entries();
     }
+    /**
+     * Computa metadados da primary key a partir das propriedades da entidade.
+     * Chamado uma vez durante o registro da entidade para lookups O(1).
+     * @private
+     */
+    computePrimaryKeyInfo(properties) {
+        for (const prop in properties) {
+            if (properties[prop].options.isPrimary) {
+                return {
+                    propertyName: prop,
+                    columnName: properties[prop].options.columnName,
+                };
+            }
+        }
+        // Fallback para 'id' (backward compatibility)
+        return {
+            propertyName: 'id',
+            columnName: 'id',
+        };
+    }
     static getInstance() {
         const scoped = orm_session_context_1.ormSessionContext.getStorage();
         if (scoped) {

package/dist/driver/bun-driver.base.d.ts

@@ -13,7 +13,7 @@ export declare abstract class BunDriverBase implements Partial<DriverInterface>
     constructor(options: ConnectionSettings);
     protected buildConnectionString(options: ConnectionSettings): string;
     protected abstract getProtocol(): string;
-    protected abstract getIdentifierQuote(): string;
+    abstract getIdentifierQuote(): string;
     connect(): Promise<void>;
     protected buildPoolOptions(options: ConnectionSettings): {
         max: number;
@@ -29,6 +29,7 @@ export declare abstract class BunDriverBase implements Partial<DriverInterface>
     transaction<T>(callback: (tx: SQL) => Promise<T>): Promise<T>;
     protected toDatabaseValue(value: unknown): string | number | boolean;
     protected escapeIdentifier(identifier: string): string;
+    protected formatDateForMysql(value: Date): string;
     protected buildWhereClause(where: string | undefined): string;
     protected buildOrderByClause(orderBy: string[] | undefined): string;
     protected buildLimitClause(limit: number | undefined): string;
@@ -41,7 +42,7 @@ export declare abstract class BunDriverBase implements Partial<DriverInterface>
         beforeSql: string;
         columnType: string;
     };
-    protected abstract handleInsertReturn(statement: Statement<any>, result: any, sql: string, startTime: number): Promise<{
+    protected abstract handleInsertReturn(statement: Statement<any>, result: any, sql: string, startTime: number, context: any): Promise<{
         query: any;
         startTime: number;
         sql: string;

package/dist/driver/bun-driver.base.js

@@ -76,7 +76,10 @@ class BunDriverBase {
             return "NULL";
         }
         if (value instanceof Date) {
-            return `'${value.toISOString()}'`;
+            const formatted = this.dbType === "mysql"
+                ? this.formatDateForMysql(value)
+                : value.toISOString();
+            return `'${formatted}'`;
         }
         switch (typeof value) {
             case "string":
@@ -94,6 +97,13 @@ class BunDriverBase {
     escapeIdentifier(identifier) {
         return `"${identifier}"`;
     }
+    formatDateForMysql(value) {
+        return value
+            .toISOString()
+            .replace('T', ' ')
+            .replace('Z', '')
+            .replace(/\.\d{3}/, '');
+    }
     buildWhereClause(where) {
         if (!where) {
             return "";
@@ -149,7 +159,7 @@ class BunDriverBase {
         if (statement.statement === "insert") {
             const sql = this.buildInsertSqlWithReturn(statement);
             const result = await context.unsafe(sql);
-            return this.handleInsertReturn(statement, result, sql, startTime);
+            return this.handleInsertReturn(statement, result, sql, startTime, context);
         }
         const sql = this.buildStatementSql(statement);
         const result = await context.unsafe(sql);
@@ -210,7 +220,10 @@ class BunDriverBase {
             return "";
         return statement.join
             .map((join) => {
-            const table = `${join.joinSchema}.${join.joinTable}`;
+            const q = this.getIdentifierQuote();
+            const table = this.dbType === 'mysql'
+                ? `${q}${join.joinTable}${q}`
+                : `${join.joinSchema}.${join.joinTable}`;
             return ` ${join.type} JOIN ${table} ${join.joinAlias} ON ${join.on}`;
         })
             .join("");

package/dist/driver/bun-mysql.driver.d.ts

@@ -4,14 +4,14 @@ export declare class BunMysqlDriver extends BunDriverBase implements DriverInter
     readonly dbType: "mysql";
     constructor(options: ConnectionSettings);
     protected getProtocol(): string;
-    protected getIdentifierQuote(): string;
+    getIdentifierQuote(): string;
     protected buildAutoIncrementType(colDiff: ColDiff): string;
     protected buildEnumType(schema: string | undefined, tableName: string, colDiff: ColDiff): {
         beforeSql: string;
         columnType: string;
     };
     protected appendReturningClause(sql: string, statement: Statement<any>): string;
-    protected handleInsertReturn(statement: Statement<any>, result: any, sql: string, startTime: number): Promise<{
+    protected handleInsertReturn(statement: Statement<any>, result: any, sql: string, startTime: number, context: any): Promise<{
         query: any;
         startTime: number;
         sql: string;

package/dist/driver/bun-mysql.driver.js

@@ -28,7 +28,7 @@ class BunMysqlDriver extends bun_driver_base_1.BunDriverBase {
     appendReturningClause(sql, statement) {
         return sql;
     }
-    async handleInsertReturn(statement, result, sql, startTime) {
+    async handleInsertReturn(statement, result, sql, startTime, context) {
         if (!statement.columns) {
             return {
                 query: { rows: Array.isArray(result) ? result : [] },
@@ -36,10 +36,28 @@ class BunMysqlDriver extends bun_driver_base_1.BunDriverBase {
                 sql,
             };
         }
-        const insertId = result.lastInsertRowid;
+        let insertId;
+        // Check if ID was manually provided in the values
+        if (statement.values && statement.values.id) {
+            insertId = statement.values.id;
+        }
+        else {
+            // For AUTO_INCREMENT, use LAST_INSERT_ID()
+            const lastIdResult = await context.unsafe('SELECT LAST_INSERT_ID() as id');
+            insertId = lastIdResult[0]?.id;
+        }
+        if (!insertId) {
+            // If no ID available, return empty result
+            return {
+                query: { rows: [] },
+                startTime,
+                sql,
+            };
+        }
         const cols = statement.columns.join(', ').replaceAll(`${statement.alias}.`, '');
-        const selectSql = `SELECT ${cols} FROM ${statement.table} WHERE id = ${insertId}`;
-        const selectResult = await this.sql.unsafe(selectSql);
+        const idValue = this.toDatabaseValue(insertId);
+        const selectSql = `SELECT ${cols} FROM ${statement.table} WHERE id = ${idValue}`;
+        const selectResult = await context.unsafe(selectSql);
         return {
             query: { rows: Array.isArray(selectResult) ? selectResult : [] },
             startTime,
@@ -58,7 +76,7 @@ class BunMysqlDriver extends bun_driver_base_1.BunDriverBase {
     }
     getCreateTableInstruction(schema, tableName, creates) {
         let beforeSql = ``;
-        const st = `CREATE TABLE \`${schema}\`.\`${tableName}\` (${creates
+        const st = `CREATE TABLE \`${tableName}\` (${creates
             .map((colDiff) => {
             const isAutoIncrement = colDiff.colChanges?.autoIncrement;
             let sql = ``;
@@ -92,7 +110,7 @@ class BunMysqlDriver extends bun_driver_base_1.BunDriverBase {
         return beforeSql + st;
     }
     getAlterTableFkInstruction(schema, tableName, colDiff, fk) {
-        return `ALTER TABLE \`${schema}\`.\`${tableName}\` ADD CONSTRAINT \`${tableName}_${colDiff.colName}_fk\` FOREIGN KEY (\`${colDiff.colName}\`) REFERENCES \`${fk.referencedTableName}\` (\`${fk.referencedColumnName}\`);`;
+        return `ALTER TABLE \`${tableName}\` ADD CONSTRAINT \`${tableName}_${colDiff.colName}_fk\` FOREIGN KEY (\`${colDiff.colName}\`) REFERENCES \`${fk.referencedTableName}\` (\`${fk.referencedColumnName}\`);`;
     }
     getCreateIndex(index, schema, tableName) {
         const properties = index.properties || [];
@@ -103,7 +121,7 @@ class BunMysqlDriver extends bun_driver_base_1.BunDriverBase {
             throw new Error("Partial indexes are only supported on postgres.");
         }
         const columns = properties.map((prop) => `\`${prop}\``).join(', ');
-        return `CREATE INDEX \`${index.name}\` ON \`${schema}\`.\`${tableName}\` (${columns});`;
+        return `CREATE INDEX \`${index.name}\` ON \`${tableName}\` (${columns});`;
     }
     getAddColumn(schema, tableName, colName, colDiff, colDiffInstructions) {
         let sql = ``;
@@ -111,10 +129,10 @@ class BunMysqlDriver extends bun_driver_base_1.BunDriverBase {
             const enumValues = colDiff.colChanges.enumItems
                 .map((item) => `'${item}'`)
                 .join(', ');
-            sql += `ALTER TABLE \`${schema}\`.\`${tableName}\` ADD COLUMN \`${colDiff.colName}\` ENUM(${enumValues})`;
+            sql += `ALTER TABLE \`${tableName}\` ADD COLUMN \`${colDiff.colName}\` ENUM(${enumValues})`;
         }
         else {
-            sql += `ALTER TABLE \`${schema}\`.\`${tableName}\` ADD COLUMN \`${colName}\` ${colDiff.colType}${colDiff.colLength ? `(${colDiff.colLength})` : ''}`;
+            sql += `ALTER TABLE \`${tableName}\` ADD COLUMN \`${colName}\` ${colDiff.colType}${colDiff.colLength ? `(${colDiff.colLength})` : ''}`;
         }
         if (!colDiff.colChanges?.nullable) {
             sql += ' NOT NULL';
@@ -131,15 +149,15 @@ class BunMysqlDriver extends bun_driver_base_1.BunDriverBase {
         colDiffInstructions.push(sql.concat(';'));
         if (colDiff.colChanges?.foreignKeys) {
             colDiff.colChanges.foreignKeys.forEach((fk) => {
-                colDiffInstructions.push(`ALTER TABLE \`${schema}\`.\`${tableName}\` ADD CONSTRAINT \`${tableName}_${colName}_fk\` FOREIGN KEY (\`${colName}\`) REFERENCES \`${fk.referencedTableName}\` (\`${fk.referencedColumnName}\`);`);
+                colDiffInstructions.push(`ALTER TABLE \`${tableName}\` ADD CONSTRAINT \`${tableName}_${colName}_fk\` FOREIGN KEY (\`${colName}\`) REFERENCES \`${fk.referencedTableName}\` (\`${fk.referencedColumnName}\`);`);
             });
         }
     }
     getDropColumn(colDiffInstructions, schema, tableName, colName) {
-        colDiffInstructions.push(`ALTER TABLE \`${schema}\`.\`${tableName}\` DROP COLUMN IF EXISTS \`${colName}\`;`);
+        colDiffInstructions.push(`ALTER TABLE \`${tableName}\` DROP COLUMN IF EXISTS \`${colName}\`;`);
     }
     getDropIndex(index, schema, tableName) {
-        return `ALTER TABLE \`${schema}\`.\`${tableName}\` DROP INDEX \`${index.name}\`;`;
+        return `ALTER TABLE \`${tableName}\` DROP INDEX \`${index.name}\`;`;
     }
     getCreateUniqueConstraint(unique, schema, tableName) {
         const properties = unique.properties || [];
@@ -147,37 +165,37 @@ class BunMysqlDriver extends bun_driver_base_1.BunDriverBase {
             throw new Error("Unique properties are required.");
         }
         const columns = properties.map((prop) => `\`${prop}\``).join(', ');
-        return `ALTER TABLE \`${schema}\`.\`${tableName}\` ADD CONSTRAINT \`${unique.name}\` UNIQUE (${columns});`;
+        return `ALTER TABLE \`${tableName}\` ADD CONSTRAINT \`${unique.name}\` UNIQUE (${columns});`;
     }
     getDropUniqueConstraint(unique, schema, tableName) {
-        return `ALTER TABLE \`${schema}\`.\`${tableName}\` DROP INDEX \`${unique.name}\`;`;
+        return `ALTER TABLE \`${tableName}\` DROP INDEX \`${unique.name}\`;`;
     }
     getAlterTableType(schema, tableName, colName, colDiff) {
-        return `ALTER TABLE \`${schema}\`.\`${tableName}\` MODIFY COLUMN \`${colName}\` ${colDiff.colType}${colDiff.colLength ? `(${colDiff.colLength})` : ''};`;
+        return `ALTER TABLE \`${tableName}\` MODIFY COLUMN \`${colName}\` ${colDiff.colType}${colDiff.colLength ? `(${colDiff.colLength})` : ''};`;
     }
     getAlterTableDefaultInstruction(schema, tableName, colName, colDiff) {
-        return `ALTER TABLE \`${schema}\`.\`${tableName}\` ALTER COLUMN \`${colName}\` SET DEFAULT ${colDiff.colChanges.default};`;
+        return `ALTER TABLE \`${tableName}\` ALTER COLUMN \`${colName}\` SET DEFAULT ${colDiff.colChanges.default};`;
     }
     getAlterTablePrimaryKeyInstruction(schema, tableName, colName, colDiff) {
-        return `ALTER TABLE \`${schema}\`.\`${tableName}\` ADD PRIMARY KEY (\`${colName}\`);`;
+        return `ALTER TABLE \`${tableName}\` ADD PRIMARY KEY (\`${colName}\`);`;
     }
     getDropConstraint(param, schema, tableName) {
-        return `ALTER TABLE \`${schema}\`.\`${tableName}\` DROP FOREIGN KEY \`${param.name}\`;`;
+        return `ALTER TABLE \`${tableName}\` DROP FOREIGN KEY \`${param.name}\`;`;
     }
     getAddUniqueConstraint(schema, tableName, colName) {
-        return `ALTER TABLE \`${schema}\`.\`${tableName}\` ADD UNIQUE (\`${colName}\`);`;
+        return `ALTER TABLE \`${tableName}\` ADD UNIQUE (\`${colName}\`);`;
     }
     getAlterTableDropNullInstruction(schema, tableName, colName, colDiff) {
-        return `ALTER TABLE \`${schema}\`.\`${tableName}\` MODIFY COLUMN \`${colName}\` ${colDiff.colType} NULL;`;
+        return `ALTER TABLE \`${tableName}\` MODIFY COLUMN \`${colName}\` ${colDiff.colType} NULL;`;
     }
     getAlterTableDropNotNullInstruction(schema, tableName, colName, colDiff) {
-        return `ALTER TABLE \`${schema}\`.\`${tableName}\` MODIFY COLUMN \`${colName}\` ${colDiff.colType} NOT NULL;`;
+        return `ALTER TABLE \`${tableName}\` MODIFY COLUMN \`${colName}\` ${colDiff.colType} NOT NULL;`;
     }
     getAlterTableEnumInstruction(schema, tableName, colName, colDiff) {
         const enumValues = colDiff.colChanges.enumItems
             .map((item) => `'${item}'`)
             .join(', ');
-        return `ALTER TABLE \`${schema}\`.\`${tableName}\` MODIFY COLUMN \`${colName}\` ENUM(${enumValues});`;
+        return `ALTER TABLE \`${tableName}\` MODIFY COLUMN \`${colName}\` ENUM(${enumValues});`;
     }
     getDropTypeEnumInstruction(param, schema, tableName) {
         return '';
@@ -224,7 +242,7 @@ class BunMysqlDriver extends bun_driver_base_1.BunDriverBase {
         return match[1].split(',').map((v) => v.trim().replace(/'/g, ''));
     }
     async index(tableName, options) {
-        const result = await this.sql.unsafe(`SHOW INDEX FROM \`${tableName}\` FROM \`${options.schema || 'information_schema'}\``);
+        const result = await this.sql.unsafe(`SHOW INDEX FROM \`${tableName}\``);
         return result
             .filter((row) => row.Key_name !== 'PRIMARY')
             .map((row) => {

package/dist/driver/bun-pg.driver.d.ts

@@ -4,14 +4,14 @@ export declare class BunPgDriver extends BunDriverBase implements DriverInterfac
     readonly dbType: "postgres";
     constructor(options: ConnectionSettings);
     protected getProtocol(): string;
-    protected getIdentifierQuote(): string;
+    getIdentifierQuote(): string;
     protected buildAutoIncrementType(colDiff: ColDiff): string;
     protected buildEnumType(schema: string | undefined, tableName: string, colDiff: ColDiff): {
         beforeSql: string;
         columnType: string;
     };
     protected appendReturningClause(sql: string, statement: Statement<any>): string;
-    protected handleInsertReturn(statement: Statement<any>, result: any, sql: string, startTime: number): Promise<{
+    protected handleInsertReturn(statement: Statement<any>, result: any, sql: string, startTime: number, context: any): Promise<{
         query: any;
         startTime: number;
         sql: string;

package/dist/driver/bun-pg.driver.js

@@ -29,7 +29,7 @@ class BunPgDriver extends bun_driver_base_1.BunDriverBase {
         const cols = statement.columns.join(', ').replaceAll(`${statement.alias}.`, '');
         return `${sql} RETURNING ${cols}`;
     }
-    async handleInsertReturn(statement, result, sql, startTime) {
+    async handleInsertReturn(statement, result, sql, startTime, context) {
         return {
             query: { rows: Array.isArray(result) ? result : [] },
             startTime,

package/dist/driver/driver-factory.d.ts

@@ -0,0 +1,12 @@
+import { ConnectionSettings, DriverInterface } from './driver.interface';
+export type DriverType = 'postgres' | 'mysql';
+export type DriverClass = new (options: ConnectionSettings) => DriverInterface;
+export declare function getDriverType(): DriverType;
+export declare function getDriverClass(type: DriverType): DriverClass;
+export declare function getDefaultConnectionSettings(type: DriverType): {
+    host: string;
+    port: number;
+    database: string;
+    username: string;
+    password: string;
+};

package/dist/driver/driver-factory.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDriverType = getDriverType;
+exports.getDriverClass = getDriverClass;
+exports.getDefaultConnectionSettings = getDefaultConnectionSettings;
+const bun_pg_driver_1 = require("./bun-pg.driver");
+const bun_mysql_driver_1 = require("./bun-mysql.driver");
+function getDriverType() {
+    const envDriver = process.env.DB_DRIVER?.toLowerCase();
+    return envDriver === 'mysql' ? 'mysql' : 'postgres';
+}
+function getDriverClass(type) {
+    return type === 'mysql' ? bun_mysql_driver_1.BunMysqlDriver : bun_pg_driver_1.BunPgDriver;
+}
+function getDefaultConnectionSettings(type) {
+    if (type === 'mysql') {
+        return {
+            host: 'localhost',
+            port: 3306,
+            database: 'mysql_test',
+            username: 'root',
+            password: 'root',
+        };
+    }
+    return {
+        host: 'localhost',
+        port: 5433,
+        database: 'postgres',
+        username: 'postgres',
+        password: 'postgres',
+    };
+}

package/dist/driver/driver.interface.d.ts

@@ -5,6 +5,7 @@ import { ValueObject } from "../common/value-object";
 export interface DriverInterface {
     connectionString: string;
     readonly dbType: "postgres" | "mysql";
+    getIdentifierQuote(): string;
     executeStatement(statement: Statement<any>): Promise<{
         query: any;
         startTime: number;
@@ -46,6 +47,7 @@ export type SnapshotConstraintInfo = {
 };
 export interface CacheSettings {
     maxKeysPerTable?: number;
+    invalidateCacheOnWrite?: boolean;
 }
 export interface ConnectionSettings<T extends DriverInterface = DriverInterface> {
     host?: string;