gdc-sdk-node-ts 0.6.3 → 0.6.4

package/dist/discovery/DefaultFirstDataspaceDiscovery.d.ts

@@ -35,6 +35,8 @@ export declare class DefaultFirstDataspaceDiscovery {
     getDigitalTwinProviders(input: SimpleDataspaceDiscoveryRequest): Promise<PublishedProviderMatch[]>;
     private getProviders;
     private createResolver;
+    private buildBootstrapPlan;
+    private resolveDefaultPublishedProviders;
 }
 /**
  * Convenience factory for the default-first portal/backend discovery facade.

package/dist/discovery/DefaultFirstDataspaceDiscovery.js

@@ -1,9 +1,57 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
-import { DataspaceDiscoverySourceMode, ServiceCapabilityToken, createDataspaceDiscoveryDefaultsRegistry, DataspaceProtocolVersions, } from 'gdc-common-utils-ts';
+import { DataspaceCoverageScope, DataspaceDiscoverySourceMode, ServiceCapabilityToken, createDataspaceDiscoveryDefaultsRegistry, DataspaceProtocolVersions, inferCoverageScopeFromCountryCode, isProviderServiceCapability, normalizeCountryCode, } from 'gdc-common-utils-ts';
 import { HttpDataspaceResolver } from './HttpDataspaceResolver.js';
 function normalizeString(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
+function equalsIgnoreCase(left, right) {
+    return left.trim().toLowerCase() === right.trim().toLowerCase();
+}
+function splitTokens(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => normalizeString(entry)).filter(Boolean);
+    }
+    const raw = normalizeString(value);
+    if (!raw)
+        return [];
+    return raw.split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+function buildCoverageTokens(areaServed, filterJurisdiction) {
+    const tokens = new Set(splitTokens(areaServed).map((token) => token.toUpperCase()));
+    const normalizedJurisdiction = normalizeCountryCode(filterJurisdiction);
+    if (normalizedJurisdiction) {
+        const inferred = inferCoverageScopeFromCountryCode(normalizedJurisdiction);
+        if (inferred)
+            tokens.add(inferred.toUpperCase());
+    }
+    return tokens;
+}
+function matchesProviderCoverage(provider, jurisdiction, coverageScope) {
+    const normalizedJurisdiction = normalizeCountryCode(jurisdiction);
+    const normalizedCoverageScope = normalizeString(coverageScope).toUpperCase();
+    if (!normalizedJurisdiction && !normalizedCoverageScope)
+        return true;
+    const tokens = buildCoverageTokens(provider.areaServed, jurisdiction);
+    if (normalizedJurisdiction && tokens.has(normalizedJurisdiction))
+        return true;
+    if (normalizedCoverageScope && tokens.has(normalizedCoverageScope))
+        return true;
+    if (normalizedCoverageScope === DataspaceCoverageScope.EuropeanUnion) {
+        return Array.from(tokens).some((token) => inferCoverageScopeFromCountryCode(token) === DataspaceCoverageScope.EuropeanUnion);
+    }
+    return false;
+}
+function matchesDefaultPublishedProvider(provider, input, providerCapability) {
+    if (!equalsIgnoreCase(provider.category, input.sector))
+        return false;
+    if (!isProviderServiceCapability(provider.serviceType))
+        return false;
+    if (!equalsIgnoreCase(provider.serviceType, providerCapability))
+        return false;
+    if (!matchesProviderCoverage(provider, input.jurisdiction, input.coverageScope))
+        return false;
+    return true;
+}
 function isDefaultsRegistry(value) {
     return Boolean(value)
         && typeof value === 'object'
@@ -60,7 +108,15 @@ export class DefaultFirstDataspaceDiscovery {
         return this.getProviders(input, ServiceCapabilityToken.DigitalTwinProvider);
     }
     async getProviders(input, providerCapability) {
-        const resolver = this.createResolver(input, [providerCapability]);
+        const bootstrapPlan = this.buildBootstrapPlan(input, [providerCapability]);
+        const defaultPublishedProviders = this.resolveDefaultPublishedProviders(bootstrapPlan.hostingOperators, input, providerCapability);
+        if (defaultPublishedProviders.length > 0) {
+            return defaultPublishedProviders;
+        }
+        const resolver = new HttpDataspaceResolver({
+            hostingOperators: bootstrapPlan.hostingOperators,
+            fetcher: this.fetcher,
+        });
         return resolver.resolvePublishedProviders({
             sector: input.sector,
             jurisdiction: input.jurisdiction,
@@ -69,7 +125,14 @@ export class DefaultFirstDataspaceDiscovery {
         });
     }
     createResolver(input, requiredCapabilities) {
-        const bootstrapPlan = this.defaultsRegistry.buildBootstrapPlan({
+        const bootstrapPlan = this.buildBootstrapPlan(input, requiredCapabilities);
+        return new HttpDataspaceResolver({
+            hostingOperators: bootstrapPlan.hostingOperators,
+            fetcher: this.fetcher,
+        });
+    }
+    buildBootstrapPlan(input, requiredCapabilities) {
+        return this.defaultsRegistry.buildBootstrapPlan({
             jurisdiction: input.jurisdiction,
             version: this.version,
             networkType: this.networkType,
@@ -78,10 +141,18 @@ export class DefaultFirstDataspaceDiscovery {
             requiredCapabilities,
             sourceMode: DataspaceDiscoverySourceMode.DefaultFirst,
         });
-        return new HttpDataspaceResolver({
-            hostingOperators: bootstrapPlan.hostingOperators,
-            fetcher: this.fetcher,
-        });
+    }
+    resolveDefaultPublishedProviders(hosts, input, providerCapability) {
+        return hosts.flatMap((host) => (host.publishedProviders || [])
+            .filter((provider) => matchesDefaultPublishedProvider(provider, input, providerCapability))
+            .map((provider) => ({
+            providerDid: provider.providerDid,
+            record: provider,
+            hostingOperator: host.record,
+            hostingOperatorDid: host.operatorDid,
+            discoveryUrl: provider.discoveryUrl || host.discoveryUrl,
+            catalogUrl: provider.catalogUrl || host.catalogUrl,
+        })));
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-sdk-node-ts",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "Next-generation Node runtime package for the GDC SDK family",
   "license": "Apache-2.0",
   "author": "Antifraud Services Inc.",
@@ -17,7 +17,7 @@
     "test:e2e:live-gw": "npm run build && RUN_LIVE_GW_E2E=1 node --test tests/live-gw-node-runtime.e2e.test.mjs"
   },
   "dependencies": {
-    "gdc-common-utils-ts": "^1.14.2",
+    "gdc-common-utils-ts": "file:../gdc-common-utils-ts",
     "gdc-sdk-core-ts": "^0.6.3"
   },
   "devDependencies": {