gdc-common-utils-ts 1.14.13 → 1.14.15

package/dist/utils/employee.js

@@ -0,0 +1,134 @@
+import { ClaimsPersonSchemaorg } from '../constants/schemaorg.js';
+import { buildFhirParametersResourceFromSearchParams, buildSearchQueryString, } from './fhir-search.js';
+function cloneClaims(claims) {
+    return { ...(claims || {}) };
+}
+function normalizeEmployeeSearchClaims(claims) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(claims || {})) {
+        if (key === '@context')
+            continue;
+        normalized[key] = value;
+    }
+    return normalized;
+}
+function inferEmployeeEntryType(method) {
+    switch (method) {
+        case 'DELETE':
+            return 'Employee-delete-request-v1.0';
+        case 'PUT':
+        case 'PATCH':
+            return 'Employee-update-request-v1.0';
+        case 'GET':
+            return 'Employee-search-request-v1.0';
+        case 'POST':
+        default:
+            return 'Employee-create-request-v1.0';
+    }
+}
+/**
+ * Builds canonical `org.schema.Person.*` employee claims from semantic input.
+ */
+export function buildEmployeeClaims(input) {
+    const claims = {
+        '@context': 'org.schema',
+        ...cloneClaims(input.additionalClaims),
+    };
+    if (typeof input.identifier === 'string' && input.identifier.trim()) {
+        claims[ClaimsPersonSchemaorg.identifier] = input.identifier.trim();
+    }
+    if (typeof input.email === 'string' && input.email.trim()) {
+        claims[ClaimsPersonSchemaorg.email] = input.email.trim();
+    }
+    if (typeof input.role === 'string' && input.role.trim()) {
+        claims[ClaimsPersonSchemaorg.hasOccupationalRoleValue] = input.role.trim();
+    }
+    if (typeof input.worksFor === 'string' && input.worksFor.trim()) {
+        claims[ClaimsPersonSchemaorg.worksFor] = input.worksFor.trim();
+    }
+    if (typeof input.memberOf === 'string' && input.memberOf.trim()) {
+        claims[ClaimsPersonSchemaorg.memberOf] = input.memberOf.trim();
+    }
+    if (typeof input.memberOfOrgTaxId === 'string' && input.memberOfOrgTaxId.trim()) {
+        claims[ClaimsPersonSchemaorg.memberOfOrgTaxId] = input.memberOfOrgTaxId.trim();
+    }
+    return claims;
+}
+/**
+ * Builds a claims-first employee batch entry from the minimum semantic input.
+ *
+ * Callers only provide the operation method, employee claims, and optional
+ * resource id. The helper places claims in the canonical `resource.meta.claims`
+ * location and infers the business `type` internally.
+ */
+export function buildEmployeeBatchEntry(input) {
+    const claims = cloneClaims(input.claims);
+    const resourceType = input.resourceType || 'Employee';
+    return {
+        type: input.type || inferEmployeeEntryType(input.method),
+        request: { method: input.method },
+        resource: {
+            resourceType,
+            ...(input.resourceId ? { id: input.resourceId } : {}),
+            meta: { claims },
+        },
+    };
+}
+/**
+ * Builds a canonical employee `_batch` bundle from one or more employee batch
+ * entries.
+ */
+export function buildEmployeeBatchBundle(input) {
+    return {
+        resourceType: 'Bundle',
+        type: 'batch',
+        entry: [...input.entries].map((entry) => buildEmployeeBatchEntry(entry)),
+    };
+}
+/**
+ * Builds the legacy query-string employee search target kept for compatibility
+ * with older `_search` wrappers.
+ */
+export function buildEmployeeSearchQuery(input = {}) {
+    const resourceType = input.resourceType || 'Employee';
+    const query = buildSearchQueryString(normalizeEmployeeSearchClaims(input.claims));
+    return query ? `${resourceType}?${query}` : resourceType;
+}
+/**
+ * Builds a canonical employee search bundle.
+ *
+ * Defaults to `POST + Parameters`. Set `method` or `encoding` to legacy GET
+ * only when talking to older search consumers.
+ */
+export function buildEmployeeSearchBundle(input = {}) {
+    const resourceType = input.resourceType || 'Employee';
+    const claims = normalizeEmployeeSearchClaims(input.claims);
+    const method = input.method || (input.encoding === 'get-query' ? 'GET' : 'POST');
+    if (method === 'GET') {
+        return {
+            resourceType: 'Bundle',
+            type: 'batch',
+            entry: [
+                {
+                    request: {
+                        method: 'GET',
+                        url: buildEmployeeSearchQuery({ ...input, resourceType }),
+                    },
+                },
+            ],
+        };
+    }
+    return {
+        resourceType: 'Bundle',
+        type: 'batch',
+        entry: [
+            {
+                request: {
+                    method: 'POST',
+                    url: `${resourceType}/_search`,
+                },
+                resource: buildFhirParametersResourceFromSearchParams(claims),
+            },
+        ],
+    };
+}

package/dist/utils/fhir-search.d.ts

@@ -0,0 +1,26 @@
+import { ParameterData } from '../models/params';
+export type SearchParameterPrimitive = string | number | boolean | readonly (string | number | boolean)[];
+export type SearchRequestEncoding = 'get-query' | 'post-parameters';
+export type FhirParametersParameter = {
+    name: string;
+    valueString?: string;
+    valueCode?: string;
+    valueBoolean?: boolean;
+    valueInteger?: number;
+    valueDecimal?: number;
+    valueUri?: string;
+    valueReference?: {
+        reference: string;
+    };
+    valueCoding?: {
+        system?: string;
+        code: string;
+    };
+};
+export type FhirParametersResource = {
+    resourceType: 'Parameters';
+    parameter: FhirParametersParameter[];
+};
+export declare function buildSearchQueryString(searchParams: Readonly<Record<string, SearchParameterPrimitive | undefined>>): string;
+export declare function buildFhirParametersResourceFromSearchParams(searchParams: Readonly<Record<string, SearchParameterPrimitive | undefined>>): FhirParametersResource;
+export declare function buildFhirParametersResourceFromParameterData(parameters: ReadonlyArray<ParameterData>): FhirParametersResource;

package/dist/utils/fhir-search.js

@@ -0,0 +1,84 @@
+function normalizeSearchPrimitiveValues(value) {
+    const values = Array.isArray(value) ? [...value] : [value];
+    return values
+        .map((item) => typeof item === 'string' ? item.trim() : item)
+        .filter((item) => item !== '' && item !== undefined && item !== null);
+}
+function toPrimitiveString(value) {
+    return typeof value === 'string' ? value.trim() : String(value);
+}
+function toSearchParameter(name, value) {
+    if (typeof value === 'boolean') {
+        return { name, valueBoolean: value };
+    }
+    if (typeof value === 'number') {
+        return Number.isInteger(value)
+            ? { name, valueInteger: value }
+            : { name, valueDecimal: value };
+    }
+    return { name, valueString: value.trim() };
+}
+function flattenParameterDataValue(parameter) {
+    const name = String(parameter?.name || '').trim();
+    if (!name) {
+        return undefined;
+    }
+    if (parameter.type === 'reference') {
+        const reference = String(parameter.reference || parameter.value || '').trim();
+        return reference ? { name, valueReference: { reference } } : undefined;
+    }
+    if (parameter.type === 'token') {
+        const code = String(parameter.value || '').trim();
+        if (!code) {
+            return undefined;
+        }
+        return parameter.system
+            ? { name, valueCoding: { system: String(parameter.system).trim(), code } }
+            : { name, valueCode: code };
+    }
+    if (parameter.type === 'uri') {
+        const value = String(parameter.value || '').trim();
+        return value ? { name, valueUri: value } : undefined;
+    }
+    if (typeof parameter.value === 'number') {
+        return Number.isInteger(parameter.value)
+            ? { name, valueInteger: parameter.value }
+            : { name, valueDecimal: parameter.value };
+    }
+    const value = String(parameter.value || '').trim();
+    return value ? { name, valueString: value } : undefined;
+}
+export function buildSearchQueryString(searchParams) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(searchParams)) {
+        if (value === undefined || value === null)
+            continue;
+        const normalized = normalizeSearchPrimitiveValues(value);
+        if (normalized.length === 0)
+            continue;
+        params.set(key, normalized.map(toPrimitiveString).join(','));
+    }
+    return params.toString();
+}
+export function buildFhirParametersResourceFromSearchParams(searchParams) {
+    const parameter = [];
+    for (const [name, value] of Object.entries(searchParams)) {
+        if (value === undefined || value === null)
+            continue;
+        for (const item of normalizeSearchPrimitiveValues(value)) {
+            parameter.push(toSearchParameter(name, item));
+        }
+    }
+    return {
+        resourceType: 'Parameters',
+        parameter,
+    };
+}
+export function buildFhirParametersResourceFromParameterData(parameters) {
+    return {
+        resourceType: 'Parameters',
+        parameter: parameters
+            .map((parameter) => flattenParameterDataValue(parameter))
+            .filter((parameter) => Boolean(parameter)),
+    };
+}

package/dist/utils/index.d.ts

@@ -14,17 +14,19 @@ export * from './did-resolution';
 export * from './dataspace-discovery';
 export * from './dataspace-discovery-defaults';
 export * from './dataspace-protocol';
+export * from './employee';
 export * from './didcomm';
 export * from './didcomm-submit';
 export * from './didcomm-submit-policy';
 export * from './discovery-normalization';
 export * from './format-converter';
 export * from './fhir-cid';
+export * from './fhir-search';
 export * from './communication-fhir-r4';
 export * from './communication-document-reference';
 export * from './communication-bundle-document-request';
 export * from './communication-identity';
-export * from './communication-bundle-session';
+export * from './communication-attached-bundle-session';
 export * from './clinical-resource-converters';
 export * from './clinical-resource-view';
 export * from './fhir-validator';

package/dist/utils/index.js

@@ -14,17 +14,19 @@ export * from './did-resolution.js';
 export * from './dataspace-discovery.js';
 export * from './dataspace-discovery-defaults.js';
 export * from './dataspace-protocol.js';
+export * from './employee.js';
 export * from './didcomm.js';
 export * from './didcomm-submit.js';
 export * from './didcomm-submit-policy.js';
 export * from './discovery-normalization.js';
 export * from './format-converter.js';
 export * from './fhir-cid.js';
+export * from './fhir-search.js';
 export * from './communication-fhir-r4.js';
 export * from './communication-document-reference.js';
 export * from './communication-bundle-document-request.js';
 export * from './communication-identity.js';
-export * from './communication-bundle-session.js';
+export * from './communication-attached-bundle-session.js';
 export * from './clinical-resource-converters.js';
 export * from './clinical-resource-view.js';
 export * from './fhir-validator.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-common-utils-ts",
-  "version": "1.14.13",
+  "version": "1.14.15",
   "publishConfig": {
     "access": "public"
   },