@mikro-orm/entity-generator 7.0.0-dev.9 → 7.0.0-dev.91

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,115 @@
+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.js

@@ -1,8 +1,11 @@
 import { EntityMetadata, ReferenceKind, types, Utils, } from '@mikro-orm/core';
 import { DatabaseSchema, } from '@mikro-orm/knex';
+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;
@@ -32,28 +35,40 @@ export class EntityGenerator {
         const metadata = await this.getEntityMetadata(schema, options);
         const defaultPath = `${this.config.get('baseDir')}/generated-entities`;
         const baseDir = Utils.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()

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,56 @@ 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);
             }
@@ -38,33 +73,9 @@ export class EntitySchemaSourceFile extends SourceFile {
             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;
+        return this.getEntityClass(classBody);
     }
-    getPropertyOptions(prop) {
+    getPropertyOptions(prop, quote = true) {
         const options = {};
         if (prop.primary) {
             options.primary = true;
@@ -79,7 +90,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);
@@ -123,14 +134,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,16 @@
+import type { EntityMetadata, GenerateOptions, NamingStrategy, Platform } from '@mikro-orm/core';
+import { SourceFile } from './SourceFile.js';
+export declare class NativeEnumSourceFile extends SourceFile {
+    protected readonly nativeEnum: {
+        name: string;
+        schema?: string;
+        items: string[];
+    };
+    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}`;
+    }
+}

package/README.md

@@ -11,7 +11,6 @@ TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-or
 [![Chat on discord](https://img.shields.io/discord/1214904142443839538?label=discord&color=blue)](https://discord.gg/w8bjxFHS7X)
 [![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
 [![Coverage Status](https://img.shields.io/coveralls/mikro-orm/mikro-orm.svg)](https://coveralls.io/r/mikro-orm/mikro-orm?branch=master)
-[![Maintainability](https://api.codeclimate.com/v1/badges/27999651d3adc47cfa40/maintainability)](https://codeclimate.com/github/mikro-orm/mikro-orm/maintainability)
 [![Build Status](https://github.com/mikro-orm/mikro-orm/workflows/tests/badge.svg?branch=master)](https://github.com/mikro-orm/mikro-orm/actions?workflow=tests)
 
 ## 🤔 Unit of What?
@@ -141,7 +140,7 @@ There is also auto-generated [CHANGELOG.md](CHANGELOG.md) file based on commit m
 - [Composite and Foreign Keys as Primary Key](https://mikro-orm.io/docs/composite-keys)
 - [Filters](https://mikro-orm.io/docs/filters)
 - [Using `QueryBuilder`](https://mikro-orm.io/docs/query-builder)
-- [Preloading Deeply Nested Structures via populate](https://mikro-orm.io/docs/nested-populate)
+- [Populating relations](https://mikro-orm.io/docs/populating-relations)
 - [Property Validation](https://mikro-orm.io/docs/property-validation)
 - [Lifecycle Hooks](https://mikro-orm.io/docs/events#hooks)
 - [Vanilla JS Support](https://mikro-orm.io/docs/usage-with-js)
@@ -382,6 +381,8 @@ See also the list of contributors who [participated](https://github.com/mikro-or
 
 Please ⭐️ this repository if this project helped you!
 
+> If you'd like to support my open-source work, consider sponsoring me directly at [github.com/sponsors/b4nan](https://github.com/sponsors/b4nan).
+
 ## 📝 License
 
 Copyright © 2018 [Martin Adámek](https://github.com/b4nan).

package/SourceFile.d.ts

@@ -9,7 +9,9 @@ export declare class SourceFile {
     protected readonly platform: Platform;
     protected readonly options: GenerateOptions;
     protected readonly coreImports: Set<string>;
+    protected readonly decoratorImports: Set<string>;
     protected readonly entityImports: Set<string>;
+    protected readonly enumImports: Map<string, string[]>;
     constructor(meta: EntityMetadata, namingStrategy: NamingStrategy, platform: Platform, options: GenerateOptions);
     generate(): string;
     protected getIndexOptions(index: EntityMetadata['indexes'][number], isAtEntityLevel?: boolean): IndexOptions<Dictionary, string>;
@@ -30,11 +32,12 @@ export declare class SourceFile {
     protected getCommonDecoratorOptions(options: Dictionary, prop: EntityProperty): void;
     private propTypeBreakdowns;
     private breakdownOfIType;
-    protected getScalarPropertyDecoratorOptions(options: Dictionary, prop: EntityProperty): void;
+    protected getScalarPropertyDecoratorOptions(options: Dictionary, prop: EntityProperty, quote?: boolean): void;
     protected getManyToManyDecoratorOptions(options: Dictionary, prop: EntityProperty): void;
     protected getOneToManyDecoratorOptions(options: Dictionary, prop: EntityProperty): void;
     protected getEmbeddedPropertyDeclarationOptions(options: Dictionary, prop: EntityProperty): void;
     protected getForeignKeyDecoratorOptions(options: OneToOneOptions<any, any>, prop: EntityProperty): void;
     protected getDecoratorType(prop: EntityProperty): string;
     protected referenceCoreImport(identifier: string): string;
+    protected referenceDecoratorImport(identifier: string): string;
 }

package/SourceFile.js

@@ -1,19 +1,20 @@
-import { Cascade, Config, DecimalType, ReferenceKind, SCALAR_TYPES, UnknownType, Utils, } from '@mikro-orm/core';
+import { Cascade, Config, DecimalType, ReferenceKind, SCALAR_TYPES, UnknownType, Utils, inspect, } from '@mikro-orm/core';
 import { parse, relative } from 'node:path';
-import { inspect } from 'node:util';
 import { POSSIBLE_TYPE_IMPORTS } from './CoreImportsHelper.js';
 /**
  * @see https://github.com/tc39/proposal-regexp-unicode-property-escapes#other-examples
  */
 export const identifierRegex = /^(?:[$_\p{ID_Start}])(?:[$\u200C\u200D\p{ID_Continue}])*$/u;
-const primitivesAndLibs = [...SCALAR_TYPES, 'bigint', 'Uint8Array', 'unknown', 'object', 'any'];
+const primitivesAndLibs = [...SCALAR_TYPES, 'unknown', 'object', 'any'];
 export class SourceFile {
     meta;
     namingStrategy;
     platform;
     options;
     coreImports = new Set();
+    decoratorImports = new Set();
     entityImports = new Set();
+    enumImports = new Map();
     constructor(meta, namingStrategy, platform, options) {
         this.meta = meta;
         this.namingStrategy = namingStrategy;
@@ -25,24 +26,24 @@ export class SourceFile {
         if (this.meta.embeddable || this.meta.collection) {
             if (this.meta.embeddable) {
                 const options = this.getEmbeddableDeclOptions();
-                ret += `@${this.referenceCoreImport('Embeddable')}(${Utils.hasObjectKeys(options) ? this.serializeObject(options) : ''})\n`;
+                ret += `@${this.referenceDecoratorImport('Embeddable')}(${Utils.hasObjectKeys(options) ? this.serializeObject(options) : ''})\n`;
             }
             else {
                 const options = this.getEntityDeclOptions();
-                ret += `@${this.referenceCoreImport('Entity')}(${Utils.hasObjectKeys(options) ? this.serializeObject(options) : ''})\n`;
+                ret += `@${this.referenceDecoratorImport('Entity')}(${Utils.hasObjectKeys(options) ? this.serializeObject(options) : ''})\n`;
             }
         }
         for (const index of this.meta.indexes) {
             if (index.properties?.length === 1 && typeof this.meta.properties[index.properties[0]] !== 'undefined') {
                 continue;
             }
-            ret += `@${this.referenceCoreImport('Index')}(${this.serializeObject(this.getIndexOptions(index))})\n`;
+            ret += `@${this.referenceDecoratorImport('Index')}(${this.serializeObject(this.getIndexOptions(index))})\n`;
         }
         for (const index of this.meta.uniques) {
             if (index.properties?.length === 1 && typeof this.meta.properties[index.properties[0]] !== 'undefined') {
                 continue;
             }
-            ret += `@${this.referenceCoreImport('Unique')}(${this.serializeObject(this.getUniqueOptions(index))})\n`;
+            ret += `@${this.referenceDecoratorImport('Unique')}(${this.serializeObject(this.getUniqueOptions(index))})\n`;
         }
         let classHead = '';
         if (this.meta.className === this.options.customBaseEntityName) {
@@ -65,7 +66,10 @@ export class SourceFile {
             classBody += definition;
             classBody += '\n';
             if (prop.enum) {
-                enumDefinitions.push(this.getEnumClassDefinition(prop, 2));
+                const def = this.getEnumClassDefinition(prop, 2);
+                if (def.length) {
+                    enumDefinitions.push(def);
+                }
             }
             if (prop.eager) {
                 eagerProperties.push(prop);
@@ -99,9 +103,12 @@ export class SourceFile {
         if (typeof index.name === 'string') {
             indexOpt.name = this.quote(index.name);
         }
-        if (index.expression) {
+        if (typeof index.expression === 'string') {
             indexOpt.expression = this.quote(index.expression);
         }
+        else if (typeof index.expression === 'function') {
+            indexOpt.expression = `${index.expression}`.replace(')=>`', ') => `');
+        }
         if (isAtEntityLevel && index.properties) {
             indexOpt.properties = Utils.asArray(index.properties).map(prop => this.quote('' + prop));
         }
@@ -112,9 +119,12 @@ export class SourceFile {
         if (typeof index.name === 'string') {
             uniqueOpt.name = this.quote(index.name);
         }
-        if (index.expression) {
+        if (typeof index.expression === 'string') {
             uniqueOpt.expression = this.quote(index.expression);
         }
+        else if (typeof index.expression === 'function') {
+            uniqueOpt.expression = `${index.expression}`.replace(')=>`', ') => `');
+        }
         if (isAtEntityLevel && index.properties) {
             uniqueOpt.properties = Utils.asArray(index.properties).map(prop => this.quote('' + prop));
         }
@@ -135,37 +145,61 @@ export class SourceFile {
                 return ret;
             }).join(', '))} } from '@mikro-orm/core';`);
         }
+        if (this.decoratorImports.size > 0) {
+            const type = this.options.decorators;
+            imports.add(`import { ${([...this.decoratorImports].sort().map(t => {
+                let ret = t;
+                if (this.options.coreImportsPrefix) {
+                    const resolvedIdentifier = `${this.options.coreImportsPrefix}${t}`;
+                    ret += ` as ${resolvedIdentifier}`;
+                }
+                return ret;
+            }).join(', '))} } from '@mikro-orm/decorators/${type}';`);
+        }
         const extension = this.options.esmImport ? '.js' : '';
         const { dir, base } = parse(`${this.options.path ?? '.'}/${this.getBaseName()}`);
         const basePath = relative(dir, this.options.path ?? '.') || '.';
         (this.options.extraImports?.(basePath, base) ?? []).forEach(v => this.entityImports.add(v));
         const entityImports = [...this.entityImports].filter(e => e !== this.meta.className);
-        entityImports.sort().forEach(entity => {
+        const importMap = new Map();
+        for (const entity of entityImports) {
             const file = this.options.onImport?.(entity, basePath, extension, base) ?? {
                 path: `${basePath}/${this.options.fileName(entity)}${extension}`,
                 name: entity,
             };
             if (file.path === '') {
                 if (file.name === '') {
-                    return;
+                    continue;
                 }
-                imports.add(`import ${this.quote(file.name)};`);
-                return;
+                importMap.set(file.path, `import ${this.quote(file.name)};`);
+                continue;
             }
             if (file.name === '') {
-                imports.add(`import * as ${entity} from ${this.quote(file.path)};`);
-                return;
+                importMap.set(file.path, `import * as ${entity} from ${this.quote(file.path)};`);
+                continue;
             }
             if (file.name === 'default') {
-                imports.add(`import ${entity} from ${this.quote(file.path)};`);
-                return;
+                importMap.set(file.path, `import ${entity} from ${this.quote(file.path)};`);
+                continue;
             }
             if (file.name === entity) {
-                imports.add(`import { ${entity} } from ${this.quote(file.path)};`);
-                return;
+                importMap.set(file.path, `import { ${entity} } from ${this.quote(file.path)};`);
+                continue;
             }
-            imports.add(`import { ${identifierRegex.test(file.name) ? file.name : this.quote(file.name)} as ${entity} } from ${this.quote(file.path)};`);
-        });
+            importMap.set(file.path, `import { ${identifierRegex.test(file.name) ? file.name : this.quote(file.name)} as ${entity} } from ${this.quote(file.path)};`);
+        }
+        if (this.enumImports.size) {
+            for (const [name, exports] of this.enumImports.entries()) {
+                const file = this.options.onImport?.(name, basePath, extension, base) ?? {
+                    path: `${basePath}/${this.options.fileName(name)}${extension}`,
+                    name,
+                };
+                importMap.set(file.path, `import { ${exports.join(', ')} } from ${this.quote(file.path)};`);
+            }
+        }
+        for (const key of [...importMap.keys()].sort()) {
+            imports.add(importMap.get(key));
+        }
         return Array.from(imports.values()).join('\n');
     }
     getEntityClass(classBody) {
@@ -195,6 +229,7 @@ export class SourceFile {
     getPropertyDefinition(prop, padLeft) {
         const padding = ' '.repeat(padLeft);
         const propName = identifierRegex.test(prop.name) ? prop.name : this.quote(prop.name);
+        const enumMode = this.options.enumMode;
         let hiddenType = '';
         if (prop.hidden) {
             hiddenType += ` & ${this.referenceCoreImport('Hidden')}`;
@@ -212,7 +247,11 @@ export class SourceFile {
             : (() => {
                 if (isScalar) {
                     if (prop.enum) {
-                        return prop.runtimeType;
+                        const method = enumMode === 'ts-enum' ? 'getEnumClassName' : 'getEnumTypeName';
+                        if (prop.nativeEnumName) {
+                            return this.namingStrategy[method](prop.nativeEnumName, undefined, this.meta.schema);
+                        }
+                        return this.namingStrategy[method](prop.fieldNames[0], this.meta.collection, this.meta.schema);
                     }
                     breakdownOfIType = this.breakdownOfIType(prop);
                     if (typeof breakdownOfIType !== 'undefined') {
@@ -247,8 +286,14 @@ export class SourceFile {
             return `${padding}${ret};\n`;
         }
         if (prop.enum && typeof prop.default === 'string') {
+            if (enumMode === 'union-type') {
+                return `${padding}${ret} = ${this.quote(prop.default)};\n`;
+            }
+            const enumClassName = prop.nativeEnumName
+                ? this.namingStrategy.getEnumClassName(prop.nativeEnumName, undefined, this.meta.schema)
+                : this.namingStrategy.getEnumClassName(prop.fieldNames[0], this.meta.collection, this.meta.schema);
             const enumVal = this.namingStrategy.enumValueToEnumProperty(prop.default, prop.fieldNames[0], this.meta.collection, this.meta.schema);
-            return `${padding}${ret} = ${propType}${identifierRegex.test(enumVal) ? `.${enumVal}` : `[${this.quote(enumVal)}]`};\n`;
+            return `${padding}${ret} = ${enumClassName}${identifierRegex.test(enumVal) ? `.${enumVal}` : `[${this.quote(enumVal)}]`};\n`;
         }
         if (prop.fieldNames?.length > 1) {
             // TODO: Composite FKs with default values require additions to default/defaultRaw that are not yet supported.
@@ -264,15 +309,51 @@ export class SourceFile {
         return `${padding}${ret} = ${prop.ref ? this.referenceCoreImport('ref') : this.referenceCoreImport('rel')}(${propType}, ${defaultVal});\n`;
     }
     getEnumClassDefinition(prop, padLeft) {
+        const enumMode = this.options.enumMode;
+        if (prop.nativeEnumName) {
+            const imports = [];
+            if (enumMode !== 'union-type') {
+                imports.push(prop.runtimeType);
+            }
+            if (!this.options.inferEntityType && enumMode !== 'ts-enum') {
+                const enumTypeName = this.namingStrategy.getEnumTypeName(prop.nativeEnumName, undefined, this.meta.schema);
+                imports.push(enumTypeName);
+            }
+            this.enumImports.set(prop.runtimeType, imports);
+            return '';
+        }
         const enumClassName = this.namingStrategy.getEnumClassName(prop.fieldNames[0], this.meta.collection, this.meta.schema);
+        const enumTypeName = this.namingStrategy.getEnumTypeName(prop.fieldNames[0], this.meta.collection, this.meta.schema);
         const padding = ' '.repeat(padLeft);
-        let ret = `export enum ${enumClassName} {\n`;
         const enumValues = prop.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, prop.fieldNames[0], this.meta.collection, this.meta.schema);
-            ret += `${padding}${identifierRegex.test(enumName) ? enumName : this.quote(enumName)} = ${this.quote(enumValue)},\n`;
+            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`;
         }
-        ret += '}\n';
         return ret;
     }
     serializeObject(options, wordwrap, spaces, level = 0) {
@@ -312,7 +393,7 @@ export class SourceFile {
             options.expression = this.quote(this.meta.expression);
         }
         else if (typeof this.meta.expression === 'function') {
-            options.expression = `${this.meta.expression}`;
+            options.expression = this.meta.expression.toString();
         }
         if (this.meta.repositoryClass) {
             this.entityImports.add(this.meta.repositoryClass);
@@ -352,7 +433,7 @@ export class SourceFile {
     getPropertyDecorator(prop, padLeft) {
         const padding = ' '.repeat(padLeft);
         const options = {};
-        let decorator = `@${this.referenceCoreImport(this.getDecoratorType(prop))}`;
+        let decorator = `@${this.referenceDecoratorImport(this.getDecoratorType(prop))}`;
         if (prop.kind === ReferenceKind.MANY_TO_MANY) {
             this.getManyToManyDecoratorOptions(options, prop);
         }
@@ -373,7 +454,7 @@ export class SourceFile {
         decorator = [...indexes.sort(), decorator].map(d => padding + d).join('\n');
         const decoratorArgs = [];
         if (prop.formula) {
-            decoratorArgs.push(`${prop.formula}`);
+            decoratorArgs.push(prop.formula.toString());
         }
         if (Utils.hasObjectKeys(options)) {
             decoratorArgs.push(`${this.serializeObject(options)}`);
@@ -402,26 +483,26 @@ export class SourceFile {
         let propIndexIsNonTrivialIndex = false;
         const nonTrivialIndexes = this.meta.indexes.filter(i => i.properties?.length === 1 && i.properties[0] === prop.name);
         for (const i of nonTrivialIndexes) {
-            ret.push(`@${this.referenceCoreImport('Index')}(${this.serializeObject(this.getIndexOptions(i, false))})`);
+            ret.push(`@${this.referenceDecoratorImport('Index')}(${this.serializeObject(this.getIndexOptions(i, false))})`);
             if (prop.index === i.name) {
                 propIndexIsNonTrivialIndex = true;
                 delete options.index;
             }
         }
         if (prop.index && !options.index && !propIndexIsNonTrivialIndex) {
-            ret.push(`@${this.referenceCoreImport('Index')}(${typeof prop.index === 'string' ? `{ name: ${this.quote(prop.index)} }` : ''})`);
+            ret.push(`@${this.referenceDecoratorImport('Index')}(${typeof prop.index === 'string' ? `{ name: ${this.quote(prop.index)} }` : ''})`);
         }
         let propIndexIsNonTrivialUnique = false;
         const nonTrivialUnique = this.meta.uniques.filter(i => i.properties?.length === 1 && i.properties[0] === prop.name);
         for (const i of nonTrivialUnique) {
-            ret.push(`@${this.referenceCoreImport('Unique')}(${this.serializeObject(this.getUniqueOptions(i, false))})`);
+            ret.push(`@${this.referenceDecoratorImport('Unique')}(${this.serializeObject(this.getUniqueOptions(i, false))})`);
             if (prop.unique === i.name) {
                 propIndexIsNonTrivialUnique = true;
                 delete options.unique;
             }
         }
         if (prop.unique && !options.unique && !propIndexIsNonTrivialUnique) {
-            ret.push(`@${this.referenceCoreImport('Unique')}(${typeof prop.unique === 'string' ? `{ name: ${this.quote(prop.unique)} }` : ''})`);
+            ret.push(`@${this.referenceDecoratorImport('Unique')}(${typeof prop.unique === 'string' ? `{ name: ${this.quote(prop.unique)} }` : ''})`);
         }
         return ret;
     }
@@ -432,7 +513,7 @@ export class SourceFile {
         if (prop.primary && (prop.enum || !(typeof prop.kind === 'undefined' || prop.kind === ReferenceKind.SCALAR))) {
             options.primary = true;
         }
-        ['persist', 'hydrate', 'trackChanges']
+        ['persist', 'hydrate']
             .filter(key => prop[key] === false)
             .forEach(key => options[key] = false);
         ['onCreate', 'onUpdate', 'serializer']
@@ -531,12 +612,23 @@ export class SourceFile {
         this.propTypeBreakdowns.set(prop, r);
         return r;
     }
-    getScalarPropertyDecoratorOptions(options, prop) {
+    getScalarPropertyDecoratorOptions(options, prop, quote = true) {
         if (prop.fieldNames[0] !== this.namingStrategy.propertyToColumnName(prop.name)) {
             options.fieldName = this.quote(prop.fieldNames[0]);
         }
         if (prop.enum) {
-            options.items = `() => ${prop.runtimeType}`;
+            if (this.options.enumMode === 'union-type') {
+                options.items = `[${prop.items.map(item => this.quote(item)).join(', ')}]`;
+            }
+            else if (prop.nativeEnumName) {
+                const enumClassName = this.namingStrategy.getEnumClassName(prop.nativeEnumName, undefined, this.meta.schema);
+                options.items = `() => ${enumClassName}`;
+                options.nativeEnumName = this.quote(prop.nativeEnumName);
+            }
+            else {
+                const enumClassName = this.namingStrategy.getEnumClassName(prop.fieldNames[0], this.meta.collection, this.meta.schema);
+                options.items = `() => ${enumClassName}`;
+            }
         }
         // For enum properties, we don't need a column type
         // or the property length or other information in the decorator.
@@ -565,7 +657,7 @@ export class SourceFile {
                     return ((useDefault && !hasUsableNullDefault) || (prop.optional && !prop.nullable));
                 })() // also when there is the "| Opt" type modifier (because reflect-metadata can't extract the base)
             ) {
-                options.type = this.quote(prop.type);
+                options.type = quote ? this.quote(prop.type) : prop.type;
             }
         }
         const columnTypeFromMappedRuntimeType = mappedRuntimeType.getColumnType({ ...prop, autoincrement: false }, this.platform);
@@ -592,7 +684,7 @@ export class SourceFile {
             assign('length');
         }
         // those are already included in the `columnType` in most cases, and when that option is present, they would be ignored anyway
-        /* v8 ignore next 4 */
+        /* v8 ignore next */
         if (mappedColumnType instanceof DecimalType && !options.columnType) {
             assign('precision');
             assign('scale');
@@ -666,7 +758,7 @@ export class SourceFile {
         if (prop.array) {
             options.array = true;
         }
-        if (prop.object) {
+        if (prop.object && !prop.array) {
             options.object = true;
         }
         if (prop.prefix === false || typeof prop.prefix === 'string') {
@@ -749,4 +841,10 @@ export class SourceFile {
             ? `${this.options.coreImportsPrefix}${identifier}`
             : identifier;
     }
+    referenceDecoratorImport(identifier) {
+        this.decoratorImports.add(identifier);
+        return this.options.coreImportsPrefix
+            ? `${this.options.coreImportsPrefix}${identifier}`
+            : identifier;
+    }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/entity-generator",
   "type": "module",
-  "version": "7.0.0-dev.9",
+  "version": "7.0.0-dev.91",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "exports": {
     "./package.json": "./package.json",
@@ -38,7 +38,7 @@
   },
   "homepage": "https://mikro-orm.io",
   "engines": {
-    "node": ">= 22.11.0"
+    "node": ">= 22.17.0"
   },
   "scripts": {
     "build": "yarn clean && yarn compile && yarn copy",
@@ -50,12 +50,12 @@
     "access": "public"
   },
   "dependencies": {
-    "@mikro-orm/knex": "7.0.0-dev.9"
+    "@mikro-orm/knex": "7.0.0-dev.91"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.4.13"
+    "@mikro-orm/core": "^6.6.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.9"
+    "@mikro-orm/core": "7.0.0-dev.91"
   }
 }