@startinblox/components-ds4go 4.1.1 → 4.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startinblox/components-ds4go",
-  "version": "4.1.1",
+  "version": "4.1.3",
   "description": "Startin'blox DS4GO",
   "main": "dist/index.js",
   "type": "module",

package/src/components/solid-dsp-connector.ts

@@ -58,6 +58,131 @@ export class SolidDspConnector extends OrbitDSPComponent {
       this.loadContracts(),
       this.loadNegotiations(),
     ]);
+
+    // Ensure to load assets from other providers when agreement does exists
+    await this.forceLoadAllAssets();
+  }
+
+  @state()
+  agreements: (ContractAgreement & { contract?: ContractNegotiation })[] = [];
+
+  // IMPROVEME: allows Consumer connector to load assets from other providers
+  private async forceLoadAllAssets() {
+    if (!this.storeService) {
+      console.error("Store not initialized. Check connector configuration.");
+      return;
+    }
+
+    try {
+      await Promise.all(
+        this.negotiations.map(async (n: ContractNegotiation) => {
+          if (n.contractAgreementId) {
+            const agreement = await this.loadAgreement(n["@id"]);
+            if (agreement && !this.agreements.find(a => a["@id"] === agreement["@id"])) {
+              this.agreements.push(agreement);
+            }
+          }
+        }),
+      );
+
+      const consumerAgreements = this.agreements.filter(
+        (a: ContractAgreement) => {
+          if (!a.consumerId) return false;
+          const consumerParticipantId = a.consumerId.split("/").pop();
+          if (!this.participantId) {
+            throw new Error("Participant ID not set");
+          }
+          return consumerParticipantId?.startsWith(this.participantId);
+        },
+      );
+
+      const assets: Promise<Response>[] = [];
+      for (const agreement of consumerAgreements) {
+        if (!this.assets.find((asset) => asset["@id"] === agreement.assetId)) {
+          for (const provider of this.providers) {
+            assets.push(
+              fetch(
+                `${provider.address.replace("/protocol", "")}/management/v3/assets/${agreement.assetId}`,
+              ),
+            );
+          }
+        }
+      }
+
+      const assetResponses = await Promise.all(assets);
+      this.assets = [
+        ...this.assets,
+        ...(await Promise.all(
+          assetResponses
+            .filter((r: Response) => r.status === 200)
+            .map((r) => r.json()),
+        )),
+      ];
+    } catch (e) {
+      console.error(`Failed to get all assets from all providers:`, e);
+    }
+  }
+
+  private async getAgreementForResource(resourceUrl: string) {
+    if (!this.storeService) {
+      console.error("Store not initialized. Check connector configuration.");
+      return;
+    }
+
+    try {
+      const relatedAsset = this.assets.find(
+        (asset) => asset.dataAddress?.baseUrl === resourceUrl,
+      );
+
+      if (!relatedAsset) {
+        throw new Error(`No asset found for resource ${resourceUrl}`);
+      }
+
+      const relatedAgreement = this.agreements.find(
+        (n) => n.assetId === relatedAsset["@id"],
+      );
+
+      if (!relatedAgreement) {
+        throw new Error(`No agreement found for asset ${relatedAsset["@id"]}`);
+      }
+
+      return relatedAgreement;
+    } catch (e) {
+      console.error(`Failed to get agreement ID for ${resourceUrl}:`, e);
+    }
+  }
+
+  public async fetchProtectedResource(resourceUrl: string) {
+    if (!this.storeService) {
+      console.error("Store not initialized. Check connector configuration.");
+      return;
+    }
+
+    try {
+      const relatedAgreement = await this.getAgreementForResource(resourceUrl);
+
+      if (!relatedAgreement) {
+        throw new Error(`No agreement found for resource ${resourceUrl}`);
+      }
+
+      const relatedNegotiation = this.negotiations.find(
+        (n) => n.contractAgreementId === relatedAgreement?.["@id"],
+      );
+
+      if (!relatedNegotiation) {
+        throw new Error(`No negotiation found for resource ${resourceUrl}`);
+      }
+
+      return await this.storeService.fetchProtectedResource(
+        resourceUrl,
+        this.participantId,
+        this.participantConnectorUri,
+        relatedNegotiation.counterPartyAddress,
+        relatedNegotiation.contractAgreementId,
+      );
+    } catch (e) {
+      console.error(`Failed to load ${resourceUrl}:`, e);
+    }
   }
 
   @state()

package/src/components/solid-fact-list.ts

@@ -118,25 +118,32 @@ export class SolidFactList extends OrbitComponent {
             },
           );
 
-          const assets: Asset[] = [];
+          const bundles = [];
           for (const agreement of consumerAgreements) {
-            const asset = this.dspConnector?.instance?.getAsset(
-              agreement.assetId,
+            const asset = this.dspConnector?.instance?.assets.find(
+              (a: Asset) => a["@id"] === agreement.assetId,
             );
-            assets.push(asset);
-          }
 
-          const bundles = [];
-          for (const asset of await Promise.all(assets)) {
-            const bundleUrl = asset?.dataAddress?.baseUrl;
-            if (bundleUrl) {
-              bundles.push(this._getProxyValue(bundleUrl));
+            if (asset) {
+              const bundleUrl = asset?.dataAddress?.baseUrl;
+              if (bundleUrl) {
+                // FIXME: Getting 403 when calling a provider with agreement id from consumer
+                // bundles.push(
+                //   this.dspConnector.instance.fetchProtectedResource(bundleUrl),
+                // );
+                // Temp workaround, using ldp store to bypass the issue
+                bundles.push(bundleUrl);
+              }
             }
           }
 
+          const fetchedBundles = (await Promise.all(bundles)).map((bundle) =>
+            this._getProxyValue(bundle),
+          );
+
           const facts = Array.from(
             new Set(
-              (await Promise.all(bundles))
+              (await Promise.all(fetchedBundles))
                 .flatMap((bundle: any) => bundle?.facts || [])
                 .map((fact: Fact) => fact["@id"]),
             ),