@startinblox/components-ds4go 3.0.2 → 3.1.0

package/src/helpers/components/ResourceMapper.ts

@@ -1,469 +0,0 @@
-/**
- * Resource Mapper Service
- *
- * Provides unified, configurable mapping from source data formats (FC self-descriptions,
- * DSP datasets, etc.) to TEMS-compatible resource objects with LDP containers.
- *
- * Architecture:
- * - Stores (sib-core): Fetch raw data
- * - ResourceMapper (solid-tems): Transform raw data to TEMS format
- * - Components (solid-tems): Configure mapper and render UI
- *
- * Usage:
- * ```typescript
- * const mapper = new ResourceMapper(fcMappingConfig);
- * const temsResource = mapper.map(sourceData, context);
- * ```
- */
-
-import type { Resource, UnknownResource } from "@src/component";
-
-// import type { Resource } from '@startinblox/core';
-
-// ============================================================================
-// Types and Interfaces
-// ============================================================================
-
-export interface ResourceMapperConfig {
-  /**
-   * Base field mappings (simple property extractions)
-   */
-  baseFields: Record<string, FieldMapping>;
-
-  /**
-   * LDP Container field mappings (arrays wrapped in ldp:Container)
-   */
-  containerFields?: Record<string, ContainerFieldMapping>;
-
-  /**
-   * Nested object mappings
-   */
-  nestedObjects?: Record<string, NestedObjectMapping>;
-
-  /**
-   * Contract negotiation field mappings
-   */
-  contractFields?: Record<string, FieldMapping>;
-
-  /**
-   * Optional custom post-processing function
-   */
-  postProcess?: (
-    resource: Resource,
-    source: any,
-    context: MappingContext,
-  ) => Resource;
-}
-
-export interface FieldMapping {
-  /**
-   * Path to source value (array of keys to traverse)
-   */
-  source: string[];
-
-  /**
-   * Optional transform function
-   */
-  transform?: (value: any, source: any, context: MappingContext) => any;
-
-  /**
-   * Optional fallback if source is not found
-   */
-  fallback?: string | ((source: any, context: MappingContext) => any);
-
-  /**
-   * Optional default value if source and fallback are not found
-   */
-  defaultValue?: any;
-}
-
-export interface ContainerFieldMapping {
-  /**
-   * Path to source array
-   */
-  source: string[];
-
-  /**
-   * LDP container type (e.g., 'ldp:Container')
-   */
-  containerType: string;
-
-  /**
-   * Item type for contained objects (e.g., 'tems:Category')
-   */
-  itemType: string;
-
-  /**
-   * Field mappings for each item
-   */
-  itemFields: Record<
-    string,
-    (item: any, index: number, context: MappingContext) => any
-  >;
-
-  /**
-   * Optional filter function to include/exclude items
-   */
-  filter?: (item: any, index: number, context: MappingContext) => boolean;
-
-  /**
-   * Optional transform for the entire array before item mapping
-   */
-  transform?: (value: any, source: any, context: MappingContext) => any[];
-}
-
-export interface NestedObjectMapping {
-  /**
-   * Path to source object
-   */
-  source: string[];
-
-  /**
-   * Field mappings for the nested object
-   */
-  fields: Record<string, string[] | FieldMapping>;
-
-  /**
-   * Optional type for the nested object
-   */
-  type?: string;
-}
-
-export interface MappingContext {
-  /**
-   * Base URL for generating @id values
-   */
-  temsServiceBase?: string;
-  temsCategoryBase?: string;
-  temsImageBase?: string;
-  temsProviderBase?: string;
-
-  /**
-   * Additional context data (provider info, etc.)
-   */
-  [key: string]: any;
-}
-
-// ============================================================================
-// Transform Functions
-// ============================================================================
-
-/**
- * Strips URN prefixes from IDs
- */
-export function stripUrnPrefix(value: string | undefined): string {
-  if (!value) return "";
-  return value.replace(/^urn:uuid:/i, "").replace(/^urn:tems:/i, "");
-}
-
-/**
- * Processes ODRL policy: strips URN prefixes and adds target field
- */
-export function processPolicyTransform(
-  policy: any,
-  source: any,
-  _context: MappingContext,
-): any {
-  if (!policy) return null;
-
-  const processedPolicy = JSON.parse(JSON.stringify(policy)); // Deep clone
-
-  // Strip URN prefix from policy @id
-  if (processedPolicy["@id"]) {
-    processedPolicy["@id"] = stripUrnPrefix(processedPolicy["@id"]);
-  }
-
-  // Add target field (asset ID)
-  const assetId = getNestedValue(source, ["@id"]) || "";
-  processedPolicy.target = stripUrnPrefix(assetId);
-
-  return processedPolicy;
-}
-
-/**
- * Extracts first value from array or returns the value itself
- */
-export function firstOrSelf(value: any): any {
-  return Array.isArray(value) && value.length > 0 ? value[0] : value;
-}
-
-/**
- * Generates unique ID based on name
- */
-export function generateIdFromName(name: string, base: string): string {
-  const slug = name
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "");
-  return `${base}${slug}`;
-}
-
-// ============================================================================
-// Helper Functions
-// ============================================================================
-
-/**
- * Gets nested value from object using path array
- */
-export function getNestedValue(obj: any, path: string[]): any {
-  // If path is empty, return undefined (don't return the entire object)
-  // Empty paths are used when the field should be computed via transform or use defaultValue
-  if (path.length === 0) {
-    return undefined;
-  }
-
-  let current = obj;
-  for (const key of path) {
-    if (current === null || current === undefined) {
-      return undefined;
-    }
-    current = current[key];
-  }
-  return current;
-}
-
-/**
- * Sets nested value in object using path array
- */
-export function setNestedValue(obj: any, path: string[], value: any): void {
-  if (path.length === 0) return;
-
-  let current = obj;
-  for (let i = 0; i < path.length - 1; i++) {
-    const key = path[i];
-    if (!(key in current)) {
-      current[key] = {};
-    }
-    current = current[key];
-  }
-
-  current[path[path.length - 1]] = value;
-}
-
-// ============================================================================
-// ResourceMapper Class
-// ============================================================================
-
-export class ResourceMapper {
-  private config: ResourceMapperConfig;
-
-  constructor(config: ResourceMapperConfig) {
-    this.config = config;
-  }
-
-  /**
-   * Maps source data to TEMS-compatible resource
-   */
-  map(source: any, context: MappingContext = {}): Resource {
-    const resource: UnknownResource = {};
-
-    // Map base fields
-    for (const [destKey, mapping] of Object.entries(this.config.baseFields)) {
-      const value = this.mapField(source, mapping, context);
-      if (value !== undefined) {
-        resource[destKey] = value;
-      }
-    }
-
-    // Map container fields
-    if (this.config.containerFields) {
-      for (const [destKey, mapping] of Object.entries(
-        this.config.containerFields,
-      )) {
-        const container = this.mapContainerField(source, mapping, context);
-        if (container) {
-          resource[destKey] = container;
-        }
-      }
-    }
-
-    // Map nested objects
-    if (this.config.nestedObjects) {
-      for (const [destKey, mapping] of Object.entries(
-        this.config.nestedObjects,
-      )) {
-        const nestedObj = this.mapNestedObject(source, mapping, context);
-        if (nestedObj) {
-          resource[destKey] = nestedObj;
-        }
-      }
-    }
-
-    // Map contract fields
-    if (this.config.contractFields) {
-      for (const [destKey, mapping] of Object.entries(
-        this.config.contractFields,
-      )) {
-        const value = this.mapField(source, mapping, context);
-        if (value !== undefined) {
-          resource[destKey] = value;
-        }
-      }
-    }
-
-    // Apply post-processing
-    if (this.config.postProcess) {
-      return this.config.postProcess((resource as Resource), source, context);
-    }
-
-    return (resource as Resource);
-  }
-
-  /**
-   * Maps a single field
-   */
-  private mapField(
-    source: any,
-    mapping: FieldMapping,
-    context: MappingContext,
-  ): any {
-    // Get source value
-    let value = getNestedValue(source, mapping.source);
-
-    // Apply transform
-    if (mapping.transform) {
-      value = mapping.transform(value, source, context);
-    }
-
-    // Apply fallback
-    if (value === undefined || value === null || value === "") {
-      if (mapping.fallback) {
-        if (typeof mapping.fallback === "function") {
-          value = mapping.fallback(source, context);
-        } else {
-          // Fallback is a path to another field
-          value = getNestedValue(source, [mapping.fallback]);
-        }
-      }
-    }
-
-    // Apply default value
-    if (value === undefined || value === null || value === "") {
-      value = mapping.defaultValue;
-    }
-
-    return value;
-  }
-
-  /**
-   * Maps a container field (array wrapped in LDP container)
-   */
-  private mapContainerField(
-    source: any,
-    mapping: ContainerFieldMapping,
-    context: MappingContext,
-  ): any {
-    // Get source array
-    let sourceArray = getNestedValue(source, mapping.source);
-
-    if (!sourceArray) {
-      return null;
-    }
-
-    // Apply array-level transform
-    if (mapping.transform) {
-      sourceArray = mapping.transform(sourceArray, source, context);
-    }
-
-    // Ensure it's an array
-    if (!Array.isArray(sourceArray)) {
-      sourceArray = [sourceArray];
-    }
-
-    // Filter items
-    if (mapping.filter) {
-      sourceArray = sourceArray.filter((item: any, index: number) =>
-        mapping.filter!(item, index, context),
-      );
-    }
-
-    // Map items
-    const items = sourceArray.map((item: any, index: number) => {
-      const mappedItem: any = {
-        "@type": mapping.itemType,
-      };
-
-      for (const [fieldKey, fieldFn] of Object.entries(mapping.itemFields)) {
-        const fieldValue = fieldFn(item, index, context);
-        if (fieldValue !== undefined) {
-          mappedItem[fieldKey] = fieldValue;
-        }
-      }
-
-      return mappedItem;
-    });
-
-    // Return LDP container
-    return {
-      "@type": mapping.containerType,
-      "ldp:contains": items,
-    };
-  }
-
-  /**
-   * Maps a nested object
-   */
-  private mapNestedObject(
-    source: any,
-    mapping: NestedObjectMapping,
-    context: MappingContext,
-  ): any {
-    // Get source object
-    const sourceObj = getNestedValue(source, mapping.source);
-
-    if (!sourceObj) {
-      return null;
-    }
-
-    const nestedObj: any = {};
-
-    // Add type if specified
-    if (mapping.type) {
-      nestedObj["@type"] = mapping.type;
-    }
-
-    // Map fields
-    for (const [destKey, fieldMapping] of Object.entries(mapping.fields)) {
-      let value: any;
-
-      if (Array.isArray(fieldMapping)) {
-        // Simple path mapping
-        value = getNestedValue(sourceObj, fieldMapping);
-      } else {
-        // Full FieldMapping
-        value = this.mapField(sourceObj, fieldMapping, context);
-      }
-
-      if (value !== undefined) {
-        nestedObj[destKey] = value;
-      }
-    }
-
-    return Object.keys(nestedObj).length > (mapping.type ? 1 : 0)
-      ? nestedObj
-      : null;
-  }
-
-  /**
-   * Unwraps LDP containers (converts ldp:contains arrays to plain arrays)
-   *
-   * This is typically called by components after mapping to simplify data structure
-   * for rendering.
-   */
-  static unwrapLdpContainers(resource: Resource): Resource {
-    const unwrapped: Resource = { ...resource };
-
-    for (const [key, value] of Object.entries(unwrapped)) {
-      if (
-        value &&
-        typeof value === "object" &&
-        value["@type"] === "ldp:Container" &&
-        value["ldp:contains"]
-      ) {
-        unwrapped[key] = value["ldp:contains"];
-      }
-    }
-
-    return unwrapped;
-  }
-}

package/src/helpers/components/orbitDspComponent.ts

@@ -1,250 +0,0 @@
-import {
-  StoreService,
-  StoreType,
-} from "https://cdn.jsdelivr.net/npm/@startinblox/core@beta/+esm";
-import { OrbitComponent, setupComponentSubscriptions } from "@helpers";
-import { ResourceMapper } from "@helpers/components/ResourceMapper";
-import { dspMappingConfig } from "@helpers/mappings/dsp-mapping-config";
-import type { DSPComponentParameters, Resource } from "@src/component.d.ts";
-import type { PropertyValues } from "lit";
-import { property, state } from "lit/decorators.js";
-
-export interface DSPProviderConfig {
-  name: string;
-  address: string;
-  color?: string;
-  participantId?: string;
-}
-
-export default class extends OrbitComponent {
-  @property({ attribute: "participant-connector-uri", reflect: true })
-  participantConnectorUri?: string;
-
-  @property({ attribute: "participant-id", reflect: true })
-  participantId?: string;
-
-  @property({ attribute: "participant-api-key", reflect: true })
-  participantApiKey?: string;
-
-  @property({ attribute: "api-gateway-config", reflect: true })
-  apiGatewayConfig?: string;
-
-  @state()
-  storeService?: StoreService;
-
-  @state()
-  dspStoreService?: StoreService;
-
-  @state()
-  _apiGatewayConfigParsed?: any;
-
-  @property({ type: Array })
-  providers: DSPProviderConfig[] = [];
-
-  willUpdate(_changedProperties: PropertyValues<this>) {
-    if (
-      (!this.providers || this.providers.length === 0) &&
-      this.component?.parameters?.providers
-    ) {
-      this.providers = this.component.parameters.providers || [];
-    }
-  }
-
-  protected async _attach(
-    defaultRoute: boolean | string,
-    setupSubscriptions: boolean,
-    ignoreRouter: boolean,
-  ) {
-    if (!this.orbit) {
-      if (window.orbit) {
-        this.orbit = window.orbit;
-        if (setupSubscriptions) {
-          setupComponentSubscriptions({
-            component: this,
-            defaultRoute: defaultRoute,
-            ignoreRouter: ignoreRouter,
-          });
-
-          if (this.route) {
-            this.component = this.orbit.getComponentFromRoute(this.route);
-            if (this.component) {
-              for (const c of this.orbit.components) {
-                if (c.uniq === this.component.uniq) {
-                  c.instance = this;
-                }
-              }
-            }
-          }
-
-          // Get connector configuration from attributes or component params
-          if (!this.participantConnectorUri) {
-            const params = this.component?.parameters as DSPComponentParameters;
-            if (params?.["participant-connector-uri"]) {
-              this.participantConnectorUri =
-                params["participant-connector-uri"];
-            }
-            if (params?.["participant-api-key"]) {
-              this.participantApiKey = params["participant-api-key"];
-            }
-            if (params?.providers) {
-              this.providers = params.providers;
-            }
-            if (params?.["participant-id"]) {
-              this.participantId = params["participant-id"];
-            }
-          }
-
-          // Parse API Gateway configuration (OPTIONAL)
-          const params = this.component?.parameters as DSPComponentParameters;
-
-          if (params?.["api-gateway-config"]) {
-            this.apiGatewayConfig = params["api-gateway-config"];
-            try {
-              this._apiGatewayConfigParsed =
-                typeof this.apiGatewayConfig === "string"
-                  ? JSON.parse(this.apiGatewayConfig)
-                  : this.apiGatewayConfig;
-            } catch (_error) {
-              this._apiGatewayConfigParsed = null;
-            }
-          }
-
-          // Initialize DataspaceConnectorStore
-          if (!this.storeService && this.participantConnectorUri) {
-            try {
-              // Use unique store name based on component ID to avoid singleton conflicts
-              const storeName = `dsp-connector-${this.component.uniq}`;
-
-              const config = {
-                type: StoreType.DataspaceConnector,
-                endpoint: this.participantConnectorUri,
-                catalogEndpoint: `${this.participantConnectorUri}/management/v3/catalog/request`,
-                contractNegotiationEndpoint: `${this.participantConnectorUri}/management/v3/contractnegotiations`,
-                transferProcessEndpoint: `${this.participantConnectorUri}/management/v3/transferprocesses`,
-                edrsEndpoint: `${this.participantConnectorUri}/management/v3/edrs`,
-                authMethod: "dsp-api-key",
-                dspApiKey: this.participantApiKey || "password",
-                participantId: this.participantId || "stbx-consumer",
-                retryAttempts: 10,
-                timeout: 30000,
-                // Include API Gateway configuration ONLY if available
-                ...(this._apiGatewayConfigParsed && {
-                  apiGatewayConfig: this._apiGatewayConfigParsed,
-                }),
-              };
-
-              this.storeService = StoreService.addStore(storeName, config);
-              // Also set dspStoreService for contract negotiation in tems-modal
-              this.dspStoreService = this.storeService;
-              // Expose globally for FederatedIndexManager auto-negotiation
-              if (!window.dspStore) {
-                window.dspStore = this.storeService;
-              }
-            } catch (error) {
-              console.error("DSP Store initialization error:", error);
-            }
-          }
-          await this._afterAttach();
-
-          this.ready = true;
-          this.dispatchEvent(
-            new CustomEvent("component-ready", {
-              detail: {
-                component: this.component,
-              },
-            }),
-          );
-
-          return Promise.resolve(true);
-        }
-      }
-    }
-    return Promise.resolve(false);
-  }
-
-  /**
-   * Fetch catalog from multiple DSP providers
-   */
-  async fetchFederatedCatalog(): Promise<Resource[]> {
-    if (!this.storeService || !this.providers || this.providers.length === 0) {
-      console.warn("DSP store or providers not configured");
-      return [];
-    }
-
-    try {
-      // FIXME: Avoid magic strings
-      // Use default base URLs for TEMS resources
-      const baseURL = "https://api.tems.example.com/services/";
-
-      // Initialize ResourceMapper with DSP configuration
-      const mapper = new ResourceMapper(dspMappingConfig);
-
-      const catalogPromises = this.providers.map(async (provider) => {
-        try {
-          const catalog = await this.storeService.getCatalog(provider.address);
-
-          if (catalog?.["dcat:dataset"]) {
-            // Normalize datasets to array - catalog may return single object if only one dataset
-            const rawDatasets = catalog["dcat:dataset"];
-            const datasets = Array.isArray(rawDatasets)
-              ? rawDatasets
-              : [rawDatasets];
-            // IMPORTANT: Prefer config's participantId over catalog response
-            // This ensures assets from different providers are distinguishable
-            // even if EDC catalogs return the same participantId (misconfiguration)
-            const catalogResponseParticipantId =
-              catalog.participantId ||
-              catalog["edc:participantId"] ||
-              catalog["https://w3id.org/edc/v0.0.1/ns/participantId"];
-
-            // Use config's participantId as authoritative (user configured it intentionally)
-            // Only fall back to catalog response if config doesn't have participantId
-            const effectiveParticipantId =
-              provider.participantId || catalogResponseParticipantId;
-
-            // Map each dataset using ResourceMapper
-            return datasets.map((dataset: Resource) => {
-              const context = {
-                temsServiceBase: baseURL,
-                temsCategoryBase: baseURL.replace(
-                  "/services/",
-                  "/providers/categories/",
-                ),
-                temsImageBase: baseURL.replace(
-                  "/services/",
-                  "/objects/images/",
-                ),
-                temsProviderBase: baseURL.replace("/services/", "/providers/"),
-                // Provider context for mapping - use config's participantId as authoritative
-                providerName: provider.name,
-                providerAddress: provider.address,
-                providerColor: provider.color,
-                providerParticipantId: effectiveParticipantId,
-              };
-
-              return mapper.map(dataset, context);
-            });
-          }
-
-          return [];
-        } catch (_error) {
-          return [];
-        }
-      });
-
-      const results = await Promise.all(catalogPromises);
-      const allDatasets = results.flat();
-
-      return allDatasets;
-    } catch (_error) {
-      return [];
-    }
-  }
-
-  /**
-   * Get current DataspaceConnectorStore instance
-   */
-  getStoreService() {
-    return this.storeService;
-  }
-}