@mikro-orm/sql 7.0.0-dev.321 → 7.0.0-dev.322

package/AbstractSqlDriver.js

@@ -60,7 +60,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         this.validateSqlOptions(options);
         const { first, last, before, after } = options;
         const isCursorPagination = [first, last, before, after].some(v => v != null);
-        qb.__populateWhere = options._populateWhere;
+        qb.state.resolvedPopulateWhere = options._populateWhere;
         qb.select(fields)
             // only add populateWhere if we are populate-joining, as this will be used to add `on` conditions
             .populate(populate, joinedProps.length > 0 ? populateWhere : undefined, joinedProps.length > 0 ? options.populateFilter : undefined)
@@ -270,7 +270,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
      * and need to be renamed back to `column_name` for the result mapper to work.
      */
     mapTPTColumns(result, meta, qb) {
-        const tptAliases = qb._tptAlias;
+        const tptAliases = qb.state.tptAlias;
         // Walk up the TPT hierarchy
         let parentMeta = meta.tptParent;
         while (parentMeta) {
@@ -528,7 +528,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
             this.buildFields(meta, populate, joinedProps, qb, qb.alias, options, schema);
         }
         this.validateSqlOptions(options);
-        qb.__populateWhere = options._populateWhere;
+        qb.state.resolvedPopulateWhere = options._populateWhere;
         qb.indexHint(options.indexHint)
             .collation(options.collation)
             .comment(options.comments)
@@ -1538,7 +1538,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
      * @internal
      */
     findTPTChildAlias(qb, childMeta) {
-        const joins = qb._joins;
+        const joins = qb.state.joins;
         for (const key of Object.keys(joins)) {
             if (joins[key].table === childMeta.tableName && key.includes('[tpt]')) {
                 return joins[key].alias;

package/PivotCollectionPersister.d.ts

@@ -1,17 +1,8 @@
 import { type Dictionary, type EntityMetadata, type EntityProperty, type Primary, type Transaction } from '@mikro-orm/core';
 import { type AbstractSqlDriver } from './AbstractSqlDriver.js';
 export declare class PivotCollectionPersister<Entity extends object> {
-    private readonly meta;
-    private readonly driver;
-    private readonly ctx?;
-    private readonly schema?;
-    private readonly loggerContext?;
-    private readonly inserts;
-    private readonly upserts;
-    private readonly deletes;
-    private readonly batchSize;
-    private order;
-    constructor(meta: EntityMetadata<Entity>, driver: AbstractSqlDriver, ctx?: Transaction | undefined, schema?: string | undefined, loggerContext?: Dictionary | undefined);
+    #private;
+    constructor(meta: EntityMetadata<Entity>, driver: AbstractSqlDriver, ctx?: Transaction, schema?: string, loggerContext?: Dictionary);
     enqueueUpdate(prop: EntityProperty<Entity>, insertDiff: Primary<Entity>[][], deleteDiff: Primary<Entity>[][] | boolean, pks: Primary<Entity>[], isInitialized?: boolean): void;
     private enqueueInsert;
     private enqueueUpsert;

package/PivotCollectionPersister.js

@@ -1,55 +1,55 @@
 class InsertStatement {
-    keys;
-    data;
     order;
+    #keys;
+    #data;
     constructor(keys, data, order) {
-        this.keys = keys;
-        this.data = data;
         this.order = order;
+        this.#keys = keys;
+        this.#data = data;
     }
     getHash() {
-        return JSON.stringify(this.data);
+        return JSON.stringify(this.#data);
     }
     getData() {
         const data = {};
-        this.keys.forEach((key, idx) => (data[key] = this.data[idx]));
+        this.#keys.forEach((key, idx) => (data[key] = this.#data[idx]));
         return data;
     }
 }
 class DeleteStatement {
-    keys;
-    cond;
+    #keys;
+    #cond;
     constructor(keys, cond) {
-        this.keys = keys;
-        this.cond = cond;
+        this.#keys = keys;
+        this.#cond = cond;
     }
     getHash() {
-        return JSON.stringify(this.cond);
+        return JSON.stringify(this.#cond);
     }
     getCondition() {
         const cond = {};
-        this.keys.forEach((key, idx) => (cond[key] = this.cond[idx]));
+        this.#keys.forEach((key, idx) => (cond[key] = this.#cond[idx]));
         return cond;
     }
 }
 export class PivotCollectionPersister {
-    meta;
-    driver;
-    ctx;
-    schema;
-    loggerContext;
-    inserts = new Map();
-    upserts = new Map();
-    deletes = new Map();
-    batchSize;
-    order = 0;
+    #inserts = new Map();
+    #upserts = new Map();
+    #deletes = new Map();
+    #batchSize;
+    #order = 0;
+    #meta;
+    #driver;
+    #ctx;
+    #schema;
+    #loggerContext;
     constructor(meta, driver, ctx, schema, loggerContext) {
-        this.meta = meta;
-        this.driver = driver;
-        this.ctx = ctx;
-        this.schema = schema;
-        this.loggerContext = loggerContext;
-        this.batchSize = this.driver.config.get('batchSize');
+        this.#meta = meta;
+        this.#driver = driver;
+        this.#ctx = ctx;
+        this.#schema = schema;
+        this.#loggerContext = loggerContext;
+        this.#batchSize = this.#driver.config.get('batchSize');
     }
     enqueueUpdate(prop, insertDiff, deleteDiff, pks, isInitialized = true) {
         if (insertDiff.length) {
@@ -68,8 +68,8 @@ export class PivotCollectionPersister {
         for (const fks of insertDiff) {
             const statement = this.createInsertStatement(prop, fks, pks);
             const hash = statement.getHash();
-            if (prop.owner || !this.inserts.has(hash)) {
-                this.inserts.set(hash, statement);
+            if (prop.owner || !this.#inserts.has(hash)) {
+                this.#inserts.set(hash, statement);
             }
         }
     }
@@ -77,26 +77,26 @@ export class PivotCollectionPersister {
         for (const fks of insertDiff) {
             const statement = this.createInsertStatement(prop, fks, pks);
             const hash = statement.getHash();
-            if (prop.owner || !this.upserts.has(hash)) {
-                this.upserts.set(hash, statement);
+            if (prop.owner || !this.#upserts.has(hash)) {
+                this.#upserts.set(hash, statement);
             }
         }
     }
     createInsertStatement(prop, fks, pks) {
         const { data, keys } = this.buildPivotKeysAndData(prop, fks, pks);
-        return new InsertStatement(keys, data, this.order++);
+        return new InsertStatement(keys, data, this.#order++);
     }
     enqueueDelete(prop, deleteDiff, pks) {
         if (deleteDiff === true) {
             const { data, keys } = this.buildPivotKeysAndData(prop, [], pks, true);
             const statement = new DeleteStatement(keys, data);
-            this.deletes.set(statement.getHash(), statement);
+            this.#deletes.set(statement.getHash(), statement);
             return;
         }
         for (const fks of deleteDiff) {
             const { data, keys } = this.buildPivotKeysAndData(prop, fks, pks);
             const statement = new DeleteStatement(keys, data);
-            this.deletes.set(statement.getHash(), statement);
+            this.#deletes.set(statement.getHash(), statement);
         }
     }
     /**
@@ -130,46 +130,46 @@ export class PivotCollectionPersister {
         return items.filter(Boolean);
     }
     async execute() {
-        if (this.deletes.size > 0) {
-            const deletes = [...this.deletes.values()];
-            for (let i = 0; i < deletes.length; i += this.batchSize) {
-                const chunk = deletes.slice(i, i + this.batchSize);
+        if (this.#deletes.size > 0) {
+            const deletes = [...this.#deletes.values()];
+            for (let i = 0; i < deletes.length; i += this.#batchSize) {
+                const chunk = deletes.slice(i, i + this.#batchSize);
                 const cond = { $or: [] };
                 for (const item of chunk) {
                     cond.$or.push(item.getCondition());
                 }
-                await this.driver.nativeDelete(this.meta.class, cond, {
-                    ctx: this.ctx,
-                    schema: this.schema,
-                    loggerContext: this.loggerContext,
+                await this.#driver.nativeDelete(this.#meta.class, cond, {
+                    ctx: this.#ctx,
+                    schema: this.#schema,
+                    loggerContext: this.#loggerContext,
                 });
             }
         }
-        if (this.inserts.size > 0) {
-            const filtered = this.collectStatements(this.inserts);
-            for (let i = 0; i < filtered.length; i += this.batchSize) {
-                const chunk = filtered.slice(i, i + this.batchSize);
-                await this.driver.nativeInsertMany(this.meta.class, chunk, {
-                    ctx: this.ctx,
-                    schema: this.schema,
+        if (this.#inserts.size > 0) {
+            const filtered = this.collectStatements(this.#inserts);
+            for (let i = 0; i < filtered.length; i += this.#batchSize) {
+                const chunk = filtered.slice(i, i + this.#batchSize);
+                await this.#driver.nativeInsertMany(this.#meta.class, chunk, {
+                    ctx: this.#ctx,
+                    schema: this.#schema,
                     convertCustomTypes: false,
                     processCollections: false,
-                    loggerContext: this.loggerContext,
+                    loggerContext: this.#loggerContext,
                 });
             }
         }
-        if (this.upserts.size > 0) {
-            const filtered = this.collectStatements(this.upserts);
-            for (let i = 0; i < filtered.length; i += this.batchSize) {
-                const chunk = filtered.slice(i, i + this.batchSize);
-                await this.driver.nativeUpdateMany(this.meta.class, [], chunk, {
-                    ctx: this.ctx,
-                    schema: this.schema,
+        if (this.#upserts.size > 0) {
+            const filtered = this.collectStatements(this.#upserts);
+            for (let i = 0; i < filtered.length; i += this.#batchSize) {
+                const chunk = filtered.slice(i, i + this.#batchSize);
+                await this.#driver.nativeUpdateMany(this.#meta.class, [], chunk, {
+                    ctx: this.#ctx,
+                    schema: this.#schema,
                     convertCustomTypes: false,
                     processCollections: false,
                     upsert: true,
                     onConflictAction: 'ignore',
-                    loggerContext: this.loggerContext,
+                    loggerContext: this.#loggerContext,
                 });
             }
         }

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -5,7 +5,7 @@ import { SchemaHelper } from '../../schema/SchemaHelper.js';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
 import type { DatabaseTable } from '../../schema/DatabaseTable.js';
 export declare class MySqlSchemaHelper extends SchemaHelper {
-    private readonly _cache;
+    #private;
     static readonly DEFAULT_VALUES: {
         'now()': string[];
         'current_timestamp(?)': string[];

package/dialects/mysql/MySqlSchemaHelper.js

@@ -1,7 +1,7 @@
 import { EnumType, StringType, TextType } from '@mikro-orm/core';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
 export class MySqlSchemaHelper extends SchemaHelper {
-    _cache = {};
+    #cache = {};
     static DEFAULT_VALUES = {
         'now()': ['now()', 'current_timestamp'],
         'current_timestamp(?)': ['current_timestamp(?)'],
@@ -344,12 +344,12 @@ export class MySqlSchemaHelper extends SchemaHelper {
         }, {});
     }
     async supportsCheckConstraints(connection) {
-        if (this._cache.supportsCheckConstraints != null) {
-            return this._cache.supportsCheckConstraints;
+        if (this.#cache.supportsCheckConstraints != null) {
+            return this.#cache.supportsCheckConstraints;
         }
         const sql = `select 1 from information_schema.tables where table_name = 'CHECK_CONSTRAINTS' and table_schema = 'information_schema'`;
         const res = await connection.execute(sql);
-        return (this._cache.supportsCheckConstraints = res.length > 0);
+        return (this.#cache.supportsCheckConstraints = res.length > 0);
     }
     getChecksSQL(tables) {
         return `select cc.constraint_schema as table_schema, tc.table_name as table_name, cc.constraint_name as name, cc.check_clause as expression

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-dev.321",
+  "version": "7.0.0-dev.322",
   "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.",
   "keywords": [
     "data-mapper",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^6.6.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.321"
+    "@mikro-orm/core": "7.0.0-dev.322"
   },
   "engines": {
     "node": ">= 22.17.0"

package/plugin/index.d.ts

@@ -33,9 +33,7 @@ export interface MikroKyselyPluginOptions {
     convertValues?: boolean;
 }
 export declare class MikroKyselyPlugin implements KyselyPlugin {
-    private readonly options;
-    private static queryNodeCache;
-    private readonly transformer;
+    #private;
     constructor(em: SqlEntityManager, options?: MikroKyselyPluginOptions);
     transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
     transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;

package/plugin/index.js

@@ -1,39 +1,39 @@
 import { SelectQueryNode as SelectQueryNodeClass, InsertQueryNode as InsertQueryNodeClass, UpdateQueryNode as UpdateQueryNodeClass, DeleteQueryNode as DeleteQueryNodeClass, } from 'kysely';
 import { MikroTransformer } from './transformer.js';
 export class MikroKyselyPlugin {
-    options;
-    static queryNodeCache = new WeakMap();
-    transformer;
+    static #queryNodeCache = new WeakMap();
+    #transformer;
+    #options;
     constructor(em, options = {}) {
-        this.options = options;
-        this.transformer = new MikroTransformer(em, options);
+        this.#options = options;
+        this.#transformer = new MikroTransformer(em, options);
     }
     transformQuery(args) {
-        this.transformer.reset();
-        const result = this.transformer.transformNode(args.node, args.queryId);
+        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)) {
             // clone the entityMap because the transformer's internal map will be cleared and reused by the next query
-            const entityMap = new Map(this.transformer.getOutputEntityMap());
-            MikroKyselyPlugin.queryNodeCache.set(args.queryId, { entityMap });
+            const entityMap = new Map(this.#transformer.getOutputEntityMap());
+            MikroKyselyPlugin.#queryNodeCache.set(args.queryId, { entityMap });
         }
         return result;
     }
     async transformResult(args) {
         // Only transform results if columnNamingStrategy is 'property' or convertValues is true
-        if (this.options.columnNamingStrategy !== 'property' && !this.options.convertValues) {
+        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);
+        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);
+        const transformedRows = this.#transformer.transformResult(args.result.rows ?? [], cache.entityMap);
         return {
             ...args.result,
             rows: transformedRows ?? [],

package/plugin/transformer.d.ts

@@ -3,29 +3,14 @@ import { type CommonTableExpressionNameNode, type DeleteQueryNode, type Identifi
 import type { MikroKyselyPluginOptions } from './index.js';
 import type { SqlEntityManager } from '../SqlEntityManager.js';
 export declare class MikroTransformer extends OperationNodeTransformer {
-    private readonly em;
-    private readonly options;
-    /**
-     * 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
-     */
-    private readonly contextStack;
-    /**
-     * Subquery alias map: maps subquery/CTE alias to its source table metadata
-     * Used to resolve columns from subqueries/CTEs to their original table definitions
-     */
-    private readonly subqueryAliasMap;
-    private readonly metadata;
-    private readonly platform;
-    /**
-     * Global map of all entities involved in the query.
-     * Populated during AST transformation and used for result transformation.
-     */
-    private readonly entityMap;
+    #private;
     constructor(em: SqlEntityManager, options?: MikroKyselyPluginOptions);
     reset(): void;
     getOutputEntityMap(): Map<string, EntityMetadata>;
+    /** @internal */
+    getContextStack(): Map<string, EntityMetadata | undefined>[];
+    /** @internal */
+    getSubqueryAliasMap(): Map<string, EntityMetadata | undefined>;
     transformSelectQuery(node: SelectQueryNode, queryId: QueryId): SelectQueryNode;
     transformInsertQuery(node: InsertQueryNode, queryId?: QueryId): InsertQueryNode;
     transformUpdateQuery(node: UpdateQueryNode, queryId?: QueryId): UpdateQueryNode;