@qooxdoo/framework 7.0.0-beta.2 → 7.0.0-beta.6

package/source/class/qx/io/jsonrpc/protocol/Request.js

@@ -0,0 +1,93 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+      2020 Christian Boulanger
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Christian Boulanger (cboulanger)
+
+************************************************************************ */
+
+/**
+ * A JSON-RPC v2.0 request object
+ *
+ * @see https://www.jsonrpc.org/specification#request_object
+ */
+qx.Class.define("qx.io.jsonrpc.protocol.Request", {
+  extend: qx.io.jsonrpc.protocol.Notification,
+  statics: {
+    /**
+     * Static counter for all request ids
+     */
+    __current_request_id : 0,
+
+    getCurrentId() {
+      return qx.io.jsonrpc.protocol.Request.__current_request_id;
+    },
+
+    resetId() {
+      qx.io.jsonrpc.protocol.Request.__current_request_id = 0;
+    }
+  },
+  properties: {
+    /**
+     * The integer id of the request
+     */
+    id : {
+      check: value => qx.lang.Type.isNumber(value) && parseInt(value, 10) === value
+    }
+  },
+
+  /**
+   * JSON-RPC request constructor
+   * @param {String} method
+   * @param {Array|Object?} params
+   * @param {Number?} id
+   *    Optional integer id. If not provided, an auto-incremented id will be
+   *    used.
+   */
+  construct(method, params, id) {
+    this.base(arguments, method, params);
+    if (id === undefined) {
+      id = ++qx.io.jsonrpc.protocol.Request.__current_request_id;
+    }
+    this.set({id});
+    this.__promise = new qx.Promise();
+  },
+
+  members: {
+
+    __promise : null,
+
+    /**
+     * Getter for promise which resolves with the result to the request
+     * @return {qx.Promise}
+     */
+    getPromise() {
+      return this.__promise;
+    },
+
+    /**
+     * Determines how an exception during transport is handled. Standard
+     * behavior is to reject the request's promise with that exception.
+     * Classes inheriting from this class might handle it differently, i.e.
+     * by allowing the transport to retry after a timeout occurred.
+     * @param {qx.io.exception.Transport} exception
+     */
+    handleTransportException(exception) {
+      try {
+        this.getPromise().reject(exception);
+      } catch (e) {
+        this.warn("Promise has already been rejected");
+      }
+    }
+  }
+});

package/source/class/qx/io/jsonrpc/protocol/Result.js

@@ -0,0 +1,48 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+      2020 Christian Boulanger
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Christian Boulanger (cboulanger)
+
+************************************************************************ */
+
+/**
+ * A JSON-RPC v2.0 result object, which is a response to a {@link qx.io.jsonrpc.protocol.Request},
+ * indicating a successfully processed request.
+ *
+ * @see https://www.jsonrpc.org/specification#response_object
+ */
+qx.Class.define("qx.io.jsonrpc.protocol.Result",{
+  extend: qx.io.jsonrpc.protocol.Message,
+  properties: {
+
+    /**
+     * The integer id of the request
+     */
+    id : {
+      check: value => qx.lang.Type.isNumber(value) && parseInt(value, 10) === value
+    },
+
+    result : {
+      nullable: true
+    }
+  },
+  /**
+   * The result messsage constructor
+   * @param {Number} id^
+   * @param {*} result
+   */
+  construct(id, result) {
+    this.set({id, result})
+  }
+});

package/source/class/qx/io/jsonrpc/protocol/__init__.js

@@ -0,0 +1,5 @@
+/**
+ * This namespace contains the implementation of the  implementing
+ * the <a href="https://www.jsonrpc.org/specification">JSON
+ * Remote Procedure Call (JSON-RPC) version 2 protocol</a>
+ */

package/source/class/qx/io/request/authentication/Bearer.js

@@ -0,0 +1,52 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2004-2011 1&1 Internet AG, Germany, http://www.1und1.de
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Tristan Koch (tristankoch)
+     * Christian Boulanger (cboulanger)
+
+************************************************************************ */
+
+/**
+ * Bearer (token) authentication.
+ */
+qx.Class.define("qx.io.request.authentication.Bearer",
+{
+
+  extend: qx.core.Object,
+
+  implement: qx.io.request.authentication.IAuthentication,
+
+  /**
+   * @param token {string} The token to use.
+   */
+  construct : function(token)
+  {
+     this.__credentials = token;
+  },
+
+  members :
+  {
+    __credentials : null,
+
+    /**
+     * Headers to include for bearer (token) authentication.
+     * @return {Map} Map containing the authentication credentials
+     */
+    getAuthHeaders: function() {
+      return [
+        {key: "Authorization", value: "Bearer " + this.__credentials}
+      ];
+    }
+  }
+});

package/source/class/qx/io/transport/AbstractClient.js

@@ -0,0 +1,100 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+      2020 Christian Boulanger
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * Christian Boulanger (cboulanger)
+
+************************************************************************ */
+
+/**
+ * This class provides a the base class for all clients that use the
+ * transport implementations in this namespace. Since the static method
+ * `registerTransport` cannot be inherited by subclasses, they mus proxy it
+ * by adding `registerTransport : qx.io.transport.AbstractClient.registerTransport`
+ * to their `statics` section.
+ *
+ */
+qx.Class.define("qx.io.transport.AbstractClient", {
+  extend: qx.core.Object,
+  type: "abstract",
+
+  statics: {
+    /**
+     * Register a transport class for use with uris that match the given
+     * regular expression. The client will use the transport which first
+     * matches, starting with the last added transport
+     * @param {RegExp} uriRegExp
+     *    A regular expression which the URI must match
+     * @param {qx.io.transport.ITransport}  transportClass
+     *    The qooxdoo class implementing the transport
+     */
+    registerTransport(uriRegExp, transportClass) {
+      if (!this.constructor.__transports) {
+        this.constructor.__transports = [];
+      }
+      if (!qx.lang.Type.isRegExp(uriRegExp)) {
+        throw new Error("First argument must be a regular expression!");
+      }
+      if (!qx.Interface.classImplements(transportClass, qx.io.transport.ITransport)) {
+        throw new Error("Transport class must implement qx.io.transport.ITransport");
+      }
+      this.constructor.__transports.push({ uriRegExp, transport: transportClass});
+    }
+  },
+
+
+  properties: {
+    /**
+     * The transport object
+     */
+    transport: {
+      check : "qx.io.transport.ITransport"
+    }
+  },
+
+  members: {
+
+    /**
+     * Given a transport object implementing {@link qx.io.transport.ITransport}
+     * select that transport; if a string URI is passed, select one that has
+     * been registered for that class of URIs.
+     * @param {qx.io.transport.ITransport|String} transportOrUri
+     * @throws qx.io.exception.Transport
+     */
+    selectTransport(transportOrUri) {
+      let transport;
+      let uri;
+      if (qx.lang.Type.isString(transportOrUri)) {
+        if (!this.constructor.__transports) {
+          throw new Error("No transport has been registered. Put @use(qx.io.transport.X) in the doc block of your class, X being the transport class of your choice (such as qx.io.transport.Xhr for http transport).");
+        }
+        uri = transportOrUri;
+        for (let registeredTransport of this.constructor.__transports.reverse()) {
+          if (uri.match(registeredTransport.uriRegExp)) {
+            // eslint-disable-next-line new-cap
+            transport = new registeredTransport.transport(uri);
+          }
+        }
+        if (!transport) {
+          throw new qx.io.exception.Transport(`No matching transport for URI '${transportOrUri}'`, qx.io.exception.Transport.INVALID_URI);
+        }
+      } else {
+        if (!(transportOrUri instanceof qx.core.Object) || !qx.Interface.classImplements(transportOrUri.constructor, qx.io.transport.ITransport)) {
+          throw new Error("Argument must be an qooxdoo object implementing qx.io.transport.ITransport");
+        }
+        transport = transportOrUri;
+      }
+      this.setTransport(transport);
+    }
+  }
+});

package/source/class/qx/io/transport/AbstractTransport.js

@@ -0,0 +1,41 @@
+/**
+ * Abstract class for JSON-RPC transports
+ *
+ * For the moment, any special configuration of the transport, such as
+ * authentication, must be done on the level of the underlying implementation,
+ * an abstract API will be added later.
+ */
+qx.Class.define("qx.io.transport.AbstractTransport", {
+
+  extend: qx.core.Object,
+  type: "abstract",
+
+  properties : {
+    /**
+     *  A representation of the the endpoint, which is either a uri (a String)
+     *  or an object (such as in the case of the PostMessage transport)
+     */
+    endpoint : {
+      check : v => typeof v == "string" || typeof v == "object",
+      nullable: true,
+      event : "changeEndpoint"
+    }
+  },
+
+  events : {
+    /**
+     * Event fired when a message is received from the endpoint. Event data
+     * is an UTF-8 encoded string
+     */
+    "message" : "qx.event.type.Data"
+  },
+
+  /**
+   * Constructor
+   * @param {String|Object} endpoint
+   */
+  construct(endpoint) {
+    this.base(arguments);
+    this.setEndpoint(endpoint);
+  }
+});

package/source/class/qx/io/transport/Fetch.js

@@ -0,0 +1,95 @@
+/**
+ * The implementation of a HTTP Transport using the Fetch API,
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch
+ */
+qx.Class.define("qx.io.transport.Fetch", {
+  extend: qx.io.transport.AbstractTransport,
+  implement: [qx.io.transport.ITransport],
+
+  /**
+   * Constructor.
+   *
+   * @param {String} url The URL of the http endpoint
+   */
+  construct(url) {
+    this.base(arguments, url);
+  },
+
+  members: {
+
+    /**
+     * @type {Object}
+     */
+    __tranportImpl: null,
+
+    /**
+     * Returns the object which implements the transport on the
+     * underlying level, so that transport-specific configuration
+     * can be done on it. In the case of the Fetch API, the
+     * "implementation" is a configuration object which will be
+     * passed to the `fetch` method as second parameter.
+     *
+     * @return {Object}
+     */
+    getTransportImpl() {
+      if (!this.__tranportImpl) {
+        this.__tranportImpl = this._createTransportImpl();
+      }
+      return this.__tranportImpl;
+    },
+
+    /**
+     * Transport the given message to the endpoint
+     *
+     * @param {String} message
+     *
+     * @return {qx.Promise} Promise that resolves (with no data)
+     * when the message has been successfully sent out, and rejects
+     * when there is an error or a cancellation up to that point.
+     * @ignore(fetch)
+     */
+    async send(message) {
+      qx.core.Assert.assertString(message);
+      let init = this.getTransportImpl();
+      init.body = message;
+      let response;
+      try {
+        response = await fetch(this.getEndpoint(), init);
+      } catch (e) {
+        throw new qx.io.exception.Transport(e.message, e.code);
+      }
+      if (!response.ok) {
+        switch (response.status) {
+          case 400:
+            // "400 Bad Request" is a really a protocol error (syntax error)
+            break;
+          default:
+            throw new qx.io.exception.Transport(response.statusText, response.status);
+        }
+      }
+      let responseData = await response.text();
+      // notify listeners
+      this.fireDataEvent("message", responseData);
+    },
+
+    /**
+     * Factory method to create a request object. In this implementation,
+     * it returns an object that will be used as the `init` parameter of the
+     * fetch method.
+     * @return {Object}
+     */
+    _createTransportImpl() {
+      let init = {};
+      init.headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      };
+      init.method = "POST";
+      return init;
+    }
+  },
+
+  defer() {
+    qx.io.graphql.Client.registerTransport(/^http/, qx.io.transport.Fetch);
+  }
+});

package/source/class/qx/io/transport/ITransport.js

@@ -0,0 +1,40 @@
+/**
+ * The interface for all transports located in this namespace
+ */
+qx.Interface.define("qx.io.transport.ITransport", {
+  properties: {
+    /**
+     * The URI of the endpoint
+     * @var {String}
+     */
+    endpoint: {
+      event: "changeEndpoint"
+    }
+  },
+  events: {
+    /**
+     * Event fired when a message is received from the endpoint. Event data
+     * is an UTF-8 encoded string
+     */
+    "message": "qx.event.type.Data"
+  },
+  members : {
+    /**
+     * Transport the given message to the endpoint
+     *
+     * @param {String} message
+     * @return {qx.Promise} Promise that resolves (with no data)
+     * when the message has been successfully sent out, and rejects
+     * when there is an error or a cancellation up to that point.
+     */
+    async send(message) {},
+
+    /**
+     * Returns the object which implements the transport on the underlying
+     * level, so that transport-specific configuration can be done on it.
+     * The object might be a new one for each request.
+     * @return {Object}
+     */
+    getTransportImpl() {}
+  }
+});

package/source/class/qx/io/transport/PostMessage.js

@@ -0,0 +1,55 @@
+/**
+ * An implementation of a PostMessage transport
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage
+ * The transport is special isasmuch it is not used with an URI, but with the
+ * target Window or Worker object with acts as the endpoint of the message.
+ */
+qx.Class.define("qx.io.transport.PostMessage", {
+  extend: qx.io.transport.AbstractTransport,
+  implement: [qx.io.transport.ITransport],
+
+  /**
+   * Constructor.
+   *
+   * @param {Window|Worker} windowOrWorker The target Window or Worker instance
+   * which is the endpoint for the request
+   */
+  construct(windowOrWorker) {
+    windowOrWorker.addEventListener("message", evt => {
+      this.fireDataEvent("message", evt.data);
+    });
+    this.base(arguments, windowOrWorker);
+  },
+
+  members: {
+
+    /**
+     * PostMessage is a very simple protocol without configuration options.
+     * No transport implementation is needed.
+     * @return {null}
+     */
+    getTransportImpl() {
+      return null;
+    },
+
+    /**
+     * Transport the given message to the endpoint
+     *
+     * @param {String} message
+     *
+     * @return {qx.Promise} Promise that resolves (with no data)
+     * when the message has been successfully sent out, and rejects
+     * when there is an error or a cancellation up to that point.
+     * @ignore(fetch)
+     */
+    async send(message) {
+      qx.core.Assert.assertString(message);
+      this.getEndpoint().postMessage(message);
+    },
+
+    /**
+     * Empty stub since no transport implementation is needed.
+     */
+    _createTransportImpl() {}
+  }
+});

package/source/class/qx/io/transport/Websocket.js

@@ -0,0 +1,97 @@
+/**
+ * An implementation of a WebSocket transport
+ * @see https://developer.mozilla.org/de/docs/Web/API/WebSocket
+ * @ignore(WebSocket)
+ */
+qx.Class.define("qx.io.transport.Websocket", {
+  extend: qx.io.transport.AbstractTransport,
+  implement: [qx.io.transport.ITransport],
+
+  /**
+   * Constructor.
+   *
+   * @param {String} url The URL of the http endpoint
+   */
+  construct(url) {
+    this.base(arguments, url);
+  },
+
+  members: {
+
+    /**
+     * @type {WebSocket}
+     */
+    __tranportImpl: null,
+
+    /**
+     * Returns the object which implements the transport on the
+     * underlying level, so that transport-specific configuration
+     * can be done on it.
+     *
+     * @return {WebSocket}
+     */
+    getTransportImpl() {
+      if (!this.__tranportImpl) {
+        this.__tranportImpl = this._createTransportImpl();
+      }
+      return this.__tranportImpl;
+    },
+
+    /**
+     * Transport the given message to the endpoint
+     *
+     * @param {String} message
+     *
+     * @return {qx.Promise} Promise that resolves (with no data)
+     * when the message has been successfully sent out, and rejects
+     * when there is an error or a cancellation up to that point.
+     * @ignore(fetch)
+     */
+    async send(message) {
+      qx.core.Assert.assertString(message);
+      let ws = this.getTransportImpl();
+      if (!ws.readyState !== WebSocket.OPEN) {
+        await new Promise(resolve => ws.addEventListener("open", resolve));
+      }
+      ws.send(message);
+    },
+
+    /**
+     * Factory method to create a websocket object.
+     * @return {WebSocket}
+     */
+    _createTransportImpl() {
+      let ws = new WebSocket(this.getEndpoint());
+      ws.addEventListener("message", msgevt => {
+        this.fireDataEvent("message", msgevt.data)
+      });
+      ws.addEventListener("close", event => {
+        let error_message;
+        let error_code;
+        switch(event.code) {
+          case  1000:
+            // everything ok
+            break;
+          default:
+            // todo translate websocket error codes into qx.io.exception.Transport error codes
+            // see https://github.com/Luka967/websocket-close-codes
+            error_message = "Error " + event.code;
+            error_code = qx.io.exception.Transport.FAILED;
+        }
+        if (error_message) {
+          throw new qx.io.exception.Transport(error_message, error_code, event);
+        }
+      });
+      return ws;
+    }
+  },
+
+  destruct() {
+    this.__tranportImpl.close();
+    this.__tranportImpl = null;
+  },
+
+  defer() {
+    qx.io.graphql.Client.registerTransport(/^ws/, qx.io.transport.Websocket);
+  }
+});