vet-data-utils-ts 0.5.24 → 0.5.25

package/README.md

@@ -211,6 +211,9 @@ Federation 1.0 trust anchors and OpenID4VP 1.0 presentation definitions;
 catalogue exchange remains Dataspace Protocol 2025-1. X.509/TLS chain
 validation, federation trust resolution, VP verification and catalogue
 authorization are separate checks performed by their owning adapters.
+`normalizeHealthDcatResource()` rejects unknown or nested index claims, while
+`projectHealthDcatResourceToJsonLd()` is the explicit standards serialization
+boundary used by host/dataspace adapters.
 
 `vet-data-utils-ts/organization-application` is the product-neutral application
 value used by UHC UNID, VetChain and SOSChain adapters. The host supplies the

package/dist/health-dcat.d.ts

@@ -38,6 +38,11 @@ export declare enum ClaimsHealthDcatCatalog {
     dataset = "dcat.dataset",
     userSelected = "Catalog.user-selected"
 }
+/** Complete allowlist for product-persisted HealthDCAT flat claims. */
+export declare const HealthDcatFlatClaimCatalog: Readonly<{
+    readonly Dataset: readonly ClaimsHealthDcatDataset[];
+    readonly Catalog: readonly ClaimsHealthDcatCatalog[];
+}>;
 export type HealthDcatResource = Readonly<{
     resourceType: 'Dataset' | 'Catalog';
     id: string;
@@ -45,6 +50,10 @@ export type HealthDcatResource = Readonly<{
         claims: Readonly<Record<string, ClaimValue>>;
     }>;
 }>;
+/** Validates an indexed HealthDCAT resource and rejects nested or unknown claims. */
+export declare function normalizeHealthDcatResource(candidate: unknown): HealthDcatResource;
+/** Explicitly projects internal flat claims to DCAT/HealthDCAT JSON-LD. */
+export declare function projectHealthDcatResourceToJsonLd(resource: unknown): Readonly<Record<string, unknown>>;
 type ControllerAuthority = Readonly<{
     organizationIdentifier: string;
     controllerIdentifier: string;

package/dist/health-dcat.js

@@ -41,6 +41,86 @@ export var ClaimsHealthDcatCatalog;
     ClaimsHealthDcatCatalog["dataset"] = "dcat.dataset";
     ClaimsHealthDcatCatalog["userSelected"] = "Catalog.user-selected";
 })(ClaimsHealthDcatCatalog || (ClaimsHealthDcatCatalog = {}));
+/** Complete allowlist for product-persisted HealthDCAT flat claims. */
+export const HealthDcatFlatClaimCatalog = Object.freeze({
+    Dataset: Object.freeze(Object.values(ClaimsHealthDcatDataset)),
+    Catalog: Object.freeze(Object.values(ClaimsHealthDcatCatalog)),
+});
+/** Validates an indexed HealthDCAT resource and rejects nested or unknown claims. */
+export function normalizeHealthDcatResource(candidate) {
+    if (!candidate || typeof candidate !== 'object')
+        throw new TypeError('health_dcat_resource_invalid');
+    const value = candidate;
+    if (value.resourceType !== 'Dataset' && value.resourceType !== 'Catalog')
+        throw new TypeError('health_dcat_resource_invalid');
+    if (typeof value.id !== 'string' || !value.id.trim())
+        throw new TypeError('health_dcat_resource_invalid');
+    if (!value.meta || typeof value.meta !== 'object' || Array.isArray(value.meta))
+        throw new TypeError('health_dcat_resource_invalid');
+    const claims = value.meta.claims;
+    if (!claims || typeof claims !== 'object' || Array.isArray(claims))
+        throw new TypeError('health_dcat_resource_invalid');
+    const allowed = HealthDcatFlatClaimCatalog[value.resourceType];
+    const normalized = {};
+    for (const [claim, raw] of Object.entries(claims)) {
+        if (!allowed.includes(claim))
+            throw new TypeError(`health_dcat_claim_not_governed:${claim}`);
+        if (typeof raw === 'string' || typeof raw === 'boolean' || typeof raw === 'number')
+            normalized[claim] = raw;
+        else if (Array.isArray(raw) && raw.every(item => typeof item === 'string'))
+            normalized[claim] = Object.freeze([...raw]);
+        else
+            throw new TypeError(`health_dcat_claim_value_invalid:${claim}`);
+    }
+    return Object.freeze({
+        resourceType: value.resourceType,
+        id: value.id,
+        meta: Object.freeze({ claims: Object.freeze(normalized) }),
+    });
+}
+const JsonLdClaimNames = Object.freeze({
+    [ClaimsHealthDcatDataset.identifier]: 'dct:identifier',
+    [ClaimsHealthDcatDataset.title]: 'dct:title',
+    [ClaimsHealthDcatDataset.description]: 'dct:description',
+    [ClaimsHealthDcatDataset.creator]: 'dct:creator',
+    [ClaimsHealthDcatDataset.publisher]: 'dct:publisher',
+    [ClaimsHealthDcatDataset.custodian]: 'geodcatap:custodian',
+    [ClaimsHealthDcatDataset.accessRights]: 'dct:accessRights',
+    [ClaimsHealthDcatDataset.applicableLegislation]: 'dcatap:applicableLegislation',
+    [ClaimsHealthDcatDataset.distribution]: 'dcat:distribution',
+    [ClaimsHealthDcatDataset.source]: 'dct:source',
+    [ClaimsHealthDcatDataset.provenance]: 'dct:provenance',
+    [ClaimsHealthDcatDataset.personalData]: 'dpv:hasPersonalData',
+    [ClaimsHealthDcatDataset.healthCategory]: 'healthdcatap:healthCategory',
+    [ClaimsHealthDcatDataset.healthDataAccessBody]: 'healthdcatap:hdab',
+    [ClaimsHealthDcatDataset.structuredData]: 'healthdcatap:hasStructuredData',
+    [ClaimsHealthDcatDataset.variables]: 'healthdcatap:hasVariables',
+    [ClaimsHealthDcatDataset.authorizationReference]: 'prov:qualifiedAttribution',
+    [ClaimsHealthDcatCatalog.dataset]: 'dcat:dataset',
+});
+/** Explicitly projects internal flat claims to DCAT/HealthDCAT JSON-LD. */
+export function projectHealthDcatResourceToJsonLd(resource) {
+    const normalized = normalizeHealthDcatResource(resource);
+    const output = {
+        '@context': Object.freeze({
+            dcat: 'http://www.w3.org/ns/dcat#',
+            dct: 'http://purl.org/dc/terms/',
+            dcatap: 'http://data.europa.eu/r5r/',
+            geodcatap: 'http://data.europa.eu/930/',
+            healthdcatap: 'http://healthdataportal.eu/ns/health#',
+            dpv: 'https://w3id.org/dpv#',
+            prov: 'http://www.w3.org/ns/prov#',
+        }),
+        '@id': normalized.id,
+        '@type': normalized.resourceType === 'Catalog' ? 'dcat:Catalog' : 'dcat:Dataset',
+    };
+    for (const [claim, value] of Object.entries(normalized.meta.claims)) {
+        const jsonLdName = JsonLdClaimNames[claim];
+        if (jsonLdName)
+            output[jsonLdName] = value;
+    }
+    return Object.freeze(output);
+}
 function required(value, field) {
     const normalized = value.trim();
     if (!normalized)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vet-data-utils-ts",
-  "version": "0.5.24",
+  "version": "0.5.25",
   "description": "Browser-safe governed VetChain data contracts",
   "license": "Apache-2.0",
   "author": "Connecting Solution & Applications Ltd",