GDC draft

src/connection.js

@@ -8,7 +8,8 @@ const AuthProvider = require('./authprovider');
 const BasicProvider = require('./basicprovider');
 const OidcProvider = require('./oidcprovider');
 
-const Capabilities = require('./capabilities');
+const GdcCapabilities = require('./gdc/capabilities');
+const GdcMigrate = require('./gdc/migrate');
 const FileTypes = require('./filetypes');
 const UserFile = require('./userfile');
 const Job = require('./job');
@@ -18,6 +19,7 @@ const Service = require('./service');
 const Builder = require('./builder/builder');
 const BuilderNode = require('./builder/node');
 
+
 const CONFORMANCE_RELS = [
  'conformance',
  'http://www.opengis.net/def/rel/ogc/1.0/conformance'
@@ -120,7 +122,8 @@ class Connection {
  }
  }
 
- this.capabilitiesObject = new Capabilities(data);
+ GdcMigrate.connection = this;
+ this.capabilitiesObject = new GdcCapabilities(data);
  return this.capabilitiesObject;
  }
 
@@ -802,6 +805,45 @@ class Connection {
  return await pg.describeUserProcess();
  }
 
+ isOgcProcess(process) {
+ let nodes = Object.values(process.process_graph);
+ return Boolean(nodes.find(node => {
+ let process = this.processes.get(node.process_id);
+ return Utils.isObject(process) && Boolean(process.ogcapi);
+ }));
+ }
+
+ async executeOgcProcess(process, abortController = null) {
+ let openEO = this._normalizeUserProcess(process);
+ let mode = null;
+ let p = Object.values(openEO.process.process_graph).find(v => {
+ let spec = this.processes.get(v.process_id);
+ if (Array.isArray(spec.jobControlOptions) && spec.jobControlOptions.includes("async-execute")) {
+ mode = 'async';
+ }
+ return Boolean(spec && spec.ogcapi);
+ });
+ let requestBody = GdcMigrate.execute(openEO);
+ let headers = {};
+ if (mode === 'async') {
+ headers.Prefer = 'respond-async';
+ }
+ console.log(p.process_id, requestBody, headers); // @todo remove
+ let response = await this._post(`/processes/${p.process_id}/execution`, requestBody, Environment.getResponseType(), abortController, headers);
+ let syncResult = {
+ data: response.data,
+ costs: null,
+ type: null,
+ logs: []
+ };
+
+ if (typeof response.headers['content-type'] === 'string') {
+ syncResult.type = response.headers['content-type'];
+ }
+
+ return syncResult;
+ }
+
  /**
  * Executes a process synchronously and returns the result as the response.
  * 
@@ -822,6 +864,9 @@ class Connection {
  budget: budget
  }
  );
+ if (this.isOgcProcess(requestBody.process)) {
+ return this.executeOgcProcess(process, abortController);
+ }
  let response = await this._post('/result', requestBody, Environment.getResponseType(), abortController);
  let syncResult = {
  data: response.data,
@@ -1129,16 +1174,18 @@ class Connection {
  * @param {*} body 
  * @param {string} responseType - Response type according to axios, defaults to `json`.
  * @param {?AbortController} [abortController=null] - An AbortController object that can be used to cancel the request.
+ * @param {Array.<Object.<string, string>>} [headers={}] - Headers
  * @returns {Promise<AxiosResponse>}
  * @throws {Error}
  * @see https://github.com/axios/axios#request-config
  */
- async _post(path, body, responseType, abortController = null) {
+ async _post(path, body, responseType, abortController = null, headers = {}) {
  let options = {
  method: 'post',
- responseType: responseType,
+ responseType,
  url: path,
- data: body
+ data: body,
+ headers
  };
  return await this._send(options, abortController);
  }

src/gdc/capabilities.js

@@ -0,0 +1,219 @@
+const Capabilities = require("../capabilities");
+const Utils = require('@openeo/js-commons/src/utils');
+const Migrate = require('./migrate');
+
+class GdcCapabilities extends Capabilities {
+
+ constructor(data) {
+ super(data);
+ Object.assign(this.featureMap, {
+ describeCoverage: 'get /collections/{collection_id}/coverage',
+ describeCoverageDomainset: 'get /collections/{collection_id}/coverage/domainset',
+ describeCoverageRangetype: 'get /collections/{collection_id}/coverage/rangetype',
+ describeCoverageRangeset: 'get /collections/{collection_id}/coverage/rangeset',
+ describeCoverageMetadata: 'get /collections/{collection_id}/coverage/metadata',
+ executeOgcProcess: 'post /processes/{processId}/execution',
+ });
+ this.checkConformance();
+ }
+
+ getConformanceClasses() {
+ if(!Array.isArray(this.data.conformsTo)) {
+ return [];
+ }
+ return this.data.conformsTo;
+ }
+
+ hasConformance(uri) {
+ if(!Array.isArray(this.data.conformsTo)) {
+ return false;
+ }
+ return this.data.conformsTo.includes(uri);
+ }
+
+ _getLink(rel) {
+ if (!Array.isArray(this.data.links)) {
+ return null;
+ }
+ return this.data.links.find(link => link.rel === rel) || null;
+ }
+
+ checkConformance() {
+ if (!Array.isArray(this.data.endpoints)) {
+ this.data.endpoints = [];
+ }
+ const isCoverage = this.hasConformance('http://www.opengis.net/spec/ogcapi-coverages-1/0.0/conf/geodata-coverage');
+ const isFeatures = this.hasConformance('http://www.opengis.net/spec/ogcapi-features-1/1.0/conf/core');
+ if (isCoverage || isFeatures) {
+ this.data.endpoints.push({
+ "path": "/collections",
+ "methods": ["GET"]
+ });
+ this.data.endpoints.push({
+ "path": "/collections/{collection_id}",
+ "methods": ["GET"]
+ });
+ }
+ // if (isFeatures) {
+ // this.data.endpoints.push({
+ // "path": "/collections/{collection_id}/items",
+ // "methods": ["GET"]
+ // });
+ // this.data.endpoints.push({
+ // "path": "/collections/{collection_id}/items/{item_id}",
+ // "methods": ["GET"]
+ // });
+ // }
+ if (isCoverage) {
+ this.data.endpoints.push({
+ "path": "/collections/{collection_id}/coverage",
+ "methods": ["GET"]
+ });
+ this.data.endpoints.push({
+ "path": "/collections/{collection_id}/coverage",
+ "methods": ["GET"]
+ });
+ this.data.endpoints.push({
+ "path": "/collections/{collection_id}/coverage/domainset",
+ "methods": ["GET"]
+ });
+ this.data.endpoints.push({
+ "path": "/collections/{collection_id}/coverage/rangetype",
+ "methods": ["GET"]
+ });
+ this.data.endpoints.push({
+ "path": "/collections/{collection_id}/coverage/rangeset",
+ "methods": ["GET"]
+ });
+ this.data.endpoints.push({
+ "path": "/collections/{collection_id}/coverage/metadata",
+ "methods": ["GET"]
+ });
+ }
+ const isProcessApi = this.hasConformance('http://www.opengis.net/spec/ogcapi-processes-1/1.0/conf/core');
+ const processDismiss = this.hasConformance('http://www.opengis.net/spec/ogcapi-processes-1/1.0/conf/dismiss');
+ const processJobList = this.hasConformance('http://www.opengis.net/spec/ogcapi-processes-1/1.0/req/job-list');
+ const processLink = this._getLink('https://www.opengis.net/def/rel/ogc/1.0/processes');
+ if (isProcessApi || processLink) {
+ this.data.endpoints.push({
+ "path": "/processes",
+ "methods": ["GET"]
+ });
+ this.data.endpoints.push({
+ "path": "/processes/{processId}",
+ "methods": ["GET"]
+ });
+ this.data.endpoints.push({
+ "path": "/processes/{processId}/execution",
+ "methods": ["POST"]
+ });
+ let jobMethods = ["GET"];
+ if (processDismiss) { // @todo Is dismiss equivalent to openEO job cancellation or deletion?
+ jobMethods.push("DELETE");
+ }
+ this.data.endpoints.push({
+ "path": "/jobs/{job_id}",
+ "methods": jobMethods
+ });
+ this.data.endpoints.push({
+ "path": "/jobs/{job_id}/results",
+ "methods": ["GET"]
+ });
+ }
+ const jobLink = this._getLink('https://www.opengis.net/def/rel/ogc/1.0/job-list');
+ if (processJobList || jobLink) {
+ this.data.endpoints.push({
+ "path": "/jobs",
+ "methods": ["GET"]
+ });
+ }
+ this.init();
+ }
+
+ /**
+ * Initializes the class.
+ * 
+ * @protected
+ */
+ init() {
+ if (Array.isArray(this.data.endpoints)) {
+ super.init();
+ }
+ }
+
+ /**
+ * Validates the capabilities.
+ * 
+ * Throws an error in case of an issue, otherwise just passes.
+ * 
+ * @protected
+ * @throws {Error}
+ */
+ validate() {
+ if(!Utils.isObject(this.data)) {
+ throw new Error("No capabilities retrieved.");
+ }
+ }
+
+ /**
+ * Returns the openEO API version implemented by the back-end.
+ * 
+ * @returns {string} openEO API version number.F
+ */
+ apiVersion() {
+ return this.data.api_version;
+ }
+
+ /**
+ * Returns the GDC API version implemented by the back-end.
+ * 
+ * @returns {string} GDC API version number.
+ */
+ gdcVersion() {
+ return this.data.gdc_version || "1.0.0-beta";
+ }
+
+ isEndpoint(response, method, endpoint) {
+ if (response.config.method !== method) {
+ return false;
+ }
+ if (endpoint.includes('{}')) {
+ let pattern = '^' + endpoint.replace('{}', '[^/]+') + '$';
+ let regex = new RegExp(pattern);
+ return regex.test(response.config.url);
+ }
+ return endpoint === response.config.url;
+ }
+
+ /**
+ * Migrates a response, if required.
+ * 
+ * @param {AxiosResponse} response 
+ * @protected
+ * @returns {AxiosResponse}
+ */
+ migrate(response) {
+ if (this.isEndpoint(response, 'get', '/collections')) {
+ response.data.collections = response.data.collections.map(collection => Migrate.collection(collection, response));
+ }
+ else if (this.isEndpoint(response, 'get', '/collections/{}')) {
+ response.data = Migrate.collection(response.data, response);
+ }
+ else if (this.isEndpoint(response, 'get', '/processes')) {
+ response.data.processes = response.data.processes.map(process => Migrate.process(process, response));
+ }
+ else if (this.isEndpoint(response, 'get', '/jobs')) {
+ response.data.jobs = response.data.jobs.map(job => Migrate.job(job, response));
+ }
+ else if (this.isEndpoint(response, 'get', '/jobs/{}')) {
+ response.data = Migrate.job(response.data, response);
+ }
+
+ response = Migrate.all(response);
+
+ return response;
+ }
+}
+
+
+module.exports = GdcCapabilities;