babelfhir-ts 1.5.3 → 1.5.5

package/out/src/generator/emitters/interface/backboneSliceTyping.js

@@ -30,7 +30,7 @@ export function generateBackboneSliceTypes(ctx) {
     const { interfaceName, baseResource, newFields, baseFields, interfaces, importManager, inferBackboneType } = ctx;
     const rules = getRules();
     // 1. Find all sliced backbone element arrays
-    const sliceGroups = collectSliceGroups(newFields, baseResource);
+    const sliceGroups = collectSliceGroups(newFields, baseFields, baseResource);
     if (sliceGroups.length === 0)
         return;
     for (const group of sliceGroups) {
@@ -70,7 +70,7 @@ export function generateBackboneSliceTypes(ctx) {
                 return childId.startsWith(sliceElementId + '.');
             });
             // Build interface body lines from slice children and the slice's own constraints
-            const { lines: bodyLines, referencedFhirTypes } = buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, backboneType);
+            const { lines: bodyLines, referencedFhirTypes } = buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, backboneType, baseFields, parentField.name);
             if (bodyLines.length === 0) {
                 // No constrainable properties — skip this slice interface
                 log.debug(`No constraints for slice ${sliceName} of ${parentField.name}, skipping`);
@@ -109,10 +109,18 @@ export function generateBackboneSliceTypes(ctx) {
 }
 /**
  * Collect sliced backbone element groups from the fields.
+ *
+ * Handles two scenarios:
+ * 1. The differential includes the unsliced parent field (e.g. Observation.component) —
+ *    the parent field carries slicing metadata and baseTypeCode.
+ * 2. The differential only contains slice entries (e.g. Observation.component:confidence)
+ *    without redeclaring the parent — common in downstream profiles. In this case the
+ *    parent field is looked up from baseFields.
  */
-function collectSliceGroups(fields, baseResource) {
+function collectSliceGroups(fields, baseFields, baseResource) {
     const groups = [];
     const seenPaths = new Set();
+    // Pass 1: parent field present in newFields
     for (const field of fields) {
         if (field.sliceName)
             continue; // Skip slice entries themselves
@@ -121,52 +129,75 @@ function collectSliceGroups(fields, baseResource) {
         const path = field.name;
         if (seenPaths.has(path))
             continue;
-        // Check if there are named slices at this path
         const sliceFields = fields.filter(f => f.name === path && f.sliceName);
         if (sliceFields.length === 0)
             continue;
-        // Must be a true backbone element — only process fields whose base FHIR type
-        // is BackboneElement or Element (inline nested types). Skip complex DataTypes
-        // like Identifier, CodeableConcept, ContactPoint, etc. — those have slices
-        // handled by the main type mapping and profiled type reference system.
-        const baseType = field.baseTypeCode || field.type || '';
-        if (baseType !== 'BackboneElement' && baseType !== 'Element')
+        if (!isEligibleBackbonePath(field.baseTypeCode || field.type || '', path, baseResource))
             continue;
-        // Skip extension slices — handled separately by postProcessExtensions
-        const fieldName = path.split('.').pop() || '';
-        if (fieldName === 'extension' || fieldName === 'modifierExtension')
+        const childFields = gatherChildFields(fields, path);
+        const slicingRules = field.slicingRules || 'open';
+        seenPaths.add(path);
+        groups.push({ parentField: field, sliceFields, childFields, slicingRules });
+    }
+    // Pass 2: orphaned slice entries whose parent path wasn't found in newFields.
+    // The differential may only contain slice entries (e.g. Observation.component:confidence)
+    // without the unsliced parent. Resolve the parent from baseFields.
+    for (const field of fields) {
+        if (!field.sliceName)
             continue;
-        // Skip Bundle.entry and similar resource-container slices — these use profiled
-        // type references that are handled by the external profile resolution system
-        if (fieldName === 'entry')
+        const path = field.name;
+        if (seenPaths.has(path))
             continue;
-        // Must be a root-level field (direct child of the base resource)
-        const parts = path.split('.');
-        if (parts.length !== 2)
+        // Find the parent field in baseFields
+        const parentField = baseFields.find(f => f.name === path && !f.sliceName);
+        if (!parentField)
             continue;
-        if (baseResource && parts[0] !== baseResource)
+        if (!parentField.isArray)
             continue;
-        // Gather all child fields for any slice of this element
-        const childFields = fields.filter(f => {
-            if (f.name === path)
-                return false; // Skip the parent itself
-            const childId = f.elementId || f.name;
-            // Match children that belong to ANY slice of this element
-            return childId.startsWith(`${path}:`) || (f.name.startsWith(`${path}.`) && f.name !== path);
-        });
-        // Determine slicing rules from the parent field's metadata
-        // The slicing rules come from the SD's element.slicing.rules
-        // We default to 'open' since that's the FHIR default
-        const slicingRules = field.slicingRules || 'open';
+        if (!isEligibleBackbonePath(parentField.baseTypeCode || parentField.type || '', path, baseResource))
+            continue;
+        const sliceFields = fields.filter(f => f.name === path && f.sliceName);
+        if (sliceFields.length === 0)
+            continue;
+        const childFields = gatherChildFields(fields, path);
+        const slicingRules = parentField.slicingRules || 'open';
         seenPaths.add(path);
-        groups.push({ parentField: field, sliceFields, childFields, slicingRules });
+        groups.push({ parentField, sliceFields, childFields, slicingRules });
     }
     return groups;
 }
+/** Check whether a field path is eligible for backbone slice typing. */
+function isEligibleBackbonePath(baseType, path, baseResource) {
+    if (baseType !== 'BackboneElement' && baseType !== 'Element')
+        return false;
+    const fieldName = path.split('.').pop() || '';
+    // Skip extension slices — handled separately by postProcessExtensions
+    if (fieldName === 'extension' || fieldName === 'modifierExtension')
+        return false;
+    // Skip Bundle.entry and similar resource-container slices
+    if (fieldName === 'entry')
+        return false;
+    // Must be a root-level field (direct child of the base resource)
+    const parts = path.split('.');
+    if (parts.length !== 2)
+        return false;
+    if (baseResource && parts[0] !== baseResource)
+        return false;
+    return true;
+}
+/** Gather all child fields for any slice of the given parent path. */
+function gatherChildFields(fields, path) {
+    return fields.filter(f => {
+        if (f.name === path)
+            return false;
+        const childId = f.elementId || f.name;
+        return childId.startsWith(`${path}:`) || (f.name.startsWith(`${path}.`) && f.name !== path);
+    });
+}
 /**
  * Build the body lines for a slice-specific interface.
  */
-function buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, _backboneType) {
+function buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, _backboneType, baseFields, parentPath) {
     const lines = [];
     const referencedFhirTypes = [];
     // Add pattern constraint from the slice field itself (discriminator value)
@@ -180,16 +211,58 @@ function buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, _bac
             }
         }
     }
-    // Process direct children of the slice
+    // Pre-scan: identify choice-type parent elements (value[x]) that have
+    // sub-slices (value[x]:valueQuantity, etc.). These parents carry only slicing
+    // metadata and should not be emitted as typed properties.
+    // Match only direct choice-type slices like "value[x]:valueString" — NOT deeper
+    // elements like "value[x].extension:questionnaireDisplay" where the colon is
+    // on a different segment.
+    const choiceTypeParents = new Set();
+    const choiceTypeSlices = [];
+    const choiceSlicePattern = /^([^.]+\[x]):([^.]+)$/; // e.g. "value[x]:valueString"
     for (const child of sliceChildren) {
         const childId = child.elementId || child.name;
         const relativePath = childId.substring(sliceElementId.length + 1);
-        // Only handle direct children (no dots in relative path)
-        if (relativePath.includes('.'))
+        const match = choiceSlicePattern.exec(relativePath);
+        if (match) {
+            choiceTypeSlices.push(child);
+            choiceTypeParents.add(match[1]); // e.g. "value[x]"
+        }
+    }
+    // Collect deeply nested fixed values for object literal synthesis.
+    // e.g. code.coding.code = "confidence" → code: { coding: [{ code: "confidence" }] }
+    const nestedFixedByProp = new Map();
+    // Process children of the slice
+    for (const child of sliceChildren) {
+        const childId = child.elementId || child.name;
+        const relativePath = childId.substring(sliceElementId.length + 1);
+        // Nested children (dots in relative path) — collect fixed values for synthesis
+        if (relativePath.includes('.')) {
+            if (child.fixedValue !== undefined) {
+                const segments = relativePath.split('.');
+                const rawPropName = segments[0];
+                const propName = rawPropName.replace(/\[x\]$/, '');
+                // Skip nested values under:
+                // - choice-type elements ([x]) — handled by direct child or sub-slices
+                // - slice notation (part:LineItem.name) — deeper-level constraints
+                // - extension/modifierExtension — handled by postProcessExtensions
+                if (!rawPropName.includes('[x]') && !rawPropName.includes(':')
+                    && propName !== 'extension' && propName !== 'modifierExtension') {
+                    const nestedPath = segments.slice(1).join('.');
+                    if (!nestedFixedByProp.has(propName))
+                        nestedFixedByProp.set(propName, new Map());
+                    nestedFixedByProp.get(propName).set(nestedPath, String(child.fixedValue));
+                }
+            }
             continue;
-        // Skip slice notation in child paths
+        }
+        // Choice-type sub-slices (value[x]:valueXxx) are processed separately below
         if (relativePath.includes(':'))
             continue;
+        // Skip choice-type parents that have sub-slices — they carry only slicing
+        // metadata and their inherited type (e.g. Quantity) is misleading
+        if (choiceTypeParents.has(relativePath))
+            continue;
         const propName = relativePath.replace(/\[x\]$/, '');
         if (child.fixedValue !== undefined) {
             // Fixed value constraint
@@ -239,6 +312,43 @@ function buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, _bac
             }
         }
     }
+    // Emit choice-type sub-slice properties (e.g. value[x]:valueQuantity → valueQuantity: Quantity)
+    for (const child of choiceTypeSlices) {
+        if (!child.sliceName || !child.type)
+            continue;
+        if (child.type === 'BackboneElement' || child.type === 'Element' || child.type === 'any')
+            continue;
+        const rawType = getRules().mapTypeToTS(child.type);
+        const mappedType = sanitizeIdentifier(rawType);
+        if (mappedType !== rawType && child.isProfiled)
+            continue;
+        const optMark = child.isOptional ? '?' : '';
+        lines.push(`${child.sliceName}${optMark}: ${mappedType};`);
+        if (getRules().isFhirType(mappedType)) {
+            referencedFhirTypes.push(mappedType);
+        }
+    }
+    // Emit synthesized nested object literals from deeply nested fixed values.
+    // Skip properties already emitted by the direct child or choice-type loops
+    // to prevent TS2717 (duplicate property) and TS2430 (incompatible extends).
+    const emittedProps = new Set(lines.map(l => l.match(/^(\w+)[?]?:/)?.[1]).filter(Boolean));
+    for (const [propName, paths] of nestedFixedByProp) {
+        if (emittedProps.has(propName))
+            continue;
+        // Check if this property is an array — look in both slice children and
+        // base fields. Synthesized literals for array properties need wrapping
+        // in [] to avoid TS2430 (incompatible extends).
+        const propFullPath = `${parentPath}.${propName}`;
+        const isArrayProp = sliceChildren.some(c => {
+            const cId = c.elementId || c.name;
+            const rel = cId.substring(sliceElementId.length + 1);
+            return rel === propName && c.isArray;
+        }) || baseFields.some(f => f.name === propFullPath && f.isArray);
+        const literal = synthesizeNestedLiteral(paths);
+        if (literal) {
+            lines.push(`${propName}: ${isArrayProp ? `[${literal}]` : literal};`);
+        }
+    }
     return { lines, referencedFhirTypes };
 }
 /**
@@ -263,6 +373,39 @@ function formatCodingLiteral(codings) {
         return null;
     return `[${entries.join(', ')}]`;
 }
+/**
+ * Synthesize a nested object literal from deeply nested fixed values.
+ *
+ * Given a map of nested paths → values (e.g. { "coding.code" → "confidence" }),
+ * produces an object literal like `{ coding: [{ code: "confidence" }] }`.
+ *
+ * Special handling: `coding` segments are wrapped in array brackets because
+ * `CodeableConcept.coding` is always an array in FHIR.
+ */
+function synthesizeNestedLiteral(paths) {
+    const codingFields = new Map();
+    const scalarFields = [];
+    for (const [path, value] of paths) {
+        if (path.startsWith('coding.')) {
+            codingFields.set(path.substring('coding.'.length), value);
+        }
+        else if (!path.includes('.')) {
+            scalarFields.push([path, value]);
+        }
+        // Deeper nesting (3+ levels) is uncommon; skip gracefully
+    }
+    const parts = [];
+    if (codingFields.size > 0) {
+        const codingParts = [...codingFields.entries()].map(([k, v]) => `${k}: "${v}"`);
+        parts.push(`coding: [{ ${codingParts.join('; ')} }]`);
+    }
+    for (const [field, value] of scalarFields) {
+        parts.push(`${field}: "${value}"`);
+    }
+    if (parts.length === 0)
+        return null;
+    return `{ ${parts.join('; ')} }`;
+}
 /**
  * Update the root interface to use the union type for a sliced backbone field.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babelfhir-ts",
-  "version": "1.5.3",
+  "version": "1.5.5",
   "description": "BabelFHIR-TS: generate TypeScript interfaces, validators, and helper classes from FHIR R4/R4B/R5 StructureDefinitions (profiles) directly inside package archives.",
   "type": "module",
   "main": "out/src/main.js",