gdc-common-utils-ts 2.0.18 → 2.2.2

package/dist/utils/backend-message-manager-mem.d.ts

@@ -0,0 +1,78 @@
+import type { IWallet } from '../interfaces/IWallet';
+import type { IProfileOutboxRepository } from '../interfaces/IProfileOutboxRepository';
+import type { BackendMessageResponseRecord, BackendMessageTransport, ProfileOutboxMessageRecord, QueueProfileMessageInput } from '../models/profile-manager';
+import { type WalletQueuedMessage } from '../models/wallet';
+export type BackendMessageManagerMemOptions = Readonly<{
+    wallet: IWallet;
+    entityId: string;
+    transport: BackendMessageTransport;
+    outboxRepository: IProfileOutboxRepository;
+}>;
+/**
+ * Memory-backed backend message manager that:
+ * - queues outbound payloads through `WalletMem`
+ * - packs the next pending message as DIDComm-like JWS+JWE
+ * - submits it through an injected transport
+ * - unwraps the response and indexes it by `thid`
+ *
+ * This is the lowest reusable BFF/proxy slice before actor-specific SDK
+ * facades appear.
+ *
+ * Normal deployment story:
+ * - the injected wallet is the unlocked wallet of the user profile runtime
+ * - that same profile wallet usually encrypts outbound messages and decrypts
+ *   replies
+ *
+ * Optional deployment story:
+ * - one BFF/proxy may also own a separate service wallet for its own
+ *   envelopes, signatures, confidential storage, or tenant-level messaging
+ * - that service wallet is a different actor and must not be confused with
+ *   the user-profile wallet handled here
+ */
+export declare class BackendMessageManagerMem {
+    private readonly wallet;
+    private readonly entityId;
+    private readonly transport;
+    private readonly outboxRepository;
+    private readonly responsesByThread;
+    constructor(options: BackendMessageManagerMemOptions);
+    /**
+     * Queues one outbound business payload for later submission.
+     */
+    queueMessage(input: QueueProfileMessageInput): Promise<WalletQueuedMessage>;
+    /**
+     * Returns queued messages in current priority/FIFO processing order.
+     */
+    listQueuedMessages(): Promise<WalletQueuedMessage[]>;
+    /**
+     * Submits the next pending message through the injected transport and stores
+     * the decoded response by `thid` when one response envelope is returned.
+     */
+    submitNextPendingMessage(recipientEncryptionJwk: Record<string, unknown>): Promise<{
+        message: WalletQueuedMessage;
+        response?: BackendMessageResponseRecord;
+        pending?: boolean;
+    }>;
+    /**
+     * Returns the latest decoded response for one DIDComm thread.
+     */
+    getResponseByThreadId(thid: string): BackendMessageResponseRecord | undefined;
+    /**
+     * Lists submitted message history records preserved by the outbox repository.
+     */
+    listOutboxHistory(): Promise<ProfileOutboxMessageRecord[]>;
+    /**
+     * Polls one previously submitted asynchronous message by id.
+     */
+    pollSubmittedMessage(messageId: string): Promise<{
+        pending: boolean;
+        response?: BackendMessageResponseRecord;
+        record: ProfileOutboxMessageRecord;
+    }>;
+    /**
+     * Reads one decoded response by thread id, first from memory and then from the repository.
+     */
+    readResponseByThreadId(thid: string): Promise<BackendMessageResponseRecord | undefined>;
+    private persistMessageRecord;
+    private requireOutboxRecord;
+}

package/dist/utils/backend-message-manager-mem.js

@@ -0,0 +1,238 @@
+// Copyright 2026 Conectate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+import { WalletQueueStatuses } from '../models/wallet.js';
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+/**
+ * Memory-backed backend message manager that:
+ * - queues outbound payloads through `WalletMem`
+ * - packs the next pending message as DIDComm-like JWS+JWE
+ * - submits it through an injected transport
+ * - unwraps the response and indexes it by `thid`
+ *
+ * This is the lowest reusable BFF/proxy slice before actor-specific SDK
+ * facades appear.
+ *
+ * Normal deployment story:
+ * - the injected wallet is the unlocked wallet of the user profile runtime
+ * - that same profile wallet usually encrypts outbound messages and decrypts
+ *   replies
+ *
+ * Optional deployment story:
+ * - one BFF/proxy may also own a separate service wallet for its own
+ *   envelopes, signatures, confidential storage, or tenant-level messaging
+ * - that service wallet is a different actor and must not be confused with
+ *   the user-profile wallet handled here
+ */
+export class BackendMessageManagerMem {
+    wallet;
+    entityId;
+    transport;
+    outboxRepository;
+    responsesByThread = new Map();
+    constructor(options) {
+        this.wallet = options.wallet;
+        this.entityId = String(options.entityId || '').trim();
+        this.transport = options.transport;
+        this.outboxRepository = options.outboxRepository;
+    }
+    /**
+     * Queues one outbound business payload for later submission.
+     */
+    async queueMessage(input) {
+        if (!this.wallet.enqueueMessage) {
+            throw new Error('BackendMessageManagerMem requires wallet.enqueueMessage().');
+        }
+        const thid = typeof input.payload['thid'] === 'string' ? String(input.payload['thid']) : undefined;
+        const messageType = typeof input.payload['type'] === 'string' ? String(input.payload['type']) : undefined;
+        return this.wallet.enqueueMessage({
+            payload: input.payload,
+            priority: input.priority,
+            thid,
+            messageType,
+        });
+    }
+    /**
+     * Returns queued messages in current priority/FIFO processing order.
+     */
+    async listQueuedMessages() {
+        if (!this.wallet.listMessages) {
+            throw new Error('BackendMessageManagerMem requires wallet.listMessages().');
+        }
+        return this.wallet.listMessages();
+    }
+    /**
+     * Submits the next pending message through the injected transport and stores
+     * the decoded response by `thid` when one response envelope is returned.
+     */
+    async submitNextPendingMessage(recipientEncryptionJwk) {
+        if (!this.wallet.peekNextMessage) {
+            throw new Error('BackendMessageManagerMem requires wallet.peekNextMessage().');
+        }
+        if (!this.wallet.pack) {
+            throw new Error('BackendMessageManagerMem requires wallet.pack().');
+        }
+        if (!this.wallet.markMessageDelivered || !this.wallet.markMessageFailed) {
+            throw new Error('BackendMessageManagerMem requires wallet.markMessageDelivered() and wallet.markMessageFailed().');
+        }
+        const next = await this.wallet.peekNextMessage();
+        if (!next || next.status !== WalletQueueStatuses.Pending) {
+            throw new Error('BackendMessageManagerMem found no pending queued message.');
+        }
+        const envelope = await this.wallet.pack(next.payload, recipientEncryptionJwk, this.entityId);
+        const transportResult = await this.transport.submit({
+            message: next,
+            envelope,
+        });
+        if (!transportResult.accepted) {
+            const failed = await this.wallet.markMessageFailed(next.id, String(transportResult.errorMessage || 'transport rejected queued message'));
+            await this.persistMessageRecord(failed, envelope, undefined, {
+                transportStatus: 'failed',
+            });
+            return { message: failed };
+        }
+        const delivered = await this.wallet.markMessageDelivered(next.id);
+        if (!transportResult.responseEnvelope) {
+            await this.persistMessageRecord(delivered, envelope, undefined, {
+                transportStatus: 'submitted',
+                locationUrl: transportResult.locationUrl,
+                pollCount: 0,
+            });
+            return { message: delivered, pending: true };
+        }
+        if (!this.wallet.unpack) {
+            throw new Error('BackendMessageManagerMem requires wallet.unpack() to decode response envelopes.');
+        }
+        const unpacked = await this.wallet.unpack(transportResult.responseEnvelope, this.entityId);
+        const responseContent = clone(unpacked.content);
+        const thid = String(responseContent['thid'] || delivered.thid || delivered.id).trim();
+        const response = {
+            thid,
+            receivedAt: new Date().toISOString(),
+            content: responseContent,
+            meta: clone(unpacked.meta),
+        };
+        this.responsesByThread.set(thid, response);
+        await this.outboxRepository.putResponse(response);
+        await this.persistMessageRecord(delivered, envelope, response.thid, {
+            transportStatus: 'completed',
+        });
+        return {
+            message: delivered,
+            response,
+        };
+    }
+    /**
+     * Returns the latest decoded response for one DIDComm thread.
+     */
+    getResponseByThreadId(thid) {
+        const normalizedThreadId = String(thid || '').trim();
+        const stored = this.responsesByThread.get(normalizedThreadId);
+        return stored ? clone(stored) : undefined;
+    }
+    /**
+     * Lists submitted message history records preserved by the outbox repository.
+     */
+    async listOutboxHistory() {
+        return this.outboxRepository.listMessages();
+    }
+    /**
+     * Polls one previously submitted asynchronous message by id.
+     */
+    async pollSubmittedMessage(messageId) {
+        if (!this.transport.poll) {
+            throw new Error('BackendMessageManagerMem requires transport.poll() for asynchronous polling.');
+        }
+        const currentRecord = await this.requireOutboxRecord(messageId);
+        const pollResult = await this.transport.poll({
+            message: currentRecord,
+        });
+        if (pollResult.pending) {
+            const pendingRecord = await this.outboxRepository.putMessage({
+                ...currentRecord,
+                transportStatus: 'submitted',
+                pollCount: (currentRecord.pollCount || 0) + 1,
+                recordedAt: new Date().toISOString(),
+            });
+            return {
+                pending: true,
+                record: pendingRecord,
+            };
+        }
+        if (!pollResult.completed || !pollResult.responseEnvelope) {
+            const failedRecord = await this.outboxRepository.putMessage({
+                ...currentRecord,
+                transportStatus: pollResult.retryable ? 'submitted' : 'failed',
+                pollCount: (currentRecord.pollCount || 0) + 1,
+                recordedAt: new Date().toISOString(),
+            });
+            return {
+                pending: Boolean(pollResult.retryable),
+                record: failedRecord,
+            };
+        }
+        if (!this.wallet.unpack) {
+            throw new Error('BackendMessageManagerMem requires wallet.unpack() to decode polled response envelopes.');
+        }
+        const unpacked = await this.wallet.unpack(pollResult.responseEnvelope, this.entityId);
+        const responseContent = clone(unpacked.content);
+        const thid = String(responseContent['thid'] || currentRecord.thid || currentRecord.id).trim();
+        const response = {
+            thid,
+            receivedAt: new Date().toISOString(),
+            content: responseContent,
+            meta: clone(unpacked.meta),
+        };
+        this.responsesByThread.set(thid, response);
+        await this.outboxRepository.putResponse(response);
+        const completedRecord = await this.outboxRepository.putMessage({
+            ...currentRecord,
+            transportStatus: 'completed',
+            responseThid: response.thid,
+            pollCount: (currentRecord.pollCount || 0) + 1,
+            recordedAt: new Date().toISOString(),
+        });
+        return {
+            pending: false,
+            response,
+            record: completedRecord,
+        };
+    }
+    /**
+     * Reads one decoded response by thread id, first from memory and then from the repository.
+     */
+    async readResponseByThreadId(thid) {
+        const inMemory = this.getResponseByThreadId(thid);
+        if (inMemory)
+            return inMemory;
+        const stored = await this.outboxRepository.getLatestResponseByThreadId(thid);
+        if (stored) {
+            this.responsesByThread.set(String(stored.thid || '').trim(), clone(stored));
+        }
+        return stored;
+    }
+    async persistMessageRecord(message, envelope, responseThid, options = {}) {
+        await this.outboxRepository.putMessage({
+            id: message.id,
+            thid: message.thid,
+            messageType: message.messageType,
+            priority: message.priority,
+            status: message.status,
+            transportStatus: options.transportStatus,
+            recordedAt: new Date().toISOString(),
+            payload: clone(message.payload),
+            envelope,
+            ...(responseThid ? { responseThid } : {}),
+            ...(options.locationUrl ? { locationUrl: options.locationUrl } : {}),
+            ...(typeof options.pollCount === 'number' ? { pollCount: options.pollCount } : {}),
+        });
+    }
+    async requireOutboxRecord(messageId) {
+        const normalizedMessageId = String(messageId || '').trim();
+        const stored = await this.outboxRepository.getMessage(normalizedMessageId);
+        if (!stored) {
+            throw new Error(`BackendMessageManagerMem outbox record not found: ${normalizedMessageId}`);
+        }
+        return stored;
+    }
+}

package/dist/utils/bundle-didcomm-payload.d.ts

@@ -0,0 +1,29 @@
+import type { IDecodedDidcommPayload } from '../models/confidential-message';
+export declare const BundleDidcommEntryTypes: Readonly<{
+    readonly Batch: "Bundle-batch-request-v1.0";
+    readonly Document: "Bundle-document-request-v1.0";
+}>;
+/**
+ * Input contract for wrapping one bundle-like resource as one low-level
+ * DIDComm-style batch payload.
+ */
+export type BuildDidcommPayloadFromBundleInput = Readonly<{
+    bundle: Record<string, unknown>;
+    iss: string;
+    aud: string;
+    jti: string;
+    thid: string;
+    entryType?: string;
+}>;
+/**
+ * Builds one low-level DIDComm-style payload carrying one direct `Bundle`
+ * resource in `body.data[0].resource`.
+ *
+ * This path is meant for operational bundles such as employee/search/purge
+ * flows that travel as a bundle itself, not nested inside a `Communication`.
+ */
+export declare function buildDidcommPayloadFromBundle(input: BuildDidcommPayloadFromBundleInput): IDecodedDidcommPayload;
+/**
+ * Reads the first `Bundle` resource carried under `body.data[0].resource`.
+ */
+export declare function getFirstBundleResourceFromDidcommPayload(payload: IDecodedDidcommPayload): Record<string, unknown>;

package/dist/utils/bundle-didcomm-payload.js

@@ -0,0 +1,49 @@
+// Copyright 2026 Conectate Soluciones y Aplicaciones SL under the Apache License, Version 2.0.
+import { DidcommMessageTypes } from '../constants/didcomm.js';
+export const BundleDidcommEntryTypes = Object.freeze({
+    Batch: DidcommMessageTypes.BundleBatchRequest,
+    Document: DidcommMessageTypes.BundleDocumentRequest,
+});
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+/**
+ * Builds one low-level DIDComm-style payload carrying one direct `Bundle`
+ * resource in `body.data[0].resource`.
+ *
+ * This path is meant for operational bundles such as employee/search/purge
+ * flows that travel as a bundle itself, not nested inside a `Communication`.
+ */
+export function buildDidcommPayloadFromBundle(input) {
+    return {
+        iss: String(input.iss || '').trim(),
+        aud: String(input.aud || '').trim(),
+        jti: String(input.jti || '').trim(),
+        thid: String(input.thid || '').trim(),
+        type: String(input.entryType || BundleDidcommEntryTypes.Batch).trim(),
+        body: {
+            data: [
+                {
+                    id: String(input.jti || '').trim(),
+                    type: String(input.entryType || BundleDidcommEntryTypes.Batch).trim(),
+                    resource: clone(input.bundle),
+                },
+            ],
+        },
+    };
+}
+/**
+ * Reads the first `Bundle` resource carried under `body.data[0].resource`.
+ */
+export function getFirstBundleResourceFromDidcommPayload(payload) {
+    const first = Array.isArray(payload?.body?.data)
+        ? payload.body.data[0]
+        : undefined;
+    const resource = first?.resource && typeof first.resource === 'object'
+        ? clone(first.resource)
+        : {};
+    if (String(resource['resourceType'] || '').trim() !== 'Bundle') {
+        throw new Error('getFirstBundleResourceFromDidcommPayload requires body.data[0].resource.resourceType = Bundle.');
+    }
+    return resource;
+}

package/dist/utils/bundle-document-builder.d.ts

@@ -4,6 +4,7 @@ export type BuildBundleDocumentFromClaimsInput = Readonly<{
     claimsList: readonly BundleDocumentClaims[];
     subjectDid?: string;
     compositionType?: string;
+    compositionClaims?: BundleDocumentClaims;
 }>;
 export type ValidateBundleDocumentResult = Readonly<{
     ok: boolean;

package/dist/utils/bundle-document-builder.js

@@ -1,4 +1,10 @@
 import { ResourceTypesFhirR4 } from '../constants/fhir-resource-types.js';
+import { AllergyIntoleranceClaim } from '../models/interoperable-claims/allergy-intolerance-claims.js';
+import { CompositionClaim } from '../models/interoperable-claims/composition-claims.js';
+import { ConditionClaim } from '../models/interoperable-claims/condition-claims.js';
+import { DiagnosticReportClaim } from '../models/interoperable-claims/diagnostic-report-claims.js';
+import { MedicationStatementClaim } from '../models/interoperable-claims/medication-statement-claims.js';
+import { ClaimConsent } from '../models/consent-rule.js';
 import { allergyIntoleranceFlatToFhirR4, appointmentFlatToFhirR4, carePlanFlatToFhirR4, clinicalImpressionFlatToFhirR4, compositionFlatToFhirR4, conditionFlatToFhirR4, convertFhirResourceToClaims, coverageFlatToFhirR4, deviceFlatToFhirR4, documentReferenceFlatToFhirR4, diagnosticReportFlatToFhirR4, encounterFlatToFhirR4, flagFlatToFhirR4, flatClaimsToFhirResource, immunizationFlatToFhirR4, locationFlatToFhirR4, medicationStatementFlatToFhirR4, observationFromFlatToFhirR4, organizationFlatToFhirR4, procedureFlatToFhirR4, relatedPersonFlatToFhirR4, } from './clinical-resource-converters.js';
 function asTrimmedString(value) {
     if (value === undefined || value === null)
@@ -93,6 +99,43 @@ function normalizeSectionCode(value) {
         return { code: system };
     return { system, code };
 }
+function resolveContainedReferenceListClaimKey(resourceType) {
+    switch (resourceType) {
+        case ResourceTypesFhirR4.MedicationStatement:
+            return MedicationStatementClaim.ContainedReferenceList;
+        case ResourceTypesFhirR4.AllergyIntolerance:
+            return AllergyIntoleranceClaim.ContainedReferenceList;
+        case ResourceTypesFhirR4.Condition:
+            return ConditionClaim.ContainedReferenceList;
+        case ResourceTypesFhirR4.DiagnosticReport:
+            return DiagnosticReportClaim.ContainedReferenceList;
+        case ResourceTypesFhirR4.Consent:
+            return ClaimConsent.containedReferenceList;
+        default:
+            return undefined;
+    }
+}
+function resolveContainedFlagClaimKey(resourceType) {
+    const normalized = asTrimmedString(resourceType);
+    return normalized ? `${normalized}.is-contained` : undefined;
+}
+function resolveContainedParentReferenceClaimKey(resourceType) {
+    const normalized = asTrimmedString(resourceType);
+    return normalized ? `${normalized}.contained-parent-reference` : undefined;
+}
+function mergeContainedResourceReferenceList(claims, references) {
+    const resourceType = detectClaimsResourceType(claims);
+    const claimKey = resourceType ? resolveContainedReferenceListClaimKey(resourceType) : undefined;
+    if (!claimKey || references.length === 0) {
+        return claims;
+    }
+    const current = splitCsv(claims[claimKey]);
+    const next = Array.from(new Set([...current, ...references].map((item) => asTrimmedString(item)).filter(Boolean)));
+    return {
+        ...claims,
+        [claimKey]: next.join(','),
+    };
+}
 export function detectClaimsResourceType(claims) {
     const keys = Object.keys(claims || {});
     if (keys.some((key) => key.startsWith('MedicationStatement.')))
@@ -181,12 +224,47 @@ export function extractBundleDocumentClaimsList(bundle, context = 'org.hl7.fhir.
         .map((entry) => entry?.resource)
         .filter((resource) => resource && typeof resource === 'object')
         .filter((resource) => !ignoredResourceTypes.has(String(resource.resourceType || '')))
-        .map((resource) => {
-        const metaClaims = resource?.meta?.claims;
-        if (metaClaims && typeof metaClaims === 'object' && !Array.isArray(metaClaims)) {
-            return ensureClaimsIdentifier({ ...metaClaims }, resource);
-        }
-        return ensureClaimsIdentifier(convertFhirResourceToClaims(resource, context), resource);
+        .flatMap((resource) => {
+        const resourceRecord = resource;
+        const resourceReference = `${asTrimmedString(resourceRecord.resourceType)}/${asTrimmedString(resourceRecord.id)}`;
+        const metaClaims = resourceRecord?.meta?.claims;
+        const baseClaims = metaClaims && typeof metaClaims === 'object' && !Array.isArray(metaClaims)
+            ? ensureClaimsIdentifier({ ...metaClaims }, resourceRecord)
+            : ensureClaimsIdentifier(convertFhirResourceToClaims(resourceRecord, context), resourceRecord);
+        const containedResources = Array.isArray(resourceRecord.contained)
+            ? resourceRecord.contained
+            : [];
+        const containedClaimsList = containedResources.map((containedResource, index) => {
+            const containedMetaClaims = (containedResource?.meta?.claims);
+            const containedClaims = containedMetaClaims && typeof containedMetaClaims === 'object' && !Array.isArray(containedMetaClaims)
+                ? ensureClaimsIdentifier({ ...containedMetaClaims }, containedResource)
+                : ensureClaimsIdentifier(convertFhirResourceToClaims(containedResource, context), containedResource);
+            const containedResourceType = asTrimmedString(containedResource.resourceType);
+            const containedFlagClaimKey = resolveContainedFlagClaimKey(containedResourceType);
+            const containedParentReferenceClaimKey = resolveContainedParentReferenceClaimKey(containedResourceType);
+            return {
+                ...containedClaims,
+                ...(containedFlagClaimKey ? { [containedFlagClaimKey]: true } : {}),
+                ...(containedParentReferenceClaimKey ? { [containedParentReferenceClaimKey]: resourceReference } : {}),
+                ...(asTrimmedString(containedResource.id) ? {} : {
+                    [`${containedResource.resourceType}.identifier`]: `${resourceReference}#contained-${index + 1}`,
+                }),
+            };
+        });
+        const containedReferences = containedResources
+            .map((containedResource, index) => {
+            const containedType = asTrimmedString(containedResource.resourceType);
+            const containedId = asTrimmedString(containedResource.id) || `${resourceReference}#contained-${index + 1}`;
+            if (!containedType || !containedId) {
+                return '';
+            }
+            return `${containedType}/${containedId}`;
+        })
+            .filter(Boolean);
+        return [
+            mergeContainedResourceReferenceList(baseClaims, containedReferences),
+            ...containedClaimsList,
+        ];
     });
 }
 export function resolveClaimsSectionList(claims) {
@@ -202,9 +280,17 @@ export function resolveClaimsSectionList(claims) {
     return Array.from(new Set(values));
 }
 export function buildBundleDocumentFromClaims(input) {
-    const compositionType = asTrimmedString(input.compositionType) || 'http://loinc.org|60591-5';
+    const compositionClaims = { ...(input.compositionClaims || {}) };
+    const compositionType = asTrimmedString(input.compositionType || compositionClaims[CompositionClaim.Type]) || 'http://loinc.org|60591-5';
+    const compositionSubject = asTrimmedString(input.subjectDid || compositionClaims[CompositionClaim.Subject]);
+    const compositionIdentifier = asTrimmedString(compositionClaims[CompositionClaim.Identifier]);
+    const compositionTitle = asTrimmedString(compositionClaims[CompositionClaim.Title]);
+    const compositionDate = asTrimmedString(compositionClaims[CompositionClaim.Date]);
+    const compositionAuthorList = splitCsv(compositionClaims[CompositionClaim.Author]);
     const compositionSections = new Map();
-    const entries = [];
+    const visibleEntries = [];
+    const resourceByReference = new Map();
+    const containedChildrenByParentReference = new Map();
     input.claimsList.forEach((claims, index) => {
         const resource = convertClaimsToFhirResource(claims);
         resource.meta = {
@@ -212,8 +298,23 @@ export function buildBundleDocumentFromClaims(input) {
             claims: { ...claims },
         };
         ensureResourceIdentifier(resource, claims, index);
-        entries.push({ resource });
-        const resourceRef = `${resource.resourceType}/${resource.id}`;
+        const resourceReference = `${resource.resourceType}/${asTrimmedString(resource.id)}`;
+        const containedFlagClaimKey = resolveContainedFlagClaimKey(resource.resourceType);
+        const containedParentReferenceClaimKey = resolveContainedParentReferenceClaimKey(resource.resourceType);
+        const isContained = containedFlagClaimKey
+            ? (claims[containedFlagClaimKey] === true || claims[containedFlagClaimKey] === 'true')
+            : false;
+        const containedParentReference = containedParentReferenceClaimKey
+            ? asTrimmedString(claims[containedParentReferenceClaimKey])
+            : '';
+        if (isContained && containedParentReference) {
+            const currentChildren = containedChildrenByParentReference.get(containedParentReference) || [];
+            containedChildrenByParentReference.set(containedParentReference, [...currentChildren, resource]);
+            return;
+        }
+        visibleEntries.push({ resource });
+        resourceByReference.set(resourceReference, resource);
+        const resourceRef = resourceReference;
         resolveClaimsSectionList(claims).forEach((sectionValue) => {
             const normalizedSection = asTrimmedString(sectionValue);
             if (!normalizedSection)
@@ -230,6 +331,13 @@ export function buildBundleDocumentFromClaims(input) {
             compositionSections.set(normalizedSection, section);
         });
     });
+    containedChildrenByParentReference.forEach((children, parentReference) => {
+        const parent = resourceByReference.get(parentReference);
+        if (!parent) {
+            return;
+        }
+        parent.contained = [...(Array.isArray(parent.contained) ? parent.contained : []), ...children];
+    });
     const [compositionSystem, compositionCode] = compositionType.split('|');
     return {
         resourceType: ResourceTypesFhirR4.Bundle,
@@ -238,8 +346,14 @@ export function buildBundleDocumentFromClaims(input) {
             {
                 resource: {
                     resourceType: ResourceTypesFhirR4.Composition,
+                    ...(compositionIdentifier ? { id: compositionIdentifier } : {}),
                     status: 'final',
-                    subject: input.subjectDid ? { reference: input.subjectDid } : undefined,
+                    ...(compositionIdentifier ? {
+                        identifier: [{ value: compositionIdentifier }],
+                    } : {}),
+                    ...(compositionSubject ? {
+                        subject: { reference: compositionSubject },
+                    } : {}),
                     type: {
                         coding: [
                             compositionCode
@@ -247,18 +361,24 @@ export function buildBundleDocumentFromClaims(input) {
                                 : { code: compositionSystem },
                         ],
                     },
+                    ...(compositionTitle ? { title: compositionTitle } : {}),
+                    ...(compositionDate ? { date: compositionDate } : {}),
+                    ...(compositionAuthorList.length > 0 ? {
+                        author: compositionAuthorList.map((reference) => ({ reference })),
+                    } : {}),
+                    meta: { claims: compositionClaims },
                     section: Array.from(compositionSections.values()),
                 },
             },
-            ...(input.subjectDid
+            ...(compositionSubject
                 ? [{
                         resource: {
                             resourceType: 'Patient',
-                            id: input.subjectDid,
+                            id: compositionSubject,
                         },
                     }]
                 : []),
-            ...entries,
+            ...visibleEntries,
         ],
     };
 }