@mikro-orm/sql 7.0.0-dev.97 → 7.0.0-dev.99

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -0,0 +1,379 @@
+import { Utils } from '@mikro-orm/core';
+import { SchemaHelper } from '../../schema/SchemaHelper.js';
+export class SqliteSchemaHelper extends SchemaHelper {
+    disableForeignKeysSQL() {
+        return 'pragma foreign_keys = off;';
+    }
+    enableForeignKeysSQL() {
+        return 'pragma foreign_keys = on;';
+    }
+    supportsSchemaConstraints() {
+        return false;
+    }
+    getListTablesSQL() {
+        return `select name as table_name from sqlite_master where type = 'table' and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys' `
+            + `union all select name as table_name from sqlite_temp_master where type = 'table' order by name`;
+    }
+    getDropDatabaseSQL(name) {
+        if (name === ':memory:') {
+            return '';
+        }
+        /* v8 ignore next */
+        return `drop database if exists ${this.quote(name)}`;
+    }
+    async loadInformationSchema(schema, connection, tables, schemas) {
+        for (const t of tables) {
+            const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
+            const cols = await this.getColumns(connection, table.name, table.schema);
+            const indexes = await this.getIndexes(connection, table.name, table.schema);
+            const checks = await this.getChecks(connection, table.name, table.schema);
+            const pks = await this.getPrimaryKeys(connection, indexes, table.name, table.schema);
+            const fks = await this.getForeignKeys(connection, table.name, table.schema);
+            const enums = await this.getEnumDefinitions(connection, table.name);
+            table.init(cols, indexes, checks, pks, fks, enums);
+        }
+    }
+    createTable(table, alter) {
+        let sql = `create table ${table.getQuotedName()} (`;
+        const columns = table.getColumns();
+        const lastColumn = columns[columns.length - 1].name;
+        for (const column of columns) {
+            const col = this.createTableColumn(column, table);
+            if (col) {
+                const comma = column.name === lastColumn ? '' : ', ';
+                sql += col + comma;
+            }
+        }
+        const primaryKey = table.getPrimaryKey();
+        const createPrimary = primaryKey?.composite;
+        if (createPrimary && primaryKey) {
+            sql += `, primary key (${primaryKey.columnNames.map(c => this.quote(c)).join(', ')})`;
+        }
+        const parts = [];
+        for (const fk of Object.values(table.getForeignKeys())) {
+            parts.push(this.createForeignKey(table, fk, false));
+        }
+        for (const check of table.getChecks()) {
+            const sql = `constraint ${this.quote(check.name)} check (${check.expression})`;
+            parts.push(sql);
+        }
+        if (parts.length > 0) {
+            sql += ', ' + parts.join(', ');
+        }
+        sql += ')';
+        const ret = [];
+        this.append(ret, sql);
+        for (const index of table.getIndexes()) {
+            this.append(ret, this.createIndex(index, table));
+        }
+        return ret;
+    }
+    createTableColumn(column, table, _changedProperties) {
+        const col = [this.quote(column.name)];
+        const checks = table.getChecks();
+        const check = checks.findIndex(check => check.columnName === column.name);
+        const useDefault = column.default != null && column.default !== 'null';
+        let columnType = column.type;
+        if (column.autoincrement) {
+            columnType = 'integer';
+        }
+        if (column.generated) {
+            columnType += ` generated always as ${column.generated}`;
+        }
+        col.push(columnType);
+        if (check !== -1) {
+            col.push(`check (${checks[check].expression})`);
+            checks.splice(check, 1);
+        }
+        Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
+        Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable && !column.generated);
+        Utils.runIfNotEmpty(() => col.push('primary key'), column.primary);
+        Utils.runIfNotEmpty(() => col.push('autoincrement'), column.autoincrement);
+        Utils.runIfNotEmpty(() => col.push(`default ${column.default}`), useDefault);
+        return col.join(' ');
+    }
+    getAddColumnsSQL(table, columns, diff) {
+        return columns.map(column => {
+            let sql = `alter table ${table.getQuotedName()} add column ${this.createTableColumn(column, table)}`;
+            const foreignKey = Object.values(diff.addedForeignKeys).find(fk => fk.columnNames.length === 1 && fk.columnNames[0] === column.name);
+            if (foreignKey && this.options.createForeignKeyConstraints) {
+                delete diff.addedForeignKeys[foreignKey.constraintName];
+                sql += ' ' + this.createForeignKey(diff.toTable, foreignKey, false, true);
+            }
+            return sql;
+        });
+    }
+    dropForeignKey(tableName, constraintName) {
+        return '';
+    }
+    getDropColumnsSQL(tableName, columns, schemaName) {
+        /* v8 ignore next */
+        const name = this.quote((schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName);
+        return columns.map(column => {
+            return `alter table ${name} drop column ${this.quote(column.name)}`;
+        }).join(';\n');
+    }
+    getCreateIndexSQL(tableName, index) {
+        /* v8 ignore next */
+        if (index.expression) {
+            return index.expression;
+        }
+        tableName = this.quote(tableName);
+        const keyName = this.quote(index.keyName);
+        const sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName} `;
+        if (index.columnNames.some(column => column.includes('.'))) {
+            // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
+            const sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName} `;
+            const columns = this.platform.getJsonIndexDefinition(index);
+            return `${sql}(${columns.join(', ')})`;
+        }
+        return `${sql}(${index.columnNames.map(c => this.quote(c)).join(', ')})`;
+    }
+    parseTableDefinition(sql, cols) {
+        const columns = {};
+        const constraints = [];
+        // extract all columns definitions
+        let columnsDef = sql.replaceAll('\n', '').match(new RegExp(`create table [\`"']?.*?[\`"']? \\((.*)\\)`, 'i'))?.[1];
+        /* v8 ignore next */
+        if (columnsDef) {
+            if (columnsDef.includes(', constraint ')) {
+                constraints.push(...columnsDef.substring(columnsDef.indexOf(', constraint') + 2).split(', '));
+                columnsDef = columnsDef.substring(0, columnsDef.indexOf(', constraint'));
+            }
+            for (let i = cols.length - 1; i >= 0; i--) {
+                const col = cols[i];
+                const re = ` *, *[\`"']?${col.name}[\`"']? (.*)`;
+                const columnDef = columnsDef.match(new RegExp(re, 'i'));
+                if (columnDef) {
+                    columns[col.name] = { name: col.name, definition: columnDef[1] };
+                    columnsDef = columnsDef.substring(0, columnDef.index);
+                }
+            }
+        }
+        return { columns, constraints };
+    }
+    async getColumns(connection, tableName, schemaName) {
+        const columns = await connection.execute(`pragma table_xinfo('${tableName}')`);
+        const sql = `select sql from sqlite_master where type = ? and name = ?`;
+        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
+        const composite = columns.reduce((count, col) => count + (col.pk ? 1 : 0), 0) > 1;
+        // there can be only one, so naive check like this should be enough
+        const hasAutoincrement = tableDefinition.sql.toLowerCase().includes('autoincrement');
+        const { columns: columnDefinitions } = this.parseTableDefinition(tableDefinition.sql, columns);
+        return columns.map(col => {
+            const mappedType = connection.getPlatform().getMappedType(col.type);
+            let generated;
+            if (col.hidden > 1) {
+                /* v8 ignore next */
+                const storage = col.hidden === 2 ? 'virtual' : 'stored';
+                const re = new RegExp(`(generated always)? as \\((.*)\\)( ${storage})?$`, 'i');
+                const match = columnDefinitions[col.name].definition.match(re);
+                if (match) {
+                    generated = `${match[2]} ${storage}`;
+                }
+            }
+            return {
+                name: col.name,
+                type: col.type,
+                default: col.dflt_value,
+                nullable: !col.notnull,
+                primary: !!col.pk,
+                mappedType,
+                unsigned: false,
+                autoincrement: !composite && col.pk && this.platform.isNumericColumn(mappedType) && hasAutoincrement,
+                generated,
+            };
+        });
+    }
+    async getEnumDefinitions(connection, tableName) {
+        const sql = `select sql from sqlite_master where type = ? and name = ?`;
+        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
+        const checkConstraints = [...(tableDefinition.sql.match(/[`["'][^`\]"']+[`\]"'] text check \(.*?\)/gi) ?? [])];
+        return checkConstraints.reduce((o, item) => {
+            // check constraints are defined as (note that last closing paren is missing):
+            // `type` text check (`type` in ('local', 'global')
+            const match = item.match(/[`["']([^`\]"']+)[`\]"'] text check \(.* \((.*)\)/i);
+            /* v8 ignore next */
+            if (match) {
+                o[match[1]] = match[2].split(',').map((item) => item.trim().match(/^\(?'(.*)'/)[1]);
+            }
+            return o;
+        }, {});
+    }
+    async getPrimaryKeys(connection, indexes, tableName, schemaName) {
+        const sql = `pragma table_info(\`${tableName}\`)`;
+        const cols = await connection.execute(sql);
+        return cols.filter(col => !!col.pk).map(col => col.name);
+    }
+    async getIndexes(connection, tableName, schemaName) {
+        const sql = `pragma table_info(\`${tableName}\`)`;
+        const cols = await connection.execute(sql);
+        const indexes = await connection.execute(`pragma index_list(\`${tableName}\`)`);
+        const ret = [];
+        for (const col of cols.filter(c => c.pk)) {
+            ret.push({
+                columnNames: [col.name],
+                keyName: 'primary',
+                constraint: true,
+                unique: true,
+                primary: true,
+            });
+        }
+        for (const index of indexes.filter(index => !this.isImplicitIndex(index.name))) {
+            const res = await connection.execute(`pragma index_info(\`${index.name}\`)`);
+            ret.push(...res.map(row => ({
+                columnNames: [row.name],
+                keyName: index.name,
+                unique: !!index.unique,
+                constraint: !!index.unique,
+                primary: false,
+            })));
+        }
+        return this.mapIndexes(ret);
+    }
+    async getChecks(connection, tableName, schemaName) {
+        const { columns, constraints } = await this.getColumnDefinitions(connection, tableName, schemaName);
+        const checks = [];
+        for (const key of Object.keys(columns)) {
+            const column = columns[key];
+            const expression = column.definition.match(/ (check \((.*)\))/i);
+            if (expression) {
+                checks.push({
+                    name: this.platform.getConfig().getNamingStrategy().indexName(tableName, [column.name], 'check'),
+                    definition: expression[1],
+                    expression: expression[2],
+                    columnName: column.name,
+                });
+            }
+        }
+        for (const constraint of constraints) {
+            const expression = constraint.match(/constraint *[`"']?(.*?)[`"']? * (check \((.*)\))/i);
+            if (expression) {
+                checks.push({
+                    name: expression[1],
+                    definition: expression[2],
+                    expression: expression[3],
+                });
+            }
+        }
+        return checks;
+    }
+    async getColumnDefinitions(connection, tableName, schemaName) {
+        const columns = await connection.execute(`pragma table_xinfo('${tableName}')`);
+        const sql = `select sql from sqlite_master where type = ? and name = ?`;
+        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
+        return this.parseTableDefinition(tableDefinition.sql, columns);
+    }
+    async getForeignKeys(connection, tableName, schemaName) {
+        const { constraints } = await this.getColumnDefinitions(connection, tableName, schemaName);
+        const fks = await connection.execute(`pragma foreign_key_list(\`${tableName}\`)`);
+        return fks.reduce((ret, fk) => {
+            const constraintName = this.platform.getIndexName(tableName, [fk.from], 'foreign');
+            const constraint = constraints?.find(c => c.includes(constraintName));
+            ret[constraintName] = {
+                constraintName,
+                columnName: fk.from,
+                columnNames: [fk.from],
+                localTableName: tableName,
+                referencedTableName: fk.table,
+                referencedColumnName: fk.to,
+                referencedColumnNames: [fk.to],
+                updateRule: fk.on_update.toLowerCase(),
+                deleteRule: fk.on_delete.toLowerCase(),
+                deferMode: constraint?.match(/ deferrable initially (deferred|immediate)/i)?.[1].toLowerCase(),
+            };
+            return ret;
+        }, {});
+    }
+    getManagementDbName() {
+        return '';
+    }
+    getCreateDatabaseSQL(name) {
+        return '';
+    }
+    async databaseExists(connection, name) {
+        const tables = await connection.execute(this.getListTablesSQL());
+        return tables.length > 0;
+    }
+    /**
+     * Implicit indexes will be ignored when diffing
+     */
+    isImplicitIndex(name) {
+        // Ignore indexes with reserved names, e.g. autoindexes
+        return name.startsWith('sqlite_');
+    }
+    dropIndex(table, index, oldIndexName = index.keyName) {
+        return `drop index ${this.quote(oldIndexName)}`;
+    }
+    alterTable(diff, safe) {
+        const ret = [];
+        const [schemaName, tableName] = this.splitTableName(diff.name);
+        if (Utils.hasObjectKeys(diff.removedChecks)
+            || Utils.hasObjectKeys(diff.changedChecks)
+            || Utils.hasObjectKeys(diff.changedForeignKeys)
+            || Utils.hasObjectKeys(diff.changedColumns)) {
+            return this.getAlterTempTableSQL(diff);
+        }
+        for (const index of Object.values(diff.removedIndexes)) {
+            this.append(ret, this.dropIndex(diff.name, index));
+        }
+        for (const index of Object.values(diff.changedIndexes)) {
+            this.append(ret, this.dropIndex(diff.name, index));
+        }
+        /* v8 ignore next */
+        if (!safe && Object.values(diff.removedColumns).length > 0) {
+            this.append(ret, this.getDropColumnsSQL(tableName, Object.values(diff.removedColumns), schemaName));
+        }
+        if (Object.values(diff.addedColumns).length > 0) {
+            this.append(ret, this.getAddColumnsSQL(diff.toTable, Object.values(diff.addedColumns), diff));
+        }
+        if (Utils.hasObjectKeys(diff.addedForeignKeys) || Utils.hasObjectKeys(diff.addedChecks)) {
+            return this.getAlterTempTableSQL(diff);
+        }
+        for (const [oldColumnName, column] of Object.entries(diff.renamedColumns)) {
+            this.append(ret, this.getRenameColumnSQL(tableName, oldColumnName, column, schemaName));
+        }
+        for (const index of Object.values(diff.addedIndexes)) {
+            ret.push(this.createIndex(index, diff.toTable));
+        }
+        for (const index of Object.values(diff.changedIndexes)) {
+            ret.push(this.createIndex(index, diff.toTable, true));
+        }
+        for (const [oldIndexName, index] of Object.entries(diff.renamedIndexes)) {
+            if (index.unique) {
+                this.append(ret, this.dropIndex(diff.name, index, oldIndexName));
+                this.append(ret, this.createIndex(index, diff.toTable));
+            }
+            else {
+                this.append(ret, this.getRenameIndexSQL(diff.name, index, oldIndexName));
+            }
+        }
+        return ret;
+    }
+    getAlterTempTableSQL(changedTable) {
+        const tempName = `${(changedTable.toTable.name)}__temp_alter`;
+        const quotedName = this.quote(changedTable.toTable.name);
+        const quotedTempName = this.quote(tempName);
+        const [first, ...rest] = this.createTable(changedTable.toTable);
+        const sql = [
+            'pragma foreign_keys = off;',
+            first.replace(`create table ${quotedName}`, `create table ${quotedTempName}`),
+        ];
+        const columns = [];
+        for (const column of changedTable.toTable.getColumns()) {
+            const fromColumn = changedTable.fromTable.getColumn(column.name);
+            if (fromColumn) {
+                columns.push(this.quote(column.name));
+            }
+            else {
+                columns.push(`null as ${this.quote(column.name)}`);
+            }
+        }
+        sql.push(`insert into ${quotedTempName} select ${columns.join(', ')} from ${quotedName};`);
+        sql.push(`drop table ${quotedName};`);
+        sql.push(`alter table ${quotedTempName} rename to ${quotedName};`);
+        sql.push(...rest);
+        sql.push('pragma foreign_keys = on;');
+        return sql;
+    }
+}

package/dialects/sqlite/index.d.ts

@@ -0,0 +1,5 @@
+export * from './BaseSqliteConnection.js';
+export * from './BaseSqlitePlatform.js';
+export * from './SqliteSchemaHelper.js';
+export * from './SqliteNativeQueryBuilder.js';
+export * from './SqliteExceptionConverter.js';

package/dialects/sqlite/index.js

@@ -0,0 +1,5 @@
+export * from './BaseSqliteConnection.js';
+export * from './BaseSqlitePlatform.js';
+export * from './SqliteSchemaHelper.js';
+export * from './SqliteNativeQueryBuilder.js';
+export * from './SqliteExceptionConverter.js';

package/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @packageDocumentation
+ * @module sql
+ */
+export { Kysely } from 'kysely';
+export * from '@mikro-orm/core';
+export * from './AbstractSqlConnection.js';
+export * from './AbstractSqlDriver.js';
+export * from './AbstractSqlPlatform.js';
+export * from './SqlEntityManager.js';
+export * from './SqlEntityRepository.js';
+export * from './query/index.js';
+export { raw } from './query/index.js';
+export * from './schema/index.js';
+export * from './dialects/index.js';
+export * from './typings.js';
+export * from './plugin/index.js';
+export { SqlEntityManager as EntityManager } from './SqlEntityManager.js';
+export { SqlEntityRepository as EntityRepository } from './SqlEntityRepository.js';

package/index.js

@@ -0,0 +1,19 @@
+/**
+ * @packageDocumentation
+ * @module sql
+ */
+export { Kysely } from 'kysely';
+export * from '@mikro-orm/core';
+export * from './AbstractSqlConnection.js';
+export * from './AbstractSqlDriver.js';
+export * from './AbstractSqlPlatform.js';
+export * from './SqlEntityManager.js';
+export * from './SqlEntityRepository.js';
+export * from './query/index.js';
+export { raw } from './query/index.js';
+export * from './schema/index.js';
+export * from './dialects/index.js';
+export * from './typings.js';
+export * from './plugin/index.js';
+export { SqlEntityManager as EntityManager } from './SqlEntityManager.js';
+export { SqlEntityRepository as EntityRepository } from './SqlEntityRepository.js';

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-dev.97",
+  "version": "7.0.0-dev.99",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "type": "module",
   "exports": {
     "./package.json": "./package.json",
-    ".": "./src/index.ts"
+    ".": "./index.js"
   },
   "repository": {
     "type": "git",
@@ -57,6 +57,6 @@
     "@mikro-orm/core": "^6.6.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.97"
+    "@mikro-orm/core": "7.0.0-dev.99"
   }
 }

package/plugin/index.d.ts

@@ -0,0 +1,53 @@
+import { type KyselyPlugin, type PluginTransformQueryArgs, type PluginTransformResultArgs, type QueryResult, type RootOperationNode, type UnknownRow } from 'kysely';
+import { MikroTransformer } from './transformer.js';
+import type { SqlEntityManager } from '../SqlEntityManager.js';
+import type { EntityMetadata } from '@mikro-orm/core';
+/**
+ * Cache for query transformation data
+ * Stores the query node and metadata about tables/aliases
+ */
+interface QueryTransformCache {
+    entityMap: Map<string, EntityMetadata>;
+}
+export interface MikroKyselyPluginOptions {
+    /**
+     * Use database table names ('table') or entity names ('entity') in queries.
+     *
+     * @default 'table'
+     */
+    tableNamingStrategy?: 'table' | 'entity';
+    /**
+     * Use database column names ('column') or property names ('property') in queries.
+     *
+     * @default 'column'
+     */
+    columnNamingStrategy?: 'column' | 'property';
+    /**
+     * Automatically process entity `onCreate` hooks in INSERT queries.
+     *
+     * @default false
+     */
+    processOnCreateHooks?: boolean;
+    /**
+     * Automatically process entity `onUpdate` hooks in UPDATE queries.
+     *
+     * @default false
+     */
+    processOnUpdateHooks?: boolean;
+    /**
+     * Convert JavaScript values to database-compatible values (e.g., Date to timestamp, custom types).
+     *
+     * @default false
+     */
+    convertValues?: boolean;
+}
+export declare class MikroKyselyPlugin implements KyselyPlugin {
+    protected readonly em: SqlEntityManager;
+    protected readonly options: MikroKyselyPluginOptions;
+    protected static queryNodeCache: WeakMap<any, QueryTransformCache>;
+    protected readonly transformer: MikroTransformer;
+    constructor(em: SqlEntityManager, options?: MikroKyselyPluginOptions);
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
+}
+export {};

package/plugin/index.js

@@ -0,0 +1,42 @@
+import { SelectQueryNode as SelectQueryNodeClass, InsertQueryNode as InsertQueryNodeClass, UpdateQueryNode as UpdateQueryNodeClass, DeleteQueryNode as DeleteQueryNodeClass, } from 'kysely';
+import { MikroTransformer } from './transformer.js';
+export class MikroKyselyPlugin {
+    em;
+    options;
+    static queryNodeCache = new WeakMap();
+    transformer;
+    constructor(em, options = {}) {
+        this.em = em;
+        this.options = options;
+        this.transformer = new MikroTransformer(em, options);
+    }
+    transformQuery(args) {
+        this.transformer.reset();
+        const result = this.transformer.transformNode(args.node, args.queryId);
+        // Cache the entity map if it is one we can process (for use in transformResult)
+        if (SelectQueryNodeClass.is(args.node) ||
+            InsertQueryNodeClass.is(args.node) ||
+            UpdateQueryNodeClass.is(args.node) ||
+            DeleteQueryNodeClass.is(args.node)) {
+            MikroKyselyPlugin.queryNodeCache.set(args.queryId, { entityMap: this.transformer.getOutputEntityMap() });
+        }
+        return result;
+    }
+    async transformResult(args) {
+        // Only transform results if columnNamingStrategy is 'property' or convertValues is true
+        if (this.options.columnNamingStrategy !== 'property' && !this.options.convertValues) {
+            return args.result;
+        }
+        // Retrieve the cached query node and metadata
+        const cache = MikroKyselyPlugin.queryNodeCache.get(args.queryId);
+        if (!cache) {
+            return args.result;
+        }
+        // Transform the result rows using the transformer
+        const transformedRows = this.transformer.transformResult(args.result.rows ?? [], cache.entityMap);
+        return {
+            ...args.result,
+            rows: transformedRows ?? [],
+        };
+    }
+}

package/plugin/transformer.d.ts

@@ -0,0 +1,115 @@
+import { type EntityMetadata, type EntityProperty, type MetadataStorage } from '@mikro-orm/core';
+import { type CommonTableExpressionNameNode, type DeleteQueryNode, type IdentifierNode, type InsertQueryNode, type JoinNode, type MergeQueryNode, type QueryId, type SelectQueryNode, type UpdateQueryNode, type WithNode, ColumnNode, OperationNodeTransformer, TableNode } from 'kysely';
+import type { MikroKyselyPluginOptions } from './index.js';
+import type { SqlEntityManager } from '../SqlEntityManager.js';
+import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
+export declare class MikroTransformer extends OperationNodeTransformer {
+    protected readonly em: SqlEntityManager;
+    protected readonly options: MikroKyselyPluginOptions;
+    /**
+     * Context stack to support nested queries (subqueries, CTEs)
+     * Each level of query scope has its own Map of table aliases/names to EntityMetadata
+     * Top of stack (highest index) is the current scope
+     */
+    protected readonly contextStack: Map<string, EntityMetadata | undefined>[];
+    /**
+     * Subquery alias map: maps subquery/CTE alias to its source table metadata
+     * Used to resolve columns from subqueries/CTEs to their original table definitions
+     */
+    protected readonly subqueryAliasMap: Map<string, EntityMetadata | undefined>;
+    protected readonly metadata: MetadataStorage;
+    protected readonly platform: AbstractSqlPlatform;
+    /**
+     * Global map of all entities involved in the query.
+     * Populated during AST transformation and used for result transformation.
+     */
+    protected readonly entityMap: Map<string, EntityMetadata<any>>;
+    constructor(em: SqlEntityManager, options?: MikroKyselyPluginOptions);
+    reset(): void;
+    getOutputEntityMap(): Map<string, EntityMetadata>;
+    transformSelectQuery(node: SelectQueryNode, queryId: QueryId): SelectQueryNode;
+    transformInsertQuery(node: InsertQueryNode, queryId?: QueryId): InsertQueryNode;
+    transformUpdateQuery(node: UpdateQueryNode, queryId?: QueryId): UpdateQueryNode;
+    transformDeleteQuery(node: DeleteQueryNode, queryId?: QueryId): DeleteQueryNode;
+    transformMergeQuery(node: MergeQueryNode, queryId?: QueryId): MergeQueryNode;
+    transformIdentifier(node: IdentifierNode, queryId: QueryId): IdentifierNode;
+    /**
+     * Find owner entity metadata for the current identifier in the context stack.
+     * Supports both aliased and non-aliased table references.
+     * Searches up the context stack to support correlated subqueries.
+     * Also checks subquery/CTE aliases to resolve to their source tables.
+     */
+    findOwnerEntityInContext(): EntityMetadata | undefined;
+    processOnCreateHooks(node: InsertQueryNode, meta: EntityMetadata): InsertQueryNode;
+    processOnUpdateHooks(node: UpdateQueryNode, meta: EntityMetadata): UpdateQueryNode;
+    processInsertValues(node: InsertQueryNode, meta: EntityMetadata): InsertQueryNode;
+    processUpdateValues(node: UpdateQueryNode, meta: EntityMetadata): UpdateQueryNode;
+    mapColumnsToProperties(columns: readonly ColumnNode[], meta: EntityMetadata): (EntityProperty | undefined)[];
+    normalizeColumnName(identifier: IdentifierNode): string;
+    findProperty(meta: EntityMetadata | undefined, columnName?: string): EntityProperty | undefined;
+    shouldConvertValues(): boolean;
+    prepareInputValue(prop: EntityProperty | undefined, value: unknown, enabled: boolean): unknown;
+    /**
+     * Look up a table name/alias in the context stack.
+     * Searches from current scope (top of stack) to parent scopes (bottom).
+     * This supports correlated subqueries and references to outer query tables.
+     */
+    lookupInContextStack(tableNameOrAlias: string): EntityMetadata | undefined;
+    /**
+     * Process WITH node (CTE definitions)
+     */
+    processWithNode(withNode: WithNode, context: Map<string, EntityMetadata | undefined>): void;
+    /**
+     * Extract CTE name from CommonTableExpressionNameNode
+     */
+    getCTEName(nameNode: CommonTableExpressionNameNode): string | undefined;
+    /**
+     * Process a FROM item (can be TableNode or AliasNode)
+     */
+    processFromItem(from: any, // OperationNode type - can be TableNode, AliasNode, or SelectQueryNode
+    context: Map<string, EntityMetadata | undefined>): void;
+    /**
+     * Process a JOIN node
+     */
+    processJoinNode(join: JoinNode, context: Map<string, EntityMetadata | undefined>): void;
+    /**
+     * Extract the primary source table from a SELECT query
+     * This helps resolve columns from subqueries to their original entity tables
+     */
+    extractSourceTableFromSelectQuery(selectQuery: SelectQueryNode): EntityMetadata | undefined;
+    /**
+     * Extract alias name from an alias node
+     */
+    extractAliasName(alias: any): string | undefined;
+    /**
+     * Extract table name from a TableNode
+     */
+    getTableName(node: TableNode | undefined): string | undefined;
+    /**
+     * Find entity metadata by table name or entity name
+     */
+    findEntityMetadata(name: string): EntityMetadata | undefined;
+    /**
+     * Transform result rows by mapping database column names to property names
+     * This is called for SELECT queries when columnNamingStrategy is 'property'
+     */
+    transformResult(rows: Record<string, any>[] | undefined, entityMap: Map<string, EntityMetadata>): Record<string, any>[] | undefined;
+    buildGlobalFieldMap(entityMap: Map<string, EntityMetadata>): Record<string, EntityProperty>;
+    buildGlobalRelationFieldMap(entityMap: Map<string, EntityMetadata>): Record<string, string>;
+    /**
+     * Build a mapping from database field names to property objects
+     * Format: { 'field_name': EntityProperty }
+     */
+    buildFieldToPropertyMap(meta: EntityMetadata, alias?: string): Record<string, EntityProperty>;
+    /**
+     * Build a mapping for relation fields
+     * For ManyToOne relations, we need to map from the foreign key field to the relation property
+     * Format: { 'foreign_key_field': 'relationPropertyName' }
+     */
+    buildRelationFieldMap(meta: EntityMetadata, alias?: string): Record<string, string>;
+    /**
+     * Transform a single row by mapping column names to property names
+     */
+    transformRow(row: Record<string, any>, fieldToPropertyMap: Record<string, EntityProperty>, relationFieldMap: Record<string, string>): Record<string, any>;
+    prepareOutputValue(prop: EntityProperty | undefined, value: unknown): unknown;
+}