@bcgov/plugin-catalog-backend-module-bc-data-catalogue 0.1.0 → 0.2.5-feature.aps-4105-connect-pipelines.cbf325cb

package/README.md

@@ -1,42 +1,43 @@
-# plugin-catalog-backend-module-bc-data-catalogue
+# @bcgov/plugin-catalog-backend-module-bc-data-catalogue
 
-This plugin integrates the BC Data Catalogue with Backstage, allowing you to import datasets, resources, and their metadata as entities in Backstage's software catalogue.
+This package is part of the BC Data Catalogue Backstage integration.
 
-## Installation
+👉 **Refer to the main project README at the root of this repository for installation and configuration instructions.**
 
-This package is published to npmjs.com under the scope `@bcgov`.
+---
 
-### Install the Package
+## Purpose
 
-#### Using Yarn
+The `@bcgov/plugin-catalog-backend-module-bc-data-catalogue` package provides the backend integration with the BC Data Catalogue.
 
-yarn add @bcgov/plugin-catalog-backend-module-bc-data-catalogue
+It is responsible for:
 
-### Usage in Backstage
+- fetching datasets from the BC Data Catalogue
+- transforming them into Backstage entities
+- registering entities such as:
+  - `Dataset`
+  - `API`
+  - `System`
+  - `Group`
+  - `User`
 
-Add the module to your Backstage backend in `packages/backend/src/index.ts`:
+---
 
-```diff
-import { createBackend } from '@backstage/backend-defaults';
+## Usage
 
-const backend = createBackend();
-// ... other backend.add() calls ...
+This package is intended to be registered as a backend module in Backstage:
 
-+ backend.add(import('@bcgov/plugin-catalog-backend-module-bc-data-catalogue'));
-
-backend.start();
+```ts
+backend.add(import('@bcgov/plugin-catalog-backend-module-bc-data-catalogue'));
 ```
 
-### Configure backend reading allowlist
-
-Add the following configuration to your `app-config.yaml` to allow the backend to access the BC Data Catalogue API:
+---
 
-```
-backend:
-reading:
-    allow:
-    - host: catalogue.data.gov.bc.ca
-        scheme: https
-```
+## Notes
 
-**Note:** Additional hosts may be required depending what resources are being loaded. See https://github.com/bcgov/csit-backstage-poc/blob/main/app-config.yaml for example.
+- This package is **not intended to be used in isolation**
+- It depends on:
+  - `@bcgov/plugin-catalog-common-bc-data-catalogue`
+- It is designed to be used together with:
+  - `@bcgov/catalog-dataset` (frontend UI)
+- All setup, configuration, and environment details are documented in the root project README

package/dist/BcDataCatalogueApisProvider.cjs.js

@@ -1,6 +1,7 @@
 'use strict';
 
-var BcDataCatalogueModel = require('./BcDataCatalogueModel.cjs.js');
+var BcDataCatalogueClient = require('./BcDataCatalogueClient.cjs.js');
+var BcDataCatalogueEntityFactory = require('./BcDataCatalogueEntityFactory.cjs.js');
 
 class BcDataCatalogueApisProvider {
   logger;
@@ -9,7 +10,6 @@ class BcDataCatalogueApisProvider {
   connection;
   taskRunner;
   allowedHosts;
-  /** [1] */
   constructor(env, reader, taskRunner, allowedHosts, logger) {
     this.env = env;
     this.reader = reader;
@@ -17,13 +17,11 @@ class BcDataCatalogueApisProvider {
     this.allowedHosts = allowedHosts;
     this.logger = logger;
   }
-  /** [2] */
   getProviderName() {
     return `bc-data-catalogue-${this.env}`;
   }
-  /** [3] */
   async connect(connection) {
-    this.logger.info("<connect");
+    this.logger.info("[BCDC Entity Provider] <connect");
     this.connection = connection;
     await this.taskRunner.run({
       id: this.getProviderName(),
@@ -31,468 +29,32 @@ class BcDataCatalogueApisProvider {
         await this.run();
       }
     });
-    this.logger.info(">connect");
+    this.logger.info("[BCDC Entity Provider] >connect");
   }
-  /** [4] */
   async run() {
-    this.logger.info("<run");
+    this.logger.info("[BCDC Entity Provider] <run");
     if (!this.connection) {
       throw new Error("Not initialized");
     }
-    let page = 0;
-    let retries = 0;
-    let allEntities = [];
-    let allPackages = [];
-    do {
-      const start = 1e3 * page;
-      const url = `https://catalogue.data.gov.bc.ca/api/3/action/package_search?start=${start}&rows=1000`;
-      const response = await this.reader.readUrl(url);
-      const data = JSON.parse((await response.buffer()).toString());
-      if (!data?.success || !Array.isArray(data.result?.results)) {
-        this.logger.warn("Invalid or unsuccessful response", { success: data?.success });
-        ++retries;
-        continue;
-      }
-      retries = 0;
-      const results = data.result.results;
-      if (results.length > 0) {
-        const packages = this.getBcDataCataloguePackages(results);
-        allPackages.push(...packages);
-        ++page;
-      } else {
-        page = -1;
-      }
-    } while (page > 0 && retries < 3);
-    this.logger.info(`Total packages ${allPackages.length}`);
-    const allGroups = /* @__PURE__ */ new Map();
-    const bcGovGroupId = this.getGroupId("gov.bc.ca");
-    allGroups.set(bcGovGroupId, this.createGroupEntity("gov.bc.ca", "Governent of British Columbia", void 0));
-    const allOrganizations = /* @__PURE__ */ new Map();
-    allPackages.forEach((pkg) => {
-      const organization = pkg.organization;
-      allOrganizations.set(organization.id, organization);
-    });
-    const allSystems = /* @__PURE__ */ new Map();
-    this.logger.info(`Organizations ${allOrganizations.size}`);
-    allOrganizations.forEach((organization) => {
-      const systemEntity = {
-        apiVersion: "backstage.io/v1alpha1",
-        kind: "System",
-        spec: {
-          owner: bcGovGroupId,
-          type: "government"
-        },
-        metadata: {
-          name: this.toSafeName(organization.name),
-          title: organization.title,
-          description: organization.description,
-          annotations: {
-            "backstage.io/managed-by-location": "url:https://catalogue.data.gov.bc.ca/api/3/action/package_search",
-            "backstage.io/managed-by-origin-location": "url:https://catalogue.data.gov.bc.ca/api/3/action/package_search",
-            "bcdata.gov.bc.ca/organization-id": organization.id,
-            "bcdata.gov.bc.ca/organization-type": organization.type,
-            "bcdata.gov.bc.ca/organization-created": organization.created,
-            "bcdata.gov.bc.ca/organization-approval-status": organization.approval_status,
-            "bcdata.gov.bc.ca/organization-state": organization.state
-          }
-        }
-      };
-      allSystems.set(this.getSystemId(organization.name), systemEntity);
+    const client = new BcDataCatalogueClient.BcDataCatalogueClient({
+      reader: this.reader,
+      logger: this.logger
     });
-    const allUsers = /* @__PURE__ */ new Map();
-    allPackages.forEach((pkg) => {
-      pkg.contacts?.forEach((contact) => {
-        const email = contact.email.toLowerCase();
-        let user = allUsers.get(email);
-        if (user == void 0) {
-          user = {
-            apiVersion: "backstage.io/v1alpha1",
-            kind: "User",
-            spec: {
-              profile: {
-                email
-              },
-              memberOf: []
-            },
-            metadata: {
-              name: this.toSafeName(email),
-              annotations: {
-                "backstage.io/managed-by-location": "url:https://catalogue.data.gov.bc.ca/api/3/action/package_search",
-                "backstage.io/managed-by-origin-location": "url:https://catalogue.data.gov.bc.ca/api/3/action/package_search"
-              }
-            }
-          };
-          allUsers.set(this.getUserId(email), user);
-        }
-        if (user?.spec.profile?.displayName == void 0) {
-          user.spec.profile.displayName = contact.name;
-        }
-        const hostName = this.getEmailHostname(email);
-        if (hostName == void 0) {
-          this.logger.warn(`Failed to extract hostname from email address ${email}`);
-        } else {
-          const groupId = this.getGroupId(hostName);
-          let group = allGroups.get(groupId);
-          if (group == void 0) {
-            allGroups.set(groupId, this.createGroupEntity(hostName, hostName, bcGovGroupId));
-          }
-          if (!user.spec.memberOf?.includes(groupId)) {
-            user.spec.memberOf?.push(groupId);
-          }
-        }
-      });
+    const factory = new BcDataCatalogueEntityFactory.BcDataCatalogueEntityFactory({
+      reader: this.reader,
+      logger: this.logger,
+      allowedHosts: this.allowedHosts
     });
-    const allComponents = /* @__PURE__ */ new Map();
-    const allApis = /* @__PURE__ */ new Map();
-    for (const pkg of allPackages) {
-      const safeName = this.toSafeName(pkg.name);
-      const systemId = this.getSystemId(pkg.organization.name);
-      const entityLinks = [];
-      pkg.contacts.forEach((contact) => {
-        const email = contact.email.toLowerCase();
-        const entityLink = {
-          url: `mailto:${email}`,
-          title: `Contact: ${contact.name}`,
-          icon: "email",
-          type: "contact"
-        };
-        entityLinks.push(entityLink);
-      });
-      pkg.more_info?.forEach((more_info) => {
-        if (more_info.url.length > 0) {
-          const entityLink = {
-            url: more_info.url,
-            title: more_info.description || more_info.url,
-            icon: "externalLink",
-            type: "more_info"
-          };
-          entityLinks.push(entityLink);
-        }
-      });
-      const apiResources = [];
-      pkg.resources?.forEach((resource) => {
-        if (resource.bcdc_type == "webservice" && resource.format != "kml" || resource.format == "arcgis_rest" || resource.format == "openapi-json") {
-          apiResources.push(resource);
-        } else if (resource.bcdc_type == "geographic") ; else if (resource.url.length > 0) {
-          const entityLink = {
-            url: resource.url,
-            title: resource.name,
-            icon: "catalog",
-            type: resource.bcdc_type
-          };
-          entityLinks.push(entityLink);
-        } else {
-          this.logger.info(`Missing URL ${resource.bcdc_type} ${resource.format} ${pkg.name}`);
-        }
-      });
-      pkg.dates.forEach((date) => {
-        ({ type: date.type, date: date.type });
-      });
-      const tags = [];
-      pkg.tags?.forEach((tag) => {
-        tags.push(this.toSafeName(tag.display_name));
-      });
-      const componentEntity = {
-        apiVersion: "backstage.io/v1alpha1",
-        kind: "Component",
-        spec: {
-          type: pkg.type,
-          lifecycle: "production",
-          owner: bcGovGroupId,
-          subcomponentOf: void 0,
-          providesApis: [],
-          consumesApis: void 0,
-          dependsOn: void 0,
-          dependencyOf: void 0,
-          system: systemId
-        },
-        metadata: {
-          name: safeName,
-          description: pkg.notes || "No description available",
-          annotations: {
-            "backstage.io/managed-by-location": "url:https://catalogue.data.gov.bc.ca/api/3/action/package_search",
-            "backstage.io/managed-by-origin-location": "url:https://catalogue.data.gov.bc.ca/api/3/action/package_search",
-            "bcdata.gov.bc.ca/package-author": pkg.author || "Unknown",
-            "bcdata.gov.bc.ca/package-author_email": pkg.author_email || "Unknown",
-            "bcdata.gov.bc.ca/package-creator_user_id": pkg.creator_user_id,
-            "bcdata.gov.bc.ca/package-download_audience": pkg.download_audience,
-            "bcdata.gov.bc.ca/package-id": pkg.id,
-            "bcdata.gov.bc.ca/package-isopen": `${pkg.isopen}`,
-            "bcdata.gov.bc.ca/package-license_id": pkg.license_id,
-            "bcdata.gov.bc.ca/package-license_title": pkg.license_title || "Unknown",
-            "bcdata.gov.bc.ca/package-license_url": pkg.license_url,
-            "bcdata.gov.bc.ca/package-maintainer": pkg.maintainer || "Unknown",
-            "bcdata.gov.bc.ca/package-maintainer_email": pkg.maintainer_email || "Unknown",
-            "bcdata.gov.bc.ca/package-metadata_created": pkg.metadata_created,
-            "bcdata.gov.bc.ca/package-metadata_modified": pkg.metadata_modified,
-            "bcdata.gov.bc.ca/package-metadata_visibility": pkg.metadata_visibility,
-            "bcdata.gov.bc.ca/package-name": pkg.name,
-            "bcdata.gov.bc.ca/package-notes": pkg.notes || "Unknown",
-            "bcdata.gov.bc.ca/package-owner_org": pkg.owner_org,
-            "bcdata.gov.bc.ca/package-private": `${pkg.private}`,
-            "bcdata.gov.bc.ca/package-publish_state": pkg.publish_state,
-            "bcdata.gov.bc.ca/package-record_create_date": pkg.record_create_date || "Unknown",
-            "bcdata.gov.bc.ca/package-record_last_modified": pkg.record_last_modified,
-            "bcdata.gov.bc.ca/package-record_publish_date": pkg.record_publish_date,
-            "bcdata.gov.bc.ca/package-resource_status": pkg.resource_status,
-            "bcdata.gov.bc.ca/package-security_class": pkg.security_class,
-            "bcdata.gov.bc.ca/package-state": pkg.state,
-            "bcdata.gov.bc.ca/package-title": pkg.title || "Unknown",
-            "bcdata.gov.bc.ca/package-type": pkg.type,
-            "bcdata.gov.bc.ca/package-url": pkg.url || "Unknown",
-            "bcdata.gov.bc.ca/package-version": pkg.version || "Unknown",
-            "bcdata.gov.bc.ca/package-view_audience": pkg.view_audience
-          },
-          links: entityLinks,
-          tags
-        }
-      };
-      allComponents.set(this.getComponentId(safeName), componentEntity);
-      for (const apiResource of apiResources) {
-        const name = apiResource.name;
-        let resourceSafeName = this.toSafeName(name);
-        let apiSafeName = resourceSafeName;
-        if (apiResource.bcdc_type === "webservice" || apiResource.format === "arcgis_rest") {
-          const prefix = apiResource.format === "openapi-json" ? "api" : apiResource.format;
-          const formatSafeName = this.toSafeName(prefix);
-          let baseName = this.toSafeName(`${formatSafeName}-${safeName}`);
-          let candidateName = baseName;
-          let candidateApiId = this.getApiId(candidateName);
-          if (allApis.has(candidateApiId)) {
-            const distinguishingSuffix = this.extractDistinguishingSuffix(name);
-            const suffixWithSeparator = `-${distinguishingSuffix}`;
-            const maxBaseLength = 63 - suffixWithSeparator.length;
-            let truncatedBase = baseName;
-            if (baseName.length > maxBaseLength) {
-              truncatedBase = baseName.slice(0, maxBaseLength).replace(/[-_.]+$/, "");
-            }
-            candidateName = this.toSafeName(`${truncatedBase}${suffixWithSeparator}`);
-            candidateApiId = this.getApiId(candidateName);
-            let counter = 1;
-            while (allApis.has(candidateApiId)) {
-              const counterSuffix = `-${counter}`;
-              const maxBaseWithCounter = 63 - suffixWithSeparator.length - counterSuffix.length;
-              let truncatedBaseForCounter = baseName;
-              if (baseName.length > maxBaseWithCounter) {
-                truncatedBaseForCounter = baseName.slice(0, maxBaseWithCounter).replace(/[-_.]+$/, "");
-              }
-              candidateName = this.toSafeName(`${truncatedBaseForCounter}${suffixWithSeparator}${counterSuffix}`);
-              candidateApiId = this.getApiId(candidateName);
-              counter++;
-            }
-          }
-          apiSafeName = candidateName;
-        }
-        const definition = apiResource.url;
-        const url = new URL(definition);
-        const host = url.host.toLowerCase();
-        if (!this.allowedHosts.includes(host)) {
-          this.logger.warn(`API definition host is NOT allowed: "${host}"`);
-        }
-        const apiEntityLinks = [];
-        if (apiResource.url && apiResource.url.length > 0) {
-          const apiEntityLink = {
-            url: apiResource.url,
-            title: apiResource.name,
-            icon: "api",
-            type: apiResource.bcdc_type
-          };
-          apiEntityLinks.push(apiEntityLink);
-        }
-        let definitionContent = apiResource.url;
-        if (apiResource.format === "openapi-json") {
-          try {
-            const response = await this.reader.readUrl(apiResource.url);
-            const content = (await response.buffer()).toString();
-            definitionContent = content;
-          } catch (error) {
-            this.logger.warn(`Failed to fetch OpenAPI definition from ${apiResource.url}: ${error}`);
-            definitionContent = apiResource.url;
-          }
-        }
-        const apiEntity = {
-          apiVersion: "backstage.io/v1alpha1",
-          kind: "API",
-          spec: {
-            type: apiResource.format === "openapi-json" ? "openapi" : apiResource.bcdc_type,
-            lifecycle: "production",
-            owner: bcGovGroupId,
-            definition: definitionContent,
-            system: systemId
-          },
-          metadata: {
-            name: apiSafeName,
-            description: apiResource.description || "No description available",
-            links: apiEntityLinks,
-            // tags: [this.toSafeName(apiResource.format)],
-            tags: [this.toSafeName(apiResource.format)],
-            annotations: {
-              "backstage.io/managed-by-location": "url:https://catalogue.data.gov.bc.ca/api/3/action/package_search",
-              "backstage.io/managed-by-origin-location": "url:https://catalogue.data.gov.bc.ca/api/3/action/package_search",
-              "bcdata.gov.bc.ca/resource-bcdc_type": apiResource.bcdc_type,
-              "bcdata.gov.bc.ca/resource-cache_last_updated": apiResource.cache_last_updated || "Undefined",
-              "bcdata.gov.bc.ca/resource-cache_url": apiResource.cache_url || "Undefined",
-              "bcdata.gov.bc.ca/resource-created": apiResource.created,
-              "bcdata.gov.bc.ca/resource-datastore_active": `${apiResource.datastore_active}`,
-              "bcdata.gov.bc.ca/resource-description": apiResource.description || "Undefined",
-              // 'bcdata.gov.bc.ca/resource-details': apiResource.details,
-              "bcdata.gov.bc.ca/resource-format": apiResource.format,
-              // 'bcdata.gov.bc.ca/resource-geographic_extent': apiResource.geographic_extent,
-              "bcdata.gov.bc.ca/resource-hash": apiResource.hash,
-              "bcdata.gov.bc.ca/resource-id": apiResource.id,
-              // 'bcdata.gov.bc.ca/resource-iso_topic_category': apiResource.iso_topic_category || 'Undefined',
-              "bcdata.gov.bc.ca/resource-metadata_modified": apiResource.metadata_modified,
-              "bcdata.gov.bc.ca/resource-mimetype": apiResource.mimetype || "Undefined",
-              "bcdata.gov.bc.ca/resource-name": apiResource.name,
-              "bcdata.gov.bc.ca/resource-package_id": apiResource.package_id,
-              "bcdata.gov.bc.ca/resource-position": `${apiResource.position}`,
-              // 'bcdata.gov.bc.ca/resource-preview_info': apiResource.preview_info,
-              "bcdata.gov.bc.ca/resource-projection_name": apiResource.projection_name || "Undefined",
-              "bcdata.gov.bc.ca/resource-resource_access_method": apiResource.resource_access_method,
-              "bcdata.gov.bc.ca/resource-resource_storage_location": apiResource.resource_storage_location,
-              "bcdata.gov.bc.ca/resource-resource_type": apiResource.resource_type,
-              "bcdata.gov.bc.ca/resource-resource_update_cycle": apiResource.resource_update_cycle,
-              "bcdata.gov.bc.ca/resource-size": `${apiResource.size}`,
-              "bcdata.gov.bc.ca/resource-spatial_datatype": apiResource.spatial_datatype || "Undefined",
-              "bcdata.gov.bc.ca/resource-state": apiResource.state,
-              "bcdata.gov.bc.ca/resource-url": apiResource.url,
-              "bcdata.gov.bc.ca/resource-url_type": apiResource.url_type || "Undefined"
-            }
-          }
-        };
-        const apiId = this.getApiId(apiSafeName);
-        if (allApis.has(apiId)) {
-          const existingApi = allApis.get(apiId);
-          this.logger.warn(
-            `Duplicate API name detected: "${apiSafeName}" (ID: ${apiId}). Existing API: name="${existingApi.metadata.name}", Format: "${existingApi.metadata.annotations?.["bcdata.gov.bc.ca/resource-format"]}", resource-id="${existingApi.metadata.annotations?.["bcdata.gov.bc.ca/resource-id"]}", package-id="${existingApi.metadata.annotations?.["bcdata.gov.bc.ca/resource-package_id"]}", url="${existingApi.metadata.annotations?.["bcdata.gov.bc.ca/resource-url"]}". New API: name="${apiEntity.metadata.name}", resource-id="${apiResource.id}", package-id="${apiResource.package_id}", url="${apiResource.url}". The new API will overwrite the existing one.`
-          );
-        }
-        allApis.set(apiId, apiEntity);
-        componentEntity.spec.providesApis?.push(apiId);
-      }
-    }
-    const userEntities = Array.from(allUsers.values());
-    const groupEntities = Array.from(allGroups.values());
-    const systemEntities = Array.from(allSystems.values());
-    const componentEntities = Array.from(allComponents.values());
-    const apiEntities = Array.from(allApis.values());
-    allEntities.push(...userEntities);
-    allEntities.push(...groupEntities);
-    allEntities.push(...systemEntities);
-    allEntities.push(...componentEntities);
-    allEntities.push(...apiEntities);
+    const packages = await client.getAllPackages();
+    const entities = await factory.createEntities(packages);
     await this.connection.applyMutation({
       type: "full",
-      entities: allEntities.map((entity) => ({
+      entities: entities.map((entity) => ({
         entity,
         locationKey: `bc-data-catalogue:${this.env}`
       }))
     });
-    this.logger.info(">run");
-  }
-  getEmailHostname(email) {
-    const match = email.trim().toLowerCase().match(/@([\w.-]+)/);
-    return match ? match[1] : void 0;
-  }
-  getSystemId(name) {
-    return `system:default/${this.toSafeName(name)}`;
-  }
-  getGroupId(hostName) {
-    return `group:default/${this.toSafeName(hostName)}`;
-  }
-  getUserId(email) {
-    return `user:default/${email.toLowerCase()}`;
-  }
-  getComponentId(name) {
-    return `component:default/${name.toLowerCase()}`;
-  }
-  getApiId(name) {
-    return `api:default/${name.toLowerCase()}`;
-  }
-  createGroupEntity(hostName, displayName, parentGroup) {
-    const groupEntity = {
-      apiVersion: "backstage.io/v1alpha1",
-      kind: "Group",
-      metadata: {
-        name: this.toSafeName(hostName),
-        annotations: {
-          "backstage.io/managed-by-location": "url:https://catalogue.data.gov.bc.ca/api/3/action/package_search",
-          "backstage.io/managed-by-origin-location": "url:https://catalogue.data.gov.bc.ca/api/3/action/package_search"
-        }
-      },
-      spec: {
-        type: "government",
-        profile: {
-          displayName
-        },
-        parent: parentGroup,
-        children: [],
-        members: []
-      }
-    };
-    return groupEntity;
-  }
-  /**
-   * Converts BC Data Catalogue (CKAN package_search) results into Backstage Entities
-   */
-  getBcDataCataloguePackages(results) {
-    this.logger.info("<getBcDataCataloguePackages", {
-      resultCount: Array.isArray(results) ? results.length : "unknown"
-    });
-    const rawPackages = results;
-    this.logger.info(`rawPackageCount ${rawPackages.length}`);
-    const validPackages = [];
-    for (const item of rawPackages) {
-      const parseResult = BcDataCatalogueModel.BcDataCataloguePackageSchema.safeParse(item);
-      if (parseResult.success) {
-        const pkg = parseResult.data;
-        if (pkg.type === "bcdc_dataset" && pkg.state === "active") {
-          validPackages.push(pkg);
-        }
-      } else {
-        this.logger.warn(JSON.stringify(item));
-        this.logger.warn("Invalid package skipped", {
-          error: parseResult.error.message
-        });
-        throw new Error(
-          `BC Data Catalogue package validation failedSee logs for details. First issue: ${parseResult.error.issues[0]?.message}`
-        );
-      }
-    }
-    this.logger.info(`>getBcDataCataloguePackages ${validPackages.length}`);
-    return validPackages;
-  }
-  toSafeName(name) {
-    return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(?:^[-_.]+|[-_.]+$)/g, "").slice(0, 63).replace(/[-_.]+$/, "");
-  }
-  /**
-   * Extracts distinguishing information from a resource name to help make API names unique.
-   * Tries to extract meaningful parts like years, version numbers, or other identifiers.
-   */
-  extractDistinguishingSuffix(resourceName) {
-    const safeName = this.toSafeName(resourceName);
-    const yearMatch = resourceName.match(/\b(19|20)\d{2}\b/);
-    if (yearMatch) {
-      return yearMatch[0];
-    }
-    const versionMatch = resourceName.match(/\b(?:v|version)[\s_-]?(\d+)\b/i);
-    if (versionMatch) {
-      return `v${versionMatch[1]}`;
-    }
-    const trailingNumberMatch = resourceName.match(/\b(\d{2,})\b/);
-    if (trailingNumberMatch) {
-      return trailingNumberMatch[0];
-    }
-    const words = safeName.split("-").filter(
-      (w) => w.length > 0 && !["service", "request", "getcapabilities", "wms", "kml", "arcgis", "rest", "online"].includes(w)
-    );
-    if (words.length >= 2) {
-      return words.slice(-2).join("-");
-    } else if (words.length === 1) {
-      return words[0];
-    } else {
-      return safeName.split("-").slice(-1)[0].slice(0, 10);
-    }
+    this.logger.info("[BCDC Entity Provider] >run");
   }
 }