@twin.org/federated-catalogue-service 0.0.3-next.2 → 0.0.3-next.21

package/dist/es/services/federatedCatalogueService.js

@@ -1,14 +1,19 @@
 // Copyright 2025 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
-import { BaseError, Converter, GeneralError, Guards, Is, NotFoundError, ObjectHelper } from "@twin.org/core";
+import { HttpUrlHelper } from "@twin.org/api-models";
+import { ContextIdKeys } from "@twin.org/context";
+import { ArrayHelper, BaseError, ComponentFactory, Converter, GeneralError, Guards, Is, JsonHelper, Mutex, NotFoundError, ObjectHelper, Url, Urn, Validation } from "@twin.org/core";
 import { Blake2b } from "@twin.org/crypto";
-import { JsonLdProcessor } from "@twin.org/data-json-ld";
+import { JsonLdHelper, JsonLdProcessor } from "@twin.org/data-json-ld";
 import { EntityStorageConnectorFactory } from "@twin.org/entity-storage-models";
-import { FederatedCatalogueContexts, FederatedCatalogueFilterFactory } from "@twin.org/federated-catalogue-models";
-import { DataspaceProtocolContexts, DataspaceProtocolDataTypes } from "@twin.org/standards-dataspace-protocol";
+import { FederatedCatalogueFilterFactory } from "@twin.org/federated-catalogue-models";
+import { DataspaceProtocolCatalogTypes, DataspaceProtocolContexts, DataspaceProtocolDataTypes, DataspaceProtocolHelper } from "@twin.org/standards-dataspace-protocol";
 import { DublinCoreContexts, DublinCoreDataTypes } from "@twin.org/standards-dublin-core";
 import { FoafDataTypes } from "@twin.org/standards-foaf";
-import { DcatClasses, DcatContexts, DcatDataTypes } from "@twin.org/standards-w3c-dcat";
+import { DcatContexts, DcatDataTypes } from "@twin.org/standards-w3c-dcat";
+import { OdrlContexts } from "@twin.org/standards-w3c-odrl";
+import { TrustHelper } from "@twin.org/trust-models";
+import { transformToCatalogError } from "../utils/catalogErrorUtils.js";
 import { datasetEntityToModel, datasetModelToEntity } from "../utils/datasetConverters.js";
 /**
  * Service for managing federated catalogue operations.
@@ -29,18 +34,26 @@ export class FederatedCatalogueService {
      * @internal
      */
     _datasetStorage;
+    /**
+     * The trust component for token verification and generation.
+     * @internal
+     */
+    _trustComponent;
     /**
      * Create a new instance of FederatedCatalogueService.
      * @param options The options for the service.
      */
     constructor(options) {
-        this._logging = options?.loggingComponent;
-        this._datasetStorage = EntityStorageConnectorFactory.get(options?.datasetStorageConnectorType ?? "dataset");
+        this._logging = ComponentFactory.getIfExists(options?.loggingComponentType);
+        this._datasetStorage = EntityStorageConnectorFactory.get(options?.datasetEntityStorageType ?? "dataset");
+        this._trustComponent = ComponentFactory.get(options?.trustComponentType ?? "trust");
         // Register JSON-LD redirects for offline processing
         DcatDataTypes.registerRedirects();
         DublinCoreDataTypes.registerRedirects();
         FoafDataTypes.registerRedirects();
         DataspaceProtocolDataTypes.registerRedirects();
+        // Register DS Protocol data types for conformance checking
+        DataspaceProtocolDataTypes.registerTypes();
     }
     /**
      * Returns the class name of the component.
@@ -51,168 +64,368 @@ export class FederatedCatalogueService {
     }
     /**
      * Retrieve a dataset by its unique identifier.
-     * @param dataSetId The unique identifier of the dataset.
-     * @returns The dataset if found.
-     * @throws NotFoundError if the dataset does not exist.
+     * @param datasetId The unique identifier of the dataset.
+     * @param trustPayload Optional payload for trust evaluation, if applicable.
+     * @returns The dataset if found, or a CatalogError if not found or an error occurs.
      */
-    async get(dataSetId) {
-        Guards.stringValue(FederatedCatalogueService.CLASS_NAME, "dataSetId", dataSetId);
-        await this._logging?.log({
-            level: "info",
-            source: FederatedCatalogueService.CLASS_NAME,
-            ts: Date.now(),
-            message: "datasetRetrieve",
-            data: { dataSetId }
-        });
-        const datasetEntity = await this._datasetStorage.get(dataSetId);
-        if (!datasetEntity) {
-            throw new NotFoundError(FederatedCatalogueService.CLASS_NAME, "datasetNotFound", dataSetId);
+    async get(datasetId, trustPayload) {
+        try {
+            Guards.stringValue(FederatedCatalogueService.CLASS_NAME, "datasetId", datasetId);
+            await TrustHelper.verifyTrust(this._trustComponent, trustPayload, "get");
+            await this._logging?.log({
+                level: "info",
+                source: FederatedCatalogueService.CLASS_NAME,
+                ts: Date.now(),
+                message: "datasetRetrieve",
+                data: { datasetId }
+            });
+            const datasetEntity = await this._datasetStorage.get(datasetId);
+            if (!datasetEntity) {
+                throw new NotFoundError(FederatedCatalogueService.CLASS_NAME, "datasetNotFound", datasetId);
+            }
+            const dataset = datasetEntityToModel(datasetEntity);
+            // Normalize to DS Protocol compliant format
+            // This ensures the payload matches exactly what the DS Protocol mandates
+            const normalizedDataset = await DataspaceProtocolHelper.normalize(JsonLdHelper.toNodeObject(dataset));
+            const structured = JsonLdHelper.toStructuredObject(normalizedDataset);
+            return structured;
+        }
+        catch (error) {
+            return transformToCatalogError(error);
         }
-        return datasetEntityToModel(datasetEntity);
     }
     /**
      * Insert or update a dataset in the catalogue.
-     * This method is internal and should not be exposed via REST endpoints.
-     * @param dataSet The dataset to store.
+     * @param dataset The dataset to store.
+     * @param trustPayload Optional payload for trust evaluation, if applicable.
+     * @returns The unique identifier of the stored dataset, or a CatalogError if an error occurs.
      */
-    async set(dataSet) {
-        Guards.object(FederatedCatalogueService.CLASS_NAME, "dataSet", dataSet);
-        const dataSetId = dataSet["@id"] ?? dataSet["dcterms:identifier"];
-        Guards.stringValue(FederatedCatalogueService.CLASS_NAME, "dataSetId", dataSetId);
-        await this._logging?.log({
-            level: "info",
-            source: FederatedCatalogueService.CLASS_NAME,
-            ts: Date.now(),
-            message: "datasetSet",
-            data: { dataSetId }
-        });
-        const datasetEntity = datasetModelToEntity(dataSet);
-        const allIndexes = {};
-        const filterNames = FederatedCatalogueFilterFactory.names();
-        for (const filterType of filterNames) {
+    async set(dataset, trustPayload) {
+        try {
+            Guards.object(FederatedCatalogueService.CLASS_NAME, "dataset", dataset);
+            const trustInfo = await TrustHelper.verifyTrust(this._trustComponent, trustPayload, "set");
+            // Normalize @id from dcterms:identifier if provided
+            const datasetId = dataset["@id"] ?? dataset["dcterms:identifier"];
+            Guards.stringValue(FederatedCatalogueService.CLASS_NAME, "datasetId", datasetId);
+            // Set @id if it was derived from dcterms:identifier
+            if (Is.empty(dataset["@id"]) && !Is.empty(dataset["dcterms:identifier"])) {
+                dataset["@id"] = datasetId;
+            }
+            // Validate @id is a valid URI (URN or URL) per DS Protocol
+            const isValidUrn = !Is.empty(Urn.tryParseExact(datasetId));
+            const isValidUrl = !Is.empty(Url.tryParseExact(datasetId));
+            if (!isValidUrn && !isValidUrl) {
+                throw new GeneralError(FederatedCatalogueService.CLASS_NAME, "datasetIdInvalidUri", {
+                    datasetId
+                });
+            }
+            // Validate @type exists
+            Guards.stringValue(FederatedCatalogueService.CLASS_NAME, "@type", dataset["@type"]);
+            // Validate dcterms:publisher exists (required for multi-participant catalog)
+            // The publisher is used to derive participantId when returning catalog query results
+            const publisher = dataset["dcterms:publisher"];
+            if (Is.empty(publisher)) {
+                throw new GeneralError(FederatedCatalogueService.CLASS_NAME, "datasetMissingPublisher", {
+                    datasetId
+                });
+            }
+            // DS Protocol compliance validation
+            const validationFailures = await DataspaceProtocolHelper.validate(JsonLdHelper.toNodeObject(dataset));
+            Validation.asValidationError(FederatedCatalogueService.CLASS_NAME, "dataset", validationFailures);
+            // Normalize dataset for storage using JSON-LD compaction
+            // This ensures the dataset uses prefixed properties that entity storage expects
+            // Entity storage schema uses DCAT-prefixed properties (dcat:distribution, not distribution)
+            // Use a standard context with prefixes to ensure proper normalization
+            const storageContext = {
+                dcat: DcatContexts.Namespace,
+                dcterms: DublinCoreContexts.NamespaceTerms,
+                odrl: OdrlContexts.Namespace
+            };
+            const normalizedDataset = await JsonLdProcessor.compact(dataset, storageContext);
+            const datasetEntity = datasetModelToEntity(normalizedDataset, trustInfo.identity);
+            // Serialise the read-check-write cycle so concurrent requests for the
+            // same dataset cannot both pass the ownership check and overwrite each other.
+            await Mutex.lock(datasetId);
             try {
-                const filter = FederatedCatalogueFilterFactory.get(filterType);
-                const filterIndexes = await filter.createIndex(dataSet);
-                allIndexes[filterType] = filterIndexes;
+                const existingEntity = await this._datasetStorage.get(datasetId);
+                if (!Is.empty(existingEntity) && existingEntity.ownerId !== trustInfo.identity) {
+                    throw new GeneralError(FederatedCatalogueService.CLASS_NAME, "datasetOwnerMismatch", {
+                        datasetId
+                    });
+                }
+                // Bake the publishing organization into distribution accessService URLs
+                await this.bakeOrganizationIntoDistributions(datasetEntity, trustInfo.identity);
                 await this._logging?.log({
                     level: "info",
                     source: FederatedCatalogueService.CLASS_NAME,
                     ts: Date.now(),
-                    message: "filterIndexPersisted",
-                    data: { dataSetId, filterType, indexCount: Object.keys(filterIndexes).length }
+                    message: "datasetSet",
+                    data: { datasetId }
                 });
+                const filterNames = FederatedCatalogueFilterFactory.names();
+                for (const filterType of filterNames) {
+                    try {
+                        const filter = FederatedCatalogueFilterFactory.get(filterType);
+                        const filterIndexes = await filter.createIndex(normalizedDataset);
+                        await this._logging?.log({
+                            level: "info",
+                            source: FederatedCatalogueService.CLASS_NAME,
+                            ts: Date.now(),
+                            message: "filterIndexPersisted",
+                            data: { datasetId, filterType, indexCount: Object.keys(filterIndexes).length }
+                        });
+                    }
+                    catch (error) {
+                        await this._logging?.log({
+                            level: "error",
+                            source: FederatedCatalogueService.CLASS_NAME,
+                            ts: Date.now(),
+                            message: "filterIndexCreationFailed",
+                            data: { datasetId, filterType },
+                            error: BaseError.fromError(error)
+                        });
+                    }
+                }
+                await this._datasetStorage.set(datasetEntity);
+                return datasetId;
             }
-            catch (error) {
+            finally {
+                Mutex.unlock(datasetId);
+            }
+        }
+        catch (error) {
+            return transformToCatalogError(error);
+        }
+    }
+    /**
+     * Remove a dataset from the catalogue by its unique identifier.
+     * Indexes are automatically removed as they are stored with the dataset.
+     * @param datasetId The unique identifier of the dataset to remove.
+     * @param trustPayload Optional payload for trust evaluation, if applicable.
+     * @returns Nothing, or a CatalogError if an error occurs.
+     */
+    async remove(datasetId, trustPayload) {
+        try {
+            Guards.stringValue(FederatedCatalogueService.CLASS_NAME, "datasetId", datasetId);
+            const trustInfo = await TrustHelper.verifyTrust(this._trustComponent, trustPayload, "remove");
+            await Mutex.lock(datasetId);
+            try {
+                const existingEntity = await this._datasetStorage.get(datasetId);
+                if (!Is.empty(existingEntity) && existingEntity.ownerId !== trustInfo.identity) {
+                    throw new GeneralError(FederatedCatalogueService.CLASS_NAME, "datasetRemoveNotOwner", {
+                        datasetId
+                    });
+                }
                 await this._logging?.log({
-                    level: "error",
+                    level: "info",
                     source: FederatedCatalogueService.CLASS_NAME,
                     ts: Date.now(),
-                    message: "filterIndexCreationFailed",
-                    data: { dataSetId, filterType },
-                    error: BaseError.fromError(error)
+                    message: "datasetRemove",
+                    data: { datasetId }
                 });
+                await this._datasetStorage.remove(datasetId);
+            }
+            finally {
+                Mutex.unlock(datasetId);
             }
         }
-        await this._datasetStorage.set(datasetEntity);
+        catch (error) {
+            return transformToCatalogError(error);
+        }
     }
     /**
      * Execute a query against the catalogue using registered filter plugins.
-     * Returns a complete DCAT Catalog object with proper JSON-LD context, metadata, and datasets.
-     * The filter payload is evaluated by the appropriate filter plugin based on its structure.
-     * Pagination properties (cursor, limit) and filter type (@type) are extracted from the filter object.
+     * Returns a DS Protocol compliant Catalog object with participantId.
+     *
+     * The root catalog's participantId is the requesting participant (from context).
+     * Own datasets (matching requestingParticipantId) go directly in root dataset[].
+     * Other participants' datasets are grouped in nested catalog[] entries.
+     *
+     * For anonymous requests (no context), uses the first publisher found as fallback.
+     * Returns CatalogError 404 when no datasets exist, CatalogError 400 for invalid requests.
+     *
      * @param filter The filter criteria containing @type, optional cursor and limit properties.
-     * @returns Complete ICatalog object with @context, @id, @type, dcat:dataset, and optional cursor.
-     * @throws NotFoundError if @type is missing or if the filter type is not registered.
+     * @param cursor Optional cursor for pagination.
+     * @param limit Optional limit for pagination.
+     * @param trustPayload Optional payload for trust evaluation, if applicable.
+     * @returns Complete IDataspaceProtocolCatalog with @context, @id, @type, participantId, dataset/catalog,
+     * or CatalogError if validation fails or an error occurs.
      */
-    async query(filter) {
-        let datasets;
-        let resultCursor;
-        const isArray = Is.array(filter);
-        if (!filter || (isArray && filter.length === 0)) {
-            const result = await this._datasetStorage.query();
-            datasets = result.entities.map(entity => datasetEntityToModel(entity));
-        }
-        else if (isArray && filter.length > 1) {
-            throw new GeneralError(FederatedCatalogueService.CLASS_NAME, "multipleFiltersNotSupported");
-        }
-        else {
-            const singleFilter = filter[0];
-            const cursor = singleFilter?.cursor;
-            const limit = singleFilter?.limit;
-            const filterType = singleFilter?.["@type"];
+    async query(filter, cursor, limit, trustPayload) {
+        try {
+            const trustInfo = await TrustHelper.verifyTrust(this._trustComponent, trustPayload, "query");
+            let datasets;
+            let resultCursor;
+            if (!Is.empty(filter) && !Is.array(filter)) {
+                throw new GeneralError(FederatedCatalogueService.CLASS_NAME, "filterMustBeArray");
+            }
+            if (!Is.arrayValue(filter)) {
+                const result = await this._datasetStorage.query(undefined, undefined, undefined, cursor, limit);
+                datasets = result.entities.map(entity => datasetEntityToModel(entity));
+                resultCursor = result.cursor;
+            }
+            else if (filter.length > 1) {
+                throw new GeneralError(FederatedCatalogueService.CLASS_NAME, "multipleFiltersNotSupported");
+            }
+            else {
+                const singleFilter = filter[0];
+                const filterType = singleFilter?.["@type"];
+                await this._logging?.log({
+                    level: "info",
+                    source: FederatedCatalogueService.CLASS_NAME,
+                    ts: Date.now(),
+                    message: "catalogQuery",
+                    data: { filterType: filterType ?? "", cursor: cursor ?? "", limit: limit ?? "" }
+                });
+                Guards.stringValue(FederatedCatalogueService.CLASS_NAME, "filterType", filterType);
+                const selectedFilter = FederatedCatalogueFilterFactory.get(filterType);
+                ObjectHelper.propertyDelete(filter, "@type");
+                const result = await selectedFilter.query(trustInfo, filter, cursor, limit);
+                datasets = result.datasets;
+                resultCursor = result.cursor;
+            }
             await this._logging?.log({
                 level: "info",
                 source: FederatedCatalogueService.CLASS_NAME,
                 ts: Date.now(),
-                message: "catalogQuery",
-                data: { filterType: filterType ?? "", cursor: cursor ?? "", limit: limit ?? "" }
+                message: "catalogQueryComplete",
+                data: { resultCount: datasets.length, hasMore: Is.stringValue(resultCursor) }
             });
-            Guards.stringValue(FederatedCatalogueService.CLASS_NAME, "filterType", filterType);
-            const selectedFilter = FederatedCatalogueFilterFactory.get(filterType);
-            ObjectHelper.propertyDelete(filter, "cursor");
-            ObjectHelper.propertyDelete(filter, "limit");
-            ObjectHelper.propertyDelete(filter, "@type");
-            const result = await selectedFilter.query(filter);
-            datasets = result.datasets;
-            resultCursor = result.cursor;
+            // Return CatalogError 404 when no datasets exist
+            if (!Is.arrayValue(datasets)) {
+                throw new NotFoundError(FederatedCatalogueService.CLASS_NAME, "noDatasetsFound");
+            }
+            let requestingParticipantId = trustInfo.identity;
+            // Group datasets by dcterms:publisher (participantId)
+            const datasetsByParticipant = new Map();
+            for (const dataset of datasets) {
+                const publisher = this.extractPublisher(dataset);
+                const participantId = publisher ?? "unknown";
+                const existing = datasetsByParticipant.get(participantId) ?? [];
+                existing.push(dataset);
+                datasetsByParticipant.set(participantId, existing);
+            }
+            const participantIds = [...datasetsByParticipant.keys()];
+            // For anonymous requests (no context), use first publisher as fallback
+            if (!Is.stringValue(requestingParticipantId)) {
+                requestingParticipantId = participantIds[0] ?? "unknown";
+            }
+            // Separate own datasets from other participants' datasets
+            const ownDatasets = datasetsByParticipant.get(requestingParticipantId) ?? [];
+            const otherParticipantIds = participantIds.filter(id => id !== requestingParticipantId);
+            let catalog;
+            if (!Is.arrayValue(otherParticipantIds)) {
+                // Only own datasets (or all datasets belong to requesting participant)
+                const catalogId = this.generateCatalogId(ownDatasets, requestingParticipantId);
+                catalog = {
+                    "@context": [DataspaceProtocolContexts.Context],
+                    "@id": catalogId,
+                    "@type": DataspaceProtocolCatalogTypes.Catalog,
+                    participantId: requestingParticipantId,
+                    dataset: ownDatasets
+                };
+            }
+            else {
+                // Mixed: own datasets at root level, others in nested catalogs
+                const nestedCatalogs = [];
+                for (const participantId of otherParticipantIds) {
+                    const participantDatasets = datasetsByParticipant.get(participantId) ?? [];
+                    const subCatalogId = this.generateCatalogId(participantDatasets, participantId);
+                    const subCatalog = {
+                        "@context": [DataspaceProtocolContexts.Context],
+                        "@id": subCatalogId,
+                        "@type": DataspaceProtocolCatalogTypes.Catalog,
+                        participantId,
+                        dataset: participantDatasets
+                    };
+                    nestedCatalogs.push(subCatalog);
+                }
+                // Root catalog contains own datasets and nested catalogs for others
+                const rootCatalogId = this.generateCatalogId(datasets, requestingParticipantId);
+                catalog = {
+                    "@context": [DataspaceProtocolContexts.Context],
+                    "@id": rootCatalogId,
+                    "@type": DataspaceProtocolCatalogTypes.Catalog,
+                    participantId: requestingParticipantId,
+                    dataset: ownDatasets,
+                    catalog: nestedCatalogs
+                };
+            }
+            // Normalize to DS Protocol compliant format
+            // This ensures the payload matches exactly what the DS Protocol mandates
+            const normalizedCatalog = await DataspaceProtocolHelper.normalize(JsonLdHelper.toNodeObject(catalog));
+            const structuredResult = JsonLdHelper.toStructuredObject(normalizedCatalog);
+            return {
+                result: structuredResult,
+                cursor: resultCursor
+            };
         }
-        await this._logging?.log({
-            level: "info",
-            source: FederatedCatalogueService.CLASS_NAME,
-            ts: Date.now(),
-            message: "catalogQueryComplete",
-            data: { resultCount: datasets.length, hasMore: Is.stringValue(resultCursor) }
-        });
-        // Generate deterministic catalog ID using canonical hash of dataset IDs
-        // Sort dataset IDs to ensure consistent ordering
+        catch (error) {
+            return {
+                result: transformToCatalogError(error)
+            };
+        }
+    }
+    /**
+     * Extract publisher from dataset.
+     * Publisher can be a string or an IFoafAgent object with @id.
+     * @param dataset The dataset to extract publisher from.
+     * @returns The publisher string or undefined if not found.
+     * @internal
+     */
+    extractPublisher(dataset) {
+        const publisher = dataset["dcterms:publisher"];
+        // Handle case where publisher is an object with @id (IFoafAgent)
+        if (Is.object(publisher)) {
+            const publisherId = publisher["@id"];
+            return Is.stringValue(publisherId) ? publisherId : undefined;
+        }
+        return Is.stringValue(publisher) ? publisher : undefined;
+    }
+    /**
+     * Bake the publishing organization token into each distribution's accessService URL.
+     * @param entity The dataset entity to modify in place.
+     * @param organizationId The publishing organization id to bake.
+     * @internal
+     */
+    async bakeOrganizationIntoDistributions(entity, organizationId) {
+        // Storage uses the prefixed JSON-LD key "dcat:accessService" (not the unprefixed
+        // "accessService" that appears in compacted query responses).
+        const distributions = ArrayHelper.fromObjectOrArray(entity["dcat:distribution"]) ?? [];
+        for (const dist of distributions) {
+            const accessService = dist?.["dcat:accessService"];
+            if (Is.stringValue(accessService)) {
+                dist["dcat:accessService"] = HttpUrlHelper.addQueryStringParam(accessService, ContextIdKeys.Organization, organizationId);
+            }
+            else if (Is.objectValue(accessService)) {
+                // DCAT object form: a dcat:DataService with an endpointURL.
+                const dataService = accessService;
+                if (Is.stringValue(dataService["dcat:endpointURL"])) {
+                    dataService["dcat:endpointURL"] = HttpUrlHelper.addQueryStringParam(dataService["dcat:endpointURL"], ContextIdKeys.Organization, organizationId);
+                }
+            }
+        }
+    }
+    /**
+     * Generate a deterministic catalog ID using canonical hash.
+     * @param datasets The datasets to include in the hash.
+     * @param participantId The participant ID to include in the hash.
+     * @returns A URN-formatted catalog ID.
+     * @internal
+     */
+    generateCatalogId(datasets, participantId) {
         const datasetIds = datasets
             .map(d => d["@id"])
             .filter(id => Is.stringValue(id))
             .sort();
-        // Create deterministic representation for hashing
-        const canonicalContent = JSON.stringify({
-            "@type": DcatClasses.Catalog,
+        const canonicalContent = JsonHelper.canonicalize({
+            "@type": DataspaceProtocolCatalogTypes.Catalog,
+            participantId,
             datasets: datasetIds
         });
         const canonicalBytes = Converter.utf8ToBytes(canonicalContent);
         const catalogHash = Converter.bytesToHex(Blake2b.sum256(canonicalBytes));
-        const catalogId = `urn:x-catalog:${catalogHash}`;
-        // Return complete catalog with deterministic ID
-        const catalog = {
-            "@context": [
-                DataspaceProtocolContexts.ContextRoot,
-                {
-                    dcat: DcatContexts.ContextRoot,
-                    dcterms: DublinCoreContexts.ContextTerms,
-                    cursor: `${FederatedCatalogueContexts.ContextRoot}cursor`
-                }
-            ],
-            "@id": catalogId,
-            "@type": DcatClasses.Catalog,
-            "dcat:dataset": datasets
-        };
-        if (resultCursor) {
-            catalog.cursor = resultCursor;
-        }
-        // Apply JSON-LD compaction to ensure proper context handling
-        const compactedCatalog = await JsonLdProcessor.compact(catalog, catalog["@context"]);
-        return compactedCatalog;
-    }
-    /**
-     * Remove a dataset from the catalogue by its unique identifier.
-     * Indexes are automatically removed as they are stored with the dataset.
-     * @param dataSetId The unique identifier of the dataset to remove.
-     */
-    async remove(dataSetId) {
-        Guards.stringValue(FederatedCatalogueService.CLASS_NAME, "dataSetId", dataSetId);
-        await this._logging?.log({
-            level: "info",
-            source: FederatedCatalogueService.CLASS_NAME,
-            ts: Date.now(),
-            message: "datasetRemove",
-            data: { dataSetId }
-        });
-        await this._datasetStorage.remove(dataSetId);
+        return `urn:x-catalog:${catalogHash}`;
     }
 }
 //# sourceMappingURL=federatedCatalogueService.js.map