@startinblox/components-ds4go 3.3.8 → 4.1.0

package/src/ds4go.d.ts

@@ -1,7 +1,10 @@
 import type { LimitedResource } from "@src/component";
 
 export interface FactBundle extends LimitedResource {
-  "@type"?: "ds4go:FactBundle" | "ldp:Container" | ["ldp:Container", "ds4go:FactBundle"];
+  "@type"?:
+    | "ds4go:FactBundle"
+    | "ldp:Container"
+    | ["ldp:Container", "ds4go:FactBundle"];
   name?: string;
   category?: string;
   description?: string;
@@ -43,3 +46,77 @@ export interface Media extends LimitedResource {
   file_type?: string;
   description?: string;
 }
+
+// ODRL Policy types
+export interface ODRLPolicy {
+  "@id"?: string;
+  "@type"?: string;
+  "odrl:permission"?: ODRLPermission | ODRLPermission[];
+  "odrl:prohibition"?: ODRLProhibition | ODRLProhibition[];
+  "odrl:obligation"?: ODRLDuty | ODRLDuty[];
+  target?: string;
+  assigner?: string;
+}
+
+export interface ODRLPermission {
+  "odrl:action"?: ODRLAction | string;
+  "odrl:constraint"?: ODRLConstraint | ODRLConstraint[];
+}
+
+export interface ODRLProhibition {
+  "odrl:action"?: ODRLAction | string;
+}
+
+export interface ODRLDuty {
+  "odrl:action"?: ODRLAction | string;
+}
+
+export interface ODRLAction {
+  "@id"?: string;
+}
+
+export interface ODRLConstraint {
+  "odrl:leftOperand"?: string;
+  "odrl:operator"?: string;
+  "odrl:rightOperand"?: string;
+}
+
+export interface DcatDistribution {
+  "@type": string;
+  "dct:format": DctFormat;
+  "dcat:accessService": DcatAccessService;
+}
+
+export interface DSPProviderConfig {
+  name: string;
+  address: string;
+  color?: string;
+  participantId?: string;
+}
+
+export interface DSPOffer extends LimitedResource {
+  "@id"?: string;
+  "@type"?: "dcat:Dataset" | "tems:Service";
+  "odrl:hasPolicy"?: ODRLPolicy;
+  "dcat:distribution"?: DcatDistribution[];
+  category?: string;
+  "dcat:endpointUrl"?: string;
+  name?: string;
+  pricingTier?: string;
+  description?: string;
+  "dct:language"?: string;
+  id?: string;
+  contenttype?: string;
+  bundleSize?: number;
+  previewLinks?: string;
+  _provider?: DSPProviderConfig;
+}
+
+export interface AgreementInfo {
+  contractId: string;
+  negotiationId: string;
+  timestamp: number;
+  assetId: string;
+  providerId: string;
+  providerAddress: string;
+}

package/src/helpers/dsp/agreementStorage.ts

@@ -0,0 +1,243 @@
+import { DSPContractStorage } from "@startinblox/solid-tems-shared";
+import type { AgreementInfo, DSPOffer } from "@src/ds4go";
+
+/**
+ * Get localStorage key for an asset
+ * Uses combination of provider ID and dataset ID for uniqueness across providers
+ */
+export function getStorageKey(offer: DSPOffer): string {
+  const datasetId = offer["@id"] || offer.id;
+  const providerId = offer._provider?.participantId || "";
+
+  if (!datasetId) return "";
+
+  // Create composite key: provider-assetId
+  const key = providerId
+    ? `dsp-agreement-${providerId}-${datasetId}`
+    : `dsp-agreement-${datasetId}`;
+  return key;
+}
+
+/**
+ * Save agreement info to localStorage
+ */
+export function saveAgreementInfo(
+  offer: DSPOffer,
+  contractId: string,
+  negotiationId: string,
+  timestamp: number,
+): void {
+  const key = getStorageKey(offer);
+  if (!key) return;
+
+  const agreementInfo: AgreementInfo = {
+    contractId,
+    negotiationId,
+    timestamp,
+    assetId: offer["@id"] || offer.id || "",
+    providerId: offer._provider?.participantId || "",
+    providerAddress: offer._provider?.address || "",
+  };
+
+  localStorage.setItem(key, JSON.stringify(agreementInfo));
+}
+
+/**
+ * Load agreement info from localStorage
+ */
+export function loadAgreementInfo(offer: DSPOffer): AgreementInfo | null {
+  const key = getStorageKey(offer);
+  if (!key) return null;
+
+  try {
+    const stored = localStorage.getItem(key);
+    if (stored) {
+      const info = JSON.parse(stored) as AgreementInfo;
+      return info;
+    }
+  } catch (error) {
+    console.error("Failed to load agreement info:", error);
+  }
+  return null;
+}
+
+/**
+ * Clear agreement info from localStorage
+ */
+export function clearAgreementInfo(offer: DSPOffer): void {
+  const key = getStorageKey(offer);
+  if (key) {
+    localStorage.removeItem(key);
+  }
+}
+
+/**
+ * Save initial contract state when negotiation starts
+ */
+export function saveInitialContractState(
+  offer: DSPOffer,
+  negotiationId: string,
+): void {
+  try {
+    const providerId = offer._provider?.participantId || "";
+    const assetId = offer["@id"] || offer.id;
+
+    if (!assetId) return;
+
+    const existingContracts = DSPContractStorage.getByAssetAndProvider(
+      assetId,
+      providerId,
+    );
+    const existingContract = existingContracts.find(
+      (c) => c.contractId === negotiationId,
+    );
+
+    if (!existingContract) {
+      // Extract index endpoint URL from asset (dcat:endpointUrl)
+      const indexEndpointUrl = offer["dcat:endpointUrl"];
+
+      const assetName = offer.name || assetId || "Unknown Asset";
+
+      // Detect if this is an index asset
+      const isIndexAsset = assetName.toLowerCase().includes("index");
+
+      // Create new contract in REQUESTED state
+      DSPContractStorage.create({
+        assetId,
+        datasetId: offer["@id"] || offer.id || "",
+        assetName,
+        assetDescription: offer.description,
+        providerName: offer._provider?.name || "Unknown Provider",
+        providerAddress: offer._provider?.address || "",
+        providerParticipantId: offer._provider?.participantId || "",
+        providerColor: offer._provider?.color,
+        policy: offer["odrl:hasPolicy"],
+        state: "REQUESTED",
+        contractId: negotiationId,
+        // Index-specific fields
+        isIndexAsset,
+        indexEndpointUrl,
+      });
+    }
+  } catch (error) {
+    console.error(
+      "[DSP Contract Catalog] Failed to save initial contract state:",
+      error,
+    );
+  }
+}
+
+/**
+ * Save contract to DSP Contract Catalog for history tracking
+ */
+export function saveToContractCatalog(
+  offer: DSPOffer,
+  contractId: string,
+  negotiationId: string,
+): void {
+  try {
+    const providerId = offer._provider?.participantId || "";
+    const assetId = offer["@id"] || offer.id;
+
+    if (!assetId) return;
+
+    const existingContracts = DSPContractStorage.getByAssetAndProvider(
+      assetId,
+      providerId,
+    );
+    const existingContract = existingContracts.find(
+      (c) => c.contractId === negotiationId || c.agreementId === contractId,
+    );
+
+    // Extract index endpoint URL from asset (dcat:endpointUrl)
+    const indexEndpointUrl = offer["dcat:endpointUrl"];
+
+    const assetName = offer.name || assetId || "Unknown Asset";
+
+    // Detect if this is an index asset
+    const isIndexAsset = assetName.toLowerCase().includes("index");
+
+    if (existingContract) {
+      // Update existing contract with index metadata
+      DSPContractStorage.updateState(existingContract.id, "FINALIZED", {
+        agreementId: contractId,
+        contractId: negotiationId,
+        isIndexAsset,
+        indexEndpointUrl,
+      });
+    } else {
+      // Create new contract entry
+      DSPContractStorage.create({
+        assetId,
+        datasetId: offer["@id"] || offer.id || "",
+        assetName,
+        assetDescription: offer.description,
+        providerName: offer._provider?.name || "Unknown Provider",
+        providerAddress: offer._provider?.address || "",
+        providerParticipantId: offer._provider?.participantId || "",
+        providerColor: offer._provider?.color,
+        policy: offer["odrl:hasPolicy"],
+        state: "FINALIZED",
+        contractId: negotiationId,
+        agreementId: contractId,
+        // Index-specific fields
+        isIndexAsset,
+        indexEndpointUrl,
+      });
+    }
+  } catch (error) {
+    console.error("[DSP Contract Catalog] Failed to save contract:", error);
+  }
+}
+
+/**
+ * Update contract state in catalog (for failures)
+ */
+export function updateContractState(
+  offer: DSPOffer,
+  negotiationId: string,
+  state: "FAILED" | "TERMINATED",
+  error?: string,
+): void {
+  try {
+    const providerId = offer._provider?.participantId || "";
+    const assetId = offer["@id"] || offer.id;
+
+    if (!assetId) return;
+
+    const existingContracts = DSPContractStorage.getByAssetAndProvider(
+      assetId,
+      providerId,
+    );
+    const existingContract = existingContracts.find(
+      (c) => c.contractId === negotiationId,
+    );
+
+    if (existingContract) {
+      DSPContractStorage.updateState(existingContract.id, state, { error });
+    }
+  } catch (error) {
+    console.error(
+      "[DSP Contract Catalog] Failed to update contract state:",
+      error,
+    );
+  }
+}
+
+/**
+ * Delete all contracts for a specific asset and provider
+ */
+export function deleteContractsForAsset(offer: DSPOffer): void {
+  const assetId = offer?.["@id"] || offer?.id;
+  const providerId = offer?._provider?.participantId || "";
+
+  if (assetId) {
+    const existingContracts = DSPContractStorage.getByAssetAndProvider(
+      assetId,
+      providerId,
+    );
+    for (const contract of existingContracts) {
+      DSPContractStorage.delete(contract.id);
+    }
+  }
+}

package/src/helpers/dsp/policyHelpers.ts

@@ -0,0 +1,223 @@
+import type { ODRLPolicy } from "@src/ds4go";
+import { html, nothing } from "lit";
+import { msg, str } from "@lit/localize";
+
+/**
+ * Extract policies from various formats (single policy, array, or object with numeric keys)
+ */
+export function extractPolicies(
+  policy: ODRLPolicy | ODRLPolicy[] | Record<string, any> | undefined,
+): { policies: ODRLPolicy[]; defaultPolicy: ODRLPolicy | undefined } {
+  let policies: ODRLPolicy[] = [];
+  let defaultPolicy: ODRLPolicy | undefined;
+
+  if (!policy) {
+    return { policies: [], defaultPolicy: undefined };
+  }
+
+  // Handle array of policies
+  if (Array.isArray(policy)) {
+    const target = (policy as any).target;
+    policies = policy.filter(
+      (item: any) => item && typeof item === "object" && item["@id"],
+    );
+
+    // Add target to each policy if it exists and policy doesn't have one
+    if (target) {
+      policies = policies.map((p: any) => {
+        if (!p.target && !p["odrl:target"]) {
+          return { ...p, target, "odrl:target": target };
+        }
+        return p;
+      });
+    }
+
+    defaultPolicy = policies.length > 0 ? policies[0] : undefined;
+  }
+  // Handle object with numeric keys (array-like object)
+  else if (typeof policy === "object" && policy !== null) {
+    const keys = Object.keys(policy);
+    const hasNumericKeys = keys.some((k) => /^\d+$/.test(k));
+
+    if (hasNumericKeys) {
+      const target = (policy as any).target;
+      const extractedPolicies: ODRLPolicy[] = [];
+
+      for (const key in policy) {
+        if (/^\d+$/.test(key)) {
+          let p = (policy as any)[key];
+          // Add target if it exists and policy doesn't have one
+          if (target && !p.target && !p["odrl:target"]) {
+            p = { ...p, target, "odrl:target": target };
+          }
+          extractedPolicies.push(p);
+        }
+      }
+
+      policies = extractedPolicies;
+      defaultPolicy = policies.length > 0 ? policies[0] : undefined;
+    } else {
+      // Single policy object
+      defaultPolicy = policy as ODRLPolicy;
+      policies = [defaultPolicy];
+    }
+  }
+
+  return { policies, defaultPolicy };
+}
+
+/**
+ * Validate that a policy doesn't have numeric keys (defensive check)
+ */
+export function validatePolicyStructure(
+  policy: ODRLPolicy | undefined,
+): boolean {
+  if (!policy || typeof policy !== "object") {
+    return false;
+  }
+
+  const policyKeys = Object.keys(policy);
+  const hasNumericKeys = policyKeys.some((k) => /^\d+$/.test(k));
+
+  if (hasNumericKeys) {
+    console.error(
+      "[policyHelpers] ERROR: Policy has numeric keys! Invalid structure.",
+      policy,
+    );
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Get policy by index from policies array
+ */
+export function getPolicyByIndex(
+  policies: ODRLPolicy[],
+  index: number | undefined,
+): ODRLPolicy | undefined {
+  if (index === undefined || !policies || policies.length === 0) {
+    return undefined;
+  }
+  return policies[index];
+}
+
+/**
+ * Check if there are multiple policies available
+ */
+export function hasMultiplePolicies(policies: ODRLPolicy[]): boolean {
+  return policies && policies.length > 1;
+}
+
+/**
+ * Format policy details for display
+ */
+export function formatPolicyDetails(
+  policy: ODRLPolicy | undefined,
+): ReturnType<typeof html> {
+  if (!policy) return html`${msg("No policy details available")}`;
+
+  const permissions = policy["odrl:permission"];
+  const prohibitions = policy["odrl:prohibition"];
+  const obligations = policy["odrl:obligation"];
+
+  const permArray = permissions
+    ? Array.isArray(permissions)
+      ? permissions
+      : [permissions]
+    : [];
+  const prohibArray = prohibitions
+    ? Array.isArray(prohibitions)
+      ? prohibitions
+      : [prohibitions]
+    : [];
+  const obligArray = obligations
+    ? Array.isArray(obligations)
+      ? obligations
+      : [obligations]
+    : [];
+
+  return html`${policy["@id"]
+    ? html`<div class="policy-detail">
+        <strong>${msg("Policy ID:")}:</strong> ${policy["@id"]}
+      </div>`
+    : nothing}
+  ${policy["@type"]
+    ? html`<div class="policy-detail">
+        <strong>${msg("Type:")}:</strong> ${policy["@type"]}
+      </div>`
+    : nothing}
+  ${permArray.length > 0
+    ? html`<div class="policy-detail">
+        <strong>${msg("Permissions:")}:</strong>
+        <ul>
+          ${permArray.map(
+            (perm: any) => html`
+              <li>
+                ${msg(
+                  str`Action: ${perm["odrl:action"]?.["@id"] || perm["odrl:action"] || msg("use")}`,
+                )}
+              </li>
+              ${perm["odrl:constraint"]
+                ? html`${(Array.isArray(perm["odrl:constraint"])
+                    ? perm["odrl:constraint"]
+                    : [perm["odrl:constraint"]]
+                  ).map(
+                    (c: any) => html`
+                      <li style="margin-left: 20px;">
+                        ${msg(
+                          str`Constraint: ${c["odrl:leftOperand"]} ${c["odrl:operator"]} ${c["odrl:rightOperand"]}`,
+                        )}
+                      </li>
+                    `,
+                  )}`
+                : nothing}
+            `,
+          )}
+        </ul>
+      </div>`
+    : nothing}
+  ${prohibArray.length > 0
+    ? html`<div class="policy-detail">
+        <strong>${msg("Prohibitions:")}:</strong>
+        <ul>
+          ${prohibArray.map(
+            (prohib: any) => html`
+              <li>
+                ${msg(
+                  str`Action: ${prohib["odrl:action"]?.["@id"] || prohib["odrl:action"] || msg("unknown")}`,
+                )}
+              </li>
+            `,
+          )}
+        </ul>
+      </div>`
+    : nothing}
+  ${obligArray.length > 0
+    ? html`<div class="policy-detail">
+        <strong>${msg("Obligations:")}:</strong>
+        <ul>
+          ${obligArray.map(
+            (oblig: any) => html`
+              <li>
+                ${msg(
+                  str`Action: ${oblig["odrl:action"]?.["@id"] || oblig["odrl:action"] || msg("unknown")}`,
+                )}
+              </li>
+            `,
+          )}
+        </ul>
+      </div>`
+    : nothing}
+  ${policy.target
+    ? html`<div class="policy-detail">
+        <strong>${msg("Target Asset:")}:</strong> ${policy.target}
+      </div>`
+    : nothing}
+  ${policy.assigner
+    ? html`<div class="policy-detail">
+        <strong>${msg("Assigner:")}:</strong> ${policy.assigner}
+      </div>`
+    : nothing}`;
+}

package/src/helpers/index.ts

@@ -21,6 +21,10 @@ import requestNavigation from "@helpers/utils/requestNavigation";
 import uniq from "@helpers/utils/uniq";
 import CLIENT_CONTEXT from "@src/context.json";
 
+// DSP helpers
+import * as dspAgreementStorage from "@helpers/dsp/agreementStorage";
+import * as dspPolicyHelpers from "@helpers/dsp/policyHelpers";
+
 export {
   CLIENT_CONTEXT,
   filterGenerator,
@@ -44,4 +48,7 @@ export {
   setupOnSaveReset,
   sort,
   uniq,
+  // DSP helpers
+  dspAgreementStorage,
+  dspPolicyHelpers,
 };

package/src/styles/cards/ds4go-card-catalog.scss

@@ -67,7 +67,7 @@ article {
     background-position: center center;
     box-sizing: border-box;
     width: 100%;
-    padding: 16px;
+    padding: var(--scale-400);
   }
   main {
     display: flex;