@mikro-orm/entity-generator 7.0.0-dev.32 → 7.0.0-dev.320

package/DefineEntitySourceFile.d.ts

@@ -0,0 +1,5 @@
+import { EntitySchemaSourceFile } from './EntitySchemaSourceFile.js';
+export declare class DefineEntitySourceFile extends EntitySchemaSourceFile {
+    generate(): string;
+    private getPropertyBuilder;
+}

package/DefineEntitySourceFile.js

@@ -0,0 +1,146 @@
+import { Config, ReferenceKind, types, } from '@mikro-orm/core';
+import { EntitySchemaSourceFile } from './EntitySchemaSourceFile.js';
+export class DefineEntitySourceFile extends EntitySchemaSourceFile {
+    generate() {
+        const enumDefinitions = [];
+        for (const prop of Object.values(this.meta.properties)) {
+            if (prop.enum && (typeof prop.kind === 'undefined' || prop.kind === ReferenceKind.SCALAR)) {
+                const def = this.getEnumClassDefinition(prop, 2);
+                if (def.length) {
+                    enumDefinitions.push(def);
+                }
+            }
+        }
+        let ret = '';
+        if (!this.options.inferEntityType) {
+            ret += this.generateClassDefinition() + '\n';
+        }
+        if (enumDefinitions.length) {
+            ret += enumDefinitions.join('\n') + '\n';
+        }
+        const entitySchemaOptions = {};
+        if (this.options.inferEntityType) {
+            entitySchemaOptions.name = this.quote(this.meta.className);
+            if (this.meta.compositePK) {
+                entitySchemaOptions.primaryKeys = this.meta.getPrimaryProps().map(p => this.quote(p.name));
+            }
+        }
+        else {
+            entitySchemaOptions.class = this.meta.className;
+        }
+        Object.assign(entitySchemaOptions, this.meta.embeddable ? this.getEmbeddableDeclOptions() : this.meta.collection ? this.getEntityDeclOptions() : {});
+        const nameSuffix = this.options.inferEntityType ? '' : 'Schema';
+        const declLine = `export const ${this.meta.className + nameSuffix} = ${this.referenceCoreImport('defineEntity')}(`;
+        ret += declLine;
+        if (this.meta.indexes.length > 0) {
+            entitySchemaOptions.indexes = this.meta.indexes.map(index => this.getIndexOptions(index));
+        }
+        if (this.meta.uniques.length > 0) {
+            entitySchemaOptions.uniques = this.meta.uniques.map(index => this.getUniqueOptions(index));
+        }
+        entitySchemaOptions.properties = Object.fromEntries(Object.entries(this.meta.properties).map(([name, prop]) => [name, this.getPropertyBuilder(prop)]));
+        // Force top level and properties to be indented, regardless of line length
+        entitySchemaOptions[Config] = true;
+        entitySchemaOptions.properties[Config] = true;
+        ret += this.serializeObject(entitySchemaOptions, declLine.length > 80 ? undefined : 80 - declLine.length, 0);
+        ret += ');\n';
+        if (this.options.inferEntityType) {
+            ret += `\nexport interface I${this.meta.className} extends ${this.referenceCoreImport('InferEntity')}<typeof ${this.meta.className}> {}\n`;
+        }
+        ret = `${this.generateImports()}\n\n${ret}`;
+        return ret;
+    }
+    getPropertyBuilder(prop) {
+        const options = this.getPropertyOptions(prop, false);
+        const p = this.referenceCoreImport('p');
+        let builder = '';
+        switch (prop.kind) {
+            case ReferenceKind.ONE_TO_ONE:
+                builder += `() => ${p}.oneToOne(${prop.type})`;
+                break;
+            case ReferenceKind.ONE_TO_MANY:
+                builder += `() => ${p}.oneToMany(${prop.type})`;
+                break;
+            case ReferenceKind.MANY_TO_ONE:
+                builder += `() => ${p}.manyToOne(${prop.type})`;
+                break;
+            case ReferenceKind.MANY_TO_MANY:
+                builder += `() => ${p}.manyToMany(${prop.type})`;
+                break;
+            case ReferenceKind.EMBEDDED:
+                builder += `() => ${p}.embedded(${prop.type})`;
+                break;
+            case ReferenceKind.SCALAR:
+            default: {
+                if (options.type && !(options.type in types)) {
+                    builder += `${p}.type(${options.type})`;
+                }
+                else {
+                    builder += options.type ? `${p}.${options.type}()` : p;
+                }
+            }
+        }
+        const simpleOptions = new Set([
+            'primary',
+            'ref',
+            'nullable',
+            'array',
+            'object',
+            'mapToPk',
+            'hidden',
+            'concurrencyCheck',
+            'lazy',
+            'eager',
+            'orphanRemoval',
+            'version',
+            'unsigned',
+            'returning',
+            'createForeignKeyConstraint',
+            'fixedOrder',
+            'owner',
+            'getter',
+            'setter',
+            'unique',
+            'index',
+            'hydrate',
+            'persist',
+            'autoincrement',
+        ]);
+        const skipOptions = new Set(['entity', 'kind', 'type', 'items']);
+        const spreadOptions = new Set([
+            'fieldNames',
+            'joinColumns',
+            'inverseJoinColumns',
+            'referencedColumnNames',
+            'ownColumns',
+            'columnTypes',
+            'cascade',
+            'ignoreSchemaChanges',
+            'customOrder',
+            'groups',
+            'where',
+            'orderBy',
+        ]);
+        const rename = {
+            fieldName: 'name',
+        };
+        for (const key of Object.keys(options)) {
+            if (typeof options[key] === 'undefined' || skipOptions.has(key)) {
+                continue;
+            }
+            const method = rename[key] ?? key;
+            const params = simpleOptions.has(key) && options[key] === true ? '' : options[key];
+            builder += `.${method}`;
+            if (key === 'enum') {
+                builder += `(${options.items})`;
+            }
+            else if (spreadOptions.has(key) && typeof params === 'string' && params.startsWith('[')) {
+                builder += `(${params.slice(1, -1)})`;
+            }
+            else {
+                builder += `(${params})`;
+            }
+        }
+        return builder;
+    }
+}

package/EntityGenerator.d.ts

@@ -1,5 +1,5 @@
 import { type GenerateOptions, type MikroORM } from '@mikro-orm/core';
-import { type EntityManager } from '@mikro-orm/knex';
+import { type EntityManager } from '@mikro-orm/sql';
 export declare class EntityGenerator {
     private readonly em;
     private readonly config;
@@ -14,6 +14,7 @@ export declare class EntityGenerator {
     static register(orm: MikroORM): void;
     generate(options?: GenerateOptions): Promise<string[]>;
     private getEntityMetadata;
+    private cleanUpReferentialIntegrityRules;
     private matchName;
     private detectManyToManyRelations;
     private generateBidirectionalRelations;

package/EntityGenerator.js

@@ -1,8 +1,11 @@
-import { EntityMetadata, ReferenceKind, types, Utils, } from '@mikro-orm/core';
-import { DatabaseSchema, } from '@mikro-orm/knex';
+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';
+import { DefineEntitySourceFile } from './DefineEntitySourceFile.js';
 import { EntitySchemaSourceFile } from './EntitySchemaSourceFile.js';
+import { NativeEnumSourceFile } from './NativeEnumSourceFile.js';
 import { SourceFile } from './SourceFile.js';
 export class EntityGenerator {
     em;
@@ -31,32 +34,45 @@ export class EntityGenerator {
         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 = Utils.normalizePath(options.path ?? defaultPath);
+        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)) {
-                if (options.entitySchema) {
-                    this.sources.push(new EntitySchemaSourceFile(meta, this.namingStrategy, this.platform, { ...options, scalarTypeInDecorator: true }));
-                }
-                else {
-                    this.sources.push(new SourceFile(meta, this.namingStrategy, this.platform, options));
-                }
+            if (meta.pivotTable && !options.outputPurePivotTables && !this.referencedEntities.has(meta)) {
+                continue;
             }
+            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));
         }
+        const files = this.sources.map(file => [file.getBaseName(), file.generate()]);
         if (options.save) {
-            Utils.ensureDir(baseDir);
-            await Promise.all(this.sources.map(async (file) => {
-                const fileName = file.getBaseName();
-                const fileDir = dirname(fileName);
-                if (fileDir !== '.') {
-                    Utils.ensureDir(join(baseDir, fileDir));
-                }
-                return writeFile(join(baseDir, fileName), file.generate(), { flush: true });
-            }));
+            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 this.sources.map(file => file.generate());
+        return files.map(([, data]) => data);
     }
     async getEntityMetadata(schema, options) {
-        const metadata = schema.getTables()
+        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 => {
@@ -72,12 +88,17 @@ export class EntityGenerator {
         });
         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}`)) {
+                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';
+                    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);
@@ -96,7 +117,9 @@ export class EntityGenerator {
                 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}`)) {
+                        if (prop.type === duplicate &&
+                            (prop.referencedTableName === meta.collection ||
+                                prop.referencedTableName === `${meta.schema ?? schema.name}.${meta.collection}`)) {
                             prop.type = meta.className;
                         }
                     }
@@ -104,6 +127,7 @@ export class EntityGenerator {
             }
         }
         this.detectManyToManyRelations(metadata, options.onlyPurePivotTables, options.readOnlyPivotTables, options.outputPurePivotTables);
+        this.cleanUpReferentialIntegrityRules(metadata);
         if (options.bidirectionalRelations) {
             this.generateBidirectionalRelations(metadata, options.outputPurePivotTables);
         }
@@ -119,6 +143,60 @@ export class EntityGenerator {
         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;
+                    }
+                }
+            }
+        }
+    }
     matchName(name, nameToMatch) {
         return typeof nameToMatch === 'string'
             ? name.toLocaleLowerCase() === nameToMatch.toLocaleLowerCase()
@@ -127,9 +205,11 @@ export class EntityGenerator {
     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);
-                });
+                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);
@@ -140,8 +220,7 @@ export class EntityGenerator {
             }
             // 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)) {
+            if (pkRelations.length !== 2 || pkRelations.some(rel => rel.kind !== ReferenceKind.MANY_TO_ONE)) {
                 continue;
             }
             const pkRelationFields = new Set(pkRelations.flatMap(rel => rel.fieldNames));
@@ -157,8 +236,7 @@ export class EntityGenerator {
                     continue;
                 }
                 const pkRelationNames = pkRelations.map(rel => rel.name);
-                let otherProps = meta.props
-                    .filter(prop => !pkRelationNames.includes(prop.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.
@@ -189,8 +267,19 @@ export class EntityGenerator {
                 }
             }
             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 name = this.namingStrategy.columnNameToProperty(meta.tableName.replace(new RegExp('^' + owner.tableName + '_'), ''));
+            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,
@@ -200,7 +289,7 @@ export class EntityGenerator {
                 inverseJoinColumns: meta.relations[1].fieldNames,
             };
             if (outputPurePivotTables || this.referencedEntities.has(meta)) {
-                ownerProp.pivotEntity = meta.className;
+                ownerProp.pivotEntity = meta.class;
             }
             if (fixedOrderColumn) {
                 ownerProp.fixedOrder = true;
@@ -246,9 +335,9 @@ export class EntityGenerator {
                     continue;
                 }
                 let i = 1;
-                const name = newProp.name = this.namingStrategy.inverseSideName(meta.className, prop.name, newProp.kind);
+                const name = (newProp.name = this.namingStrategy.inverseSideName(meta.className, prop.name, newProp.kind));
                 while (targetMeta.properties[newProp.name]) {
-                    newProp.name = name + (i++);
+                    newProp.name = name + i++;
                 }
                 targetMeta.addProperty(newProp);
             }
@@ -264,20 +353,16 @@ export class EntityGenerator {
         }
     }
     generateAndAttachCustomBaseEntity(metadata, customBaseEntityName) {
-        let baseClassExists = false;
+        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) {
-                baseClassExists = true;
-                continue;
+            if (meta.className !== customBaseEntityName) {
+                meta.extends ??= base.class;
             }
-            meta.extends ??= customBaseEntityName;
-        }
-        if (!baseClassExists) {
-            metadata.push(new EntityMetadata({
-                className: customBaseEntityName,
-                abstract: true,
-                relations: [],
-            }));
         }
     }
     castNullDefaultsToUndefined(metadata) {

package/EntitySchemaSourceFile.d.ts

@@ -2,7 +2,8 @@ import { type Dictionary, type EntityProperty } from '@mikro-orm/core';
 import { SourceFile } from './SourceFile.js';
 export declare class EntitySchemaSourceFile extends SourceFile {
     generate(): string;
-    private getPropertyOptions;
+    protected generateClassDefinition(): string;
+    protected getPropertyOptions(prop: EntityProperty, quote?: boolean): Dictionary;
     protected getPropertyIndexesOptions(prop: EntityProperty, options: Dictionary): void;
-    protected getScalarPropertyDecoratorOptions(options: Dictionary, prop: EntityProperty): void;
+    protected getScalarPropertyDecoratorOptions(options: Dictionary, prop: EntityProperty, quote?: boolean): void;
 }

package/EntitySchemaSourceFile.js

@@ -2,21 +2,60 @@ import { Config, ReferenceKind, } from '@mikro-orm/core';
 import { SourceFile } from './SourceFile.js';
 export class EntitySchemaSourceFile extends SourceFile {
     generate() {
+        const classDefinition = this.generateClassDefinition();
+        const enumDefinitions = [];
+        for (const prop of Object.values(this.meta.properties)) {
+            if (prop.enum && (typeof prop.kind === 'undefined' || prop.kind === ReferenceKind.SCALAR)) {
+                const def = this.getEnumClassDefinition(prop, 2);
+                if (def.length) {
+                    enumDefinitions.push(def);
+                }
+            }
+        }
+        let ret = classDefinition;
+        if (enumDefinitions.length) {
+            ret += '\n' + enumDefinitions.join('\n');
+        }
+        ret += `\n`;
+        const entitySchemaOptions = {
+            class: this.meta.className,
+            ...(this.meta.embeddable
+                ? this.getEmbeddableDeclOptions()
+                : this.meta.collection
+                    ? this.getEntityDeclOptions()
+                    : {}),
+        };
+        const declLine = `export const ${this.meta.className}Schema = new ${this.referenceCoreImport('EntitySchema')}(`;
+        ret += declLine;
+        if (this.meta.indexes.length > 0) {
+            entitySchemaOptions.indexes = this.meta.indexes.map(index => this.getIndexOptions(index));
+        }
+        if (this.meta.uniques.length > 0) {
+            entitySchemaOptions.uniques = this.meta.uniques.map(index => this.getUniqueOptions(index));
+        }
+        entitySchemaOptions.properties = Object.fromEntries(Object.entries(this.meta.properties).map(([name, prop]) => [name, this.getPropertyOptions(prop)]));
+        // Force top level and properties to be indented, regardless of line length
+        entitySchemaOptions[Config] = true;
+        entitySchemaOptions.properties[Config] = true;
+        ret += this.serializeObject(entitySchemaOptions, declLine.length > 80 ? undefined : 80 - declLine.length, 0);
+        ret += ');\n';
+        ret = `${this.generateImports()}\n\n${ret}`;
+        return ret;
+    }
+    generateClassDefinition() {
         let classBody = '';
-        if (this.meta.className === this.options.customBaseEntityName) {
+        if (!this.options.customBaseEntityName || this.meta.className === this.options.customBaseEntityName) {
             const defineConfigTypeSettings = {};
             defineConfigTypeSettings.forceObject = this.platform.getConfig().get('serialization').forceObject ?? false;
-            classBody += `${' '.repeat(2)}[${this.referenceCoreImport('Config')}]?: ${this.referenceCoreImport('DefineConfig')}<${this.serializeObject(defineConfigTypeSettings)}>;\n`;
+            if (defineConfigTypeSettings.forceObject) {
+                classBody += `${' '.repeat(2)}[${this.referenceCoreImport('Config')}]?: ${this.referenceCoreImport('DefineConfig')}<${this.serializeObject(defineConfigTypeSettings)}>;\n`;
+            }
         }
-        const enumDefinitions = [];
         const eagerProperties = [];
         const primaryProps = [];
         const props = [];
         for (const prop of Object.values(this.meta.properties)) {
             props.push(this.getPropertyDefinition(prop, 2));
-            if (prop.enum && (typeof prop.kind === 'undefined' || prop.kind === ReferenceKind.SCALAR)) {
-                enumDefinitions.push(this.getEnumClassDefinition(prop, 2));
-            }
             if (prop.eager) {
                 eagerProperties.push(prop);
             }
@@ -37,34 +76,10 @@ export class EntitySchemaSourceFile extends SourceFile {
             const eagerPropertyNames = eagerProperties.map(prop => `'${prop.name}'`).sort();
             classBody += `${' '.repeat(2)}[${this.referenceCoreImport('EagerProps')}]?: ${eagerPropertyNames.join(' | ')};\n`;
         }
-        classBody += `${props.join('')}`;
-        let ret = this.getEntityClass(classBody);
-        if (enumDefinitions.length) {
-            ret += '\n' + enumDefinitions.join('\n');
-        }
-        ret += `\n`;
-        const entitySchemaOptions = {
-            class: this.meta.className,
-            ...(this.meta.embeddable ? this.getEmbeddableDeclOptions() : (this.meta.collection ? this.getEntityDeclOptions() : {})),
-        };
-        const declLine = `export const ${this.meta.className}Schema = new ${this.referenceCoreImport('EntitySchema')}(`;
-        ret += declLine;
-        if (this.meta.indexes.length > 0) {
-            entitySchemaOptions.indexes = this.meta.indexes.map(index => this.getIndexOptions(index));
-        }
-        if (this.meta.uniques.length > 0) {
-            entitySchemaOptions.uniques = this.meta.uniques.map(index => this.getUniqueOptions(index));
-        }
-        entitySchemaOptions.properties = Object.fromEntries(Object.entries(this.meta.properties).map(([name, prop]) => [name, this.getPropertyOptions(prop)]));
-        // Force top level and properties to be indented, regardless of line length
-        entitySchemaOptions[Config] = true;
-        entitySchemaOptions.properties[Config] = true;
-        ret += this.serializeObject(entitySchemaOptions, declLine.length > 80 ? undefined : 80 - declLine.length, 0);
-        ret += ');\n';
-        ret = `${this.generateImports()}\n\n${ret}`;
-        return ret;
+        classBody += props.join('');
+        return this.getEntityClass(classBody);
     }
-    getPropertyOptions(prop) {
+    getPropertyOptions(prop, quote = true) {
         const options = {};
         if (prop.primary) {
             options.primary = true;
@@ -79,7 +94,7 @@ export class EntitySchemaSourceFile extends SourceFile {
             this.getOneToManyDecoratorOptions(options, prop);
         }
         else if (prop.kind === ReferenceKind.SCALAR || typeof prop.kind === 'undefined') {
-            this.getScalarPropertyDecoratorOptions(options, prop);
+            this.getScalarPropertyDecoratorOptions(options, prop, quote);
         }
         else if (prop.kind === ReferenceKind.EMBEDDED) {
             this.getEmbeddedPropertyDeclarationOptions(options, prop);
@@ -111,7 +126,7 @@ export class EntitySchemaSourceFile extends SourceFile {
             }
             const defaultName = this.platform.getIndexName(this.meta.collection, prop.fieldNames, type);
             /* v8 ignore next */
-            options[type] = (propType === true || defaultName === propType) ? 'true' : this.quote(propType);
+            options[type] = propType === true || defaultName === propType ? 'true' : this.quote(propType);
             const expected = {
                 index: this.platform.indexForeignKeys(),
                 unique: prop.kind === ReferenceKind.ONE_TO_ONE,
@@ -123,14 +138,14 @@ export class EntitySchemaSourceFile extends SourceFile {
         processIndex('index');
         processIndex('unique');
     }
-    getScalarPropertyDecoratorOptions(options, prop) {
+    getScalarPropertyDecoratorOptions(options, prop, quote = true) {
         if (prop.enum) {
             options.enum = true;
             options.items = `() => ${prop.runtimeType}`;
         }
         else {
-            options.type = this.quote(prop.type);
+            options.type = quote ? this.quote(prop.type) : prop.type;
         }
-        super.getScalarPropertyDecoratorOptions(options, prop);
+        super.getScalarPropertyDecoratorOptions(options, prop, quote);
     }
 }

package/NativeEnumSourceFile.d.ts

@@ -0,0 +1,12 @@
+import type { EntityMetadata, GenerateOptions, NamingStrategy, Platform } from '@mikro-orm/core';
+import { SourceFile } from './SourceFile.js';
+export declare class NativeEnumSourceFile extends SourceFile {
+    private readonly nativeEnum;
+    constructor(meta: EntityMetadata, namingStrategy: NamingStrategy, platform: Platform, options: GenerateOptions, nativeEnum: {
+        name: string;
+        schema?: string;
+        items: string[];
+    });
+    generate(): string;
+    getBaseName(extension?: string): string;
+}

package/NativeEnumSourceFile.js

@@ -0,0 +1,47 @@
+import { identifierRegex, SourceFile } from './SourceFile.js';
+export class NativeEnumSourceFile extends SourceFile {
+    nativeEnum;
+    constructor(meta, namingStrategy, platform, options, nativeEnum) {
+        super(meta, namingStrategy, platform, options);
+        this.nativeEnum = nativeEnum;
+    }
+    generate() {
+        const enumClassName = this.namingStrategy.getEnumClassName(this.nativeEnum.name, undefined, this.nativeEnum.schema);
+        const enumTypeName = this.namingStrategy.getEnumTypeName(this.nativeEnum.name, undefined, this.nativeEnum.schema);
+        const padding = '  ';
+        const enumMode = this.options.enumMode;
+        const enumValues = this.nativeEnum.items;
+        if (enumMode === 'union-type') {
+            return `export type ${enumTypeName} = ${enumValues.map(item => this.quote(item)).join(' | ')};\n`;
+        }
+        let ret = '';
+        if (enumMode === 'dictionary') {
+            ret += `export const ${enumClassName} = {\n`;
+        }
+        else {
+            ret += `export enum ${enumClassName} {\n`;
+        }
+        for (const enumValue of enumValues) {
+            const enumName = this.namingStrategy.enumValueToEnumProperty(enumValue, this.nativeEnum.name, '', this.nativeEnum.schema);
+            if (enumMode === 'dictionary') {
+                ret += `${padding}${identifierRegex.test(enumName) ? enumName : this.quote(enumName)}: ${this.quote(enumValue)},\n`;
+            }
+            else {
+                ret += `${padding}${identifierRegex.test(enumName) ? enumName : this.quote(enumName)} = ${this.quote(enumValue)},\n`;
+            }
+        }
+        if (enumMode === 'dictionary') {
+            ret += '} as const;\n';
+        }
+        else {
+            ret += '}\n';
+        }
+        if (enumMode === 'dictionary') {
+            ret += `\nexport type ${enumTypeName} = (typeof ${enumClassName})[keyof typeof ${enumClassName}];\n`;
+        }
+        return ret;
+    }
+    getBaseName(extension = '.ts') {
+        return `${this.options.fileName(this.nativeEnum.name)}${extension}`;
+    }
+}