@twin.org/dataspace-control-plane-service 0.0.3-next.49 → 0.0.3-next.51

package/dist/es/dataspaceControlPlaneService.js

@@ -10,6 +10,7 @@ import { ComparisonOperator } from "@twin.org/entity";
 import { EntityStorageConnectorFactory } from "@twin.org/entity-storage-models";
 import { OdrlPolicyHelper, PolicyRequesterFactory } from "@twin.org/rights-management-models";
 import { DataspaceProtocolContexts, DataspaceProtocolContractNegotiationTypes, DataspaceProtocolEndpointType, DataspaceProtocolHelper, DataspaceProtocolTransferProcessStateType, DataspaceProtocolTransferProcessTypes } from "@twin.org/standards-dataspace-protocol";
+import { OdrlPolicyType } from "@twin.org/standards-w3c-odrl";
 import { MetricHelper } from "@twin.org/telemetry-models";
 import { TrustHelper } from "@twin.org/trust-models";
 import { DataspaceControlPlanePolicyRequester } from "./dataspaceControlPlanePolicyRequester.js";
@@ -174,7 +175,7 @@ export class DataspaceControlPlaneService {
             ? StringHelper.trimLeadingAndTrailingSlashes(options.config.callbackPath)
             : undefined;
         this._taskScheduler = ComponentFactory.getIfExists(options?.taskSchedulerComponentType ?? "task-scheduler");
-        this._platformComponent = ComponentFactory.getIfExists(options?.platformComponentType ?? "platform");
+        this._platformComponent = ComponentFactory.get(options?.platformComponentType ?? "platform");
         this._telemetryComponent = ComponentFactory.getIfExists(options?.telemetryComponentType);
         // Data plane component is optional and resolved lazily. The control plane is initialised
         // BEFORE the data plane in engine startup order, so `getRegisteredInstanceTypeOptional`
@@ -265,7 +266,7 @@ export class DataspaceControlPlaneService {
         let totalDatasets = 0;
         // The platform component execute is used so that the dataset publication runs in the
         // tenant context, also works in single tenant mode
-        await this._platformComponent?.execute(async () => {
+        await this._platformComponent.execute(async () => {
             // The tenant context id is set here for each system tenant
             let cursor;
             do {
@@ -1295,7 +1296,7 @@ export class DataspaceControlPlaneService {
      * @param offerId The offer ID from the provider's catalog.
      * @param providerEndpoint The provider's contract negotiation endpoint URL.
      * @param trustPayload The trust payload for authentication.
-     * @returns The negotiation ID. Use the registered callback for completion notification.
+     * @returns For implicit trust: `{ agreementId }`. For external negotiation: `{ negotiationId }`.
      */
     async negotiateAgreement(datasetId, offerId, providerEndpoint, trustPayload) {
         Guards.stringValue(DataspaceControlPlaneService.CLASS_NAME, "datasetId", datasetId);
@@ -1375,6 +1376,9 @@ export class DataspaceControlPlaneService {
                 offerType: getJsonLdType(matchingOffer)
             }
         });
+        if (trustInfo.identity === organizationId) {
+            return this.negotiateImplicitTrustAgreement(organizationId, datasetId);
+        }
         const negotiationId = await this._policyNegotiationPointComponent.sendRequestToProvider(providerEndpoint, DataspaceControlPlaneService._REQUESTER_TYPE, offerId, publicOrigin);
         if (!negotiationId) {
             throw new GeneralError(DataspaceControlPlaneService.CLASS_NAME, "negotiationInitiationFailed", {
@@ -1866,6 +1870,29 @@ export class DataspaceControlPlaneService {
             });
         }
     }
+    /**
+     * Resolve the control-plane component for the given URL and invoke an action with it. When the
+     * URL maps to a local origin the action runs against this instance inside that origin's context
+     * (avoiding HTTP serialisation). Otherwise the action runs against a remote REST client. Falls
+     * back to remote when no platform component is available or the locality check throws.
+     * @param url The endpoint URL to resolve.
+     * @param action The action to run with the resolved component.
+     * @returns The result of the action.
+     * @internal
+     */
+    async withControlPlaneComponent(url, action) {
+        try {
+            const localContext = await this._platformComponent.getLocalOriginContext(url);
+            if (!Is.empty(localContext)) {
+                return await ContextIdStore.run(localContext, async () => action(this));
+            }
+        }
+        catch {
+            // Fall back to remote component if locality check throws
+        }
+        const remoteComponent = ComponentFactory.create(this._remoteControlPlaneComponentType, { endpoint: url, pathPrefix: "" });
+        return action(remoteComponent);
+    }
     /**
      * Deliver a transfer state-change DSP message to the consumer's callback (provider → consumer), via a
      * remote control-plane client and the supplied sender. Mirrors negotiation's sendOfferToConsumer.
@@ -1891,8 +1918,7 @@ export class DataspaceControlPlaneService {
                     agreementId: entity.agreementId
                 }
             });
-            const remoteControlPlane = ComponentFactory.create(this._remoteControlPlaneComponentType, { endpoint: entity.callbackAddress, pathPrefix: "" });
-            const result = await send(remoteControlPlane, outboundToken);
+            const result = await this.withControlPlaneComponent(entity.callbackAddress, async (component) => send(component, outboundToken));
             if (getJsonLdType(result) === DataspaceProtocolTransferProcessTypes.TransferError) {
                 await this._loggingComponent?.log({
                     level: "error",
@@ -2488,5 +2514,67 @@ export class DataspaceControlPlaneService {
         const contextIds = await ContextIdStore.getContextIds();
         return contextIds?.[ContextIdKeys.Tenant];
     }
+    /**
+     * Return an existing full-access agreement for the same-organization (implicit trust) case,
+     * or create and store one if none exists. Fires onFinalized on all registered callbacks in
+     * both cases.
+     * @param organizationId The local organization ID (both assigner and assignee).
+     * @param datasetId The dataset being granted access to.
+     * @returns The agreement ID.
+     * @internal
+     */
+    async negotiateImplicitTrustAgreement(organizationId, datasetId) {
+        const { policies } = await this._policyAdministrationPointComponent.query({
+            type: OdrlPolicyType.Agreement,
+            assigner: organizationId,
+            assignee: organizationId,
+            target: datasetId
+        });
+        let agreementId;
+        if (policies.length > 0) {
+            agreementId = OdrlPolicyHelper.getUid(policies[0]);
+            await this._loggingComponent?.log({
+                level: "info",
+                source: DataspaceControlPlaneService.CLASS_NAME,
+                ts: Date.now(),
+                message: "implicitTrustAgreementReused",
+                data: { agreementId, datasetId, organizationId }
+            });
+        }
+        else {
+            const implicitAgreement = {
+                "@context": "http://www.w3.org/ns/odrl.jsonld",
+                "@type": "Agreement",
+                assigner: organizationId,
+                assignee: organizationId,
+                target: datasetId,
+                permission: [{ action: "use" }]
+            };
+            agreementId = await this._policyAdministrationPointComponent.create(implicitAgreement);
+            await MetricHelper.metricIncrement(this._telemetryComponent, DataspaceControlPlaneMetricIds.NegotiationsInitiated);
+            await this._loggingComponent?.log({
+                level: "info",
+                source: DataspaceControlPlaneService.CLASS_NAME,
+                ts: Date.now(),
+                message: "implicitTrustAgreementCreated",
+                data: { agreementId, datasetId, organizationId }
+            });
+        }
+        for (const [key, cb] of this._negotiationCallbacks.entries()) {
+            try {
+                await cb.onFinalized(undefined, agreementId);
+            }
+            catch (error) {
+                await this._loggingComponent?.log({
+                    level: "error",
+                    source: DataspaceControlPlaneService.CLASS_NAME,
+                    ts: Date.now(),
+                    message: "negotiationCallbackError",
+                    data: { key, negotiationId: agreementId, method: "onFinalized", error }
+                });
+            }
+        }
+        return { agreementId };
+    }
 }
 //# sourceMappingURL=dataspaceControlPlaneService.js.map