@mikro-orm/entity-generator 7.0.4 → 7.0.5-dev.0

package/EntityGenerator.js

@@ -1,5 +1,5 @@
-import { EntitySchema, ReferenceKind, types, Utils } from '@mikro-orm/core';
-import { DatabaseSchema } from '@mikro-orm/sql';
+import { EntitySchema, ReferenceKind, types, Utils, } from '@mikro-orm/core';
+import { DatabaseSchema, } from '@mikro-orm/sql';
 import { fs } from '@mikro-orm/core/fs-utils';
 import { dirname, join } from 'node:path';
 import { writeFile } from 'node:fs/promises';
@@ -9,405 +9,371 @@ import { NativeEnumSourceFile } from './NativeEnumSourceFile.js';
 import { SourceFile } from './SourceFile.js';
 /** Generates entity source files by introspecting an existing database schema. */
 export class EntityGenerator {
-  #config;
-  #driver;
-  #platform;
-  #helper;
-  #connection;
-  #namingStrategy;
-  #sources = [];
-  #referencedEntities = new WeakSet();
-  #em;
-  constructor(em) {
-    this.#em = em;
-    this.#config = this.#em.config;
-    this.#driver = this.#em.getDriver();
-    this.#platform = this.#driver.getPlatform();
-    this.#helper = this.#platform.getSchemaHelper();
-    this.#connection = this.#driver.getConnection();
-    this.#namingStrategy = this.#config.getNamingStrategy();
-  }
-  static register(orm) {
-    orm.config.registerExtension('@mikro-orm/entity-generator', () => new EntityGenerator(orm.em));
-  }
-  async generate(options = {}) {
-    options = Utils.mergeConfig({}, this.#config.get('entityGenerator'), options);
-    const schema = await DatabaseSchema.create(
-      this.#connection,
-      this.#platform,
-      this.#config,
-      undefined,
-      undefined,
-      options.takeTables,
-      options.skipTables,
-    );
-    const metadata = await this.getEntityMetadata(schema, options);
-    const defaultPath = `${this.#config.get('baseDir')}/generated-entities`;
-    const baseDir = fs.normalizePath(options.path ?? defaultPath);
-    this.#sources.length = 0;
-    const map = {
-      defineEntity: DefineEntitySourceFile,
-      entitySchema: EntitySchemaSourceFile,
-      decorators: SourceFile,
-    };
-    if (options.entityDefinition !== 'decorators') {
-      options.scalarTypeInDecorator = true;
+    #config;
+    #driver;
+    #platform;
+    #helper;
+    #connection;
+    #namingStrategy;
+    #sources = [];
+    #referencedEntities = new WeakSet();
+    #em;
+    constructor(em) {
+        this.#em = em;
+        this.#config = this.#em.config;
+        this.#driver = this.#em.getDriver();
+        this.#platform = this.#driver.getPlatform();
+        this.#helper = this.#platform.getSchemaHelper();
+        this.#connection = this.#driver.getConnection();
+        this.#namingStrategy = this.#config.getNamingStrategy();
     }
-    for (const meta of metadata) {
-      if (meta.pivotTable && !options.outputPurePivotTables && !this.#referencedEntities.has(meta)) {
-        continue;
-      }
-      this.#sources.push(new map[options.entityDefinition](meta, this.#namingStrategy, this.#platform, options));
+    static register(orm) {
+        orm.config.registerExtension('@mikro-orm/entity-generator', () => new EntityGenerator(orm.em));
     }
-    for (const nativeEnum of Object.values(schema.getNativeEnums())) {
-      this.#sources.push(new NativeEnumSourceFile({}, this.#namingStrategy, this.#platform, options, nativeEnum));
-    }
-    const files = this.#sources.map(file => [file.getBaseName(), file.generate()]);
-    if (options.save) {
-      fs.ensureDir(baseDir);
-      const promises = [];
-      for (const [fileName, data] of files) {
-        promises.push(
-          (async () => {
-            const fileDir = dirname(fileName);
-            if (fileDir !== '.') {
-              fs.ensureDir(join(baseDir, fileDir));
-            }
-            await writeFile(join(baseDir, fileName), data, { flush: true });
-          })(),
-        );
-      }
-      await Promise.all(promises);
-    }
-    return files.map(([, data]) => data);
-  }
-  async getEntityMetadata(schema, options) {
-    const metadata = schema
-      .getTables()
-      .filter(table => !options.schema || table.schema === options.schema)
-      .sort((a, b) => `${a.schema}.${a.name}`.localeCompare(`${b.schema}.${b.name}`))
-      .map(table => {
-        const skipColumns = options.skipColumns?.[table.getShortestName(false)];
-        if (skipColumns) {
-          for (const col of table.getColumns()) {
-            if (skipColumns.some(matchColumnName => this.matchName(col.name, matchColumnName))) {
-              table.removeColumn(col.name);
-            }
-          }
+    async generate(options = {}) {
+        options = Utils.mergeConfig({}, this.#config.get('entityGenerator'), options);
+        const schema = await DatabaseSchema.create(this.#connection, this.#platform, this.#config, undefined, undefined, options.takeTables, options.skipTables);
+        const metadata = await this.getEntityMetadata(schema, options);
+        const defaultPath = `${this.#config.get('baseDir')}/generated-entities`;
+        const baseDir = fs.normalizePath(options.path ?? defaultPath);
+        this.#sources.length = 0;
+        const map = {
+            defineEntity: DefineEntitySourceFile,
+            entitySchema: EntitySchemaSourceFile,
+            decorators: SourceFile,
+        };
+        if (options.entityDefinition !== 'decorators') {
+            options.scalarTypeInDecorator = true;
         }
-        return table.getEntityDeclaration(this.#namingStrategy, this.#helper, options.scalarPropertiesForRelations);
-      });
-    for (const meta of metadata) {
-      for (const prop of meta.relations) {
-        if (
-          !metadata.some(
-            otherMeta =>
-              prop.referencedTableName === otherMeta.collection ||
-              prop.referencedTableName === `${otherMeta.schema ?? schema.name}.${otherMeta.collection}`,
-          )
-        ) {
-          prop.kind = ReferenceKind.SCALAR;
-          const mappedTypes = prop.columnTypes.map((t, i) => this.#platform.getMappedType(t));
-          const runtimeTypes = mappedTypes.map(t => t.runtimeType);
-          prop.runtimeType = runtimeTypes.length === 1 ? runtimeTypes[0] : `[${runtimeTypes.join(', ')}]`;
-          prop.type =
-            mappedTypes.length === 1
-              ? (Utils.entries(types).find(([k, v]) => Object.getPrototypeOf(mappedTypes[0]) === v.prototype)?.[0] ??
-                mappedTypes[0].name)
-              : 'unknown';
+        for (const meta of metadata) {
+            if (meta.pivotTable && !options.outputPurePivotTables && !this.#referencedEntities.has(meta)) {
+                continue;
+            }
+            this.#sources.push(new map[options.entityDefinition](meta, this.#namingStrategy, this.#platform, options));
         }
-        const meta2 = metadata.find(meta2 => meta2.className === prop.type);
-        const targetPrimaryColumns = meta2?.getPrimaryProps().flatMap(p => p.fieldNames);
-        if (targetPrimaryColumns && targetPrimaryColumns.length !== prop.referencedColumnNames.length) {
-          prop.ownColumns = prop.joinColumns.filter(col => {
-            return !meta.props.find(p => p.name !== prop.name && (!p.fieldNames || p.fieldNames.includes(col)));
-          });
+        for (const nativeEnum of Object.values(schema.getNativeEnums())) {
+            this.#sources.push(new NativeEnumSourceFile({}, this.#namingStrategy, this.#platform, options, nativeEnum));
         }
-      }
-    }
-    await options.onInitialMetadata?.(metadata, this.#platform);
-    // enforce schema usage in class names only on duplicates
-    const duplicates = Utils.findDuplicates(metadata.map(meta => meta.className));
-    for (const duplicate of duplicates) {
-      for (const meta of metadata.filter(meta => meta.className === duplicate)) {
-        meta.className = this.#namingStrategy.getEntityName(`${meta.schema ?? schema.name}_${meta.className}`);
-        for (const relMeta of metadata) {
-          for (const prop of relMeta.relations) {
-            if (
-              prop.type === duplicate &&
-              (prop.referencedTableName === meta.collection ||
-                prop.referencedTableName === `${meta.schema ?? schema.name}.${meta.collection}`)
-            ) {
-              prop.type = meta.className;
+        const files = this.#sources.map(file => [file.getBaseName(), file.generate()]);
+        if (options.save) {
+            fs.ensureDir(baseDir);
+            const promises = [];
+            for (const [fileName, data] of files) {
+                promises.push((async () => {
+                    const fileDir = dirname(fileName);
+                    if (fileDir !== '.') {
+                        fs.ensureDir(join(baseDir, fileDir));
+                    }
+                    await writeFile(join(baseDir, fileName), data, { flush: true });
+                })());
             }
-          }
+            await Promise.all(promises);
         }
-      }
-    }
-    this.detectManyToManyRelations(
-      metadata,
-      options.onlyPurePivotTables,
-      options.readOnlyPivotTables,
-      options.outputPurePivotTables,
-    );
-    this.cleanUpReferentialIntegrityRules(metadata);
-    if (options.bidirectionalRelations) {
-      this.generateBidirectionalRelations(metadata, options.outputPurePivotTables);
-    }
-    if (options.identifiedReferences) {
-      this.generateIdentifiedReferences(metadata);
-    }
-    if (options.customBaseEntityName) {
-      this.generateAndAttachCustomBaseEntity(metadata, options.customBaseEntityName);
+        return files.map(([, data]) => data);
     }
-    if (options.undefinedDefaults) {
-      this.castNullDefaultsToUndefined(metadata);
-    }
-    await options.onProcessedMetadata?.(metadata, this.#platform);
-    return metadata;
-  }
-  cleanUpReferentialIntegrityRules(metadata) {
-    // Clear FK rules that match defaults for:
-    // 1. FK-as-PK entities (all PKs are FKs) - cascade for both update and delete
-    // 2. Fixed-order pivot tables (autoincrement id + 2 FK relations only) - cascade for both
-    // 3. Relations to composite PK targets - cascade for update
-    for (const meta of metadata) {
-      const pks = meta.getPrimaryProps();
-      const fkPks = pks.filter(pk => pk.kind !== ReferenceKind.SCALAR);
-      // Case 1: All PKs are FKs - default is cascade for both update and delete
-      if (fkPks.length > 0 && fkPks.length === pks.length) {
-        for (const pk of fkPks) {
-          if (pk.deleteRule === 'cascade') {
-            delete pk.deleteRule;
-          }
-          if (pk.updateRule === 'cascade') {
-            delete pk.updateRule;
-          }
-        }
-      }
-      // Case 2: Fixed-order pivot table (single autoincrement id PK + exactly 2 M:1 relations)
-      const hasAutoIncrementPk = pks.length === 1 && pks[0].autoincrement;
-      const m2oRelations = meta.relations.filter(r => r.kind === ReferenceKind.MANY_TO_ONE);
-      if (hasAutoIncrementPk && m2oRelations.length === 2) {
-        // Check if all columns are either the PK or FK columns
-        const fkColumns = new Set(m2oRelations.flatMap(r => r.fieldNames));
-        const pkColumns = new Set(pks.flatMap(p => p.fieldNames));
-        const allColumns = new Set(meta.props.filter(p => p.persist !== false).flatMap(p => p.fieldNames));
-        const isPivotLike = [...allColumns].every(col => fkColumns.has(col) || pkColumns.has(col));
-        if (isPivotLike) {
-          for (const rel of m2oRelations) {
-            if (rel.updateRule === 'cascade') {
-              delete rel.updateRule;
+    async getEntityMetadata(schema, options) {
+        const metadata = schema
+            .getTables()
+            .filter(table => !options.schema || table.schema === options.schema)
+            .sort((a, b) => `${a.schema}.${a.name}`.localeCompare(`${b.schema}.${b.name}`))
+            .map(table => {
+            const skipColumns = options.skipColumns?.[table.getShortestName(false)];
+            if (skipColumns) {
+                for (const col of table.getColumns()) {
+                    if (skipColumns.some(matchColumnName => this.matchName(col.name, matchColumnName))) {
+                        table.removeColumn(col.name);
+                    }
+                }
             }
-            if (rel.deleteRule === 'cascade') {
-              delete rel.deleteRule;
+            return table.getEntityDeclaration(this.#namingStrategy, this.#helper, options.scalarPropertiesForRelations);
+        });
+        for (const meta of metadata) {
+            for (const prop of meta.relations) {
+                if (!metadata.some(otherMeta => prop.referencedTableName === otherMeta.collection ||
+                    prop.referencedTableName === `${otherMeta.schema ?? schema.name}.${otherMeta.collection}`)) {
+                    prop.kind = ReferenceKind.SCALAR;
+                    const mappedTypes = prop.columnTypes.map((t, i) => this.#platform.getMappedType(t));
+                    const runtimeTypes = mappedTypes.map(t => t.runtimeType);
+                    prop.runtimeType = (runtimeTypes.length === 1 ? runtimeTypes[0] : `[${runtimeTypes.join(', ')}]`);
+                    prop.type =
+                        mappedTypes.length === 1
+                            ? (Utils.entries(types).find(([k, v]) => Object.getPrototypeOf(mappedTypes[0]) === v.prototype)?.[0] ??
+                                mappedTypes[0].name)
+                            : 'unknown';
+                }
+                const meta2 = metadata.find(meta2 => meta2.className === prop.type);
+                const targetPrimaryColumns = meta2?.getPrimaryProps().flatMap(p => p.fieldNames);
+                if (targetPrimaryColumns && targetPrimaryColumns.length !== prop.referencedColumnNames.length) {
+                    prop.ownColumns = prop.joinColumns.filter(col => {
+                        return !meta.props.find(p => p.name !== prop.name && (!p.fieldNames || p.fieldNames.includes(col)));
+                    });
+                }
             }
-          }
-        }
-      }
-      // Case 3: Relations to composite PK targets - default is cascade for update
-      // Case 4: Nullable relations - default is set null for delete
-      for (const rel of meta.relations) {
-        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(rel.kind)) {
-          const targetMeta = metadata.find(m => m.className === rel.type);
-          if (targetMeta?.compositePK && rel.updateRule === 'cascade') {
-            delete rel.updateRule;
-          }
-          if (rel.nullable && rel.deleteRule === 'set null') {
-            delete rel.deleteRule;
-          }
-        }
-      }
-    }
-  }
-  matchName(name, nameToMatch) {
-    return typeof nameToMatch === 'string'
-      ? name.toLocaleLowerCase() === nameToMatch.toLocaleLowerCase()
-      : nameToMatch.test(name);
-  }
-  detectManyToManyRelations(metadata, onlyPurePivotTables, readOnlyPivotTables, outputPurePivotTables) {
-    for (const meta of metadata) {
-      const isReferenced = metadata.some(m => {
-        return (
-          m.tableName !== meta.tableName &&
-          m.relations.some(r => {
-            return (
-              r.referencedTableName === meta.tableName &&
-              [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(r.kind)
-            );
-          })
-        );
-      });
-      if (isReferenced) {
-        this.#referencedEntities.add(meta);
-      }
-      // Entities with non-composite PKs are never pivot tables. Skip.
-      if (!meta.compositePK) {
-        continue;
-      }
-      // Entities where there are not exactly 2 PK relations that are both ManyToOne are never pivot tables. Skip.
-      const pkRelations = meta.relations.filter(rel => rel.primary);
-      if (pkRelations.length !== 2 || pkRelations.some(rel => rel.kind !== ReferenceKind.MANY_TO_ONE)) {
-        continue;
-      }
-      const pkRelationFields = new Set(pkRelations.flatMap(rel => rel.fieldNames));
-      const nonPkFields = Array.from(new Set(meta.props.flatMap(prop => prop.fieldNames))).filter(
-        fieldName => !pkRelationFields.has(fieldName),
-      );
-      let fixedOrderColumn;
-      let isReadOnly = false;
-      // If there are any fields other than the ones in the two PK relations, table may or may not be a pivot one.
-      // Check further and skip on disqualification.
-      if (nonPkFields.length > 0) {
-        // Additional columns have been disabled with the setting.
-        // Skip table even it otherwise would have qualified as a pivot table.
-        if (onlyPurePivotTables) {
-          continue;
         }
-        const pkRelationNames = pkRelations.map(rel => rel.name);
-        let otherProps = meta.props.filter(
-          prop =>
-            !pkRelationNames.includes(prop.name) &&
-            prop.persist !== false && // Skip checking non-persist props
-            prop.fieldNames.some(fieldName => nonPkFields.includes(fieldName)),
-        );
-        // Deal with the auto increment column first. That is the column used for fixed ordering, if present.
-        const autoIncrementProp = meta.props.find(prop => prop.autoincrement && prop.fieldNames.length === 1);
-        if (autoIncrementProp) {
-          otherProps = otherProps.filter(prop => prop !== autoIncrementProp);
-          fixedOrderColumn = autoIncrementProp.fieldNames[0];
+        await options.onInitialMetadata?.(metadata, this.#platform);
+        // enforce schema usage in class names only on duplicates
+        const duplicates = Utils.findDuplicates(metadata.map(meta => meta.className));
+        for (const duplicate of duplicates) {
+            for (const meta of metadata.filter(meta => meta.className === duplicate)) {
+                meta.className = this.#namingStrategy.getEntityName(`${meta.schema ?? schema.name}_${meta.className}`);
+                for (const relMeta of metadata) {
+                    for (const prop of relMeta.relations) {
+                        if (prop.type === duplicate &&
+                            (prop.referencedTableName === meta.collection ||
+                                prop.referencedTableName === `${meta.schema ?? schema.name}.${meta.collection}`)) {
+                            prop.type = meta.className;
+                        }
+                    }
+                }
+            }
         }
-        isReadOnly = otherProps.some(prop => {
-          // If the prop is non-nullable and unique, it will trivially end up causing issues.
-          // Mark as read only.
-          if (!prop.nullable && prop.unique) {
-            return true;
-          }
-          // Any other props need to also be optional.
-          // Whether they have a default or are generated,
-          // we've already checked that not explicitly setting the property means the default is either NULL,
-          // or a non-unique non-null value, making it safe to write to pivot entity.
-          return !prop.optional;
-        });
-        if (isReadOnly && !readOnlyPivotTables) {
-          continue;
+        this.detectManyToManyRelations(metadata, options.onlyPurePivotTables, options.readOnlyPivotTables, options.outputPurePivotTables);
+        this.cleanUpReferentialIntegrityRules(metadata);
+        if (options.bidirectionalRelations) {
+            this.generateBidirectionalRelations(metadata, options.outputPurePivotTables);
         }
-        // If this now proven pivot entity has persistent props other than the fixed order column,
-        // output it, by considering it as a referenced one.
-        if (otherProps.length > 0) {
-          this.#referencedEntities.add(meta);
+        if (options.identifiedReferences) {
+            this.generateIdentifiedReferences(metadata);
         }
-      }
-      meta.pivotTable = true;
-      // Clear FK rules that match the default for pivot tables (cascade)
-      // so they don't get output explicitly in generated code
-      for (const rel of meta.relations) {
-        if (rel.updateRule === 'cascade') {
-          delete rel.updateRule;
+        if (options.customBaseEntityName) {
+            this.generateAndAttachCustomBaseEntity(metadata, options.customBaseEntityName);
         }
-        if (rel.deleteRule === 'cascade') {
-          delete rel.deleteRule;
+        if (options.undefinedDefaults) {
+            this.castNullDefaultsToUndefined(metadata);
         }
-      }
-      const owner = metadata.find(m => m.className === meta.relations[0].type);
-      const target = metadata.find(m => m.className === meta.relations[1].type);
-      const name = this.#namingStrategy.manyToManyPropertyName(
-        owner.className,
-        target.className,
-        meta.tableName,
-        owner.tableName,
-        meta.schema,
-      );
-      const ownerProp = {
-        name,
-        kind: ReferenceKind.MANY_TO_MANY,
-        pivotTable: meta.tableName,
-        type: meta.relations[1].type,
-        joinColumns: meta.relations[0].fieldNames,
-        inverseJoinColumns: meta.relations[1].fieldNames,
-      };
-      if (outputPurePivotTables || this.#referencedEntities.has(meta)) {
-        ownerProp.pivotEntity = meta.class;
-      }
-      if (fixedOrderColumn) {
-        ownerProp.fixedOrder = true;
-        ownerProp.fixedOrderColumn = fixedOrderColumn;
-      }
-      if (isReadOnly) {
-        ownerProp.persist = false;
-      }
-      owner.addProperty(ownerProp);
+        await options.onProcessedMetadata?.(metadata, this.#platform);
+        return metadata;
     }
-  }
-  generateBidirectionalRelations(metadata, includeUnreferencedPurePivotTables) {
-    const filteredMetadata = includeUnreferencedPurePivotTables
-      ? metadata
-      : metadata.filter(m => !m.pivotTable || this.#referencedEntities.has(m));
-    for (const meta of filteredMetadata) {
-      for (const prop of meta.relations) {
-        const targetMeta = metadata.find(m => m.className === prop.type);
-        if (!targetMeta) {
-          continue;
-        }
-        const newProp = {
-          type: meta.className,
-          joinColumns: prop.fieldNames,
-          referencedTableName: meta.tableName,
-          referencedColumnNames: Utils.flatten(targetMeta.getPrimaryProps().map(pk => pk.fieldNames)),
-          mappedBy: prop.name,
-          persist: prop.persist,
-        };
-        if (prop.kind === ReferenceKind.MANY_TO_ONE) {
-          newProp.kind = ReferenceKind.ONE_TO_MANY;
-        } else if (prop.kind === ReferenceKind.ONE_TO_ONE && !prop.mappedBy) {
-          newProp.kind = ReferenceKind.ONE_TO_ONE;
-          newProp.nullable = true;
-          newProp.default = null;
-          newProp.defaultRaw = 'null';
-        } else if (prop.kind === ReferenceKind.MANY_TO_MANY && !prop.mappedBy) {
-          newProp.kind = ReferenceKind.MANY_TO_MANY;
-        } else {
-          continue;
+    cleanUpReferentialIntegrityRules(metadata) {
+        // Clear FK rules that match defaults for:
+        // 1. FK-as-PK entities (all PKs are FKs) - cascade for both update and delete
+        // 2. Fixed-order pivot tables (autoincrement id + 2 FK relations only) - cascade for both
+        // 3. Relations to composite PK targets - cascade for update
+        for (const meta of metadata) {
+            const pks = meta.getPrimaryProps();
+            const fkPks = pks.filter(pk => pk.kind !== ReferenceKind.SCALAR);
+            // Case 1: All PKs are FKs - default is cascade for both update and delete
+            if (fkPks.length > 0 && fkPks.length === pks.length) {
+                for (const pk of fkPks) {
+                    if (pk.deleteRule === 'cascade') {
+                        delete pk.deleteRule;
+                    }
+                    if (pk.updateRule === 'cascade') {
+                        delete pk.updateRule;
+                    }
+                }
+            }
+            // Case 2: Fixed-order pivot table (single autoincrement id PK + exactly 2 M:1 relations)
+            const hasAutoIncrementPk = pks.length === 1 && pks[0].autoincrement;
+            const m2oRelations = meta.relations.filter(r => r.kind === ReferenceKind.MANY_TO_ONE);
+            if (hasAutoIncrementPk && m2oRelations.length === 2) {
+                // Check if all columns are either the PK or FK columns
+                const fkColumns = new Set(m2oRelations.flatMap(r => r.fieldNames));
+                const pkColumns = new Set(pks.flatMap(p => p.fieldNames));
+                const allColumns = new Set(meta.props.filter(p => p.persist !== false).flatMap(p => p.fieldNames));
+                const isPivotLike = [...allColumns].every(col => fkColumns.has(col) || pkColumns.has(col));
+                if (isPivotLike) {
+                    for (const rel of m2oRelations) {
+                        if (rel.updateRule === 'cascade') {
+                            delete rel.updateRule;
+                        }
+                        if (rel.deleteRule === 'cascade') {
+                            delete rel.deleteRule;
+                        }
+                    }
+                }
+            }
+            // Case 3: Relations to composite PK targets - default is cascade for update
+            // Case 4: Nullable relations - default is set null for delete
+            for (const rel of meta.relations) {
+                if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(rel.kind)) {
+                    const targetMeta = metadata.find(m => m.className === rel.type);
+                    if (targetMeta?.compositePK && rel.updateRule === 'cascade') {
+                        delete rel.updateRule;
+                    }
+                    if (rel.nullable && rel.deleteRule === 'set null') {
+                        delete rel.deleteRule;
+                    }
+                }
+            }
         }
-        let i = 1;
-        const name = (newProp.name = this.#namingStrategy.inverseSideName(meta.className, prop.name, newProp.kind));
-        while (targetMeta.properties[newProp.name]) {
-          newProp.name = name + i++;
+    }
+    matchName(name, nameToMatch) {
+        return typeof nameToMatch === 'string'
+            ? name.toLocaleLowerCase() === nameToMatch.toLocaleLowerCase()
+            : nameToMatch.test(name);
+    }
+    detectManyToManyRelations(metadata, onlyPurePivotTables, readOnlyPivotTables, outputPurePivotTables) {
+        for (const meta of metadata) {
+            const isReferenced = metadata.some(m => {
+                return (m.tableName !== meta.tableName &&
+                    m.relations.some(r => {
+                        return (r.referencedTableName === meta.tableName &&
+                            [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(r.kind));
+                    }));
+            });
+            if (isReferenced) {
+                this.#referencedEntities.add(meta);
+            }
+            // Entities with non-composite PKs are never pivot tables. Skip.
+            if (!meta.compositePK) {
+                continue;
+            }
+            // Entities where there are not exactly 2 PK relations that are both ManyToOne are never pivot tables. Skip.
+            const pkRelations = meta.relations.filter(rel => rel.primary);
+            if (pkRelations.length !== 2 || pkRelations.some(rel => rel.kind !== ReferenceKind.MANY_TO_ONE)) {
+                continue;
+            }
+            const pkRelationFields = new Set(pkRelations.flatMap(rel => rel.fieldNames));
+            const nonPkFields = Array.from(new Set(meta.props.flatMap(prop => prop.fieldNames))).filter(fieldName => !pkRelationFields.has(fieldName));
+            let fixedOrderColumn;
+            let isReadOnly = false;
+            // If there are any fields other than the ones in the two PK relations, table may or may not be a pivot one.
+            // Check further and skip on disqualification.
+            if (nonPkFields.length > 0) {
+                // Additional columns have been disabled with the setting.
+                // Skip table even it otherwise would have qualified as a pivot table.
+                if (onlyPurePivotTables) {
+                    continue;
+                }
+                const pkRelationNames = pkRelations.map(rel => rel.name);
+                let otherProps = meta.props.filter(prop => !pkRelationNames.includes(prop.name) &&
+                    prop.persist !== false && // Skip checking non-persist props
+                    prop.fieldNames.some(fieldName => nonPkFields.includes(fieldName)));
+                // Deal with the auto increment column first. That is the column used for fixed ordering, if present.
+                const autoIncrementProp = meta.props.find(prop => prop.autoincrement && prop.fieldNames.length === 1);
+                if (autoIncrementProp) {
+                    otherProps = otherProps.filter(prop => prop !== autoIncrementProp);
+                    fixedOrderColumn = autoIncrementProp.fieldNames[0];
+                }
+                isReadOnly = otherProps.some(prop => {
+                    // If the prop is non-nullable and unique, it will trivially end up causing issues.
+                    // Mark as read only.
+                    if (!prop.nullable && prop.unique) {
+                        return true;
+                    }
+                    // Any other props need to also be optional.
+                    // Whether they have a default or are generated,
+                    // we've already checked that not explicitly setting the property means the default is either NULL,
+                    // or a non-unique non-null value, making it safe to write to pivot entity.
+                    return !prop.optional;
+                });
+                if (isReadOnly && !readOnlyPivotTables) {
+                    continue;
+                }
+                // If this now proven pivot entity has persistent props other than the fixed order column,
+                // output it, by considering it as a referenced one.
+                if (otherProps.length > 0) {
+                    this.#referencedEntities.add(meta);
+                }
+            }
+            meta.pivotTable = true;
+            // Clear FK rules that match the default for pivot tables (cascade)
+            // so they don't get output explicitly in generated code
+            for (const rel of meta.relations) {
+                if (rel.updateRule === 'cascade') {
+                    delete rel.updateRule;
+                }
+                if (rel.deleteRule === 'cascade') {
+                    delete rel.deleteRule;
+                }
+            }
+            const owner = metadata.find(m => m.className === meta.relations[0].type);
+            const target = metadata.find(m => m.className === meta.relations[1].type);
+            const name = this.#namingStrategy.manyToManyPropertyName(owner.className, target.className, meta.tableName, owner.tableName, meta.schema);
+            const ownerProp = {
+                name,
+                kind: ReferenceKind.MANY_TO_MANY,
+                pivotTable: meta.tableName,
+                type: meta.relations[1].type,
+                joinColumns: meta.relations[0].fieldNames,
+                inverseJoinColumns: meta.relations[1].fieldNames,
+            };
+            if (outputPurePivotTables || this.#referencedEntities.has(meta)) {
+                ownerProp.pivotEntity = meta.class;
+            }
+            if (fixedOrderColumn) {
+                ownerProp.fixedOrder = true;
+                ownerProp.fixedOrderColumn = fixedOrderColumn;
+            }
+            if (isReadOnly) {
+                ownerProp.persist = false;
+            }
+            owner.addProperty(ownerProp);
         }
-        targetMeta.addProperty(newProp);
-      }
     }
-  }
-  generateIdentifiedReferences(metadata) {
-    for (const meta of metadata.filter(m => !m.pivotTable || this.#referencedEntities.has(m))) {
-      for (const prop of Object.values(meta.properties)) {
-        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) || prop.lazy) {
-          prop.ref = true;
+    generateBidirectionalRelations(metadata, includeUnreferencedPurePivotTables) {
+        const filteredMetadata = includeUnreferencedPurePivotTables
+            ? metadata
+            : metadata.filter(m => !m.pivotTable || this.#referencedEntities.has(m));
+        for (const meta of filteredMetadata) {
+            for (const prop of meta.relations) {
+                const targetMeta = metadata.find(m => m.className === prop.type);
+                if (!targetMeta) {
+                    continue;
+                }
+                const newProp = {
+                    type: meta.className,
+                    joinColumns: prop.fieldNames,
+                    referencedTableName: meta.tableName,
+                    referencedColumnNames: Utils.flatten(targetMeta.getPrimaryProps().map(pk => pk.fieldNames)),
+                    mappedBy: prop.name,
+                    persist: prop.persist,
+                };
+                if (prop.kind === ReferenceKind.MANY_TO_ONE) {
+                    newProp.kind = ReferenceKind.ONE_TO_MANY;
+                }
+                else if (prop.kind === ReferenceKind.ONE_TO_ONE && !prop.mappedBy) {
+                    newProp.kind = ReferenceKind.ONE_TO_ONE;
+                    newProp.nullable = true;
+                    newProp.default = null;
+                    newProp.defaultRaw = 'null';
+                }
+                else if (prop.kind === ReferenceKind.MANY_TO_MANY && !prop.mappedBy) {
+                    newProp.kind = ReferenceKind.MANY_TO_MANY;
+                }
+                else {
+                    continue;
+                }
+                let i = 1;
+                const name = (newProp.name = this.#namingStrategy.inverseSideName(meta.className, prop.name, newProp.kind));
+                while (targetMeta.properties[newProp.name]) {
+                    newProp.name = name + i++;
+                }
+                targetMeta.addProperty(newProp);
+            }
         }
-      }
     }
-  }
-  generateAndAttachCustomBaseEntity(metadata, customBaseEntityName) {
-    let base = metadata.find(meta => meta.className === customBaseEntityName);
-    if (!base) {
-      const schema = new EntitySchema({ className: customBaseEntityName, abstract: true });
-      base = schema.init().meta;
-      metadata.push(base);
+    generateIdentifiedReferences(metadata) {
+        for (const meta of metadata.filter(m => !m.pivotTable || this.#referencedEntities.has(m))) {
+            for (const prop of Object.values(meta.properties)) {
+                if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) || prop.lazy) {
+                    prop.ref = true;
+                }
+            }
+        }
     }
-    for (const meta of metadata) {
-      if (meta.className !== customBaseEntityName) {
-        meta.extends ??= base.class;
-      }
+    generateAndAttachCustomBaseEntity(metadata, customBaseEntityName) {
+        let base = metadata.find(meta => meta.className === customBaseEntityName);
+        if (!base) {
+            const schema = new EntitySchema({ className: customBaseEntityName, abstract: true });
+            base = schema.init().meta;
+            metadata.push(base);
+        }
+        for (const meta of metadata) {
+            if (meta.className !== customBaseEntityName) {
+                meta.extends ??= base.class;
+            }
+        }
     }
-  }
-  castNullDefaultsToUndefined(metadata) {
-    for (const meta of metadata) {
-      for (const prop of Object.values(meta.properties)) {
-        if (prop.nullable && !prop.optional && prop.default === null && typeof prop.defaultRaw === 'undefined') {
-          prop.default = undefined;
-          prop.optional = true;
+    castNullDefaultsToUndefined(metadata) {
+        for (const meta of metadata) {
+            for (const prop of Object.values(meta.properties)) {
+                if (prop.nullable && !prop.optional && prop.default === null && typeof prop.defaultRaw === 'undefined') {
+                    prop.default = undefined;
+                    prop.optional = true;
+                }
+            }
         }
-      }
     }
-  }
 }