gdc-common-utils-ts 2.0.18 → 2.2.2

package/dist/utils/bundle-editor-helpers.d.ts

@@ -0,0 +1,53 @@
+import { type BundleRequest } from '../models/bundle';
+import { type BundleOperation } from '../models/bundle-editor-types';
+export declare function cloneEntry<T>(value: T): T;
+/** Clones one claim value while preserving simple arrays used by flat claims. */
+export declare function cloneClaimValue<T>(value: T): T;
+/**
+ * Trims one candidate identifier-like value and returns `undefined` when it is
+ * empty or absent.
+ *
+ * Use this before writing ids, references, `fullUrl`, or flat-claim scalars so
+ * every editor follows the same blank-value rule.
+ */
+export declare function normalizeOptionalIdentifier(value: unknown): string | undefined;
+/** Returns one canonical `urn:uuid:*` identifier for new entry/resource drafts. */
+export declare function createCanonicalIdentifierUrn(): string;
+/**
+ * Maps the editor's high-level business operation to the low-level request
+ * method stored in staged bundle entries.
+ */
+export declare function resolveRequestMethodForOperation(operation: BundleOperation): BundleRequest['method'];
+/**
+ * Resolves the legacy entry `type` string used by employee-oriented batch flows.
+ *
+ * This is not the same concept as `resource.resourceType`.
+ */
+export declare function resolveEntryTypeForOperation(operation: BundleOperation): string;
+/**
+ * Builds the generic entry `type` string for non-employee resource drafts.
+ *
+ * This is one bundle-internal classification token, not a FHIR field.
+ */
+export declare function inferGenericEntryType(resourceType: string, operation: BundleOperation): string;
+/**
+ * Resolves which flat-claims key stores the CSV of linked/contained resource
+ * references for one parent resource type.
+ */
+export declare function resolveContainedReferenceListClaimKey(resourceType: string): string;
+/** Returns the internal visibility-control claim that marks one resource as contained. */
+export declare function resolveContainedFlagClaimKey(resourceType: string): string;
+/** Returns the internal parent-reference claim for one contained child resource. */
+export declare function resolveContainedParentReferenceClaimKey(resourceType: string): string;
+/**
+ * Normalizes one linked-resource reference into both:
+ * - `identifier`: the entry-local id part
+ * - `reference`: the canonical `ResourceType/<id>` string
+ *
+ * This lets the editors accept either a bare id or a full FHIR-style reference
+ * while keeping one normalized shape internally.
+ */
+export declare function normalizeContainedReference(resourceType: string, referenceOrIdentifier: string): {
+    identifier: string;
+    reference: string;
+};

package/dist/utils/bundle-editor-helpers.js

@@ -0,0 +1,146 @@
+/**
+ * File discipline note:
+ * - Read `ARCHITECTURE.md` and `CONTRIBUTING.md` before changing this module.
+ * - Keep only reusable pure helper logic here.
+ * - Do not move entry-specific orchestration back into this file; that belongs
+ *   in the editor classes.
+ */
+import { ResourceTypesFhirR4 } from '../constants/fhir-resource-types.js';
+import { AllergyIntoleranceClaim, } from '../models/interoperable-claims/allergy-intolerance-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 { BundleEditableResourceTypes, } from '../models/bundle-editor-types.js';
+import { EmployeeBatchEntryTypes, EmployeeBundleMethods, EmployeeBundleOperations, } from './employee.js';
+export function cloneEntry(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+/** Clones one claim value while preserving simple arrays used by flat claims. */
+export function cloneClaimValue(value) {
+    if (Array.isArray(value)) {
+        return [...value];
+    }
+    return value;
+}
+/**
+ * Trims one candidate identifier-like value and returns `undefined` when it is
+ * empty or absent.
+ *
+ * Use this before writing ids, references, `fullUrl`, or flat-claim scalars so
+ * every editor follows the same blank-value rule.
+ */
+export function normalizeOptionalIdentifier(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    const normalized = String(value).trim();
+    return normalized ? normalized : undefined;
+}
+/** Returns one canonical `urn:uuid:*` identifier for new entry/resource drafts. */
+export function createCanonicalIdentifierUrn() {
+    const cryptoLike = globalThis;
+    const uuid = typeof cryptoLike.crypto?.randomUUID === 'function'
+        ? cryptoLike.crypto.randomUUID()
+        : `resource-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    return `urn:uuid:${uuid}`;
+}
+/**
+ * Maps the editor's high-level business operation to the low-level request
+ * method stored in staged bundle entries.
+ */
+export function resolveRequestMethodForOperation(operation) {
+    switch (operation) {
+        case EmployeeBundleOperations.disable:
+            return EmployeeBundleMethods.disable;
+        case EmployeeBundleOperations.search:
+        case EmployeeBundleOperations.create:
+        case EmployeeBundleOperations.purge:
+        default:
+            return EmployeeBundleMethods.create;
+    }
+}
+/**
+ * Resolves the legacy entry `type` string used by employee-oriented batch flows.
+ *
+ * This is not the same concept as `resource.resourceType`.
+ */
+export function resolveEntryTypeForOperation(operation) {
+    switch (operation) {
+        case EmployeeBundleOperations.search:
+            return EmployeeBatchEntryTypes.search;
+        case EmployeeBundleOperations.disable:
+            return EmployeeBatchEntryTypes.disable;
+        case EmployeeBundleOperations.purge:
+            return EmployeeBatchEntryTypes.purge;
+        case EmployeeBundleOperations.create:
+        default:
+            return EmployeeBatchEntryTypes.create;
+    }
+}
+/**
+ * Builds the generic entry `type` string for non-employee resource drafts.
+ *
+ * This is one bundle-internal classification token, not a FHIR field.
+ */
+export function inferGenericEntryType(resourceType, operation) {
+    const normalizedResourceType = String(resourceType || '').trim();
+    if (normalizedResourceType === BundleEditableResourceTypes.employee) {
+        return resolveEntryTypeForOperation(operation);
+    }
+    return `${normalizedResourceType}-${operation}-request-v1.0`;
+}
+/**
+ * Resolves which flat-claims key stores the CSV of linked/contained resource
+ * references for one parent resource type.
+ */
+export function resolveContainedReferenceListClaimKey(resourceType) {
+    switch (resourceType) {
+        case ResourceTypesFhirR4.AllergyIntolerance:
+            return AllergyIntoleranceClaim.ContainedReferenceList;
+        case ResourceTypesFhirR4.Condition:
+            return ConditionClaim.ContainedReferenceList;
+        case ResourceTypesFhirR4.MedicationStatement:
+            return MedicationStatementClaim.ContainedReferenceList;
+        case ResourceTypesFhirR4.DiagnosticReport:
+            return DiagnosticReportClaim.ContainedReferenceList;
+        case ResourceTypesFhirR4.Consent:
+            return ClaimConsent.containedReferenceList;
+        default:
+            return '';
+    }
+}
+/** Returns the internal visibility-control claim that marks one resource as contained. */
+export function resolveContainedFlagClaimKey(resourceType) {
+    return `${resourceType}.is-contained`;
+}
+/** Returns the internal parent-reference claim for one contained child resource. */
+export function resolveContainedParentReferenceClaimKey(resourceType) {
+    return `${resourceType}.contained-parent-reference`;
+}
+/**
+ * Normalizes one linked-resource reference into both:
+ * - `identifier`: the entry-local id part
+ * - `reference`: the canonical `ResourceType/<id>` string
+ *
+ * This lets the editors accept either a bare id or a full FHIR-style reference
+ * while keeping one normalized shape internally.
+ */
+export function normalizeContainedReference(resourceType, referenceOrIdentifier) {
+    const normalizedValue = normalizeOptionalIdentifier(referenceOrIdentifier);
+    if (!normalizedValue) {
+        return { identifier: '', reference: '' };
+    }
+    const slashIndex = normalizedValue.indexOf('/');
+    if (slashIndex > 0) {
+        const identifier = normalizedValue.slice(slashIndex + 1).trim();
+        return {
+            identifier,
+            reference: `${String(resourceType || '').trim() || normalizedValue.slice(0, slashIndex).trim()}/${identifier}`,
+        };
+    }
+    return {
+        identifier: normalizedValue,
+        reference: `${String(resourceType || '').trim()}/${normalizedValue}`,
+    };
+}

package/dist/utils/bundle-editor-registry.d.ts

@@ -0,0 +1,6 @@
+import type { BundleEditor } from './bundle-editor-core';
+import type { BundleEntryEditor } from './bundle-entry-editor';
+export type BundleEntryEditorConstructor<T extends BundleEntryEditor = BundleEntryEditor> = new (bundleEditor: BundleEditor, entryIndex: number) => T;
+export declare function registerBundleEntryEditor(resourceType: string, ctor: BundleEntryEditorConstructor): void;
+export declare function getBundleEntryEditorConstructor(resourceType: string): BundleEntryEditorConstructor | undefined;
+export declare function createRegisteredBundleEntryEditor<T extends BundleEntryEditor>(resourceType: string, bundleEditor: BundleEditor, entryIndex: number): T;

package/dist/utils/bundle-editor-registry.js

@@ -0,0 +1,14 @@
+const bundleEntryEditorConstructors = new Map();
+export function registerBundleEntryEditor(resourceType, ctor) {
+    bundleEntryEditorConstructors.set(String(resourceType || '').trim(), ctor);
+}
+export function getBundleEntryEditorConstructor(resourceType) {
+    return bundleEntryEditorConstructors.get(String(resourceType || '').trim());
+}
+export function createRegisteredBundleEntryEditor(resourceType, bundleEditor, entryIndex) {
+    const ctor = getBundleEntryEditorConstructor(resourceType);
+    if (!ctor) {
+        throw new Error('BundleEntryEditor has not registered a constructor for resource type: ' + String(resourceType || '').trim());
+    }
+    return new ctor(bundleEditor, entryIndex);
+}