@mikro-orm/entity-generator 6.5.10-dev.14 → 6.5.10-dev.16

package/DefineEntitySourceFile.d.ts

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

package/DefineEntitySourceFile.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefineEntitySourceFile = void 0;
+const core_1 = require("@mikro-orm/core");
+const EntitySchemaSourceFile_1 = require("./EntitySchemaSourceFile");
+class DefineEntitySourceFile extends EntitySchemaSourceFile_1.EntitySchemaSourceFile {
+    generate() {
+        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));
+            }
+        }
+        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[core_1.Config] = true;
+        entitySchemaOptions.properties[core_1.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 core_1.ReferenceKind.ONE_TO_ONE:
+                builder += `() => ${p}.oneToOne(${prop.type})`;
+                break;
+            case core_1.ReferenceKind.ONE_TO_MANY:
+                builder += `() => ${p}.oneToMany(${prop.type})`;
+                break;
+            case core_1.ReferenceKind.MANY_TO_ONE:
+                builder += `() => ${p}.manyToOne(${prop.type})`;
+                break;
+            case core_1.ReferenceKind.MANY_TO_MANY:
+                builder += `() => ${p}.manyToMany(${prop.type})`;
+                break;
+            case core_1.ReferenceKind.EMBEDDED:
+                builder += `() => ${p}.embedded(${prop.type})`;
+                break;
+            case core_1.ReferenceKind.SCALAR:
+            default: {
+                if (options.type && !(options.type in core_1.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;
+    }
+}
+exports.DefineEntitySourceFile = DefineEntitySourceFile;

package/EntityGenerator.js

@@ -5,6 +5,7 @@ const core_1 = require("@mikro-orm/core");
 const knex_1 = require("@mikro-orm/knex");
 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 SourceFile_1 = require("./SourceFile");
 class EntityGenerator {
@@ -37,7 +38,10 @@ class EntityGenerator {
         const baseDir = core_1.Utils.normalizePath(options.path ?? defaultPath);
         for (const meta of metadata) {
             if (!meta.pivotTable || options.outputPurePivotTables || this.referencedEntities.has(meta)) {
-                if (options.entitySchema) {
+                if (options.defineEntity) {
+                    this.sources.push(new DefineEntitySourceFile_1.DefineEntitySourceFile(meta, this.namingStrategy, this.platform, { ...options, scalarTypeInDecorator: true }));
+                }
+                else if (options.entitySchema) {
                     this.sources.push(new EntitySchemaSourceFile_1.EntitySchemaSourceFile(meta, this.namingStrategy, this.platform, { ...options, scalarTypeInDecorator: true }));
                 }
                 else {

package/EntitySchemaSourceFile.d.ts

@@ -2,7 +2,8 @@ import { type Dictionary, type EntityProperty } from '@mikro-orm/core';
 import { SourceFile } from './SourceFile';
 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

@@ -5,43 +5,14 @@ const core_1 = require("@mikro-orm/core");
 const SourceFile_1 = require("./SourceFile");
 class EntitySchemaSourceFile extends SourceFile_1.SourceFile {
     generate() {
-        let classBody = '';
-        if (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`;
-        }
+        const classDefinition = this.generateClassDefinition();
         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 === core_1.ReferenceKind.SCALAR)) {
                 enumDefinitions.push(this.getEnumClassDefinition(prop, 2));
             }
-            if (prop.eager) {
-                eagerProperties.push(prop);
-            }
-            if (prop.primary && (!['id', '_id', 'uuid'].includes(prop.name) || this.meta.compositePK)) {
-                primaryProps.push(prop);
-            }
-        }
-        if (primaryProps.length > 0) {
-            const primaryPropNames = primaryProps.map(prop => `'${prop.name}'`);
-            if (primaryProps.length > 1) {
-                classBody += `${' '.repeat(2)}[${this.referenceCoreImport('PrimaryKeyProp')}]?: [${primaryPropNames.join(', ')}];\n`;
-            }
-            else {
-                classBody += `${' '.repeat(2)}[${this.referenceCoreImport('PrimaryKeyProp')}]?: ${primaryPropNames[0]};\n`;
-            }
         }
-        if (eagerProperties.length > 0) {
-            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);
+        let ret = classDefinition;
         if (enumDefinitions.length) {
             ret += '\n' + enumDefinitions.join('\n');
         }
@@ -67,7 +38,44 @@ class EntitySchemaSourceFile extends SourceFile_1.SourceFile {
         ret = `${this.generateImports()}\n\n${ret}`;
         return ret;
     }
-    getPropertyOptions(prop) {
+    generateClassDefinition() {
+        let classBody = '';
+        if (!this.options.customBaseEntityName || this.meta.className === this.options.customBaseEntityName) {
+            const defineConfigTypeSettings = {};
+            defineConfigTypeSettings.forceObject = this.platform.getConfig().get('serialization').forceObject ?? false;
+            if (defineConfigTypeSettings.forceObject) {
+                classBody += `${' '.repeat(2)}[${this.referenceCoreImport('Config')}]?: ${this.referenceCoreImport('DefineConfig')}<${this.serializeObject(defineConfigTypeSettings)}>;\n`;
+            }
+        }
+        const eagerProperties = [];
+        const primaryProps = [];
+        const props = [];
+        for (const prop of Object.values(this.meta.properties)) {
+            props.push(this.getPropertyDefinition(prop, 2));
+            if (prop.eager) {
+                eagerProperties.push(prop);
+            }
+            if (prop.primary && (!['id', '_id', 'uuid'].includes(prop.name) || this.meta.compositePK)) {
+                primaryProps.push(prop);
+            }
+        }
+        if (primaryProps.length > 0) {
+            const primaryPropNames = primaryProps.map(prop => `'${prop.name}'`);
+            if (primaryProps.length > 1) {
+                classBody += `${' '.repeat(2)}[${this.referenceCoreImport('PrimaryKeyProp')}]?: [${primaryPropNames.join(', ')}];\n`;
+            }
+            else {
+                classBody += `${' '.repeat(2)}[${this.referenceCoreImport('PrimaryKeyProp')}]?: ${primaryPropNames[0]};\n`;
+            }
+        }
+        if (eagerProperties.length > 0) {
+            const eagerPropertyNames = eagerProperties.map(prop => `'${prop.name}'`).sort();
+            classBody += `${' '.repeat(2)}[${this.referenceCoreImport('EagerProps')}]?: ${eagerPropertyNames.join(' | ')};\n`;
+        }
+        classBody += `${props.join('')}`;
+        return this.getEntityClass(classBody);
+    }
+    getPropertyOptions(prop, quote = true) {
         const options = {};
         if (prop.primary) {
             options.primary = true;
@@ -82,7 +90,7 @@ class EntitySchemaSourceFile extends SourceFile_1.SourceFile {
             this.getOneToManyDecoratorOptions(options, prop);
         }
         else if (prop.kind === core_1.ReferenceKind.SCALAR || typeof prop.kind === 'undefined') {
-            this.getScalarPropertyDecoratorOptions(options, prop);
+            this.getScalarPropertyDecoratorOptions(options, prop, quote);
         }
         else if (prop.kind === core_1.ReferenceKind.EMBEDDED) {
             this.getEmbeddedPropertyDeclarationOptions(options, prop);
@@ -126,15 +134,15 @@ class EntitySchemaSourceFile extends SourceFile_1.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);
     }
 }
 exports.EntitySchemaSourceFile = EntitySchemaSourceFile;

package/SourceFile.d.ts

@@ -30,7 +30,7 @@ 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;

package/SourceFile.js

@@ -540,7 +540,7 @@ 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]);
         }
@@ -574,7 +574,7 @@ 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);
@@ -675,7 +675,7 @@ 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') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/entity-generator",
-  "version": "6.5.10-dev.14",
+  "version": "6.5.10-dev.16",
   "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.14",
+    "@mikro-orm/knex": "6.5.10-dev.16",
     "fs-extra": "11.3.2"
   },
   "devDependencies": {
     "@mikro-orm/core": "^6.5.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.5.10-dev.14"
+    "@mikro-orm/core": "6.5.10-dev.16"
   }
 }