fix(generator): give complex sub-extensions a valid, unfrozen date default

The two latent defects the previous commit recorded but left alone.

complexExtValueDefault supplies the value[x] default for a sub-extension of a
complex extension:
  - dateTime, instant and date fell through to `default: value`, emitting
    valueDateTime: "value", which is not a valid FHIR dateTime.
  - Period interpolated a generation-time new Date(), freezing the wall clock into
    the emitted source — the same defect just removed from getTypePlaceholder.

Both now use the __DATE_EXPR__ / __DATE10_EXPR__ placeholders that the class
emitter resolves into randomDate(), so the value is valid and fresh per call.

The risk that held this back is cleared. The result becomes fixedValue on the
extension child, and a placeholder leaking into a validator comparison would emit
a check against the literal "__DATE_EXPR__". Every validator consumer of
fixedValue guards on typeof string/number/boolean, and buildFixedValueValidations
emits nothing for any other shape, so an array-of-objects fixedValue never reaches
a comparison. Only the class emitter renders it, and objectToCodeExpression
resolves the placeholder in a nested object value — checked by executing it, not by
reading it.

Verified on us-core@9.0.0: zero baked timestamps, zero unresolved placeholders in
the emitted output, and HL7 parity unchanged at 54/54 random and 54/54 empty.

Tests written first; 4 of 5 failed for the intended reasons before the change.

Author: quotentiroler

src/generator/parser/sliceAggregatorComposition.ts

@@ -23,7 +23,15 @@ export function complexExtValueDefault(fhirType: string): unknown {
         case 'canonical':      return 'https://example.org';
         case 'Reference':      return { reference: 'Resource/example' };
         case 'Quantity':        return { value: 1, unit: 'unit' };
-        case 'Period':          return { start: new Date().toISOString() };
+        // Dates go through the same placeholders the class emitter resolves into
+        // randomDate(), so a sub-extension gets a fresh value per random() call.
+        // Previously dateTime/instant/date fell through to 'value', which is not a
+        // valid FHIR dateTime, and Period froze the generation-time clock into the
+        // emitted source.
+        case 'dateTime':
+        case 'instant':        return '__DATE_EXPR__';
+        case 'date':           return '__DATE10_EXPR__';
+        case 'Period':         return { start: '__DATE_EXPR__' };
         default:               return 'value';
     }
 }

src/test/complexExtValueDefault.test.ts

@@ -0,0 +1,66 @@
+/**
+ * complexExtValueDefault supplies the value[x] default for a sub-extension of a
+ * complex extension. Its result becomes `fixedValue` on the extension child and is
+ * rendered into a generated class by objectToCodeExpression, which resolves the
+ * __DATE_EXPR__ placeholders into randomDate() calls.
+ *
+ * Two defects it had:
+ *   - dateTime/instant/date fell through to `default: 'value'`, emitting
+ *     `valueDateTime: "value"` — not a valid FHIR dateTime.
+ *   - Period interpolated a generation-time `new Date()`, freezing the wall clock
+ *     into the emitted source.
+ *
+ * Safe to express as placeholders: every validator consumer of `fixedValue` guards
+ * on typeof string/number/boolean, so an array-of-objects fixedValue never reaches
+ * a comparison — only the class emitter renders it.
+ */
+import { describe, it, expect } from 'vitest';
+import { complexExtValueDefault } from '../generator/parser/sliceAggregatorComposition.js';
+import { objectToCodeExpression } from '../generator/emitters/class/sliceElementDefaults.js';
+
+const ISO_TIMESTAMP = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/;
+
+/** Render the way sliceAggregator builds a sub-extension, then emits it. */
+function renderSubExtension(fhirType: string, valueProp: string): string {
+  return objectToCodeExpression({
+    url: 'subExt',
+    [valueProp]: complexExtValueDefault(fhirType),
+  });
+}
+
+describe('complexExtValueDefault date handling', () => {
+  it('does not answer "value" for a dateTime', () => {
+    expect(complexExtValueDefault('dateTime')).not.toBe('value');
+    expect(complexExtValueDefault('instant')).not.toBe('value');
+    expect(complexExtValueDefault('date')).not.toBe('value');
+  });
+
+  it('renders dateTime and instant as a runtime date call', () => {
+    expect(renderSubExtension('dateTime', 'valueDateTime')).toContain('randomDate()');
+    expect(renderSubExtension('instant', 'valueInstant')).toContain('randomDate()');
+  });
+
+  it('renders date at day precision', () => {
+    const rendered = renderSubExtension('date', 'valueDate');
+    expect(rendered).toContain('randomDate()');
+    expect(rendered).toContain('slice(0, 10)');
+  });
+
+  it('freezes no timestamp for Period, and stays stable across calls', async () => {
+    const first = JSON.stringify(complexExtValueDefault('Period'));
+    expect(first).not.toMatch(ISO_TIMESTAMP);
+    await new Promise(r => setTimeout(r, 5));
+    expect(JSON.stringify(complexExtValueDefault('Period'))).toBe(first);
+    expect(renderSubExtension('Period', 'valuePeriod')).toContain('randomDate()');
+  });
+
+  it('leaves the non-date defaults alone', () => {
+    expect(complexExtValueDefault('boolean')).toBe(true);
+    expect(complexExtValueDefault('string')).toBe('value');
+    expect(complexExtValueDefault('code')).toBe('unknown');
+    expect(complexExtValueDefault('integer')).toBe(1);
+    expect(complexExtValueDefault('Reference')).toEqual({ reference: 'Resource/example' });
+    // An unknown type still falls back to a plain string.
+    expect(complexExtValueDefault('SomethingElse')).toBe('value');
+  });
+});