@mikro-orm/sql 7.0.0-rc.3 → 7.0.1-dev.0

package/plugin/transformer.js

@@ -1,44 +1,52 @@
 import { ReferenceKind, isRaw, } from '@mikro-orm/core';
 import { AliasNode, ColumnNode, ColumnUpdateNode, OperationNodeTransformer, PrimitiveValueListNode, ReferenceNode, SchemableIdentifierNode, TableNode, ValueListNode, ValueNode, ValuesNode, } from 'kysely';
 export class MikroTransformer extends OperationNodeTransformer {
-    em;
-    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
      */
-    contextStack = [];
+    #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
      */
-    subqueryAliasMap = new Map();
-    metadata;
-    platform;
+    #subqueryAliasMap = new Map();
+    #metadata;
+    #platform;
     /**
      * Global map of all entities involved in the query.
      * Populated during AST transformation and used for result transformation.
      */
-    entityMap = new Map();
+    #entityMap = new Map();
+    #em;
+    #options;
     constructor(em, options = {}) {
         super();
-        this.em = em;
-        this.options = options;
-        this.metadata = em.getMetadata();
-        this.platform = em.getDriver().getPlatform();
+        this.#em = em;
+        this.#options = options;
+        this.#metadata = em.getMetadata();
+        this.#platform = em.getDriver().getPlatform();
     }
     reset() {
-        this.subqueryAliasMap.clear();
-        this.entityMap.clear();
+        this.#subqueryAliasMap.clear();
+        this.#entityMap.clear();
     }
     getOutputEntityMap() {
-        return this.entityMap;
+        return this.#entityMap;
+    }
+    /** @internal */
+    getContextStack() {
+        return this.#contextStack;
+    }
+    /** @internal */
+    getSubqueryAliasMap() {
+        return this.#subqueryAliasMap;
     }
     transformSelectQuery(node, queryId) {
         // Push a new context for this query scope (starts with inherited parent context)
         const currentContext = new Map();
-        this.contextStack.push(currentContext);
+        this.#contextStack.push(currentContext);
         try {
             // Process WITH clause (CTEs) first - they define names available in this scope
             if (node.with) {
@@ -60,12 +68,12 @@ export class MikroTransformer extends OperationNodeTransformer {
         }
         finally {
             // Pop the context when exiting this query scope
-            this.contextStack.pop();
+            this.#contextStack.pop();
         }
     }
     transformInsertQuery(node, queryId) {
         const currentContext = new Map();
-        this.contextStack.push(currentContext);
+        this.#contextStack.push(currentContext);
         try {
             let entityMeta;
             if (node.into) {
@@ -75,12 +83,12 @@ export class MikroTransformer extends OperationNodeTransformer {
                     if (meta) {
                         entityMeta = meta;
                         currentContext.set(meta.tableName, meta);
-                        this.entityMap.set(meta.tableName, meta);
+                        this.#entityMap.set(meta.tableName, meta);
                     }
                 }
             }
-            const nodeWithHooks = this.options.processOnCreateHooks && entityMeta ? this.processOnCreateHooks(node, entityMeta) : node;
-            const nodeWithConvertedValues = this.options.convertValues && entityMeta ? this.processInsertValues(nodeWithHooks, entityMeta) : nodeWithHooks;
+            const nodeWithHooks = this.#options.processOnCreateHooks && entityMeta ? this.processOnCreateHooks(node, entityMeta) : node;
+            const nodeWithConvertedValues = this.#options.convertValues && entityMeta ? this.processInsertValues(nodeWithHooks, entityMeta) : nodeWithHooks;
             // Handle ON CONFLICT clause
             let finalNode = nodeWithConvertedValues;
             if (node.onConflict?.updates && entityMeta) {
@@ -91,14 +99,14 @@ export class MikroTransformer extends OperationNodeTransformer {
                     table: node.into, // Dummy table
                     updates: node.onConflict.updates,
                 };
-                const updatesWithHooks = this.options.processOnUpdateHooks
+                const updatesWithHooks = this.#options.processOnUpdateHooks
                     ? this.processOnUpdateHooks(tempUpdateNode, entityMeta).updates
                     : node.onConflict.updates;
                 const tempUpdateNodeWithHooks = {
                     ...tempUpdateNode,
                     updates: updatesWithHooks,
                 };
-                const updatesWithConvertedValues = this.options.convertValues
+                const updatesWithConvertedValues = this.#options.convertValues
                     ? this.processUpdateValues(tempUpdateNodeWithHooks, entityMeta).updates
                     : updatesWithHooks;
                 if (updatesWithConvertedValues && updatesWithConvertedValues !== node.onConflict.updates) {
@@ -115,12 +123,12 @@ export class MikroTransformer extends OperationNodeTransformer {
             return super.transformInsertQuery(finalNode, queryId);
         }
         finally {
-            this.contextStack.pop();
+            this.#contextStack.pop();
         }
     }
     transformUpdateQuery(node, queryId) {
         const currentContext = new Map();
-        this.contextStack.push(currentContext);
+        this.#contextStack.push(currentContext);
         try {
             let entityMeta;
             if (node.table && TableNode.is(node.table)) {
@@ -130,7 +138,7 @@ export class MikroTransformer extends OperationNodeTransformer {
                     if (meta) {
                         entityMeta = meta;
                         currentContext.set(meta.tableName, meta);
-                        this.entityMap.set(meta.tableName, meta);
+                        this.#entityMap.set(meta.tableName, meta);
                     }
                 }
             }
@@ -146,17 +154,17 @@ export class MikroTransformer extends OperationNodeTransformer {
                     this.processJoinNode(join, currentContext);
                 }
             }
-            const nodeWithHooks = this.options.processOnUpdateHooks && entityMeta ? this.processOnUpdateHooks(node, entityMeta) : node;
-            const nodeWithConvertedValues = this.options.convertValues && entityMeta ? this.processUpdateValues(nodeWithHooks, entityMeta) : nodeWithHooks;
+            const nodeWithHooks = this.#options.processOnUpdateHooks && entityMeta ? this.processOnUpdateHooks(node, entityMeta) : node;
+            const nodeWithConvertedValues = this.#options.convertValues && entityMeta ? this.processUpdateValues(nodeWithHooks, entityMeta) : nodeWithHooks;
             return super.transformUpdateQuery(nodeWithConvertedValues, queryId);
         }
         finally {
-            this.contextStack.pop();
+            this.#contextStack.pop();
         }
     }
     transformDeleteQuery(node, queryId) {
         const currentContext = new Map();
-        this.contextStack.push(currentContext);
+        this.#contextStack.push(currentContext);
         try {
             const froms = node.from?.froms;
             if (froms && froms.length > 0) {
@@ -167,7 +175,7 @@ export class MikroTransformer extends OperationNodeTransformer {
                         const meta = this.findEntityMetadata(tableName);
                         if (meta) {
                             currentContext.set(meta.tableName, meta);
-                            this.entityMap.set(meta.tableName, meta);
+                            this.#entityMap.set(meta.tableName, meta);
                         }
                     }
                 }
@@ -181,24 +189,24 @@ export class MikroTransformer extends OperationNodeTransformer {
             return super.transformDeleteQuery(node, queryId);
         }
         finally {
-            this.contextStack.pop();
+            this.#contextStack.pop();
         }
     }
     transformMergeQuery(node, queryId) {
         const currentContext = new Map();
-        this.contextStack.push(currentContext);
+        this.#contextStack.push(currentContext);
         try {
             return super.transformMergeQuery(node, queryId);
         }
         finally {
-            this.contextStack.pop();
+            this.#contextStack.pop();
         }
     }
     transformIdentifier(node, queryId) {
         node = super.transformIdentifier(node, queryId);
         const parent = this.nodeStack[this.nodeStack.length - 2];
         // Transform table names when tableNamingStrategy is 'entity'
-        if (this.options.tableNamingStrategy === 'entity' && parent && SchemableIdentifierNode.is(parent)) {
+        if (this.#options.tableNamingStrategy === 'entity' && parent && SchemableIdentifierNode.is(parent)) {
             const meta = this.findEntityMetadata(node.name);
             if (meta) {
                 return {
@@ -209,7 +217,7 @@ export class MikroTransformer extends OperationNodeTransformer {
         }
         // Transform column names when columnNamingStrategy is 'property'
         // Support ColumnNode, ColumnUpdateNode, and ReferenceNode (for JOIN conditions)
-        if (this.options.columnNamingStrategy === 'property' &&
+        if (this.#options.columnNamingStrategy === 'property' &&
             parent &&
             (ColumnNode.is(parent) || ColumnUpdateNode.is(parent) || ReferenceNode.is(parent))) {
             const ownerMeta = this.findOwnerEntityInContext();
@@ -239,8 +247,8 @@ export class MikroTransformer extends OperationNodeTransformer {
             const tableName = this.getTableName(reference.table);
             if (tableName) {
                 // First, check in subquery alias map (for CTE/subquery columns)
-                if (this.subqueryAliasMap.has(tableName)) {
-                    return this.subqueryAliasMap.get(tableName);
+                if (this.#subqueryAliasMap.has(tableName)) {
+                    return this.#subqueryAliasMap.get(tableName);
                 }
                 // Find entity metadata to get the actual table name
                 // Context uses table names (meta.tableName) as keys, not entity names
@@ -267,16 +275,16 @@ export class MikroTransformer extends OperationNodeTransformer {
             }
         }
         // If no explicit table reference, use the first entity in current context
-        if (this.contextStack.length > 0) {
-            const currentContext = this.contextStack[this.contextStack.length - 1];
+        if (this.#contextStack.length > 0) {
+            const currentContext = this.#contextStack[this.#contextStack.length - 1];
             for (const [alias, meta] of currentContext.entries()) {
                 if (meta) {
                     return meta;
                 }
                 // If the context value is undefined but the alias is in subqueryAliasMap,
                 // use the mapped metadata (for CTE/subquery cases)
-                if (!meta && this.subqueryAliasMap.has(alias)) {
-                    const mappedMeta = this.subqueryAliasMap.get(alias);
+                if (!meta && this.#subqueryAliasMap.has(alias)) {
+                    const mappedMeta = this.#subqueryAliasMap.get(alias);
                     if (mappedMeta) {
                         return mappedMeta;
                     }
@@ -306,7 +314,7 @@ export class MikroTransformer extends OperationNodeTransformer {
         }
         const newRows = node.values.values.map(row => {
             const valuesToAdd = missingProps.map(prop => {
-                const val = prop.onCreate(undefined, this.em);
+                const val = prop.onCreate(undefined, this.#em);
                 return val;
             });
             if (ValueListNode.is(row)) {
@@ -344,7 +352,7 @@ export class MikroTransformer extends OperationNodeTransformer {
         }
         const newUpdates = [...node.updates];
         for (const prop of missingProps) {
-            const val = prop.onUpdate(undefined, this.em);
+            const val = prop.onUpdate(undefined, this.#em);
             newUpdates.push(ColumnUpdateNode.create(ColumnNode.create(prop.name), ValueNode.create(val)));
         }
         return {
@@ -459,7 +467,7 @@ export class MikroTransformer extends OperationNodeTransformer {
         return meta.props.find(prop => prop.fieldNames?.includes(columnName));
     }
     shouldConvertValues() {
-        return !!this.options.convertValues;
+        return !!this.#options.convertValues;
     }
     prepareInputValue(prop, value, enabled) {
         if (!enabled || !prop || value == null) {
@@ -474,14 +482,14 @@ export class MikroTransformer extends OperationNodeTransformer {
             }
         }
         if (prop.customType && !isRaw(value)) {
-            return prop.customType.convertToDatabaseValue(value, this.platform, {
+            return prop.customType.convertToDatabaseValue(value, this.#platform, {
                 fromQuery: true,
                 key: prop.name,
                 mode: 'query-data',
             });
         }
         if (value instanceof Date) {
-            return this.platform.processDateProperty(value);
+            return this.#platform.processDateProperty(value);
         }
         return value;
     }
@@ -492,8 +500,8 @@ export class MikroTransformer extends OperationNodeTransformer {
      */
     lookupInContextStack(tableNameOrAlias) {
         // Search from top of stack (current scope) to bottom (parent scopes)
-        for (let i = this.contextStack.length - 1; i >= 0; i--) {
-            const context = this.contextStack[i];
+        for (let i = this.#contextStack.length - 1; i >= 0; i--) {
+            const context = this.#contextStack[i];
             if (context.has(tableNameOrAlias)) {
                 return context.get(tableNameOrAlias);
             }
@@ -515,10 +523,10 @@ export class MikroTransformer extends OperationNodeTransformer {
                 if (cte.expression?.kind === 'SelectQueryNode') {
                     const sourceMeta = this.extractSourceTableFromSelectQuery(cte.expression);
                     if (sourceMeta) {
-                        this.subqueryAliasMap.set(cteName, sourceMeta);
+                        this.#subqueryAliasMap.set(cteName, sourceMeta);
                         // Add CTE to entityMap so it can be used for result transformation if needed
                         // (though CTEs usually don't appear in result rows directly, but their columns might)
-                        this.entityMap.set(cteName, sourceMeta);
+                        this.#entityMap.set(cteName, sourceMeta);
                     }
                 }
             }
@@ -548,11 +556,11 @@ export class MikroTransformer extends OperationNodeTransformer {
                     if (aliasName) {
                         context.set(aliasName, meta);
                         if (meta) {
-                            this.entityMap.set(aliasName, meta);
+                            this.#entityMap.set(aliasName, meta);
                         }
                         // Also map the alias in subqueryAliasMap if the table name is a CTE
-                        if (this.subqueryAliasMap.has(tableName)) {
-                            this.subqueryAliasMap.set(aliasName, this.subqueryAliasMap.get(tableName));
+                        if (this.#subqueryAliasMap.has(tableName)) {
+                            this.#subqueryAliasMap.set(aliasName, this.#subqueryAliasMap.get(tableName));
                         }
                     }
                 }
@@ -565,7 +573,7 @@ export class MikroTransformer extends OperationNodeTransformer {
                     // Try to extract the source table from the subquery
                     const sourceMeta = this.extractSourceTableFromSelectQuery(from.node);
                     if (sourceMeta) {
-                        this.subqueryAliasMap.set(aliasName, sourceMeta);
+                        this.#subqueryAliasMap.set(aliasName, sourceMeta);
                     }
                 }
             }
@@ -584,7 +592,7 @@ export class MikroTransformer extends OperationNodeTransformer {
                 const meta = this.findEntityMetadata(tableName);
                 context.set(tableName, meta);
                 if (meta) {
-                    this.entityMap.set(tableName, meta);
+                    this.#entityMap.set(tableName, meta);
                 }
             }
         }
@@ -604,11 +612,11 @@ export class MikroTransformer extends OperationNodeTransformer {
                     if (aliasName) {
                         context.set(aliasName, meta);
                         if (meta) {
-                            this.entityMap.set(aliasName, meta);
+                            this.#entityMap.set(aliasName, meta);
                         }
                         // Also map the alias in subqueryAliasMap if the table name is a CTE
-                        if (this.subqueryAliasMap.has(tableName)) {
-                            this.subqueryAliasMap.set(aliasName, this.subqueryAliasMap.get(tableName));
+                        if (this.#subqueryAliasMap.has(tableName)) {
+                            this.#subqueryAliasMap.set(aliasName, this.#subqueryAliasMap.get(tableName));
                         }
                     }
                 }
@@ -621,7 +629,7 @@ export class MikroTransformer extends OperationNodeTransformer {
                     // Try to extract the source table from the subquery
                     const sourceMeta = this.extractSourceTableFromSelectQuery(joinTable.node);
                     if (sourceMeta) {
-                        this.subqueryAliasMap.set(aliasName, sourceMeta);
+                        this.#subqueryAliasMap.set(aliasName, sourceMeta);
                     }
                 }
             }
@@ -641,7 +649,7 @@ export class MikroTransformer extends OperationNodeTransformer {
                 // Use table name (meta.tableName) as key to match transformUpdateQuery behavior
                 if (meta) {
                     context.set(meta.tableName, meta);
-                    this.entityMap.set(meta.tableName, meta);
+                    this.#entityMap.set(meta.tableName, meta);
                     // Also set with entity name for backward compatibility
                     context.set(tableName, meta);
                 }
@@ -704,11 +712,11 @@ export class MikroTransformer extends OperationNodeTransformer {
      * Find entity metadata by table name or entity name
      */
     findEntityMetadata(name) {
-        const byEntity = this.metadata.getByClassName(name, false);
+        const byEntity = this.#metadata.getByClassName(name, false);
         if (byEntity) {
             return byEntity;
         }
-        const allMetadata = Array.from(this.metadata);
+        const allMetadata = Array.from(this.#metadata);
         const byTable = allMetadata.find(m => m.tableName === name);
         if (byTable) {
             return byTable;
@@ -721,7 +729,7 @@ export class MikroTransformer extends OperationNodeTransformer {
      */
     transformResult(rows, entityMap) {
         // Only transform if columnNamingStrategy is 'property' or convertValues is true, and we have data
-        if ((this.options.columnNamingStrategy !== 'property' && !this.options.convertValues) ||
+        if ((this.#options.columnNamingStrategy !== 'property' && !this.#options.convertValues) ||
             !rows ||
             rows.length === 0) {
             return rows;
@@ -818,7 +826,7 @@ export class MikroTransformer extends OperationNodeTransformer {
                 continue;
             }
             const converted = this.prepareOutputValue(prop, transformed[fieldName]);
-            if (this.options.columnNamingStrategy === 'property' && prop.name !== fieldName) {
+            if (this.#options.columnNamingStrategy === 'property' && prop.name !== fieldName) {
                 if (!(prop.name in transformed)) {
                     transformed[prop.name] = converted;
                 }
@@ -828,13 +836,13 @@ export class MikroTransformer extends OperationNodeTransformer {
                 delete transformed[fieldName];
                 continue;
             }
-            if (this.options.convertValues) {
+            if (this.#options.convertValues) {
                 transformed[fieldName] = converted;
             }
         }
         // Second pass: handle relation fields
         // Only run if columnNamingStrategy is 'property', as we don't want to rename FKs otherwise
-        if (this.options.columnNamingStrategy === 'property') {
+        if (this.#options.columnNamingStrategy === 'property') {
             for (const [fieldName, relationPropertyName] of Object.entries(relationFieldMap)) {
                 if (fieldName in transformed && !(relationPropertyName in transformed)) {
                     // Move the foreign key value to the relation property name
@@ -846,36 +854,36 @@ export class MikroTransformer extends OperationNodeTransformer {
         return transformed;
     }
     prepareOutputValue(prop, value) {
-        if (!this.options.convertValues || !prop || value == null) {
+        if (!this.#options.convertValues || !prop || value == null) {
             return value;
         }
         if (prop.customType) {
-            return prop.customType.convertToJSValue(value, this.platform);
+            return prop.customType.convertToJSValue(value, this.#platform);
         }
         // Aligned with EntityComparator.getResultMapper logic
         if (prop.runtimeType === 'boolean') {
             // Use !! conversion like EntityComparator: value == null ? value : !!value
             return value == null ? value : !!value;
         }
-        if (prop.runtimeType === 'Date' && !this.platform.isNumericProperty(prop)) {
+        if (prop.runtimeType === 'Date' && !this.#platform.isNumericProperty(prop)) {
             // Aligned with EntityComparator: exclude numeric timestamp properties
             // If already Date instance or null, return as is
             if (value == null || value instanceof Date) {
                 return value;
             }
             // Handle timezone like EntityComparator.parseDate
-            const tz = this.platform.getTimezone();
+            const tz = this.#platform.getTimezone();
             if (!tz || tz === 'local') {
-                return this.platform.parseDate(value);
+                return this.#platform.parseDate(value);
             }
             // For non-local timezone, check if value already has timezone info
             // Number (timestamp) doesn't need timezone handling, string needs check
             if (typeof value === 'number' ||
                 (typeof value === 'string' && (value.includes('+') || value.lastIndexOf('-') > 10 || value.endsWith('Z')))) {
-                return this.platform.parseDate(value);
+                return this.#platform.parseDate(value);
             }
             // Append timezone if not present (only for string values)
-            return this.platform.parseDate(value + tz);
+            return this.#platform.parseDate(value + tz);
         }
         // For all other runtimeTypes (number, string, bigint, Buffer, object, any, etc.)
         // EntityComparator just assigns directly without conversion

package/query/ArrayCriteriaNode.d.ts

@@ -6,6 +6,6 @@ import type { IQueryBuilder, ICriteriaNodeProcessOptions } from '../typings.js';
 export declare class ArrayCriteriaNode<T extends object> extends CriteriaNode<T> {
     process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
     unwrap(): any;
-    willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): any;
+    willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
     isStrict(): boolean;
 }

package/query/CriteriaNodeFactory.js

@@ -2,6 +2,7 @@ import { GroupOperator, isRaw, JsonType, RawQueryFragment, ReferenceKind, Utils,
 import { ObjectCriteriaNode } from './ObjectCriteriaNode.js';
 import { ArrayCriteriaNode } from './ArrayCriteriaNode.js';
 import { ScalarCriteriaNode } from './ScalarCriteriaNode.js';
+import { EMBEDDABLE_ARRAY_OPS } from './enums.js';
 /**
  * @internal
  */
@@ -69,15 +70,26 @@ export class CriteriaNodeFactory {
             }, {});
             return this.createNode(metadata, entityName, map, node, key, validate);
         }
+        // For array embeddeds stored as real columns, route property-level queries
+        // as scalar nodes so QueryBuilderHelper generates EXISTS subqueries with
+        // JSON array iteration.  Keys containing `~` indicate the property lives
+        // inside a parent's object-mode JSON column (MetadataDiscovery uses `~` as
+        // the glue for object embeds), where JSON path access is used instead.
+        if (prop.array && !String(key).includes('~')) {
+            const keys = Object.keys(val);
+            const hasOnlyArrayOps = keys.every(k => EMBEDDABLE_ARRAY_OPS.includes(k));
+            if (!hasOnlyArrayOps) {
+                return this.createScalarNode(metadata, entityName, val, node, key, validate);
+            }
+        }
         // array operators can be used on embedded properties
-        const allowedOperators = ['$contains', '$contained', '$overlap'];
-        const operator = Object.keys(val).some(f => Utils.isOperator(f) && !allowedOperators.includes(f));
+        const operator = Object.keys(val).some(f => Utils.isOperator(f) && !EMBEDDABLE_ARRAY_OPS.includes(f));
         if (operator) {
             throw ValidationError.cannotUseOperatorsInsideEmbeddables(entityName, prop.name, payload);
         }
         const map = Object.keys(val).reduce((oo, k) => {
             const embeddedProp = prop.embeddedProps[k] ?? Object.values(prop.embeddedProps).find(p => p.name === k);
-            if (!embeddedProp && !allowedOperators.includes(k)) {
+            if (!embeddedProp && !EMBEDDABLE_ARRAY_OPS.includes(k)) {
                 throw ValidationError.invalidEmbeddableQuery(entityName, k, prop.type);
             }
             if (embeddedProp) {

package/query/NativeQueryBuilder.d.ts

@@ -38,14 +38,14 @@ interface Options {
     onConflict?: OnConflictClause;
     lockMode?: LockMode;
     lockTables?: string[];
-    returning?: (string | RawQueryFragment)[];
+    returning?: (string | RawQueryFragment | [name: string, type: unknown])[];
     comment?: string[];
     hintComment?: string[];
     flags?: Set<QueryFlag>;
     wrap?: [prefix: string, suffix: string];
     ctes?: CteClause[];
 }
-interface TableOptions {
+export interface TableOptions {
     schema?: string;
     indexHint?: string;
     alias?: string;
@@ -108,7 +108,7 @@ export declare class NativeQueryBuilder implements Subquery {
     distinct(): this;
     distinctOn(fields: string[]): this;
     onConflict(options: OnConflictClause): OnConflictClause;
-    returning(fields: (string | RawQueryFragment)[]): this;
+    returning(fields: (string | RawQueryFragment | [name: string, type: unknown])[]): this;
     lockMode(lockMode: LockMode, lockTables?: string[]): this;
     comment(comment: string | string[]): this;
     hintComment(comment: string | string[]): this;

package/query/NativeQueryBuilder.js

@@ -30,7 +30,8 @@ export class NativeQueryBuilder {
             tableName = tableName.toRaw();
         }
         if (typeof tableName === 'string') {
-            const alias = options?.alias ? ` as ${this.platform.quoteIdentifier(options.alias)}` : '';
+            const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
+            const alias = options?.alias ? `${asKeyword}${this.platform.quoteIdentifier(options.alias)}` : '';
             const schema = options?.schema && options.schema !== this.platform.getDefaultSchemaName() ? `${options.schema}.` : '';
             tableName = this.quote(schema + tableName) + alias;
         }
@@ -474,7 +475,8 @@ export class NativeQueryBuilder {
             const parts = id.split(/ as /i);
             const a = this.platform.quoteIdentifier(parts[0]);
             const b = this.platform.quoteIdentifier(parts[1]);
-            return `${a} as ${b}`;
+            const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
+            return `${a}${asKeyword}${b}`;
         }
         if (id === '*') {
             return id;

package/query/ObjectCriteriaNode.js

@@ -39,7 +39,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
                         throw new Error('Mixing collection operators with other filters is not allowed.');
                     }
                     const payload = this.payload[key].unwrap();
-                    const qb2 = qb.clone(true, ['_schema']);
+                    const qb2 = qb.clone(true, ['schema']);
                     const joinAlias = qb2.getNextAlias(this.prop.targetMeta.class);
                     const sub = qb2
                         .from(parentMeta.class)
@@ -289,12 +289,12 @@ export class ObjectCriteriaNode extends CriteriaNode {
             qb.join(field, nestedAlias, undefined, JoinType.pivotJoin, path);
         }
         else {
-            const prev = qb._fields?.slice();
+            const prev = qb.state.fields?.slice();
             const toOneProperty = [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind);
             const joinType = toOneProperty && !this.prop.nullable ? JoinType.innerJoin : JoinType.leftJoin;
             qb[method](field, nestedAlias, undefined, joinType, path);
             if (!qb.hasFlag(QueryFlag.INFER_POPULATE)) {
-                qb._fields = prev;
+                qb.state.fields = prev;
             }
         }
         if (options?.type !== 'orderBy') {
@@ -303,6 +303,6 @@ export class ObjectCriteriaNode extends CriteriaNode {
         return nestedAlias;
     }
     isPrefixed(field) {
-        return !!field.match(/\w+\./);
+        return !!/\w+\./.exec(field);
     }
 }