gdc-common-utils-ts 1.14.2 → 1.14.3

package/README.md

@@ -111,6 +111,8 @@ Main entry points:
 - [`src/utils/dataspace-discovery-defaults.ts`](src/utils/dataspace-discovery-defaults.ts)
   - defaults registry for ICAs and hosting operators plus the backend
     `default-first` bootstrap plan used to unblock portal integration
+  - includes authority-based helpers so integrators can seed from a single
+    domain/IP instead of manually assembling `did:web` and discovery URLs
 - [`src/examples/dataspace-discovery.ts`](src/examples/dataspace-discovery.ts)
   - synthetic provider/operator examples that distinguish discovery URL from
     derived catalog artifact URL

package/dist/models/dataspace-discovery-defaults.d.ts

@@ -1,5 +1,5 @@
 import type { DataspaceDiscoverySourceModeValue } from '../constants/dataspace-discovery';
-import type { HostingOperatorSemanticRecord } from './dataspace-discovery';
+import type { HostingOperatorSemanticRecord, PublishedProviderCatalogRecord } from './dataspace-discovery';
 /**
  * Shared host/ICA context used to select dataspace discovery defaults.
  *
@@ -29,6 +29,7 @@ export type DefaultHostingOperatorRegistration = DataspaceDiscoveryNetworkContex
     discoveryUrl?: string;
     catalogUrl?: string;
     record: HostingOperatorSemanticRecord;
+    publishedProviders?: readonly PublishedProviderCatalogRecord[];
     title?: string;
 }>;
 /**

package/dist/utils/dataspace-discovery-defaults.d.ts

@@ -1,4 +1,68 @@
 import type { DataspaceDiscoveryBootstrapInput, DataspaceDiscoveryBootstrapPlan, DataspaceDiscoveryDefaultHostingFilter, DataspaceDiscoveryDefaultIcaFilter, DataspaceDiscoveryDefaultsRegistrySeed, DefaultHostingOperatorRegistration, DefaultIcaRegistration } from '../models/dataspace-discovery-defaults';
+import type { PublishedProviderCatalogRecord } from '../models/dataspace-discovery';
+export type BuildDefaultIcaRegistrationFromAuthorityInput = Readonly<{
+    authority: string;
+    jurisdiction: string;
+    version: string;
+    networkType: string;
+    title?: string;
+}>;
+export type BuildDefaultHostingOperatorRegistrationFromAuthorityInput = Readonly<{
+    authority: string;
+    jurisdiction: string;
+    version: string;
+    networkType: string;
+    sector: string;
+    serviceTypes: readonly string[];
+    title?: string;
+    areaServed?: readonly string[];
+    addressCountry?: string;
+    coverageScope?: string;
+}>;
+export type BuildDefaultPublishedProviderRecordFromTenantInput = Readonly<{
+    hostAuthority: string;
+    tenantId: string;
+    jurisdiction: string;
+    version: string;
+    sector: string;
+    providerCapability: string;
+    areaServed?: readonly string[];
+    /**
+     * Optional public domain for a future externally visible provider surface.
+     *
+     * For now most deployments will not use it, so the helper falls back to the
+     * hosted/internal tenant route under the hosting operator domain.
+     */
+    externalDomain?: string;
+}>;
+/**
+ * Builds one ICA default seed from a domain/IP authority.
+ *
+ * This helper exists so integrators do not have to handcraft:
+ * - the `did:web`
+ * - the well-known ICA URL
+ * - the repeated host/network context fields
+ */
+export declare function buildDefaultIcaRegistrationFromAuthority(input: BuildDefaultIcaRegistrationFromAuthorityInput): DefaultIcaRegistration;
+/**
+ * Builds one hosting-operator default seed from a domain/IP authority.
+ *
+ * This helper exists so integrators do not have to handcraft:
+ * - the `did:web`
+ * - the host-scoped DSP discovery URL
+ * - the semantic host record shape
+ */
+export declare function buildDefaultHostingOperatorRegistrationFromAuthority(input: BuildDefaultHostingOperatorRegistrationFromAuthorityInput): DefaultHostingOperatorRegistration;
+/**
+ * Builds one published-provider default entry from a tenant id under a given
+ * hosting operator authority.
+ *
+ * Integrator-friendly rule:
+ * - the backend usually knows `tenantId`
+ * - it usually does not want to handcraft the hosted/internal `did:web`
+ * - this helper derives the hosted provider DID and tenant-scoped DSP URLs
+ */
+export declare function buildDefaultPublishedProviderRecordFromTenant(input: BuildDefaultPublishedProviderRecordFromTenantInput): PublishedProviderCatalogRecord;
 /**
  * Mutable in-memory registry for discovery defaults used by portal/backend
  * bootstrap code.

package/dist/utils/dataspace-discovery-defaults.js

@@ -1,12 +1,57 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
 import { DataspaceDiscoverySourceMode, } from '../constants/dataspace-discovery.js';
+import { normalizeCountryCode } from '../constants/eu-countries.js';
+import { buildOrganizationDidWeb, getBaseUrlFromDidWeb } from './did.js';
 import { matchesHostingOperatorDiscoveryFilter } from './dataspace-discovery.js';
 function normalizeString(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
+function normalizeAuthority(value) {
+    const raw = normalizeString(value).replace(/\/+$/, '');
+    if (!raw)
+        return '';
+    if (/^https?:\/\//i.test(raw)) {
+        try {
+            return new URL(raw).host;
+        }
+        catch {
+            return raw.replace(/^https?:\/\//i, '');
+        }
+    }
+    return raw;
+}
+function getProtocolForAuthority(authority) {
+    const normalized = authority.trim().toLowerCase();
+    return normalized.startsWith('localhost')
+        || normalized.startsWith('127.0.0.1')
+        || normalized.startsWith('[::1]')
+        ? 'http'
+        : 'https';
+}
+function encodeDidWebAuthority(authority) {
+    return authority.replace(/:/g, '%3A').toLowerCase();
+}
+function buildDidWebFromAuthority(authority) {
+    return `did:web:${encodeDidWebAuthority(authority)}`;
+}
 function normalizeCapabilities(values) {
     return Array.from(new Set((values || []).map((value) => normalizeString(value)).filter(Boolean)));
 }
+function normalizePublishedProvider(input) {
+    return {
+        providerDid: normalizeString(input.providerDid),
+        serviceType: normalizeString(input.serviceType),
+        category: normalizeString(input.category),
+        areaServed: normalizeCapabilities(Array.isArray(input.areaServed)
+            ? input.areaServed
+            : normalizeString(input.areaServed)
+                ? normalizeString(input.areaServed).split(',')
+                : undefined).join(',') || undefined,
+        endpointUrl: normalizeString(input.endpointUrl) || undefined,
+        discoveryUrl: normalizeString(input.discoveryUrl) || undefined,
+        catalogUrl: normalizeString(input.catalogUrl) || undefined,
+    };
+}
 function normalizeIcaRegistration(input) {
     return {
         jurisdiction: normalizeString(input.jurisdiction),
@@ -34,6 +79,7 @@ function normalizeHostingOperatorRegistration(input) {
             addressCountry: normalizeString(input.record.addressCountry) || undefined,
             coverageScope: normalizeString(input.record.coverageScope) || undefined,
         },
+        publishedProviders: (input.publishedProviders || []).map((provider) => normalizePublishedProvider(provider)),
         title: normalizeString(input.title) || undefined,
     };
 }
@@ -46,6 +92,92 @@ function matchesNetworkContext(left, right) {
         return false;
     return true;
 }
+/**
+ * Builds one ICA default seed from a domain/IP authority.
+ *
+ * This helper exists so integrators do not have to handcraft:
+ * - the `did:web`
+ * - the well-known ICA URL
+ * - the repeated host/network context fields
+ */
+export function buildDefaultIcaRegistrationFromAuthority(input) {
+    const authority = normalizeAuthority(input.authority);
+    const protocol = getProtocolForAuthority(authority);
+    return normalizeIcaRegistration({
+        jurisdiction: input.jurisdiction,
+        version: input.version,
+        networkType: input.networkType,
+        title: input.title,
+        icaUrl: `${protocol}://${authority}/.well-known/ica-configuration`,
+        icaDid: buildDidWebFromAuthority(authority),
+    });
+}
+/**
+ * Builds one hosting-operator default seed from a domain/IP authority.
+ *
+ * This helper exists so integrators do not have to handcraft:
+ * - the `did:web`
+ * - the host-scoped DSP discovery URL
+ * - the semantic host record shape
+ */
+export function buildDefaultHostingOperatorRegistrationFromAuthority(input) {
+    const authority = normalizeAuthority(input.authority);
+    const protocol = getProtocolForAuthority(authority);
+    const addressCountry = normalizeCountryCode(input.addressCountry) || normalizeCountryCode(input.jurisdiction);
+    const coverageScope = normalizeString(input.coverageScope) || undefined;
+    const areaServed = Array.from(new Set((input.areaServed || [input.jurisdiction])
+        .map((value) => normalizeString(value))
+        .filter(Boolean)));
+    return normalizeHostingOperatorRegistration({
+        jurisdiction: input.jurisdiction,
+        version: input.version,
+        networkType: input.networkType,
+        title: input.title,
+        operatorDid: buildDidWebFromAuthority(authority),
+        discoveryUrl: `${protocol}://${authority}/host/cds-${input.jurisdiction}/${input.version}/${input.networkType}/.well-known/dspace-version`,
+        record: {
+            subjectId: buildDidWebFromAuthority(authority),
+            serviceTypes: [...input.serviceTypes],
+            categories: [normalizeString(input.sector)],
+            areaServed,
+            addressCountry: addressCountry || undefined,
+            coverageScope,
+        },
+    });
+}
+/**
+ * Builds one published-provider default entry from a tenant id under a given
+ * hosting operator authority.
+ *
+ * Integrator-friendly rule:
+ * - the backend usually knows `tenantId`
+ * - it usually does not want to handcraft the hosted/internal `did:web`
+ * - this helper derives the hosted provider DID and tenant-scoped DSP URLs
+ */
+export function buildDefaultPublishedProviderRecordFromTenant(input) {
+    const hostAuthority = normalizeAuthority(input.hostAuthority);
+    const hostDidWeb = buildDidWebFromAuthority(hostAuthority);
+    const providerDid = buildOrganizationDidWeb({
+        hostDidWeb,
+        tenantId: input.tenantId,
+        jurisdiction: input.jurisdiction,
+        version: input.version,
+        sector: input.sector,
+    });
+    const providerBaseUrl = normalizeAuthority(input.externalDomain)
+        ? `${getProtocolForAuthority(normalizeAuthority(input.externalDomain))}://${normalizeAuthority(input.externalDomain)}/`
+        : getBaseUrlFromDidWeb(providerDid);
+    const areaServed = normalizeCapabilities((input.areaServed || [input.jurisdiction]).map((value) => normalizeString(value))).join(',') || undefined;
+    return normalizePublishedProvider({
+        providerDid,
+        serviceType: input.providerCapability,
+        category: input.sector,
+        areaServed,
+        endpointUrl: providerBaseUrl,
+        discoveryUrl: new URL('.well-known/dspace-version', providerBaseUrl).toString(),
+        catalogUrl: new URL('dsp/catalog/dcat.json', providerBaseUrl).toString(),
+    });
+}
 /**
  * Mutable in-memory registry for discovery defaults used by portal/backend
  * bootstrap code.
@@ -133,6 +265,9 @@ export class DataspaceDiscoveryDefaultsRegistry {
                 categories: [...registration.record.categories],
                 areaServed: [...registration.record.areaServed],
             },
+            publishedProviders: (registration.publishedProviders || []).map((provider) => ({
+                ...provider,
+            })),
         }));
     }
     /**

package/package.json

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