vet-sdk-core-ts 0.4.33 → 0.4.35

package/README.md

@@ -14,6 +14,18 @@ UHC SDK packages and must not import them.
 The SDK consumes governed browser-safe values from `vet-data-utils-ts` and
 owns gateway request construction. GW VET remains the policy authority.
 
+`vet-sdk-core-ts/health-dcat` provides the neutral manager for tenant-owned
+HealthDCAT metadata. It publishes and searches claims-first resources, asks an
+ICA adapter for host catalogue capabilities, and sends explicit controller
+federation requests. GW authentication, OpenID Federation trust resolution,
+OpenID4VP verification and Dataspace Protocol exchange stay in injected
+transports; the SDK neither exposes tenant inventories through ICA nor treats
+the host as the tenant publisher.
+Study publication writes the derived Dataset and its `CatalogRecord` together.
+Withdrawal updates only that record to `archived`; it does not delete or alter
+the ResearchStudy, eligibility/team Groups, ResearchSubjects or data-access
+classification.
+
 ## Veterinary scheduling bundles
 
 The `vet-sdk-core-ts/scheduling` entrypoint extends the generic GW bundle

package/dist/health-dcat.d.ts

@@ -0,0 +1,65 @@
+import { buildCatalogHostAdvertisement, buildHealthDcatFederationRequest, buildResearchStudyDatasetPublication, updateHealthDcatCatalogRecordStatus, type HealthDcatResource } from 'vet-data-utils-ts/health-dcat';
+export type HealthDcatResourceType = HealthDcatResource['resourceType'];
+export type HealthDcatBatchMethod = 'POST' | 'PUT';
+/** Builds a claims-first HealthDCAT batch accepted by a product GW adapter. */
+export declare function buildHealthDcatBatch(resources: readonly unknown[], method?: HealthDcatBatchMethod): Readonly<{
+    data: readonly Readonly<{
+        type: "Dataset-health-dcat" | "Catalog-health-dcat" | "CatalogRecord-health-dcat" | "Distribution-health-dcat" | "DataService-health-dcat";
+        resource: Readonly<{
+            resourceType: "Dataset" | "Catalog" | "CatalogRecord" | "Distribution" | "DataService";
+            id: string;
+            meta: Readonly<{
+                claims: Readonly<Record<string, string | number | boolean | readonly string[]>>;
+            }>;
+        }>;
+        request: Readonly<{
+            method: HealthDcatBatchMethod;
+            url: `Dataset/${string}` | `Catalog/${string}` | `CatalogRecord/${string}` | `Distribution/${string}` | `DataService/${string}`;
+        }>;
+    }>[];
+}>;
+/** Builds a governed flat-claim search without projecting JSON-LD in the client. */
+export declare function buildHealthDcatSearch(resourceType: HealthDcatResourceType, claims?: Readonly<Record<string, unknown>>): Readonly<{
+    data: readonly Readonly<{
+        resource: Readonly<{
+            resourceType: "Dataset" | "Catalog" | "CatalogRecord" | "Distribution" | "DataService";
+            id: string;
+            meta: Readonly<{
+                claims: Readonly<Record<string, string | number | boolean | readonly string[]>>;
+            }>;
+        }>;
+    }>[];
+}>;
+export type HealthDcatCatalogRequest = Readonly<{
+    operation: 'batch';
+    envelope: ReturnType<typeof buildHealthDcatBatch>;
+} | {
+    operation: 'search';
+    resourceType: HealthDcatResourceType;
+    envelope: ReturnType<typeof buildHealthDcatSearch>;
+} | {
+    operation: 'discover-hosts';
+} | {
+    operation: 'federate';
+    request: ReturnType<typeof buildHealthDcatFederationRequest>;
+}>;
+export type HealthDcatCatalogTransport = Readonly<{
+    execute(request: HealthDcatCatalogRequest): Promise<unknown>;
+}>;
+/**
+ * Neutral manager for tenant-owned HealthDCAT catalogues. Authentication,
+ * ICA resolution, OpenID Federation, OpenID4VP and DSP exchange remain in the
+ * injected host transport.
+ */
+export declare class HealthDcatCatalogManager {
+    #private;
+    constructor(transport: HealthDcatCatalogTransport);
+    publish(resources: readonly unknown[], method?: HealthDcatBatchMethod): Promise<unknown>;
+    search(resourceType: HealthDcatResourceType, claims?: Readonly<Record<string, unknown>>): Promise<readonly HealthDcatResource[]>;
+    discoverHosts(): Promise<readonly ReturnType<typeof buildCatalogHostAdvertisement>[]>;
+    federate(input: Parameters<typeof buildHealthDcatFederationRequest>[0]): Promise<unknown>;
+    /** Publishes a study-derived Dataset and its editorial record atomically in one batch. */
+    publishResearchStudyDataset(input: Parameters<typeof buildResearchStudyDatasetPublication>[0]): Promise<ReturnType<typeof buildResearchStudyDatasetPublication>>;
+    /** Updates only the CatalogRecord status; the ResearchStudy and Dataset remain intact. */
+    setResearchStudyDatasetPublicationStatus(input: Parameters<typeof updateHealthDcatCatalogRecordStatus>[0]): Promise<HealthDcatResource>;
+}

package/dist/health-dcat.js

@@ -0,0 +1,103 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _HealthDcatCatalogManager_transport;
+import { buildCatalogHostAdvertisement, buildHealthDcatFederationRequest, buildResearchStudyDatasetPublication, updateHealthDcatCatalogRecordStatus, normalizeHealthDcatResource, } from 'vet-data-utils-ts/health-dcat';
+/** Builds a claims-first HealthDCAT batch accepted by a product GW adapter. */
+export function buildHealthDcatBatch(resources, method = 'POST') {
+    return Object.freeze({ data: Object.freeze(resources.map(candidate => {
+            const resource = normalizeHealthDcatResource(candidate);
+            return Object.freeze({
+                type: `${resource.resourceType}-health-dcat`,
+                resource,
+                request: Object.freeze({ method, url: `${resource.resourceType}/${resource.id}` }),
+            });
+        })) });
+}
+/** Builds a governed flat-claim search without projecting JSON-LD in the client. */
+export function buildHealthDcatSearch(resourceType, claims = {}) {
+    const resource = normalizeHealthDcatResource({ resourceType, id: 'search', meta: { claims } });
+    return Object.freeze({ data: Object.freeze([Object.freeze({ resource })]) });
+}
+/**
+ * Neutral manager for tenant-owned HealthDCAT catalogues. Authentication,
+ * ICA resolution, OpenID Federation, OpenID4VP and DSP exchange remain in the
+ * injected host transport.
+ */
+export class HealthDcatCatalogManager {
+    constructor(transport) {
+        _HealthDcatCatalogManager_transport.set(this, void 0);
+        if (!transport || typeof transport.execute !== 'function')
+            throw new TypeError('health_dcat_transport_invalid');
+        __classPrivateFieldSet(this, _HealthDcatCatalogManager_transport, transport, "f");
+    }
+    async publish(resources, method = 'POST') {
+        const envelope = buildHealthDcatBatch(resources, method);
+        if (!envelope.data.length)
+            throw new TypeError('health_dcat_resources_required');
+        return __classPrivateFieldGet(this, _HealthDcatCatalogManager_transport, "f").execute(Object.freeze({ operation: 'batch', envelope }));
+    }
+    async search(resourceType, claims = {}) {
+        const envelope = buildHealthDcatSearch(resourceType, claims);
+        const response = await __classPrivateFieldGet(this, _HealthDcatCatalogManager_transport, "f").execute(Object.freeze({ operation: 'search', resourceType, envelope }));
+        const body = responseBody(response);
+        if (!body || typeof body !== 'object' || !Array.isArray(body.data))
+            throw new TypeError('health_dcat_search_invalid');
+        return Object.freeze(body.data.map(entry => {
+            if (!entry || typeof entry !== 'object' || !('resource' in entry))
+                throw new TypeError('health_dcat_search_invalid');
+            const resource = normalizeHealthDcatResource(entry.resource);
+            if (resource.resourceType !== resourceType)
+                throw new TypeError('health_dcat_search_invalid');
+            return resource;
+        }));
+    }
+    async discoverHosts() {
+        const response = await __classPrivateFieldGet(this, _HealthDcatCatalogManager_transport, "f").execute(Object.freeze({ operation: 'discover-hosts' }));
+        const body = responseBody(response);
+        if (!body || typeof body !== 'object' || !Array.isArray(body.data))
+            throw new TypeError('catalog_host_discovery_invalid');
+        return Object.freeze(body.data.map(candidate => {
+            if (!candidate || typeof candidate !== 'object')
+                throw new TypeError('catalog_host_discovery_invalid');
+            const value = candidate;
+            if (value.catalogProtocol !== 'dataspace-protocol-2025-1')
+                throw new TypeError('catalog_host_discovery_invalid');
+            return buildCatalogHostAdvertisement({
+                hostIdentifier: String(value.hostIdentifier ?? ''),
+                catalogEndpoint: String(value.catalogEndpoint ?? ''),
+                tenantDiscovery: value.tenantDiscovery === 'public' ? 'public' : 'openid4vp',
+            });
+        }));
+    }
+    async federate(input) {
+        const request = buildHealthDcatFederationRequest(input);
+        return __classPrivateFieldGet(this, _HealthDcatCatalogManager_transport, "f").execute(Object.freeze({ operation: 'federate', request }));
+    }
+    /** Publishes a study-derived Dataset and its editorial record atomically in one batch. */
+    async publishResearchStudyDataset(input) {
+        const publication = buildResearchStudyDatasetPublication(input);
+        await __classPrivateFieldGet(this, _HealthDcatCatalogManager_transport, "f").execute(Object.freeze({ operation: 'batch', envelope: buildHealthDcatBatch([publication.dataset, publication.record]) }));
+        return publication;
+    }
+    /** Updates only the CatalogRecord status; the ResearchStudy and Dataset remain intact. */
+    async setResearchStudyDatasetPublicationStatus(input) {
+        const record = updateHealthDcatCatalogRecordStatus(input);
+        await __classPrivateFieldGet(this, _HealthDcatCatalogManager_transport, "f").execute(Object.freeze({ operation: 'batch', envelope: buildHealthDcatBatch([record], 'PUT') }));
+        return record;
+    }
+}
+_HealthDcatCatalogManager_transport = new WeakMap();
+function responseBody(value) {
+    if (value && typeof value === 'object' && 'body' in value)
+        return value.body;
+    return value;
+}

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export * from "./reusable-bff.js";
 export * from "./research-study.js";
 export * from "./payment.js";
 export * from "./place-service-directory.js";
+export * from "./health-dcat.js";
 export * from "./health-card-issuance.js";
 export * from "./secure-clinic-channel.js";
 export * from "./scheduling.js";

package/dist/index.js

@@ -7,6 +7,7 @@ export * from "./reusable-bff.js";
 export * from "./research-study.js";
 export * from "./payment.js";
 export * from "./place-service-directory.js";
+export * from "./health-dcat.js";
 export * from "./health-card-issuance.js";
 export * from "./secure-clinic-channel.js";
 export * from "./scheduling.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vet-sdk-core-ts",
-  "version": "0.4.33",
+  "version": "0.4.35",
   "description": "Browser-safe VetChain core contracts and governed animal species identifiers",
   "license": "Apache-2.0",
   "author": "Connecting Solution & Applications Ltd",
@@ -48,6 +48,10 @@
       "types": "./dist/place-service-directory.d.ts",
       "default": "./dist/place-service-directory.js"
     },
+    "./health-dcat": {
+      "types": "./dist/health-dcat.d.ts",
+      "default": "./dist/health-dcat.js"
+    },
     "./health-card-issuance": {
       "types": "./dist/health-card-issuance.d.ts",
       "default": "./dist/health-card-issuance.js"
@@ -85,6 +89,6 @@
     "@noble/hashes": "^2.2.0",
     "@noble/post-quantum": "0.5.4",
     "gdc-common-utils-ts": "2.9.10",
-    "vet-data-utils-ts": "0.5.22"
+    "vet-data-utils-ts": "0.5.26"
   }
 }