gdc-sdk-front-ts 0.6.2 → 0.6.5

package/dist/gdc-sdk-core-ts/src/communication-outbox.d.ts

@@ -0,0 +1,49 @@
+import type { CommunicationDraft, CommunicationOutboxJob, CommunicationOutboxStatus, OutboxJob } from './communication-draft.js';
+export type OutboxQuery<TStatus extends string = CommunicationOutboxStatus> = Readonly<{
+    status?: TStatus | TStatus[];
+    draftId?: string;
+    thid?: string;
+}>;
+/**
+ * Runtime-neutral repository contract for communication drafts and outbox jobs.
+ *
+ * Frontend packages can back this with IndexedDB/SQLite/secure storage.
+ * Node packages can back it with memory, files, or a database.
+ */
+export interface IOutboxRepository<TDraft extends {
+    id: string;
+} = CommunicationDraft, TJob extends {
+    id: string;
+    draftId: string;
+    thid: string;
+    status: string;
+} = OutboxJob, TStatus extends string = CommunicationOutboxStatus> {
+    initialize(): Promise<void>;
+    putDraft(draft: TDraft): Promise<boolean>;
+    getDraft(draftId: string): Promise<TDraft | undefined>;
+    listDrafts(): Promise<TDraft[]>;
+    deleteDraft(draftId: string): Promise<boolean>;
+    putJob(job: TJob): Promise<boolean>;
+    getJob(jobId: string): Promise<TJob | undefined>;
+    listJobs(query?: OutboxQuery<TStatus>): Promise<TJob[]>;
+    deleteJob(jobId: string): Promise<boolean>;
+}
+/**
+ * Memory-backed reference implementation of `IOutboxRepository`.
+ *
+ * Useful for tests, demos, server-local drafts, and as the baseline behavior
+ * before wiring persistent adapters in frontend or node runtimes.
+ */
+export declare class OutboxRepositoryMemory implements IOutboxRepository {
+    private readonly drafts;
+    private readonly jobs;
+    initialize(): Promise<void>;
+    putDraft(draft: CommunicationDraft): Promise<boolean>;
+    getDraft(draftId: string): Promise<CommunicationDraft | undefined>;
+    listDrafts(): Promise<CommunicationDraft[]>;
+    deleteDraft(draftId: string): Promise<boolean>;
+    putJob(job: CommunicationOutboxJob): Promise<boolean>;
+    getJob(jobId: string): Promise<CommunicationOutboxJob | undefined>;
+    listJobs(query?: OutboxQuery): Promise<CommunicationOutboxJob[]>;
+    deleteJob(jobId: string): Promise<boolean>;
+}

package/dist/gdc-sdk-core-ts/src/communication-outbox.js

@@ -0,0 +1,62 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function normalizeStatuses(status) {
+    if (!status)
+        return undefined;
+    const values = Array.isArray(status) ? status : [status];
+    return new Set(values);
+}
+/**
+ * Memory-backed reference implementation of `IOutboxRepository`.
+ *
+ * Useful for tests, demos, server-local drafts, and as the baseline behavior
+ * before wiring persistent adapters in frontend or node runtimes.
+ */
+export class OutboxRepositoryMemory {
+    constructor() {
+        this.drafts = new Map();
+        this.jobs = new Map();
+    }
+    async initialize() { }
+    async putDraft(draft) {
+        this.drafts.set(draft.id, clone(draft));
+        return true;
+    }
+    async getDraft(draftId) {
+        const draft = this.drafts.get(draftId);
+        return draft ? clone(draft) : undefined;
+    }
+    async listDrafts() {
+        return [...this.drafts.values()].map((draft) => clone(draft));
+    }
+    async deleteDraft(draftId) {
+        return this.drafts.delete(draftId);
+    }
+    async putJob(job) {
+        this.jobs.set(job.id, clone(job));
+        return true;
+    }
+    async getJob(jobId) {
+        const job = this.jobs.get(jobId);
+        return job ? clone(job) : undefined;
+    }
+    async listJobs(query = {}) {
+        const acceptedStatuses = normalizeStatuses(query.status);
+        return [...this.jobs.values()]
+            .filter((job) => {
+            if (acceptedStatuses && !acceptedStatuses.has(job.status))
+                return false;
+            if (query.draftId && job.draftId !== query.draftId)
+                return false;
+            if (query.thid && job.thid !== query.thid)
+                return false;
+            return true;
+        })
+            .map((job) => clone(job));
+    }
+    async deleteJob(jobId) {
+        return this.jobs.delete(jobId);
+    }
+}

package/dist/gdc-sdk-core-ts/src/communication-resource-helpers.d.ts

@@ -0,0 +1,180 @@
+import { ResourceTypesFhirR4 } from 'gdc-common-utils-ts/constants/fhir-resource-types';
+import { FhirVersions } from 'gdc-common-utils-ts/constants/fhir-versions';
+export type FhirResourceLike = Record<string, unknown>;
+export type CommunicationResourceLike = FhirResourceLike & {
+    resourceType: typeof ResourceTypesFhirR4.Communication;
+    payload?: Array<Record<string, unknown>>;
+    note?: Array<Record<string, unknown>>;
+};
+export type AttachmentEncodingInput = Readonly<{
+    contentType?: string;
+    title?: string;
+    dataBase64?: string;
+    url?: string;
+}>;
+export type CommunicationCreationOptions = Readonly<{
+    subject: string;
+    sender?: string;
+    recipient?: string | string[];
+    sent?: string;
+    status?: string;
+    category?: ReadonlyArray<{
+        system?: string;
+        code: string;
+    }> | string[];
+    /** Optional note text. In FHIR `Communication.note[].text`, markdown is allowed. */
+    noteText?: string;
+    claims?: Record<string, unknown>;
+}>;
+export type ResourceAttachmentOptions = Readonly<{
+    /** Optional note text. In FHIR `Communication.note[].text`, markdown is allowed. */
+    noteText?: string;
+    asDocumentReference?: boolean;
+    documentReferenceIdentifier?: string;
+    attachmentTitle?: string;
+    attachmentContentType?: string;
+    documentDescription?: string;
+    documentDate?: string;
+    documentSubject?: string;
+}>;
+export type CommunicationPayloadResolution = Readonly<{
+    payloadIndex: number;
+    payloadType: 'attachment' | 'reference';
+    documentReference?: FhirResourceLike;
+    bundle?: FhirResourceLike;
+    resource?: FhirResourceLike;
+    noteText?: string;
+}>;
+export type ObservationCodeFilter = Readonly<{
+    code?: string;
+    codes?: string[];
+}>;
+export type CommunicationBatchMessageOptions = Readonly<{
+    thid?: string;
+    jti?: string;
+    iss?: string;
+    aud?: string;
+    requestUrl?: string;
+    entryType?: string;
+    messageType?: string;
+    fhirVersion?: typeof FhirVersions[keyof typeof FhirVersions];
+}>;
+/**
+ * Creates a minimal FHIR `Communication` resource ready to receive payloads.
+ *
+ * @param options.subject Subject reference carried by `Communication.subject.reference`.
+ * @param options.sender Optional sender reference.
+ * @param options.recipient Optional recipient reference or references.
+ * @param options.sent Optional sent timestamp.
+ * @param options.status Optional FHIR communication status. Defaults to `completed`.
+ * @param options.category Optional coding tokens or coding descriptors.
+ * @param options.noteText Optional message note text. FHIR allows markdown here.
+ * @param options.claims Optional `resource.meta.claims` payload to preserve.
+ */
+export declare function createCommunicationResource(options: CommunicationCreationOptions): CommunicationResourceLike;
+/**
+ * Wraps a FHIR `Communication` into a batch message payload suitable for
+ * the legacy/FHIR ingestion routes used by the GW.
+ *
+ * @param communication FHIR `Communication` resource to submit.
+ * @param options.thid Optional thread id for the envelope.
+ * @param options.jti Optional envelope id.
+ * @param options.iss Optional issuer DID.
+ * @param options.aud Optional audience DID.
+ * @param options.requestUrl Optional FHIR batch request URL.
+ * @param options.entryType Optional business type for the batch entry.
+ * @param options.messageType Optional outer message MIME type.
+ * @param options.fhirVersion Optional FHIR version parameter used in the MIME type.
+ */
+export declare function buildCommunicationBatchMessage(communication: FhirResourceLike, options?: CommunicationBatchMessageOptions): Record<string, unknown>;
+/**
+ * Adds a FHIR resource as a `Communication.payload` attachment.
+ *
+ * When `options.asDocumentReference` is enabled, the resource is first
+ * wrapped into a FHIR `DocumentReference` whose `content.attachment`
+ * contains the serialized resource.
+ *
+ * @param communication Target FHIR `Communication` resource.
+ * @param resource FHIR resource to attach.
+ * @param options.noteText Optional note text appended to `Communication.note`. FHIR allows markdown here.
+ * @param options.asDocumentReference Whether to wrap the resource into `DocumentReference`.
+ * @param options.documentReferenceIdentifier Optional `DocumentReference.identifier`.
+ * @param options.attachmentTitle Optional attachment filename/title.
+ * @param options.attachmentContentType Optional attachment MIME type.
+ * @param options.documentDescription Optional `DocumentReference.description`.
+ * @param options.documentDate Optional `DocumentReference.date`.
+ * @param options.documentSubject Optional `DocumentReference.subject.reference`.
+ */
+export declare function addFhirResourceToCommunication(communication: FhirResourceLike, resource: FhirResourceLike, options?: ResourceAttachmentOptions): CommunicationResourceLike;
+/**
+ * Adds a claims-only pseudo-resource into `Communication.payload`.
+ *
+ * The resource is created with `resourceType` plus `resource.meta.claims`
+ * and then attached using the same logic as `addFhirResourceToCommunication(...)`.
+ *
+ * @param communication Target FHIR `Communication` resource.
+ * @param resourceType FHIR `resourceType` name to materialize.
+ * @param claims Canonical interoperable claims to place under `meta.claims`.
+ * @param options Attachment/document wrapping options.
+ */
+export declare function addClaimsResourceToCommunication(communication: FhirResourceLike, resourceType: string, claims: Record<string, unknown>, options?: ResourceAttachmentOptions): CommunicationResourceLike;
+/**
+ * Resolves every `Communication.payload[]` entry into a normalized shape.
+ *
+ * The resolver abstracts:
+ * - direct resource attachment
+ * - embedded `DocumentReference`
+ * - embedded `Bundle document`
+ * - best-effort note text associated to the payload slot
+ *
+ * @param communication FHIR `Communication` resource to inspect.
+ */
+export declare function resolveCommunicationPayloads(communication: FhirResourceLike): CommunicationPayloadResolution[];
+/**
+ * Returns the first FHIR `Bundle document` reachable from a `Communication`.
+ *
+ * It transparently supports direct bundle attachments and bundles wrapped
+ * inside `DocumentReference.content.attachment`.
+ *
+ * @param communication FHIR `Communication` resource to inspect.
+ */
+export declare function getFirstBundleDocumentFromCommunication(communication: FhirResourceLike): FhirResourceLike | undefined;
+/**
+ * Extracts concrete FHIR resources from a `Bundle.entry[].resource` list.
+ *
+ * @param bundle FHIR `Bundle` document.
+ */
+export declare function getBundleDocumentEntries(bundle: FhirResourceLike | undefined): FhirResourceLike[];
+/**
+ * Returns bundle resources filtered by `resourceType`.
+ *
+ * @param bundle FHIR `Bundle` document.
+ * @param resourceType FHIR `resourceType` name to keep.
+ */
+export declare function getBundleDocumentResourcesByType(bundle: FhirResourceLike | undefined, resourceType: string): FhirResourceLike[];
+/**
+ * Extracts `MedicationStatement.meta.claims` rows from the first document
+ * bundle found inside a `Communication`.
+ *
+ * @param communication FHIR `Communication` resource to inspect.
+ */
+export declare function getMedicationClaimsFromCommunicationDocument(communication: FhirResourceLike): Record<string, unknown>[];
+/**
+ * Sorts FHIR resources by their first canonical clinical date descending.
+ *
+ * The helper inspects common date fields such as `effectiveDateTime`,
+ * `issued`, `authoredOn`, `performedDateTime`, `recordedDate`, `date`, and `sent`.
+ *
+ * @param resources Resources to sort.
+ */
+export declare function sortFhirResourcesByDateDescending<T extends FhirResourceLike>(resources: T[]): T[];
+/**
+ * Returns `Observation` resources from a communication document filtered by code.
+ *
+ * Accepted filter values may be bare codes or `<system>|<code>` tokens.
+ *
+ * @param communication FHIR `Communication` resource to inspect.
+ * @param filter.code Optional single code filter.
+ * @param filter.codes Optional list of accepted codes.
+ */
+export declare function getObservationsByCodeFromCommunicationDocument(communication: FhirResourceLike, filter: ObservationCodeFilter): FhirResourceLike[];