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

package/query/ScalarCriteriaNode.js

@@ -18,7 +18,9 @@ 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);
             }
         }

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/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());
@@ -94,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;
     }
@@ -291,28 +303,33 @@ export class DatabaseSchema {
             (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 => {
+        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)));
         });
         // 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;

package/schema/DatabaseTable.js

@@ -3,51 +3,60 @@ import { DecimalType, EntitySchema, RawQueryFragment, ReferenceKind, t, Type, Un
  * @internal
  */
 export class DatabaseTable {
-    platform;
     name;
     schema;
-    columns = {};
-    indexes = [];
-    checks = [];
-    foreignKeys = {};
+    #columns = {};
+    #indexes = [];
+    #checks = [];
+    #foreignKeys = {};
+    #platform;
     nativeEnums = {}; // for postgres
     comment;
     constructor(platform, name, schema) {
-        this.platform = platform;
         this.name = name;
         this.schema = schema;
-        Object.defineProperties(this, {
-            platform: { enumerable: false, writable: true },
-        });
+        this.#platform = platform;
     }
     getQuotedName() {
-        return this.platform.quoteIdentifier(this.getShortestName());
+        return this.#platform.quoteIdentifier(this.getShortestName());
     }
     getColumns() {
-        return Object.values(this.columns);
+        return Object.values(this.#columns);
     }
     getColumn(name) {
-        return this.columns[name];
+        return this.#columns[name];
     }
     removeColumn(name) {
-        delete this.columns[name];
+        delete this.#columns[name];
     }
     getIndexes() {
-        return Utils.removeDuplicates(this.indexes);
+        return Utils.removeDuplicates(this.#indexes);
     }
     getChecks() {
-        return this.checks;
+        return this.#checks;
+    }
+    /** @internal */
+    setIndexes(indexes) {
+        this.#indexes = indexes;
+    }
+    /** @internal */
+    setChecks(checks) {
+        this.#checks = checks;
+    }
+    /** @internal */
+    setForeignKeys(fks) {
+        this.#foreignKeys = fks;
     }
     init(cols, indexes = [], checks = [], pks, fks = {}, enums = {}) {
-        this.indexes = indexes;
-        this.checks = checks;
-        this.foreignKeys = fks;
-        this.columns = cols.reduce((o, v) => {
+        this.#indexes = indexes;
+        this.#checks = checks;
+        this.#foreignKeys = fks;
+        this.#columns = cols.reduce((o, v) => {
             const index = indexes.filter(i => i.columnNames[0] === v.name);
             v.primary = v.primary || pks.includes(v.name);
             v.unique = index.some(i => i.unique && !i.primary);
             const type = v.name in enums ? 'enum' : v.type;
-            v.mappedType = this.platform.getMappedType(type);
+            v.mappedType = this.#platform.getMappedType(type);
             v.default = v.default?.toString().startsWith('nextval(') ? null : v.default;
             v.enumItems ??= enums[v.name] || [];
             o[v.name] = v;
@@ -55,14 +64,14 @@ export class DatabaseTable {
         }, {});
     }
     addColumn(column) {
-        this.columns[column.name] = column;
+        this.#columns[column.name] = column;
     }
     addColumnFromProperty(prop, meta, config) {
         prop.fieldNames?.forEach((field, idx) => {
             const type = prop.enum ? 'enum' : prop.columnTypes[idx];
-            const mappedType = this.platform.getMappedType(type);
+            const mappedType = this.#platform.getMappedType(type);
             if (mappedType instanceof DecimalType) {
-                const match = prop.columnTypes[idx].match(/\w+\((\d+), ?(\d+)\)/);
+                const match = /\w+\((\d+), ?(\d+)\)/.exec(prop.columnTypes[idx]);
                 /* v8 ignore next */
                 if (match) {
                     prop.precision ??= +match[1];
@@ -71,24 +80,24 @@ export class DatabaseTable {
                 }
             }
             if (prop.length == null && prop.columnTypes[idx]) {
-                prop.length = this.platform.getSchemaHelper().inferLengthFromColumnType(prop.columnTypes[idx]);
+                prop.length = this.#platform.getSchemaHelper().inferLengthFromColumnType(prop.columnTypes[idx]);
                 if (typeof mappedType.getDefaultLength !== 'undefined') {
-                    prop.length ??= mappedType.getDefaultLength(this.platform);
+                    prop.length ??= mappedType.getDefaultLength(this.#platform);
                 }
             }
             const primary = !meta.compositePK && prop.fieldNames.length === 1 && !!prop.primary;
-            this.columns[field] = {
+            this.#columns[field] = {
                 name: prop.fieldNames[idx],
                 type: prop.columnTypes[idx],
                 generated: prop.generated instanceof RawQueryFragment
-                    ? this.platform.formatQuery(prop.generated.sql, prop.generated.params)
+                    ? this.#platform.formatQuery(prop.generated.sql, prop.generated.params)
                     : prop.generated,
                 mappedType,
-                unsigned: prop.unsigned && this.platform.isNumericColumn(mappedType),
+                unsigned: prop.unsigned && this.#platform.isNumericColumn(mappedType),
                 autoincrement: prop.autoincrement ??
-                    (primary && prop.kind === ReferenceKind.SCALAR && this.platform.isNumericColumn(mappedType)),
+                    (primary && prop.kind === ReferenceKind.SCALAR && this.#platform.isNumericColumn(mappedType)),
                 primary,
-                nullable: this.columns[field]?.nullable ?? !!prop.nullable,
+                nullable: this.#columns[field]?.nullable ?? !!prop.nullable,
                 nativeEnumName: prop.nativeEnumName,
                 length: prop.length,
                 precision: prop.precision,
@@ -99,23 +108,29 @@ export class DatabaseTable {
                 extra: prop.extra,
                 ignoreSchemaChanges: prop.ignoreSchemaChanges,
             };
-            this.columns[field].unsigned ??= this.columns[field].autoincrement;
+            this.#columns[field].unsigned ??= this.#columns[field].autoincrement;
             if (this.nativeEnums[type]) {
-                this.columns[field].enumItems ??= this.nativeEnums[type].items;
+                this.#columns[field].enumItems ??= this.nativeEnums[type].items;
             }
-            const defaultValue = this.platform.getSchemaHelper().normalizeDefaultValue(prop.defaultRaw, prop.length);
-            this.columns[field].default = defaultValue;
+            const defaultValue = this.#platform.getSchemaHelper().normalizeDefaultValue(prop.defaultRaw, prop.length);
+            this.#columns[field].default = defaultValue;
         });
         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.polymorphic) {
             const constraintName = this.getIndexName(prop.foreignKeyName ?? true, prop.fieldNames, 'foreign');
             let schema = prop.targetMeta.root.schema === '*'
                 ? this.schema
-                : (prop.targetMeta.root.schema ?? config.get('schema', this.platform.getDefaultSchemaName()));
+                : (prop.targetMeta.root.schema ?? config.get('schema', this.#platform.getDefaultSchemaName()));
             if (prop.referencedTableName.includes('.')) {
                 schema = undefined;
             }
+            // For cross-schema FKs on MySQL/MariaDB (where schema = database), when the referenced
+            // table has no explicit schema but the current table does, qualify with dbName so the
+            // FK can resolve the referenced table in the correct database
+            if (!schema && this.schema && !this.#platform.getDefaultSchemaName()) {
+                schema = config.get('dbName');
+            }
             if (prop.createForeignKeyConstraint) {
-                this.foreignKeys[constraintName] = {
+                this.#foreignKeys[constraintName] = {
                     constraintName,
                     columnNames: prop.fieldNames,
                     localTableName: this.getShortestName(false),
@@ -123,15 +138,15 @@ export class DatabaseTable {
                     referencedTableName: schema ? `${schema}.${prop.referencedTableName}` : prop.referencedTableName,
                 };
                 const schemaConfig = config.get('schemaGenerator');
-                this.foreignKeys[constraintName].deleteRule = prop.deleteRule ?? schemaConfig.defaultDeleteRule;
-                this.foreignKeys[constraintName].updateRule = prop.updateRule ?? schemaConfig.defaultUpdateRule;
+                this.#foreignKeys[constraintName].deleteRule = prop.deleteRule ?? schemaConfig.defaultDeleteRule;
+                this.#foreignKeys[constraintName].updateRule = prop.updateRule ?? schemaConfig.defaultUpdateRule;
                 if (prop.deferMode) {
-                    this.foreignKeys[constraintName].deferMode = prop.deferMode;
+                    this.#foreignKeys[constraintName].deferMode = prop.deferMode;
                 }
             }
         }
         if (prop.index) {
-            this.indexes.push({
+            this.#indexes.push({
                 columnNames: prop.fieldNames,
                 composite: prop.fieldNames.length > 1,
                 keyName: this.getIndexName(prop.index, prop.fieldNames, 'index'),
@@ -141,7 +156,7 @@ export class DatabaseTable {
             });
         }
         if (prop.unique && !(prop.primary && !meta.compositePK)) {
-            this.indexes.push({
+            this.#indexes.push({
                 columnNames: prop.fieldNames,
                 composite: prop.fieldNames.length > 1,
                 keyName: this.getIndexName(prop.unique, prop.fieldNames, 'unique'),
@@ -156,7 +171,7 @@ export class DatabaseTable {
         if (typeof value === 'string') {
             return value;
         }
-        return this.platform.getIndexName(this.name, columnNames, type);
+        return this.#platform.getIndexName(this.name, columnNames, type);
     }
     getEntityDeclaration(namingStrategy, schemaHelper, scalarPropertiesForRelations) {
         const { fksOnColumnProps, fksOnStandaloneProps, columnFks, fkIndexes, nullableForeignKeys, skippedColumnNames } = this.foreignKeysToProps(namingStrategy, scalarPropertiesForRelations);
@@ -164,7 +179,7 @@ export class DatabaseTable {
         const schema = new EntitySchema({ name, collection: this.name, schema: this.schema, comment: this.comment });
         const compositeFkIndexes = {};
         const compositeFkUniques = {};
-        const potentiallyUnmappedIndexes = this.indexes.filter(index => !index.primary && // Skip primary index. Whether it's in use by scalar column or FK, it's already mapped.
+        const potentiallyUnmappedIndexes = this.#indexes.filter(index => !index.primary && // Skip primary index. Whether it's in use by scalar column or FK, it's already mapped.
             // Non-trivial non-composite indexes will be declared at the entity's metadata, though later outputted in the property
             (index.columnNames.length > 1 || // All composite indexes are to be mapped to entity decorators or FK props.
                 skippedColumnNames.includes(index.columnNames[0]) || // Non-composite indexes for skipped columns are to be mapped as entity decorators.
@@ -456,7 +471,7 @@ export class DatabaseTable {
     }
     findFkIndex(currentFk) {
         const fkColumnsLength = currentFk.columnNames.length;
-        const possibleIndexes = this.indexes.filter(index => {
+        const possibleIndexes = this.#indexes.filter(index => {
             return (index.columnNames.length === fkColumnsLength &&
                 !currentFk.columnNames.some((columnName, i) => index.columnNames[i] !== columnName));
         });
@@ -557,7 +572,7 @@ export class DatabaseTable {
      * The shortest name is stripped of the default namespace. All other namespaced elements are returned as full-qualified names.
      */
     getShortestName(skipDefaultSchema = true) {
-        const defaultSchema = this.platform.getDefaultSchemaName();
+        const defaultSchema = this.#platform.getDefaultSchemaName();
         if (!this.schema ||
             this.name.startsWith(defaultSchema + '.') ||
             (this.schema === defaultSchema && skipDefaultSchema)) {
@@ -566,25 +581,25 @@ export class DatabaseTable {
         return `${this.schema}.${this.name}`;
     }
     getForeignKeys() {
-        return this.foreignKeys;
+        return this.#foreignKeys;
     }
     hasColumn(columnName) {
-        return columnName in this.columns;
+        return columnName in this.#columns;
     }
     getIndex(indexName) {
-        return this.indexes.find(i => i.keyName === indexName);
+        return this.#indexes.find(i => i.keyName === indexName);
     }
     hasIndex(indexName) {
         return !!this.getIndex(indexName);
     }
     getCheck(checkName) {
-        return this.checks.find(i => i.name === checkName);
+        return this.#checks.find(i => i.name === checkName);
     }
     hasCheck(checkName) {
         return !!this.getCheck(checkName);
     }
     getPrimaryKey() {
-        return this.indexes.find(i => i.primary);
+        return this.#indexes.find(i => i.primary);
     }
     hasPrimaryKey() {
         return !!this.getPrimaryKey();
@@ -637,15 +652,15 @@ export class DatabaseTable {
         const prop = this.getPropertyName(namingStrategy, column.name, fk);
         const persist = !(column.name in columnFks && typeof fk === 'undefined');
         const index = compositeFkIndexes[prop] ||
-            this.indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && !idx.unique && !idx.primary);
+            this.#indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && !idx.unique && !idx.primary);
         const unique = compositeFkUniques[prop] ||
-            this.indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && idx.unique && !idx.primary);
+            this.#indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && idx.unique && !idx.primary);
         const kind = this.getReferenceKind(fk, unique);
         const runtimeType = this.getPropertyTypeForColumn(namingStrategy, column, fk);
         const type = fk
             ? runtimeType
             : (Utils.keys(t).find(k => {
-                const typeInCoreMap = this.platform.getMappedType(k);
+                const typeInCoreMap = this.#platform.getMappedType(k);
                 return ((typeInCoreMap !== Type.getType(UnknownType) || k === 'unknown') && typeInCoreMap === column.mappedType);
             }) ?? runtimeType);
         const ignoreSchemaChanges = type === 'unknown' && column.length ? (column.extra ? ['type', 'extra'] : ['type']) : undefined;
@@ -728,7 +743,7 @@ export class DatabaseTable {
         if (fk) {
             return this.getPropertyTypeForForeignKey(namingStrategy, fk);
         }
-        const enumMode = this.platform.getConfig().get('entityGenerator').enumMode;
+        const enumMode = this.#platform.getConfig().get('entityGenerator').enumMode;
         // If this column is using an enum.
         if (column.enumItems?.length) {
             const name = column.nativeEnumName ?? column.name;
@@ -755,7 +770,7 @@ export class DatabaseTable {
             return +defaultValue;
         }
         // unquote string defaults if `raw = false`
-        const match = ('' + val).match(/^'(.*)'$/);
+        const match = /^'(.*)'$/.exec('' + val);
         if (!raw && match) {
             return match[1];
         }
@@ -772,7 +787,7 @@ export class DatabaseTable {
             };
             const columns = meta.createSchemaColumnMappingObject();
             const exp = expression(columns, table, indexName);
-            return exp instanceof RawQueryFragment ? this.platform.formatQuery(exp.sql, exp.params) : exp;
+            return exp instanceof RawQueryFragment ? this.#platform.formatQuery(exp.sql, exp.params) : exp;
         }
         return expression;
     }
@@ -847,7 +862,7 @@ export class DatabaseTable {
         if (index.fillFactor != null && (index.fillFactor < 0 || index.fillFactor > 100)) {
             throw new Error(`fillFactor must be between 0 and 100, got ${index.fillFactor} for index '${name}' on entity '${meta.className}'`);
         }
-        this.indexes.push({
+        this.#indexes.push({
             keyName: name,
             columnNames: properties,
             composite: properties.length > 1,
@@ -868,10 +883,10 @@ export class DatabaseTable {
         });
     }
     addCheck(check) {
-        this.checks.push(check);
+        this.#checks.push(check);
     }
     toJSON() {
-        const { platform, columns, ...rest } = this;
+        const columns = this.#columns;
         const columnsMapped = Utils.keys(columns).reduce((o, col) => {
             const c = columns[col];
             const normalized = {
@@ -908,6 +923,15 @@ export class DatabaseTable {
             o[col] = normalized;
             return o;
         }, {});
-        return { columns: columnsMapped, ...rest };
+        return {
+            name: this.name,
+            schema: this.schema,
+            columns: columnsMapped,
+            indexes: this.#indexes,
+            checks: this.#checks,
+            foreignKeys: this.#foreignKeys,
+            nativeEnums: this.nativeEnums,
+            comment: this.comment,
+        };
     }
 }

package/schema/SchemaComparator.d.ts

@@ -7,9 +7,7 @@ import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
  * Compares two Schemas and return an instance of SchemaDifference.
  */
 export declare class SchemaComparator {
-    private readonly platform;
-    private readonly helper;
-    private readonly logger;
+    #private;
     constructor(platform: AbstractSqlPlatform);
     /**
      * Returns a SchemaDifference object containing the differences between the schemas fromSchema and toSchema.