@mikro-orm/entity-generator 7.0.4-dev.9 → 7.0.4

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,371 +9,405 @@ 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();
+  #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;
     }
-    static register(orm) {
-        orm.config.registerExtension('@mikro-orm/entity-generator', () => new EntityGenerator(orm.em));
+    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));
     }
-    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;
-        }
-        for (const meta of metadata) {
-            if (meta.pivotTable && !options.outputPurePivotTables && !this.#referencedEntities.has(meta)) {
-                continue;
+    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);
             }
-            this.#sources.push(new map[options.entityDefinition](meta, this.#namingStrategy, this.#platform, options));
+          }
         }
-        for (const nativeEnum of Object.values(schema.getNativeEnums())) {
-            this.#sources.push(new NativeEnumSourceFile({}, this.#namingStrategy, this.#platform, options, nativeEnum));
+        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 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 });
-                })());
+        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)));
+          });
+        }
+      }
+    }
+    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;
             }
-            await Promise.all(promises);
+          }
         }
-        return files.map(([, data]) => data);
+      }
+    }
+    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);
     }
-    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 (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;
             }
-            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)));
-                    });
-                }
+            if (rel.deleteRule === 'cascade') {
+              delete rel.deleteRule;
             }
+          }
         }
-        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;
-                        }
-                    }
-                }
-            }
+      }
+      // 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;
+          }
         }
-        this.detectManyToManyRelations(metadata, options.onlyPurePivotTables, options.readOnlyPivotTables, options.outputPurePivotTables);
-        this.cleanUpReferentialIntegrityRules(metadata);
-        if (options.bidirectionalRelations) {
-            this.generateBidirectionalRelations(metadata, options.outputPurePivotTables);
+      }
+    }
+  }
+  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;
         }
-        if (options.identifiedReferences) {
-            this.generateIdentifiedReferences(metadata);
+        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];
         }
-        if (options.customBaseEntityName) {
-            this.generateAndAttachCustomBaseEntity(metadata, options.customBaseEntityName);
+        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 (options.undefinedDefaults) {
-            this.castNullDefaultsToUndefined(metadata);
+        // 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);
         }
-        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;
-                        }
-                        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;
-                    }
-                }
-            }
+      }
+      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;
         }
-    }
-    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);
+        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);
     }
-    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);
-            }
+  }
+  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;
         }
-    }
-    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;
-                }
-            }
+        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;
         }
-    }
-    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);
+        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++;
         }
-        for (const meta of metadata) {
-            if (meta.className !== customBaseEntityName) {
-                meta.extends ??= base.class;
-            }
+        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;
         }
+      }
     }
-    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;
-                }
-            }
+  }
+  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;
         }
+      }
     }
+  }
 }