@mikro-orm/entity-generator 6.5.10-dev.19 → 6.5.10-dev.20

package/DefineEntitySourceFile.js

@@ -8,7 +8,10 @@ class DefineEntitySourceFile extends EntitySchemaSourceFile_1.EntitySchemaSource
         const enumDefinitions = [];
         for (const prop of Object.values(this.meta.properties)) {
             if (prop.enum && (typeof prop.kind === 'undefined' || prop.kind === core_1.ReferenceKind.SCALAR)) {
-                enumDefinitions.push(this.getEnumClassDefinition(prop, 2));
+                const def = this.getEnumClassDefinition(prop, 2);
+                if (def.length) {
+                    enumDefinitions.push(def);
+                }
             }
         }
         let ret = '';

package/EntityGenerator.js

@@ -7,6 +7,7 @@ const node_path_1 = require("node:path");
 const fs_extra_1 = require("fs-extra");
 const DefineEntitySourceFile_1 = require("./DefineEntitySourceFile");
 const EntitySchemaSourceFile_1 = require("./EntitySchemaSourceFile");
+const NativeEnumSourceFile_1 = require("./NativeEnumSourceFile");
 const SourceFile_1 = require("./SourceFile");
 class EntityGenerator {
     em;
@@ -54,6 +55,9 @@ class EntityGenerator {
             }
             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_1.NativeEnumSourceFile({}, this.namingStrategy, this.platform, options, nativeEnum));
+        }
         const files = this.sources.map(file => [file.getBaseName(), file.generate()]);
         if (options.save) {
             await (0, fs_extra_1.ensureDir)(baseDir);

package/EntitySchemaSourceFile.js

@@ -9,7 +9,10 @@ class EntitySchemaSourceFile extends SourceFile_1.SourceFile {
         const enumDefinitions = [];
         for (const prop of Object.values(this.meta.properties)) {
             if (prop.enum && (typeof prop.kind === 'undefined' || prop.kind === core_1.ReferenceKind.SCALAR)) {
-                enumDefinitions.push(this.getEnumClassDefinition(prop, 2));
+                const def = this.getEnumClassDefinition(prop, 2);
+                if (def.length) {
+                    enumDefinitions.push(def);
+                }
             }
         }
         let ret = classDefinition;

package/NativeEnumSourceFile.d.ts

@@ -0,0 +1,16 @@
+import type { EntityMetadata, GenerateOptions, NamingStrategy, Platform } from '@mikro-orm/core';
+import { SourceFile } from './SourceFile';
+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,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeEnumSourceFile = void 0;
+const SourceFile_1 = require("./SourceFile");
+class NativeEnumSourceFile extends SourceFile_1.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}${SourceFile_1.identifierRegex.test(enumName) ? enumName : this.quote(enumName)}: ${this.quote(enumValue)},\n`;
+            }
+            else {
+                ret += `${padding}${SourceFile_1.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}`;
+    }
+}
+exports.NativeEnumSourceFile = NativeEnumSourceFile;

package/SourceFile.d.ts

@@ -10,6 +10,7 @@ export declare class SourceFile {
     protected readonly options: GenerateOptions;
     protected readonly coreImports: 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>;

package/SourceFile.js

@@ -17,6 +17,7 @@ class SourceFile {
     options;
     coreImports = new Set();
     entityImports = new Set();
+    enumImports = new Map();
     constructor(meta, namingStrategy, platform, options) {
         this.meta = meta;
         this.namingStrategy = namingStrategy;
@@ -68,7 +69,10 @@ 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);
@@ -149,32 +153,45 @@ class SourceFile {
         const basePath = (0, node_path_1.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 { ${exports.identifierRegex.test(file.name) ? file.name : this.quote(file.name)} as ${entity} } from ${this.quote(file.path)};`);
-        });
+            importMap.set(file.path, `import { ${exports.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) {
@@ -223,6 +240,9 @@ class SourceFile {
                 if (isScalar) {
                     if (prop.enum) {
                         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);
@@ -258,11 +278,12 @@ class SourceFile {
             return `${padding}${ret};\n`;
         }
         if (prop.enum && typeof prop.default === 'string') {
-            const method = enumMode === 'union-type' ? 'getEnumTypeName' : 'getEnumClassName';
-            const enumClassName = this.namingStrategy[method](prop.fieldNames[0], this.meta.collection, this.meta.schema);
             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} = ${enumClassName}${exports.identifierRegex.test(enumVal) ? `.${enumVal}` : `[${this.quote(enumVal)}]`};\n`;
         }
@@ -280,10 +301,22 @@ 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);
-        const enumMode = this.options.enumMode;
         const enumValues = prop.items;
         if (enumMode === 'union-type') {
             return `export type ${enumTypeName} = ${enumValues.map(item => this.quote(item)).join(' | ')};\n`;
@@ -579,6 +612,11 @@ class SourceFile {
             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}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/entity-generator",
-  "version": "6.5.10-dev.19",
+  "version": "6.5.10-dev.20",
   "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -58,13 +58,13 @@
     "access": "public"
   },
   "dependencies": {
-    "@mikro-orm/knex": "6.5.10-dev.19",
+    "@mikro-orm/knex": "6.5.10-dev.20",
     "fs-extra": "11.3.2"
   },
   "devDependencies": {
     "@mikro-orm/core": "^6.5.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.5.10-dev.19"
+    "@mikro-orm/core": "6.5.10-dev.20"
   }
 }