@loaders.gl/wms 3.4.0-alpha.1 → 3.4.0-alpha.3

package/src/lib/{data-sources/adhoc-image-service.ts → services/generic/image-service.ts}

@@ -1,14 +1,18 @@
 // loaders.gl, MIT license
 
+import {LoaderOptions} from '@loaders.gl/loader-utils';
 import type {ImageType} from '@loaders.gl/images';
 import {ImageLoader} from '@loaders.gl/images';
 
-import type {ImageSourceMetadata, GetImageParameters} from './image-source';
-import {ImageSource} from './image-source';
+import type {ImageSourceMetadata, GetImageParameters} from '../../sources/image-source';
+import {ImageSource} from '../../sources/image-source';
 
-export type AdHocImageServiceProps = {
-  /** Template URL string should contain `${width}` etc which will be substituted. */
-  templateUrl: string;
+/** Template URL string should contain `${width}` etc which will be substituted. */
+export type ImageServiceProps = {
+  /** Base URL to the service */
+  url: string;
+  /** Any load options to the loaders.gl Loaders used by the WMSService methods */
+  loadOptions?: LoaderOptions;
 };
 
 /**
@@ -16,15 +20,15 @@ export type AdHocImageServiceProps = {
  * ImageSource allows template url strings to be used to ad hoc connect to arbitrary image data sources
  * Accepts a template url string and builds requests URLs
  */
-export class AdHocImageService extends ImageSource {
+export class ImageService extends ImageSource {
   static type: 'template' = 'template';
   static testURL = (url: string): boolean => url.toLowerCase().includes('{');
 
-  templateUrl: string;
+  props: ImageServiceProps;
 
-  constructor(props: AdHocImageServiceProps) {
-    super();
-    this.templateUrl = props.templateUrl;
+  constructor(props: ImageServiceProps) {
+    super(props);
+    this.props = props;
   }
 
   // IMAGE SOURCE API
@@ -36,7 +40,7 @@ export class AdHocImageService extends ImageSource {
   async getImage(parameters: GetImageParameters): Promise<ImageType> {
     const granularParameters = this.getGranularParameters(parameters);
     const url = this.getURLFromTemplate(granularParameters);
-    const response = await fetch(url);
+    const response = await this.fetch(url);
     const arrayBuffer = await response.arrayBuffer();
     return await ImageLoader.parse(arrayBuffer);
   }
@@ -49,12 +53,14 @@ export class AdHocImageService extends ImageSource {
     return {...parameters, east, north, south, west};
   }
 
+  /** Supports both ${} and {} notations */
   protected getURLFromTemplate(parameters: Record<string, unknown>): string {
-    let url = this.templateUrl;
+    let url = this.props.url;
     for (const [key, value] of Object.entries(parameters)) {
       // TODO - parameter could be repeated
       // const regex = new RegExp(`\${${key}}`, 'g');
       url = url.replace(`\${${key}}`, String(value));
+      url = url.replace(`{${key}}`, String(value));
     }
     return url;
   }

package/src/lib/services/ogc/csw-service.ts

@@ -0,0 +1,251 @@
+// loaders.gl, MIT license
+
+/* eslint-disable camelcase */
+
+import type {DataSourceProps} from '../../sources/data-source';
+import {DataSource} from '../../sources/data-source';
+
+import type {CSWCapabilities} from '../../../csw-capabilities-loader';
+import {CSWCapabilitiesLoader} from '../../../csw-capabilities-loader';
+
+import type {CSWRecords} from '../../../csw-records-loader';
+import {CSWRecordsLoader} from '../../../csw-records-loader';
+
+import type {CSWDomain} from '../../../csw-domain-loader';
+import {CSWDomainLoader} from '../../../csw-domain-loader';
+
+import {WMSErrorLoader as CSWErrorLoader} from '../../../wms-error-loader';
+
+type CSWCommonParameters = {
+  /** In case the endpoint supports multiple services */
+  service?: 'CSW';
+  /** In case the endpoint supports multiple CSW versions */
+  version?: '1.1.1' | '2.0.0' | '2.0.1' | '3.0.0' | '3.0.0';
+};
+
+export type CSWGetCapabilitiesParameters = CSWCommonParameters & {
+  /** Request type */
+  request?: 'GetCapabilities';
+};
+
+export type CSWGetRecordsParameters = CSWCommonParameters & {
+  /** Request type */
+  request?: 'GetRecords';
+  /** type of records */
+  typenames: 'csw:Record';
+};
+
+export type CSWGetDomainParameters = CSWCommonParameters & {
+  /** Request type */
+  request?: 'GetDomain';
+  // TBA
+};
+
+export type Service = {name: string; type: string; url: string; params?: string; scheme?: string};
+
+export type CSWServiceProps = DataSourceProps & {
+  url: string;
+};
+
+/**
+ * The CSWService class provides
+ * - provides type safe methods to form URLs to a CSW service
+ * - provides type safe methods to query and parse results (and errors) from a CSW service
+ * - implements the ImageService interface
+ * @note Only the URL parameter conversion is supported. XML posts are not supported.
+ */
+export class CSWService extends DataSource {
+  static type: 'csw' = 'csw';
+  static testURL = (url: string): boolean => url.toLowerCase().includes('csw');
+
+  props: CSWServiceProps;
+  capabilities: CSWCapabilities | null = null;
+
+  /** A list of loaders used by the CSWService methods */
+  readonly loaders = [CSWErrorLoader, CSWCapabilitiesLoader];
+
+  /** Create a CSWService */
+  constructor(props: CSWServiceProps) {
+    super(props);
+    this.props = props;
+  }
+
+  async getMetadata(): Promise<CSWCapabilities> {
+    const capabilities = await this.getCapabilities();
+    return this.normalizeMetadata(capabilities);
+  }
+
+  normalizeMetadata(capabilities: CSWCapabilities): CSWCapabilities {
+    return capabilities;
+  }
+
+  async getServiceDirectory(options?: {includeUnknown?: boolean}): Promise<Service[]> {
+    const services: Service[] = [];
+    const unknownServices: Service[] = [];
+
+    const records = await this.getRecords();
+    for (const record of records.records) {
+      for (const reference of record.references) {
+        const url = reference.value;
+        switch (reference.scheme) {
+          case 'OGC:WMS':
+            services.push({name: record.title, type: 'ogc-wms-service', ...this._parseOGCUrl(url)});
+            break;
+          case 'OGC:WMTS':
+            services.push({
+              name: record.title,
+              type: 'ogc-wmts-service',
+              ...this._parseOGCUrl(url)
+            });
+            break;
+          case 'OGC:WFS':
+            services.push({name: record.title, type: 'ogc-wfs-service', ...this._parseOGCUrl(url)});
+            break;
+          default:
+            unknownServices.push({
+              name: record.title,
+              type: 'unknown',
+              url: reference.value,
+              scheme: reference.scheme
+            });
+        }
+      }
+    }
+
+    return options?.includeUnknown ? services.concat(unknownServices) : services;
+  }
+
+  _parseOGCUrl(url: string): {url: string; params: string} {
+    const parts = url.split('?');
+    return {
+      url: parts[0],
+      params: parts[1] || ''
+    };
+  }
+
+  // CSW Service API Stubs
+
+  /** Get Capabilities */
+  async getCapabilities(
+    wmsParameters?: CSWGetCapabilitiesParameters,
+    vendorParameters?: Record<string, unknown>
+  ): Promise<CSWCapabilities> {
+    const url = this.getCapabilitiesURL(wmsParameters, vendorParameters);
+    const response = await this.fetch(url);
+    const arrayBuffer = await response.arrayBuffer();
+    this._checkResponse(response, arrayBuffer);
+    const capabilities = await CSWCapabilitiesLoader.parse(arrayBuffer, this.props.loadOptions);
+    return capabilities;
+  }
+
+  /** Get Records */
+  async getRecords(
+    wmsParameters?: CSWGetRecordsParameters,
+    vendorParameters?: Record<string, unknown>
+  ): Promise<CSWRecords> {
+    const url = this.getRecordsURL(wmsParameters, vendorParameters);
+    const response = await this.fetch(url);
+    const arrayBuffer = await response.arrayBuffer();
+    this._checkResponse(response, arrayBuffer);
+    return await CSWRecordsLoader.parse(arrayBuffer, this.props.loadOptions);
+  }
+
+  /** Get Domain */
+  async getDomain(
+    wmsParameters?: CSWGetDomainParameters,
+    vendorParameters?: Record<string, unknown>
+  ): Promise<CSWDomain> {
+    const url = this.getDomainURL(wmsParameters, vendorParameters);
+    const response = await this.fetch(url);
+    const arrayBuffer = await response.arrayBuffer();
+    this._checkResponse(response, arrayBuffer);
+    return await CSWDomainLoader.parse(arrayBuffer, this.props.loadOptions);
+  }
+
+  // Typed URL creators
+  // For applications that want full control of fetching and parsing
+
+  /** Generate a URL for the GetCapabilities request */
+  getCapabilitiesURL(
+    wmsParameters?: CSWGetCapabilitiesParameters,
+    vendorParameters?: Record<string, unknown>
+  ): string {
+    const options: Required<CSWGetCapabilitiesParameters> = {
+      version: '3.0.0',
+      ...wmsParameters,
+      ...vendorParameters,
+      service: 'CSW',
+      request: 'GetCapabilities'
+    };
+    return this._getCSWUrl(options, vendorParameters);
+  }
+
+  /** Generate a URL for the GetCapabilities request */
+  getRecordsURL(
+    wmsParameters?: CSWGetRecordsParameters,
+    vendorParameters?: Record<string, unknown>
+  ): string {
+    const options: Required<CSWGetRecordsParameters> = {
+      version: '3.0.0',
+      typenames: 'csw:Record',
+      ...wmsParameters,
+      ...vendorParameters,
+      service: 'CSW',
+      request: 'GetRecords'
+    };
+    return this._getCSWUrl(options, vendorParameters);
+  }
+
+  /** Generate a URL for the GetCapabilities request */
+  getDomainURL(
+    wmsParameters?: CSWGetDomainParameters,
+    vendorParameters?: Record<string, unknown>
+  ): string {
+    const options: Required<CSWGetDomainParameters> = {
+      version: '3.0.0',
+      ...wmsParameters,
+      ...vendorParameters,
+      service: 'CSW',
+      request: 'GetDomain'
+    };
+    return this._getCSWUrl(options, vendorParameters);
+  }
+
+  // INTERNAL METHODS
+
+  /**
+   * @note case _getCSWUrl may need to be overridden to handle certain backends?
+   * */
+  protected _getCSWUrl(
+    options: Record<string, unknown>,
+    vendorParameters?: Record<string, unknown>
+  ): string {
+    let url = this.props.url;
+    let first = true;
+    for (const [key, value] of Object.entries(options)) {
+      url += first ? '?' : '&';
+      first = false;
+      if (Array.isArray(value)) {
+        url += `${key.toUpperCase()}=${value.join(',')}`;
+      } else {
+        url += `${key.toUpperCase()}=${value ? String(value) : ''}`;
+      }
+    }
+    return encodeURI(url);
+  }
+
+  /** Checks for and parses a CSW XML formatted ServiceError and throws an exception */
+  protected _checkResponse(response: Response, arrayBuffer: ArrayBuffer): void {
+    const contentType = response.headers['content-type'];
+    if (!response.ok || CSWErrorLoader.mimeTypes.includes(contentType)) {
+      const error = CSWErrorLoader.parseSync(arrayBuffer, this.props.loadOptions);
+      throw new Error(error);
+    }
+  }
+
+  /** Error situation detected */
+  protected _parseError(arrayBuffer: ArrayBuffer): Error {
+    const error = CSWErrorLoader.parseSync(arrayBuffer, this.props.loadOptions);
+    return new Error(error);
+  }
+}