@mikro-orm/entity-generator 6.3.14-dev.1 → 6.3.14-dev.3

package/EntityGenerator.d.ts

@@ -20,4 +20,5 @@ export declare class EntityGenerator {
     private generateBidirectionalRelations;
     private generateIdentifiedReferences;
     private generateAndAttachCustomBaseEntity;
+    private castNullDefaultsToUndefined;
 }

package/EntityGenerator.js

@@ -108,6 +108,9 @@ class EntityGenerator {
         if (options.customBaseEntityName) {
             this.generateAndAttachCustomBaseEntity(metadata, options.customBaseEntityName);
         }
+        if (options.undefinedDefaults) {
+            this.castNullDefaultsToUndefined(metadata);
+        }
         await options.onProcessedMetadata?.(metadata, this.platform);
         return metadata;
     }
@@ -226,6 +229,8 @@ class EntityGenerator {
                 else if (prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.mappedBy) {
                     newProp.kind = core_1.ReferenceKind.ONE_TO_ONE;
                     newProp.nullable = true;
+                    newProp.default = null;
+                    newProp.defaultRaw = 'null';
                 }
                 else if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY && !prop.mappedBy) {
                     newProp.kind = core_1.ReferenceKind.MANY_TO_MANY;
@@ -268,5 +273,15 @@ class EntityGenerator {
             }));
         }
     }
+    castNullDefaultsToUndefined(metadata) {
+        for (const meta of metadata) {
+            for (const prop of Object.values(meta.properties)) {
+                if (prop.nullable && !prop.optional && prop.default === null && typeof prop.defaultRaw === 'undefined') {
+                    prop.default = undefined;
+                    prop.optional = true;
+                }
+            }
+        }
+    }
 }
 exports.EntityGenerator = EntityGenerator;

package/SourceFile.js

@@ -204,7 +204,7 @@ class SourceFile {
             return `${padding}${propName}${hiddenType ? `: ${this.referenceCoreImport('Collection')}<${prop.type}>${hiddenType}` : ''} = new ${this.referenceCoreImport('Collection')}<${prop.type}>(this);\n`;
         }
         const isScalar = typeof prop.kind === 'undefined' || prop.kind === core_1.ReferenceKind.SCALAR;
-        let hasITypeWrapper = false;
+        let breakdownOfIType;
         const propType = prop.mapToPk
             ? (() => {
                 const runtimeTypes = prop.columnTypes.map((t, i) => (prop.customTypes?.[i] ?? this.platform.getMappedType(t)).runtimeType);
@@ -215,33 +215,43 @@ class SourceFile {
                     if (prop.enum) {
                         return prop.runtimeType;
                     }
-                    const breakdownOfIType = this.breakdownOfIType(prop);
+                    breakdownOfIType = this.breakdownOfIType(prop);
                     if (typeof breakdownOfIType !== 'undefined') {
-                        hasITypeWrapper = true;
+                        if (breakdownOfIType.length >= 3) {
+                            hiddenType = '';
+                        }
                         return `${this.referenceCoreImport('IType')}<${breakdownOfIType.join(', ')}>`;
                     }
                     return prop.runtimeType;
                 }
                 return prop.type;
             })();
-        const useDefault = prop.default != null && (propType !== 'unknown');
-        const optional = prop.nullable ? '?' : (useDefault ? '' : '!');
-        let ret = `${propName}${optional}: ${prop.ref ? `${this.referenceCoreImport('Ref')}<${propType}>` : `${(this.options.esmImport && !isScalar) ? `${this.referenceCoreImport('Rel')}<${propType}>` : propType}`}`;
-        if (prop.array && (prop.kind === core_1.ReferenceKind.EMBEDDED || prop.enum)) {
-            ret += '[]';
-        }
+        const hasUsableNullDefault = (prop.nullable && !this.options.forceUndefined && prop.default === null);
+        const useDefault = hasUsableNullDefault || (!(typeof prop.default === 'undefined' || prop.default === null) && propType !== 'unknown' && typeof breakdownOfIType === 'undefined');
+        const optional = (prop.nullable && (this.options.forceUndefined || prop.optional)) ? '?' : (useDefault ? '' : '!');
+        let ret = `${propName}${optional}: `;
+        const isArray = prop.array && (prop.kind === core_1.ReferenceKind.EMBEDDED || prop.enum);
+        const complexType = isArray ? `${propType}[]` : propType;
+        let wrappedType = prop.ref
+            ? `${this.referenceCoreImport('Ref')}<${complexType}${(isScalar && prop.nullable && !this.options.forceUndefined) ? ' | null' : ''}>`
+            : ((this.options.esmImport && !isScalar) ? `${this.referenceCoreImport('Rel')}<${complexType}>` : complexType);
+        if (prop.nullable && !this.options.forceUndefined && (!isScalar || (!prop.ref && !wrappedType.includes(' | null')))) {
+            wrappedType += ' | null';
+        }
+        const optionalType = (optional !== '?' && prop.optional)
+            ? ` & ${this.referenceCoreImport('Opt')}`
+            : '';
+        ret += (!this.options.forceUndefined && prop.nullable && (hiddenType || optionalType)) ? `(${wrappedType})` : wrappedType;
         ret += hiddenType;
-        if (useDefault || (prop.optional && !prop.nullable)) {
-            ret += ` & ${this.referenceCoreImport('Opt')}`;
-        }
-        if (!useDefault || hasITypeWrapper || prop.type === 'unknown') {
+        ret += optionalType;
+        if (!useDefault) {
             return `${padding}${ret};\n`;
         }
         if (prop.enum && typeof prop.default === 'string') {
             const enumVal = this.namingStrategy.enumValueToEnumProperty(prop.default, prop.fieldNames[0], this.meta.collection, this.meta.schema);
             return `${padding}${ret} = ${propType}${exports.identifierRegex.test(enumVal) ? `.${enumVal}` : `[${this.quote(enumVal)}]`};\n`;
         }
-        if (prop.fieldNames.length > 1) {
+        if (prop.fieldNames?.length > 1) {
             // TODO: Composite FKs with default values require additions to default/defaultRaw that are not yet supported.
             return `${padding}${ret};\n`;
         }
@@ -249,6 +259,9 @@ class SourceFile {
         if (isScalar) {
             return `${padding}${ret} = ${prop.ref ? `${this.referenceCoreImport('ref')}(${defaultVal})` : defaultVal};\n`;
         }
+        if (hasUsableNullDefault) {
+            return `${padding}${ret} = null;\n`;
+        }
         return `${padding}${ret} = ${prop.ref ? this.referenceCoreImport('ref') : this.referenceCoreImport('rel')}(${propType}, ${defaultVal});\n`;
     }
     getEnumClassDefinition(prop, padLeft) {
@@ -414,7 +427,7 @@ class SourceFile {
         return ret;
     }
     getCommonDecoratorOptions(options, prop) {
-        if (prop.nullable && !prop.mappedBy) {
+        if (!prop.mappedBy && (prop.nullable || prop.customTypes?.[0]?.prop?.nullable)) {
             options.nullable = true;
         }
         if (prop.primary && (prop.enum || !(typeof prop.kind === 'undefined' || prop.kind === core_1.ReferenceKind.SCALAR))) {
@@ -443,11 +456,11 @@ class SourceFile {
         }
         // TODO: Composite FKs with default values require additions to default/defaultRaw that are not yet supported.
         if (prop.fieldNames?.length <= 1) {
-            if (typeof prop.defaultRaw !== 'undefined' && prop.defaultRaw !== 'null' &&
+            if (typeof prop.defaultRaw !== 'undefined' && prop.defaultRaw !== 'null' && prop.defaultRaw !== '' &&
                 prop.defaultRaw !== (typeof prop.default === 'string' ? this.quote(prop.default) : `${prop.default}`)) {
                 options.defaultRaw = `\`${prop.defaultRaw}\``;
             }
-            else if (prop.default != null && (prop.ref || (!prop.enum && (typeof prop.kind === 'undefined' || prop.kind === core_1.ReferenceKind.SCALAR) && (prop.type === 'unknown' || typeof this.breakdownOfIType(prop) !== 'undefined')))) {
+            else if (!(typeof prop.default === 'undefined' || prop.default === null) && (prop.ref || (!prop.enum && (typeof prop.kind === 'undefined' || prop.kind === core_1.ReferenceKind.SCALAR) && (prop.type === 'unknown' || typeof this.breakdownOfIType(prop) !== 'undefined')))) {
                 options.default = typeof prop.default === 'string' ? this.quote(prop.default) : prop.default;
             }
         }
@@ -472,7 +485,8 @@ class SourceFile {
             ? this.platform.getMappedType(prop.columnTypes[0])
             : mappedDeclaredType));
         const rawType = mappedRawType.runtimeType;
-        const serializedType = (prop.customType ?? mappedRawType).runtimeType;
+        const mappedSerializedType = (prop.customType ?? mappedRawType);
+        const serializedType = mappedSerializedType.runtimeType;
         // Add non-lib imports where needed.
         for (const typeSpec of [prop.runtimeType, rawType, serializedType]) {
             const simplePropType = typeSpec.replace(/\[]+$/, '');
@@ -480,13 +494,37 @@ class SourceFile {
                 this.entityImports.add(simplePropType);
             }
         }
-        if (prop.runtimeType !== rawType || rawType !== serializedType) {
-            if (rawType !== serializedType) {
+        const nullables = [
+            prop.nullable ?? false,
+            mappedRawType.prop?.nullable ?? prop.nullable ?? false,
+            mappedSerializedType.prop?.nullable ?? prop.nullable ?? false,
+        ];
+        const hasMixedNullability = (new Set(nullables)).size > 1;
+        if (prop.runtimeType !== rawType || rawType !== serializedType || hasMixedNullability) {
+            const nullType = this.options.forceUndefined ? ' | undefined' : ' | null';
+            if (rawType !== serializedType || nullables[1] !== nullables[2] || (prop.hidden && nullables[0] !== nullables[1])) {
                 const r = [prop.runtimeType, rawType, serializedType];
+                if (hasMixedNullability || prop.hidden) {
+                    for (let i = r.length - 1; i >= 0; --i) {
+                        if (nullables[i]) {
+                            r[i] += nullType;
+                        }
+                    }
+                    if (prop.hidden) {
+                        r[2] = `(${r[2]}) & ${this.referenceCoreImport('Hidden')}`;
+                    }
+                }
                 this.propTypeBreakdowns.set(prop, r);
                 return r;
             }
             const r = [prop.runtimeType, rawType];
+            if (hasMixedNullability) {
+                for (let i = r.length - 1; i >= 0; --i) {
+                    if (nullables[i]) {
+                        r[i] += nullType;
+                    }
+                }
+            }
             this.propTypeBreakdowns.set(prop, r);
             return r;
         }
@@ -519,8 +557,14 @@ class SourceFile {
         }
         else {
             if (this.options.scalarTypeInDecorator // always output type if forced by the generator options
-                || prop.hidden || (prop.optional && (!prop.nullable || prop.default != null)) // also when there are prop type modifiers, because reflect-metadata can't extract the base
-                || (new Set([mappedRuntimeType.name, mappedColumnType.name, mappedDeclaredType.name, this.platform.getMappedType(prop.runtimeType === 'Date' ? 'datetime' : prop.runtimeType).name])).size > 1 // also if there's any ambiguity in the type.
+                || (prop.nullable && !this.options.forceUndefined) // also when there is the "| null" type modifier (because reflect-metadata can't extract the base)
+                || prop.hidden // also when there is the "& Hidden" type modifier (because reflect-metadata can't extract the base)
+                || (new Set([mappedRuntimeType.name, mappedColumnType.name, mappedDeclaredType.name, this.platform.getMappedType(prop.runtimeType === 'Date' ? 'datetime' : prop.runtimeType).name])).size > 1 // also, if there's any ambiguity in the type
+                || (() => {
+                    const hasUsableNullDefault = (prop.nullable && !this.options.forceUndefined && prop.default === null);
+                    const useDefault = hasUsableNullDefault || !(typeof prop.default === 'undefined' || prop.default === null);
+                    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);
             }
@@ -659,7 +703,7 @@ class SourceFile {
         if (prop.generated) {
             options.generated = typeof prop.generated === 'string' ? this.quote(prop.generated) : `${prop.generated}`;
         }
-        if (prop.fieldNames.length > 1 && prop.default != null) {
+        if (prop.fieldNames.length > 1 && !(typeof prop.default === 'undefined' || prop.default === null)) {
             // TODO: Composite FKs with default values require additions to default/defaultRaw that are not yet supported.
             options.ignoreSchemaChanges = [this.quote('default')];
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/entity-generator",
-  "version": "6.3.14-dev.1",
+  "version": "6.3.14-dev.3",
   "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.3.14-dev.1",
+    "@mikro-orm/knex": "6.3.14-dev.3",
     "fs-extra": "11.2.0"
   },
   "devDependencies": {
     "@mikro-orm/core": "^6.3.13"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.3.14-dev.1"
+    "@mikro-orm/core": "6.3.14-dev.3"
   }
 }