@mikro-orm/sql 7.0.0-rc.2 → 7.0.0

package/query/ScalarCriteriaNode.js

@@ -7,7 +7,8 @@ import { QueryBuilder } from './QueryBuilder.js';
  */
 export class ScalarCriteriaNode extends CriteriaNode {
     process(qb, options) {
-        const matchPopulateJoins = options?.matchPopulateJoins || (this.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
+        const matchPopulateJoins = options?.matchPopulateJoins ||
+            (this.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
         const nestedAlias = qb.getAliasForJoinPath(this.getPath(options), { ...options, matchPopulateJoins });
         if (this.shouldJoin(qb, nestedAlias)) {
             const path = this.getPath();
@@ -17,12 +18,14 @@ export class ScalarCriteriaNode extends CriteriaNode {
             const type = this.prop.kind === ReferenceKind.MANY_TO_MANY ? JoinType.pivotJoin : JoinType.leftJoin;
             qb.join(field, nestedAlias, undefined, type, path);
             // select the owner as virtual property when joining from 1:1 inverse side, but only if the parent is root entity
-            if (this.prop.kind === ReferenceKind.ONE_TO_ONE && !parentPath.includes('.') && !qb._fields?.includes(field)) {
+            if (this.prop.kind === ReferenceKind.ONE_TO_ONE &&
+                !parentPath.includes('.') &&
+                !qb.state.fields?.includes(field)) {
                 qb.addSelect(field);
             }
         }
         if (this.payload instanceof QueryBuilder) {
-            return this.payload.getNativeQuery().toRaw();
+            return this.payload.toRaw();
         }
         if (this.payload && typeof this.payload === 'object') {
             const keys = Object.keys(this.payload).filter(key => ARRAY_OPERATORS.includes(key) && Array.isArray(this.payload[key]));
@@ -36,14 +39,20 @@ export class ScalarCriteriaNode extends CriteriaNode {
         return this.shouldJoin(qb, alias);
     }
     shouldJoin(qb, nestedAlias) {
-        if (!this.parent || !this.prop || (nestedAlias && [QueryType.SELECT, QueryType.COUNT].includes(qb.type ?? QueryType.SELECT))) {
+        if (!this.parent ||
+            !this.prop ||
+            (nestedAlias && [QueryType.SELECT, QueryType.COUNT].includes(qb.type ?? QueryType.SELECT))) {
             return false;
         }
         switch (this.prop.kind) {
-            case ReferenceKind.ONE_TO_MANY: return true;
-            case ReferenceKind.MANY_TO_MANY: return true;
-            case ReferenceKind.ONE_TO_ONE: return !this.prop.owner;
-            default: return false; // SCALAR, MANY_TO_ONE
+            case ReferenceKind.ONE_TO_MANY:
+                return true;
+            case ReferenceKind.MANY_TO_MANY:
+                return true;
+            case ReferenceKind.ONE_TO_ONE:
+                return !this.prop.owner;
+            default:
+                return false; // SCALAR, MANY_TO_ONE
         }
     }
 }

package/query/enums.d.ts

@@ -7,6 +7,8 @@ export declare enum QueryType {
     DELETE = "DELETE",
     UPSERT = "UPSERT"
 }
+/** Operators that apply to the embedded array column itself, not to individual elements. */
+export declare const EMBEDDABLE_ARRAY_OPS: string[];
 export declare enum JoinType {
     leftJoin = "left join",
     innerJoin = "inner join",

package/query/enums.js

@@ -8,6 +8,8 @@ export var QueryType;
     QueryType["DELETE"] = "DELETE";
     QueryType["UPSERT"] = "UPSERT";
 })(QueryType || (QueryType = {}));
+/** Operators that apply to the embedded array column itself, not to individual elements. */
+export const EMBEDDABLE_ARRAY_OPS = ['$contains', '$contained', '$overlap'];
 export var JoinType;
 (function (JoinType) {
     JoinType["leftJoin"] = "left join";

package/query/raw.js

@@ -1,4 +1,4 @@
-import { raw as raw_, Utils } from '@mikro-orm/core';
+import { raw as raw_, Utils, } from '@mikro-orm/core';
 /**
  * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
  * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value

package/schema/DatabaseSchema.d.ts

@@ -7,19 +7,21 @@ import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
  * @internal
  */
 export declare class DatabaseSchema {
-    private readonly platform;
+    #private;
     readonly name: string;
-    private tables;
-    private views;
-    private namespaces;
-    private nativeEnums;
     constructor(platform: AbstractSqlPlatform, name: string);
     addTable(name: string, schema: string | undefined | null, comment?: string): DatabaseTable;
     getTables(): DatabaseTable[];
+    /** @internal */
+    setTables(tables: DatabaseTable[]): void;
+    /** @internal */
+    setNamespaces(namespaces: Set<string>): void;
     getTable(name: string): DatabaseTable | undefined;
     hasTable(name: string): boolean;
     addView(name: string, schema: string | undefined | null, definition: string, materialized?: boolean, withData?: boolean): DatabaseView;
     getViews(): DatabaseView[];
+    /** @internal */
+    setViews(views: DatabaseView[]): void;
     getView(name: string): DatabaseView | undefined;
     hasView(name: string): boolean;
     setNativeEnums(nativeEnums: Dictionary<{

package/schema/DatabaseSchema.js

@@ -4,32 +4,40 @@ import { DatabaseTable } from './DatabaseTable.js';
  * @internal
  */
 export class DatabaseSchema {
-    platform;
     name;
-    tables = [];
-    views = [];
-    namespaces = new Set();
-    nativeEnums = {}; // for postgres
+    #tables = [];
+    #views = [];
+    #namespaces = new Set();
+    #nativeEnums = {}; // for postgres
+    #platform;
     constructor(platform, name) {
-        this.platform = platform;
         this.name = name;
+        this.#platform = platform;
     }
     addTable(name, schema, comment) {
         const namespaceName = schema ?? this.name;
-        const table = new DatabaseTable(this.platform, name, namespaceName);
-        table.nativeEnums = this.nativeEnums;
+        const table = new DatabaseTable(this.#platform, name, namespaceName);
+        table.nativeEnums = this.#nativeEnums;
         table.comment = comment;
-        this.tables.push(table);
+        this.#tables.push(table);
         if (namespaceName != null) {
-            this.namespaces.add(namespaceName);
+            this.#namespaces.add(namespaceName);
         }
         return table;
     }
     getTables() {
-        return this.tables;
+        return this.#tables;
+    }
+    /** @internal */
+    setTables(tables) {
+        this.#tables = tables;
+    }
+    /** @internal */
+    setNamespaces(namespaces) {
+        this.#namespaces = namespaces;
     }
     getTable(name) {
-        return this.tables.find(t => t.name === name || `${t.schema}.${t.name}` === name);
+        return this.#tables.find(t => t.name === name || `${t.schema}.${t.name}` === name);
     }
     hasTable(name) {
         return !!this.getTable(name);
@@ -37,43 +45,47 @@ export class DatabaseSchema {
     addView(name, schema, definition, materialized, withData) {
         const namespaceName = schema ?? this.name;
         const view = { name, schema: namespaceName, definition, materialized, withData };
-        this.views.push(view);
+        this.#views.push(view);
         if (namespaceName != null) {
-            this.namespaces.add(namespaceName);
+            this.#namespaces.add(namespaceName);
         }
         return view;
     }
     getViews() {
-        return this.views;
+        return this.#views;
+    }
+    /** @internal */
+    setViews(views) {
+        this.#views = views;
     }
     getView(name) {
-        return this.views.find(v => v.name === name || `${v.schema}.${v.name}` === name);
+        return this.#views.find(v => v.name === name || `${v.schema}.${v.name}` === name);
     }
     hasView(name) {
         return !!this.getView(name);
     }
     setNativeEnums(nativeEnums) {
-        this.nativeEnums = nativeEnums;
+        this.#nativeEnums = nativeEnums;
         for (const nativeEnum of Object.values(nativeEnums)) {
             if (nativeEnum.schema && nativeEnum.schema !== '*') {
-                this.namespaces.add(nativeEnum.schema);
+                this.#namespaces.add(nativeEnum.schema);
             }
         }
     }
     getNativeEnums() {
-        return this.nativeEnums;
+        return this.#nativeEnums;
     }
     getNativeEnum(name) {
-        return this.nativeEnums[name];
+        return this.#nativeEnums[name];
     }
     hasNamespace(namespace) {
-        return this.namespaces.has(namespace);
+        return this.#namespaces.has(namespace);
     }
     hasNativeEnum(name) {
-        return name in this.nativeEnums;
+        return name in this.#nativeEnums;
     }
     getNamespaces() {
-        return [...this.namespaces];
+        return [...this.#namespaces];
     }
     static async create(connection, platform, config, schemaName, schemas, takeTables, skipTables, skipViews) {
         const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema') ?? platform.getDefaultSchemaName());
@@ -81,8 +93,11 @@ export class DatabaseSchema {
         const parts = config.get('migrations').tableName.split('.');
         const migrationsTableName = parts[1] ?? parts[0];
         const migrationsSchemaName = parts.length > 1 ? parts[0] : config.get('schema', platform.getDefaultSchemaName());
-        const tables = allTables.filter(t => this.isTableNameAllowed(t.table_name, takeTables, skipTables) && (t.table_name !== migrationsTableName || (t.schema_name && t.schema_name !== migrationsSchemaName)));
-        await platform.getSchemaHelper().loadInformationSchema(schema, connection, tables, schemas && schemas.length > 0 ? schemas : undefined);
+        const tables = allTables.filter(t => this.isTableNameAllowed(t.table_name, takeTables, skipTables) &&
+            (t.table_name !== migrationsTableName || (t.schema_name && t.schema_name !== migrationsSchemaName)));
+        await platform
+            .getSchemaHelper()
+            .loadInformationSchema(schema, connection, tables, schemas && schemas.length > 0 ? schemas : undefined);
         // Load views from database
         await platform.getSchemaHelper().loadViews(schema, connection);
         // Load materialized views (PostgreSQL only)
@@ -91,7 +106,7 @@ export class DatabaseSchema {
         }
         // Filter out skipped views
         if (skipViews && skipViews.length > 0) {
-            schema.views = schema.views.filter(v => this.isNameAllowed(v.name, skipViews));
+            schema.#views = schema.#views.filter(v => this.isNameAllowed(v.name, skipViews));
         }
         return schema;
     }
@@ -140,9 +155,7 @@ export class DatabaseSchema {
             table.comment = meta.comment;
             // For TPT child entities, only use ownProps (properties defined in this entity only)
             // For all other entities (including TPT root), use all props
-            const propsToProcess = meta.inheritanceType === 'tpt' && meta.tptParent && meta.ownProps
-                ? meta.ownProps
-                : meta.props;
+            const propsToProcess = meta.inheritanceType === 'tpt' && meta.tptParent && meta.ownProps ? meta.ownProps : meta.props;
             for (const prop of propsToProcess) {
                 if (!this.shouldHaveColumn(meta, prop, skipColumns)) {
                     continue;
@@ -177,7 +190,9 @@ export class DatabaseSchema {
             table.addIndex(meta, { properties: pkPropsForIndex.map(prop => prop.name) }, 'primary');
             for (const check of meta.checks) {
                 const columnName = check.property ? meta.properties[check.property].fieldNames[0] : undefined;
-                const expression = isRaw(check.expression) ? platform.formatQuery(check.expression.sql, check.expression.params) : check.expression;
+                const expression = isRaw(check.expression)
+                    ? platform.formatQuery(check.expression.sql, check.expression.params)
+                    : check.expression;
                 table.addCheck({
                     name: check.name,
                     expression,
@@ -229,7 +244,7 @@ export class DatabaseSchema {
         const pkColumnNames = meta.primaryKeys.flatMap(pk => meta.properties[pk].fieldNames);
         const parentPkColumnNames = parent.primaryKeys.flatMap(pk => parent.properties[pk].fieldNames);
         // Determine the parent table name with schema
-        const parentSchema = parent.schema === '*' ? undefined : parent.schema ?? config.get('schema', platform.getDefaultSchemaName());
+        const parentSchema = parent.schema === '*' ? undefined : (parent.schema ?? config.get('schema', platform.getDefaultSchemaName()));
         const parentTableName = parentSchema ? `${parentSchema}.${parent.tableName}` : parent.tableName;
         // Create FK constraint name
         const constraintName = platform.getIndexName(table.name, pkColumnNames, 'foreign');
@@ -284,29 +299,37 @@ export class DatabaseSchema {
         if (rootProp.kind === ReferenceKind.EMBEDDED) {
             return prop === rootProp || !rootProp.object;
         }
-        return [ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE].includes(prop.kind) || (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner);
+        return ([ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE].includes(prop.kind) ||
+            (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner));
     }
     toJSON() {
-        const { platform, namespaces, ...rest } = this;
-        return { namespaces: [...namespaces], ...rest };
+        return {
+            name: this.name,
+            namespaces: [...this.#namespaces],
+            tables: this.#tables,
+            views: this.#views,
+            nativeEnums: this.#nativeEnums,
+        };
     }
     prune(schema, wildcardSchemaTables) {
         const hasWildcardSchema = wildcardSchemaTables.length > 0;
-        this.tables = this.tables.filter(table => {
-            return (!schema && !hasWildcardSchema) // no schema specified and we don't have any multi-schema entity
-                || table.schema === schema // specified schema matches the table's one
-                || (!schema && !wildcardSchemaTables.includes(table.name)); // no schema specified and the table has fixed one provided
+        this.#tables = this.#tables.filter(table => {
+            return ((!schema && !hasWildcardSchema) || // no schema specified and we don't have any multi-schema entity
+                table.schema === schema || // specified schema matches the table's one
+                (!schema && !wildcardSchemaTables.includes(table.name))); // no schema specified and the table has fixed one provided
         });
-        this.views = this.views.filter(view => {
+        this.#views = this.#views.filter(view => {
             /* v8 ignore next */
-            return (!schema && !hasWildcardSchema)
-                || view.schema === schema
-                || (!schema && !wildcardSchemaTables.includes(view.name));
+            return ((!schema && !hasWildcardSchema) ||
+                view.schema === schema ||
+                (!schema && !wildcardSchemaTables.includes(view.name)));
         });
         // remove namespaces of ignored tables and views
-        for (const ns of this.namespaces) {
-            if (!this.tables.some(t => t.schema === ns) && !this.views.some(v => v.schema === ns) && !Object.values(this.nativeEnums).some(e => e.schema === ns)) {
-                this.namespaces.delete(ns);
+        for (const ns of this.#namespaces) {
+            if (!this.#tables.some(t => t.schema === ns) &&
+                !this.#views.some(v => v.schema === ns) &&
+                !Object.values(this.#nativeEnums).some(e => e.schema === ns)) {
+                this.#namespaces.delete(ns);
             }
         }
     }

package/schema/DatabaseTable.d.ts

@@ -6,13 +6,9 @@ import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
  * @internal
  */
 export declare class DatabaseTable {
-    private readonly platform;
+    #private;
     readonly name: string;
     readonly schema?: string | undefined;
-    private columns;
-    private indexes;
-    private checks;
-    private foreignKeys;
     nativeEnums: Dictionary<{
         name: string;
         schema?: string;
@@ -26,6 +22,12 @@ export declare class DatabaseTable {
     removeColumn(name: string): void;
     getIndexes(): IndexDef[];
     getChecks(): CheckDef[];
+    /** @internal */
+    setIndexes(indexes: IndexDef[]): void;
+    /** @internal */
+    setChecks(checks: CheckDef[]): void;
+    /** @internal */
+    setForeignKeys(fks: Dictionary<ForeignKey>): void;
     init(cols: Column[], indexes: IndexDef[] | undefined, checks: CheckDef[] | undefined, pks: string[], fks?: Dictionary<ForeignKey>, enums?: Dictionary<string[]>): void;
     addColumn(column: Column): void;
     addColumnFromProperty(prop: EntityProperty, meta: EntityMetadata, config: Configuration): void;
@@ -43,7 +45,7 @@ export declare class DatabaseTable {
     hasColumn(columnName: string): boolean;
     getIndex(indexName: string): IndexDef | undefined;
     hasIndex(indexName: string): boolean;
-    getCheck(checkName: string): CheckDef<unknown> | undefined;
+    getCheck(checkName: string): CheckDef | undefined;
     hasCheck(checkName: string): boolean;
     getPrimaryKey(): IndexDef | undefined;
     hasPrimaryKey(): boolean;