fix: date optional (#2460)

Author: jonaslagoni

src/generators/typescript/presets/utils/UnmarshalFunction.ts

@@ -17,8 +17,10 @@ import {
  */
 function renderUnmarshalProperty(
   modelInstanceVariable: string,
-  model: ConstrainedMetaModel
+  model: ConstrainedMetaModel,
+  isOptional: boolean = false
 ) {
+  const nullValue = isOptional ? 'undefined' : 'null';
   if (
     model instanceof ConstrainedReferenceModel &&
     !(model.ref instanceof ConstrainedEnumModel)
@@ -33,7 +35,7 @@ function renderUnmarshalProperty(
     !(model.valueModel instanceof ConstrainedUnionModel)
   ) {
     return `${modelInstanceVariable} == null
-    ? null
+    ? ${nullValue}
     : ${modelInstanceVariable}.map((item: any) => ${model.valueModel.type}.unmarshal(item))`;
   }
 
@@ -43,7 +45,7 @@ function renderUnmarshalProperty(
     ['date', 'date-time', 'time'].includes(model.options?.format ?? '')
   ) {
     // Null check prevents new Date(null) → epoch date
-    return `${modelInstanceVariable} == null ? null : new Date(${modelInstanceVariable})`;
+    return `${modelInstanceVariable} == null ? ${nullValue} : new Date(${modelInstanceVariable})`;
   }
 
   return `${modelInstanceVariable}`;
@@ -58,9 +60,11 @@ function unmarshalRegularProperty(propModel: ConstrainedObjectPropertyModel) {
   }
 
   const modelInstanceVariable = `obj["${propModel.unconstrainedPropertyName}"]`;
+  const isOptional = propModel.required === false;
   const unmarshalCode = renderUnmarshalProperty(
     modelInstanceVariable,
-    propModel.property
+    propModel.property,
+    isOptional
   );
   return `if (${modelInstanceVariable} !== undefined) {
   instance.${propModel.propertyName} = ${unmarshalCode};

test/generators/typescript/preset/MarshallingPreset.spec.ts

@@ -18,6 +18,23 @@ const dateDoc = {
   required: ['createdAt']
 };
 
+// Schema with nullable types (type: ['null', 'string']) - explicit null in type array
+const nullableDoc = {
+  $id: 'NullableTest',
+  type: 'object',
+  properties: {
+    // Nullable string (type includes null explicitly)
+    nullableString: { type: ['null', 'string'] },
+    // Nullable date (type includes null explicitly)
+    nullableDate: { type: ['null', 'string'], format: 'date-time' },
+    // Required nullable date (required but explicitly allows null)
+    requiredNullableDate: { type: ['null', 'string'], format: 'date-time' },
+    // Non-nullable required date for comparison
+    requiredDate: { type: 'string', format: 'date-time' }
+  },
+  required: ['requiredNullableDate', 'requiredDate']
+};
+
 const doc = {
   definitions: {
     NestedTest: {
@@ -147,7 +164,7 @@ describe('Marshalling preset', () => {
       expect(result).toMatchSnapshot();
     });
 
-    test('should handle null/undefined values for date properties', async () => {
+    test('should return null for required date properties, undefined for optional', async () => {
       const generator = new TypeScriptGenerator({
         presets: [
           {
@@ -161,11 +178,63 @@ describe('Marshalling preset', () => {
       const models = await generator.generate(dateDoc);
       const result = models[0].result;
 
-      // Should include null safety check for date conversion
+      // Required property (createdAt) should use null in unmarshal
       // Pattern: value == null ? null : new Date(value)
       expect(result).toMatch(
         /obj\["createdAt"\]\s*==\s*null\s*\?\s*null\s*:\s*new Date/
       );
+
+      // Optional property (optionalDate) should use undefined in unmarshal
+      // Pattern: value == null ? undefined : new Date(value)
+      expect(result).toMatch(
+        /obj\["optionalDate"\]\s*==\s*null\s*\?\s*undefined\s*:\s*new Date/
+      );
+    });
+  });
+
+  describe('nullable types (type: [null, string])', () => {
+    test('should generate correct types and unmarshal for nullable properties', async () => {
+      const generator = new TypeScriptGenerator({
+        presets: [
+          {
+            preset: TS_COMMON_PRESET,
+            options: {
+              marshalling: true
+            }
+          }
+        ]
+      });
+      const models = await generator.generate(nullableDoc);
+      expect(models).toHaveLength(1);
+      const result = models[0].result;
+
+      // Snapshot for full verification
+      expect(result).toMatchSnapshot();
+    });
+
+    test('should handle nullable date types with proper null handling', async () => {
+      const generator = new TypeScriptGenerator({
+        presets: [
+          {
+            preset: TS_COMMON_PRESET,
+            options: {
+              marshalling: true
+            }
+          }
+        ]
+      });
+      const models = await generator.generate(nullableDoc);
+      const result = models[0].result;
+
+      // Required non-nullable date should use null in unmarshal
+      expect(result).toMatch(
+        /obj\["requiredDate"\]\s*==\s*null\s*\?\s*null\s*:\s*new Date/
+      );
+
+      // Nullable date properties should use Date conversion
+      // Note: The behavior for nullable types (type: ['null', 'string'])
+      // depends on how Modelina interprets them - as union types
+      expect(result).toContain('new Date(');
     });
   });
 });

test/generators/typescript/preset/__snapshots__/MarshallingPreset.spec.ts.snap

@@ -79,16 +79,16 @@ exports[`Marshalling preset date unmarshal should convert date-formatted string
       instance.createdAt = obj[\\"createdAt\\"] == null ? null : new Date(obj[\\"createdAt\\"]);
     }
     if (obj[\\"birthDate\\"] !== undefined) {
-      instance.birthDate = obj[\\"birthDate\\"] == null ? null : new Date(obj[\\"birthDate\\"]);
+      instance.birthDate = obj[\\"birthDate\\"] == null ? undefined : new Date(obj[\\"birthDate\\"]);
     }
     if (obj[\\"meetingTime\\"] !== undefined) {
-      instance.meetingTime = obj[\\"meetingTime\\"] == null ? null : new Date(obj[\\"meetingTime\\"]);
+      instance.meetingTime = obj[\\"meetingTime\\"] == null ? undefined : new Date(obj[\\"meetingTime\\"]);
     }
     if (obj[\\"regularString\\"] !== undefined) {
       instance.regularString = obj[\\"regularString\\"];
     }
     if (obj[\\"optionalDate\\"] !== undefined) {
-      instance.optionalDate = obj[\\"optionalDate\\"] == null ? null : new Date(obj[\\"optionalDate\\"]);
+      instance.optionalDate = obj[\\"optionalDate\\"] == null ? undefined : new Date(obj[\\"optionalDate\\"]);
     }
   
     instance.additionalProperties = new Map();
@@ -101,6 +101,95 @@ exports[`Marshalling preset date unmarshal should convert date-formatted string
 }"
 `;
 
+exports[`Marshalling preset nullable types (type: [null, string]) should generate correct types and unmarshal for nullable properties 1`] = `
+"class NullableTest {
+  private _nullableString?: string | null;
+  private _nullableDate?: Date | null;
+  private _requiredNullableDate: Date | null;
+  private _requiredDate: Date;
+  private _additionalProperties?: Map<string, any>;
+
+  constructor(input: {
+    nullableString?: string | null,
+    nullableDate?: Date | null,
+    requiredNullableDate: Date | null,
+    requiredDate: Date,
+    additionalProperties?: Map<string, any>,
+  }) {
+    this._nullableString = input.nullableString;
+    this._nullableDate = input.nullableDate;
+    this._requiredNullableDate = input.requiredNullableDate;
+    this._requiredDate = input.requiredDate;
+    this._additionalProperties = input.additionalProperties;
+  }
+
+  get nullableString(): string | null | undefined { return this._nullableString; }
+  set nullableString(nullableString: string | null | undefined) { this._nullableString = nullableString; }
+
+  get nullableDate(): Date | null | undefined { return this._nullableDate; }
+  set nullableDate(nullableDate: Date | null | undefined) { this._nullableDate = nullableDate; }
+
+  get requiredNullableDate(): Date | null { return this._requiredNullableDate; }
+  set requiredNullableDate(requiredNullableDate: Date | null) { this._requiredNullableDate = requiredNullableDate; }
+
+  get requiredDate(): Date { return this._requiredDate; }
+  set requiredDate(requiredDate: Date) { this._requiredDate = requiredDate; }
+
+  get additionalProperties(): Map<string, any> | undefined { return this._additionalProperties; }
+  set additionalProperties(additionalProperties: Map<string, any> | undefined) { this._additionalProperties = additionalProperties; }
+
+  public marshal() : string {
+    let json = '{'
+    if(this.nullableString !== undefined) {
+      json += \`\\"nullableString\\": \${typeof this.nullableString === 'number' || typeof this.nullableString === 'boolean' ? this.nullableString : JSON.stringify(this.nullableString)},\`;
+    }
+    if(this.nullableDate !== undefined) {
+      json += \`\\"nullableDate\\": \${typeof this.nullableDate === 'number' || typeof this.nullableDate === 'boolean' ? this.nullableDate : JSON.stringify(this.nullableDate)},\`;
+    }
+    if(this.requiredNullableDate !== undefined) {
+      json += \`\\"requiredNullableDate\\": \${typeof this.requiredNullableDate === 'number' || typeof this.requiredNullableDate === 'boolean' ? this.requiredNullableDate : JSON.stringify(this.requiredNullableDate)},\`;
+    }
+    if(this.requiredDate !== undefined) {
+      json += \`\\"requiredDate\\": \${typeof this.requiredDate === 'number' || typeof this.requiredDate === 'boolean' ? this.requiredDate : JSON.stringify(this.requiredDate)},\`;
+    }
+    if(this.additionalProperties !== undefined) { 
+      for (const [key, value] of this.additionalProperties.entries()) {
+        //Only unwrap those that are not already a property in the JSON object
+        if([\\"nullableString\\",\\"nullableDate\\",\\"requiredNullableDate\\",\\"requiredDate\\",\\"additionalProperties\\"].includes(String(key))) continue;
+        json += \`\\"\${key}\\": \${typeof value === 'number' || typeof value === 'boolean' ? value : JSON.stringify(value)},\`;
+      }
+    }
+    //Remove potential last comma 
+    return \`\${json.charAt(json.length-1) === ',' ? json.slice(0, json.length-1) : json}}\`;
+  }
+
+  public static unmarshal(json: string | object): NullableTest {
+    const obj = typeof json === \\"object\\" ? json : JSON.parse(json);
+    const instance = new NullableTest({} as any);
+
+    if (obj[\\"nullableString\\"] !== undefined) {
+      instance.nullableString = obj[\\"nullableString\\"];
+    }
+    if (obj[\\"nullableDate\\"] !== undefined) {
+      instance.nullableDate = obj[\\"nullableDate\\"] == null ? undefined : new Date(obj[\\"nullableDate\\"]);
+    }
+    if (obj[\\"requiredNullableDate\\"] !== undefined) {
+      instance.requiredNullableDate = obj[\\"requiredNullableDate\\"] == null ? null : new Date(obj[\\"requiredNullableDate\\"]);
+    }
+    if (obj[\\"requiredDate\\"] !== undefined) {
+      instance.requiredDate = obj[\\"requiredDate\\"] == null ? null : new Date(obj[\\"requiredDate\\"]);
+    }
+  
+    instance.additionalProperties = new Map();
+    const propsToCheck = Object.entries(obj).filter((([key,]) => {return ![\\"nullableString\\",\\"nullableDate\\",\\"requiredNullableDate\\",\\"requiredDate\\",\\"additionalProperties\\"].includes(key);}));
+    for (const [key, value] of propsToCheck) {
+      instance.additionalProperties.set(key, value as any);
+    }
+    return instance;
+  }
+}"
+`;
+
 exports[`Marshalling preset should render un/marshal code 1`] = `
 "class Test {
   private _stringProp: string;
@@ -273,7 +362,7 @@ exports[`Marshalling preset should render un/marshal code 1`] = `
     }
     if (obj[\\"arrayTest\\"] !== undefined) {
       instance.arrayTest = obj[\\"arrayTest\\"] == null
-        ? null
+        ? undefined
         : obj[\\"arrayTest\\"].map((item: any) => NestedTest.unmarshal(item));
     }
     if (obj[\\"primitiveArrayTest\\"] !== undefined) {

test/runtime/generic-input-all.json

@@ -71,12 +71,26 @@
     },
     "enum_type": {
       "enum": ["test", 1, true, {"test": 2}]
+    },
+    "nullable_string": {
+      "type": ["null", "string"],
+      "description": "Optional nullable string (type includes null explicitly)"
+    },
+    "nullable_date": {
+      "type": ["null", "string"],
+      "format": "date-time",
+      "description": "Optional nullable date (type includes null explicitly)"
+    },
+    "required_nullable_date": {
+      "type": ["null", "string"],
+      "format": "date-time",
+      "description": "Required nullable date (required but explicitly allows null)"
     }
   },
   "patternProperties": {
     "^S(.?*)test&": {
       "type": "string"
     }
   },
-  "required": ["string_type", "boolean_type"]
+  "required": ["string_type", "boolean_type", "required_nullable_date"]
 }

test/runtime/runtime-typescript/package-lock.json

@@ -1,11 +1,13 @@
 {
   "scripts": {
-    "test": "jest"
+    "typecheck": "tsc --noEmit",
+    "test": "npm run typecheck && jest"
   },
   "dependencies": {
     "jsonbinpack": "1.1.2",
     "jest": "^27.2.5",
     "@swc/core": "^1.3.5",
-    "@swc/jest": "^0.2.23"
+    "@swc/jest": "^0.2.23",
+    "typescript": "~5.6.0"
   }
-}
+}

test/runtime/runtime-typescript/package.json

@@ -17,7 +17,8 @@ describe('Default exports', () => {
       additionalProperties: new Map(Object.entries({"test": "test"})),
       enumType: EnumType.CURLYLEFT_QUOTATION_TEST_QUOTATION_COLON_2_CURLYRIGHT,
       tupleType: ['test', 1],
-      unionType: 'test'
+      unionType: 'test',
+      requiredNullableDate: new Date('2023-01-01T00:00:00Z')
     });
     expect(testObject.stringType).toEqual('test');
     expect(testObject.numberType).toEqual(1);