parse-server 2.8.4 → 8.6.2

package/lib/Adapters/Auth/wechat.js

@@ -1,48 +1,110 @@
-'use strict';
+"use strict";
 
-// Helper functions for accessing the WeChat Graph API.
-var https = require('https');
-var Parse = require('parse/node').Parse;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _BaseCodeAuthAdapter = _interopRequireDefault(require("./BaseCodeAuthAdapter"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Parse Server authentication adapter for WeChat.
+ *
+ * @class WeChatAdapter
+ * @param {Object} options - The adapter options object.
+ * @param {boolean} [options.enableInsecureAuth=false] - **[DEPRECATED]** Enable insecure authentication (not recommended).
+ * @param {string} options.clientId - Your WeChat App ID.
+ * @param {string} options.clientSecret - Your WeChat App Secret.
+ *
+ * @description
+ * ## Parse Server Configuration
+ * To configure Parse Server for WeChat authentication, use the following structure:
+ * ### Secure Configuration (Recommended)
+ * ```json
+ * {
+ *   "auth": {
+ *     "wechat": {
+ *       "clientId": "your-client-id",
+ *       "clientSecret": "your-client-secret"
+ *     }
+ *   }
+ * }
+ * ```
+ * ### Insecure Configuration (Not Recommended)
+ * ```json
+ * {
+ *   "auth": {
+ *     "wechat": {
+ *       "enableInsecureAuth": true
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The adapter requires the following `authData` fields:
+ * - **With `enableInsecureAuth` (Not Recommended)**: `id`, `access_token`.
+ * - **Without `enableInsecureAuth`**: `code`.
+ *
+ * ## Auth Payloads
+ * ### Secure Authentication Payload (Recommended)
+ * ```json
+ * {
+ *   "wechat": {
+ *     "code": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+ *   }
+ * }
+ * ```
+ * ### Insecure Authentication Payload (Not Recommended)
+ * ```json
+ * {
+ *   "wechat": {
+ *     "id": "1234567",
+ *     "access_token": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * - With `enableInsecureAuth`, the adapter directly validates the `id` and `access_token` sent by the client.
+ * - Without `enableInsecureAuth`, the adapter uses the `code` provided by the client to exchange for an access token via WeChat's OAuth API.
+ * - The `enableInsecureAuth` flag is **deprecated** and may be removed in future versions. Use secure authentication with the `code` field instead.
+ *
+ * @example <caption>Auth Data Example</caption>
+ * // Example authData provided by the client:
+ * const authData = {
+ *   wechat: {
+ *     code: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+ *   }
+ * };
+ *
+ * @see {@link https://developers.weixin.qq.com/doc/offiaccount/en/OA_Web_Apps/Wechat_webpage_authorization.html WeChat Authentication Documentation}
+ */
 
-// Returns a promise that fulfills iff this user id is valid.
-function validateAuthData(authData) {
-  return graphRequest('auth?access_token=' + authData.access_token + '&openid=' + authData.id).then(function (data) {
-    if (data.errcode == 0) {
-      return;
+class WeChatAdapter extends _BaseCodeAuthAdapter.default {
+  constructor() {
+    super('WeChat');
+  }
+  async getUserFromAccessToken(access_token, authData) {
+    const response = await fetch(`https://api.weixin.qq.com/sns/auth?access_token=${access_token}&openid=${authData.id}`);
+    const data = await response.json();
+    if (!response.ok || data.errcode !== 0) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'WeChat auth is invalid for this user.');
     }
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'wechat auth is invalid for this user.');
-  });
-}
-
-// Returns a promise that fulfills if this app id is valid.
-function validateAppId() {
-  return Promise.resolve();
-}
-
-// A promisey wrapper for WeChat graph requests.
-function graphRequest(path) {
-  return new Promise(function (resolve, reject) {
-    https.get('https://api.weixin.qq.com/sns/' + path, function (res) {
-      var data = '';
-      res.on('data', function (chunk) {
-        data += chunk;
-      });
-      res.on('end', function () {
-        try {
-          data = JSON.parse(data);
-        } catch (e) {
-          return reject(e);
-        }
-        resolve(data);
-      });
-    }).on('error', function () {
-      reject('Failed to validate this access token with wechat.');
-    });
-  });
+    return data;
+  }
+  async getAccessTokenFromCode(authData) {
+    if (!authData.code) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'WeChat auth requires a code to be sent.');
+    }
+    const appId = this.clientId;
+    const appSecret = this.clientSecret;
+    const response = await fetch(`https://api.weixin.qq.com/sns/oauth2/access_token?appid=${appId}&secret=${appSecret}&code=${authData.code}&grant_type=authorization_code`);
+    const data = await response.json();
+    if (!response.ok || data.errcode) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'WeChat auth is invalid for this user.');
+    }
+    authData.id = data.openid;
+    return data.access_token;
+  }
 }
-
-module.exports = {
-  validateAppId,
-  validateAuthData
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9BdXRoL3dlY2hhdC5qcyJdLCJuYW1lcyI6WyJodHRwcyIsInJlcXVpcmUiLCJQYXJzZSIsInZhbGlkYXRlQXV0aERhdGEiLCJhdXRoRGF0YSIsImdyYXBoUmVxdWVzdCIsImFjY2Vzc190b2tlbiIsImlkIiwidGhlbiIsImRhdGEiLCJlcnJjb2RlIiwiRXJyb3IiLCJPQkpFQ1RfTk9UX0ZPVU5EIiwidmFsaWRhdGVBcHBJZCIsIlByb21pc2UiLCJyZXNvbHZlIiwicGF0aCIsInJlamVjdCIsImdldCIsInJlcyIsIm9uIiwiY2h1bmsiLCJKU09OIiwicGFyc2UiLCJlIiwibW9kdWxlIiwiZXhwb3J0cyJdLCJtYXBwaW5ncyI6Ijs7QUFBQTtBQUNBLElBQUlBLFFBQVFDLFFBQVEsT0FBUixDQUFaO0FBQ0EsSUFBSUMsUUFBUUQsUUFBUSxZQUFSLEVBQXNCQyxLQUFsQzs7QUFFQTtBQUNBLFNBQVNDLGdCQUFULENBQTBCQyxRQUExQixFQUFvQztBQUNsQyxTQUFPQyxhQUFhLHVCQUF1QkQsU0FBU0UsWUFBaEMsR0FBK0MsVUFBL0MsR0FBNERGLFNBQVNHLEVBQWxGLEVBQXNGQyxJQUF0RixDQUEyRixVQUFVQyxJQUFWLEVBQWdCO0FBQ2hILFFBQUlBLEtBQUtDLE9BQUwsSUFBZ0IsQ0FBcEIsRUFBdUI7QUFDckI7QUFDRDtBQUNELFVBQU0sSUFBSVIsTUFBTVMsS0FBVixDQUFnQlQsTUFBTVMsS0FBTixDQUFZQyxnQkFBNUIsRUFBOEMsdUNBQTlDLENBQU47QUFDRCxHQUxNLENBQVA7QUFNRDs7QUFFRDtBQUNBLFNBQVNDLGFBQVQsR0FBeUI7QUFDdkIsU0FBT0MsUUFBUUMsT0FBUixFQUFQO0FBQ0Q7O0FBRUQ7QUFDQSxTQUFTVixZQUFULENBQXNCVyxJQUF0QixFQUE0QjtBQUMxQixTQUFPLElBQUlGLE9BQUosQ0FBWSxVQUFVQyxPQUFWLEVBQW1CRSxNQUFuQixFQUEyQjtBQUM1Q2pCLFVBQU1rQixHQUFOLENBQVUsbUNBQW1DRixJQUE3QyxFQUFtRCxVQUFVRyxHQUFWLEVBQWU7QUFDaEUsVUFBSVYsT0FBTyxFQUFYO0FBQ0FVLFVBQUlDLEVBQUosQ0FBTyxNQUFQLEVBQWUsVUFBVUMsS0FBVixFQUFpQjtBQUM5QlosZ0JBQVFZLEtBQVI7QUFDRCxPQUZEO0FBR0FGLFVBQUlDLEVBQUosQ0FBTyxLQUFQLEVBQWMsWUFBWTtBQUN4QixZQUFJO0FBQ0ZYLGlCQUFPYSxLQUFLQyxLQUFMLENBQVdkLElBQVgsQ0FBUDtBQUNELFNBRkQsQ0FFRSxPQUFNZSxDQUFOLEVBQVM7QUFDVCxpQkFBT1AsT0FBT08sQ0FBUCxDQUFQO0FBQ0Q7QUFDRFQsZ0JBQVFOLElBQVI7QUFDRCxPQVBEO0FBUUQsS0FiRCxFQWFHVyxFQWJILENBYU0sT0FiTixFQWFlLFlBQVk7QUFDekJILGFBQU8sbURBQVA7QUFDRCxLQWZEO0FBZ0JELEdBakJNLENBQVA7QUFrQkQ7O0FBRURRLE9BQU9DLE9BQVAsR0FBaUI7QUFDZmIsZUFEZTtBQUVmVjtBQUZlLENBQWpCIiwiZmlsZSI6IndlY2hhdC5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEhlbHBlciBmdW5jdGlvbnMgZm9yIGFjY2Vzc2luZyB0aGUgV2VDaGF0IEdyYXBoIEFQSS5cbnZhciBodHRwcyA9IHJlcXVpcmUoJ2h0dHBzJyk7XG52YXIgUGFyc2UgPSByZXF1aXJlKCdwYXJzZS9ub2RlJykuUGFyc2U7XG5cbi8vIFJldHVybnMgYSBwcm9taXNlIHRoYXQgZnVsZmlsbHMgaWZmIHRoaXMgdXNlciBpZCBpcyB2YWxpZC5cbmZ1bmN0aW9uIHZhbGlkYXRlQXV0aERhdGEoYXV0aERhdGEpIHtcbiAgcmV0dXJuIGdyYXBoUmVxdWVzdCgnYXV0aD9hY2Nlc3NfdG9rZW49JyArIGF1dGhEYXRhLmFjY2Vzc190b2tlbiArICcmb3BlbmlkPScgKyBhdXRoRGF0YS5pZCkudGhlbihmdW5jdGlvbiAoZGF0YSkge1xuICAgIGlmIChkYXRhLmVycmNvZGUgPT0gMCkge1xuICAgICAgcmV0dXJuO1xuICAgIH1cbiAgICB0aHJvdyBuZXcgUGFyc2UuRXJyb3IoUGFyc2UuRXJyb3IuT0JKRUNUX05PVF9GT1VORCwgJ3dlY2hhdCBhdXRoIGlzIGludmFsaWQgZm9yIHRoaXMgdXNlci4nKTtcbiAgfSk7XG59XG5cbi8vIFJldHVybnMgYSBwcm9taXNlIHRoYXQgZnVsZmlsbHMgaWYgdGhpcyBhcHAgaWQgaXMgdmFsaWQuXG5mdW5jdGlvbiB2YWxpZGF0ZUFwcElkKCkge1xuICByZXR1cm4gUHJvbWlzZS5yZXNvbHZlKCk7XG59XG5cbi8vIEEgcHJvbWlzZXkgd3JhcHBlciBmb3IgV2VDaGF0IGdyYXBoIHJlcXVlc3RzLlxuZnVuY3Rpb24gZ3JhcGhSZXF1ZXN0KHBhdGgpIHtcbiAgcmV0dXJuIG5ldyBQcm9taXNlKGZ1bmN0aW9uIChyZXNvbHZlLCByZWplY3QpIHtcbiAgICBodHRwcy5nZXQoJ2h0dHBzOi8vYXBpLndlaXhpbi5xcS5jb20vc25zLycgKyBwYXRoLCBmdW5jdGlvbiAocmVzKSB7XG4gICAgICB2YXIgZGF0YSA9ICcnO1xuICAgICAgcmVzLm9uKCdkYXRhJywgZnVuY3Rpb24gKGNodW5rKSB7XG4gICAgICAgIGRhdGEgKz0gY2h1bms7XG4gICAgICB9KTtcbiAgICAgIHJlcy5vbignZW5kJywgZnVuY3Rpb24gKCkge1xuICAgICAgICB0cnkge1xuICAgICAgICAgIGRhdGEgPSBKU09OLnBhcnNlKGRhdGEpO1xuICAgICAgICB9IGNhdGNoKGUpIHtcbiAgICAgICAgICByZXR1cm4gcmVqZWN0KGUpO1xuICAgICAgICB9XG4gICAgICAgIHJlc29sdmUoZGF0YSk7XG4gICAgICB9KTtcbiAgICB9KS5vbignZXJyb3InLCBmdW5jdGlvbiAoKSB7XG4gICAgICByZWplY3QoJ0ZhaWxlZCB0byB2YWxpZGF0ZSB0aGlzIGFjY2VzcyB0b2tlbiB3aXRoIHdlY2hhdC4nKTtcbiAgICB9KTtcbiAgfSk7XG59XG5cbm1vZHVsZS5leHBvcnRzID0ge1xuICB2YWxpZGF0ZUFwcElkLFxuICB2YWxpZGF0ZUF1dGhEYXRhXG59O1xuIl19
+var _default = exports.default = new WeChatAdapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfQmFzZUNvZGVBdXRoQWRhcHRlciIsIl9pbnRlcm9wUmVxdWlyZURlZmF1bHQiLCJyZXF1aXJlIiwiZSIsIl9fZXNNb2R1bGUiLCJkZWZhdWx0IiwiV2VDaGF0QWRhcHRlciIsIkJhc2VBdXRoQ29kZUFkYXB0ZXIiLCJjb25zdHJ1Y3RvciIsImdldFVzZXJGcm9tQWNjZXNzVG9rZW4iLCJhY2Nlc3NfdG9rZW4iLCJhdXRoRGF0YSIsInJlc3BvbnNlIiwiZmV0Y2giLCJpZCIsImRhdGEiLCJqc29uIiwib2siLCJlcnJjb2RlIiwiUGFyc2UiLCJFcnJvciIsIk9CSkVDVF9OT1RfRk9VTkQiLCJnZXRBY2Nlc3NUb2tlbkZyb21Db2RlIiwiY29kZSIsImFwcElkIiwiY2xpZW50SWQiLCJhcHBTZWNyZXQiLCJjbGllbnRTZWNyZXQiLCJvcGVuaWQiLCJfZGVmYXVsdCIsImV4cG9ydHMiXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvQWRhcHRlcnMvQXV0aC93ZWNoYXQuanMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBQYXJzZSBTZXJ2ZXIgYXV0aGVudGljYXRpb24gYWRhcHRlciBmb3IgV2VDaGF0LlxuICpcbiAqIEBjbGFzcyBXZUNoYXRBZGFwdGVyXG4gKiBAcGFyYW0ge09iamVjdH0gb3B0aW9ucyAtIFRoZSBhZGFwdGVyIG9wdGlvbnMgb2JqZWN0LlxuICogQHBhcmFtIHtib29sZWFufSBbb3B0aW9ucy5lbmFibGVJbnNlY3VyZUF1dGg9ZmFsc2VdIC0gKipbREVQUkVDQVRFRF0qKiBFbmFibGUgaW5zZWN1cmUgYXV0aGVudGljYXRpb24gKG5vdCByZWNvbW1lbmRlZCkuXG4gKiBAcGFyYW0ge3N0cmluZ30gb3B0aW9ucy5jbGllbnRJZCAtIFlvdXIgV2VDaGF0IEFwcCBJRC5cbiAqIEBwYXJhbSB7c3RyaW5nfSBvcHRpb25zLmNsaWVudFNlY3JldCAtIFlvdXIgV2VDaGF0IEFwcCBTZWNyZXQuXG4gKlxuICogQGRlc2NyaXB0aW9uXG4gKiAjIyBQYXJzZSBTZXJ2ZXIgQ29uZmlndXJhdGlvblxuICogVG8gY29uZmlndXJlIFBhcnNlIFNlcnZlciBmb3IgV2VDaGF0IGF1dGhlbnRpY2F0aW9uLCB1c2UgdGhlIGZvbGxvd2luZyBzdHJ1Y3R1cmU6XG4gKiAjIyMgU2VjdXJlIENvbmZpZ3VyYXRpb24gKFJlY29tbWVuZGVkKVxuICogYGBganNvblxuICoge1xuICogICBcImF1dGhcIjoge1xuICogICAgIFwid2VjaGF0XCI6IHtcbiAqICAgICAgIFwiY2xpZW50SWRcIjogXCJ5b3VyLWNsaWVudC1pZFwiLFxuICogICAgICAgXCJjbGllbnRTZWNyZXRcIjogXCJ5b3VyLWNsaWVudC1zZWNyZXRcIlxuICogICAgIH1cbiAqICAgfVxuICogfVxuICogYGBgXG4gKiAjIyMgSW5zZWN1cmUgQ29uZmlndXJhdGlvbiAoTm90IFJlY29tbWVuZGVkKVxuICogYGBganNvblxuICoge1xuICogICBcImF1dGhcIjoge1xuICogICAgIFwid2VjaGF0XCI6IHtcbiAqICAgICAgIFwiZW5hYmxlSW5zZWN1cmVBdXRoXCI6IHRydWVcbiAqICAgICB9XG4gKiAgIH1cbiAqIH1cbiAqIGBgYFxuICpcbiAqIFRoZSBhZGFwdGVyIHJlcXVpcmVzIHRoZSBmb2xsb3dpbmcgYGF1dGhEYXRhYCBmaWVsZHM6XG4gKiAtICoqV2l0aCBgZW5hYmxlSW5zZWN1cmVBdXRoYCAoTm90IFJlY29tbWVuZGVkKSoqOiBgaWRgLCBgYWNjZXNzX3Rva2VuYC5cbiAqIC0gKipXaXRob3V0IGBlbmFibGVJbnNlY3VyZUF1dGhgKio6IGBjb2RlYC5cbiAqXG4gKiAjIyBBdXRoIFBheWxvYWRzXG4gKiAjIyMgU2VjdXJlIEF1dGhlbnRpY2F0aW9uIFBheWxvYWQgKFJlY29tbWVuZGVkKVxuICogYGBganNvblxuICoge1xuICogICBcIndlY2hhdFwiOiB7XG4gKiAgICAgXCJjb2RlXCI6IFwieHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHhcIlxuICogICB9XG4gKiB9XG4gKiBgYGBcbiAqICMjIyBJbnNlY3VyZSBBdXRoZW50aWNhdGlvbiBQYXlsb2FkIChOb3QgUmVjb21tZW5kZWQpXG4gKiBgYGBqc29uXG4gKiB7XG4gKiAgIFwid2VjaGF0XCI6IHtcbiAqICAgICBcImlkXCI6IFwiMTIzNDU2N1wiLFxuICogICAgIFwiYWNjZXNzX3Rva2VuXCI6IFwieHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHhcIlxuICogICB9XG4gKiB9XG4gKiBgYGBcbiAqXG4gKiAjIyBOb3Rlc1xuICogLSBXaXRoIGBlbmFibGVJbnNlY3VyZUF1dGhgLCB0aGUgYWRhcHRlciBkaXJlY3RseSB2YWxpZGF0ZXMgdGhlIGBpZGAgYW5kIGBhY2Nlc3NfdG9rZW5gIHNlbnQgYnkgdGhlIGNsaWVudC5cbiAqIC0gV2l0aG91dCBgZW5hYmxlSW5zZWN1cmVBdXRoYCwgdGhlIGFkYXB0ZXIgdXNlcyB0aGUgYGNvZGVgIHByb3ZpZGVkIGJ5IHRoZSBjbGllbnQgdG8gZXhjaGFuZ2UgZm9yIGFuIGFjY2VzcyB0b2tlbiB2aWEgV2VDaGF0J3MgT0F1dGggQVBJLlxuICogLSBUaGUgYGVuYWJsZUluc2VjdXJlQXV0aGAgZmxhZyBpcyAqKmRlcHJlY2F0ZWQqKiBhbmQgbWF5IGJlIHJlbW92ZWQgaW4gZnV0dXJlIHZlcnNpb25zLiBVc2Ugc2VjdXJlIGF1dGhlbnRpY2F0aW9uIHdpdGggdGhlIGBjb2RlYCBmaWVsZCBpbnN0ZWFkLlxuICpcbiAqIEBleGFtcGxlIDxjYXB0aW9uPkF1dGggRGF0YSBFeGFtcGxlPC9jYXB0aW9uPlxuICogLy8gRXhhbXBsZSBhdXRoRGF0YSBwcm92aWRlZCBieSB0aGUgY2xpZW50OlxuICogY29uc3QgYXV0aERhdGEgPSB7XG4gKiAgIHdlY2hhdDoge1xuICogICAgIGNvZGU6IFwieHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHhcIlxuICogICB9XG4gKiB9O1xuICpcbiAqIEBzZWUge0BsaW5rIGh0dHBzOi8vZGV2ZWxvcGVycy53ZWl4aW4ucXEuY29tL2RvYy9vZmZpYWNjb3VudC9lbi9PQV9XZWJfQXBwcy9XZWNoYXRfd2VicGFnZV9hdXRob3JpemF0aW9uLmh0bWwgV2VDaGF0IEF1dGhlbnRpY2F0aW9uIERvY3VtZW50YXRpb259XG4gKi9cblxuaW1wb3J0IEJhc2VBdXRoQ29kZUFkYXB0ZXIgZnJvbSAnLi9CYXNlQ29kZUF1dGhBZGFwdGVyJztcblxuY2xhc3MgV2VDaGF0QWRhcHRlciBleHRlbmRzIEJhc2VBdXRoQ29kZUFkYXB0ZXIge1xuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcignV2VDaGF0Jyk7XG4gIH1cblxuICBhc3luYyBnZXRVc2VyRnJvbUFjY2Vzc1Rva2VuKGFjY2Vzc190b2tlbiwgYXV0aERhdGEpIHtcbiAgICBjb25zdCByZXNwb25zZSA9IGF3YWl0IGZldGNoKFxuICAgICAgYGh0dHBzOi8vYXBpLndlaXhpbi5xcS5jb20vc25zL2F1dGg/YWNjZXNzX3Rva2VuPSR7YWNjZXNzX3Rva2VufSZvcGVuaWQ9JHthdXRoRGF0YS5pZH1gXG4gICAgKTtcblxuICAgIGNvbnN0IGRhdGEgPSBhd2FpdCByZXNwb25zZS5qc29uKCk7XG5cbiAgICBpZiAoIXJlc3BvbnNlLm9rIHx8IGRhdGEuZXJyY29kZSAhPT0gMCkge1xuICAgICAgdGhyb3cgbmV3IFBhcnNlLkVycm9yKFBhcnNlLkVycm9yLk9CSkVDVF9OT1RfRk9VTkQsICdXZUNoYXQgYXV0aCBpcyBpbnZhbGlkIGZvciB0aGlzIHVzZXIuJyk7XG4gICAgfVxuXG4gICAgcmV0dXJuIGRhdGE7XG4gIH1cblxuICBhc3luYyBnZXRBY2Nlc3NUb2tlbkZyb21Db2RlKGF1dGhEYXRhKSB7XG4gICAgaWYgKCFhdXRoRGF0YS5jb2RlKSB7XG4gICAgICB0aHJvdyBuZXcgUGFyc2UuRXJyb3IoUGFyc2UuRXJyb3IuT0JKRUNUX05PVF9GT1VORCwgJ1dlQ2hhdCBhdXRoIHJlcXVpcmVzIGEgY29kZSB0byBiZSBzZW50LicpO1xuICAgIH1cblxuICAgIGNvbnN0IGFwcElkID0gdGhpcy5jbGllbnRJZDtcbiAgICBjb25zdCBhcHBTZWNyZXQgPSB0aGlzLmNsaWVudFNlY3JldFxuXG5cbiAgICBjb25zdCByZXNwb25zZSA9IGF3YWl0IGZldGNoKFxuICAgICAgYGh0dHBzOi8vYXBpLndlaXhpbi5xcS5jb20vc25zL29hdXRoMi9hY2Nlc3NfdG9rZW4/YXBwaWQ9JHthcHBJZH0mc2VjcmV0PSR7YXBwU2VjcmV0fSZjb2RlPSR7YXV0aERhdGEuY29kZX0mZ3JhbnRfdHlwZT1hdXRob3JpemF0aW9uX2NvZGVgXG4gICAgKTtcblxuICAgIGNvbnN0IGRhdGEgPSBhd2FpdCByZXNwb25zZS5qc29uKCk7XG5cbiAgICBpZiAoIXJlc3BvbnNlLm9rIHx8IGRhdGEuZXJyY29kZSkge1xuICAgICAgdGhyb3cgbmV3IFBhcnNlLkVycm9yKFBhcnNlLkVycm9yLk9CSkVDVF9OT1RfRk9VTkQsICdXZUNoYXQgYXV0aCBpcyBpbnZhbGlkIGZvciB0aGlzIHVzZXIuJyk7XG4gICAgfVxuXG4gICAgYXV0aERhdGEuaWQgPSBkYXRhLm9wZW5pZDtcblxuICAgIHJldHVybiBkYXRhLmFjY2Vzc190b2tlbjtcbiAgfVxufVxuXG5leHBvcnQgZGVmYXVsdCBuZXcgV2VDaGF0QWRhcHRlcigpO1xuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUF5RUEsSUFBQUEsb0JBQUEsR0FBQUMsc0JBQUEsQ0FBQUMsT0FBQTtBQUF3RCxTQUFBRCx1QkFBQUUsQ0FBQSxXQUFBQSxDQUFBLElBQUFBLENBQUEsQ0FBQUMsVUFBQSxHQUFBRCxDQUFBLEtBQUFFLE9BQUEsRUFBQUYsQ0FBQTtBQXpFeEQ7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBOztBQUlBLE1BQU1HLGFBQWEsU0FBU0MsNEJBQW1CLENBQUM7RUFDOUNDLFdBQVdBLENBQUEsRUFBRztJQUNaLEtBQUssQ0FBQyxRQUFRLENBQUM7RUFDakI7RUFFQSxNQUFNQyxzQkFBc0JBLENBQUNDLFlBQVksRUFBRUMsUUFBUSxFQUFFO0lBQ25ELE1BQU1DLFFBQVEsR0FBRyxNQUFNQyxLQUFLLENBQzFCLG1EQUFtREgsWUFBWSxXQUFXQyxRQUFRLENBQUNHLEVBQUUsRUFDdkYsQ0FBQztJQUVELE1BQU1DLElBQUksR0FBRyxNQUFNSCxRQUFRLENBQUNJLElBQUksQ0FBQyxDQUFDO0lBRWxDLElBQUksQ0FBQ0osUUFBUSxDQUFDSyxFQUFFLElBQUlGLElBQUksQ0FBQ0csT0FBTyxLQUFLLENBQUMsRUFBRTtNQUN0QyxNQUFNLElBQUlDLEtBQUssQ0FBQ0MsS0FBSyxDQUFDRCxLQUFLLENBQUNDLEtBQUssQ0FBQ0MsZ0JBQWdCLEVBQUUsdUNBQXVDLENBQUM7SUFDOUY7SUFFQSxPQUFPTixJQUFJO0VBQ2I7RUFFQSxNQUFNTyxzQkFBc0JBLENBQUNYLFFBQVEsRUFBRTtJQUNyQyxJQUFJLENBQUNBLFFBQVEsQ0FBQ1ksSUFBSSxFQUFFO01BQ2xCLE1BQU0sSUFBSUosS0FBSyxDQUFDQyxLQUFLLENBQUNELEtBQUssQ0FBQ0MsS0FBSyxDQUFDQyxnQkFBZ0IsRUFBRSx5Q0FBeUMsQ0FBQztJQUNoRztJQUVBLE1BQU1HLEtBQUssR0FBRyxJQUFJLENBQUNDLFFBQVE7SUFDM0IsTUFBTUMsU0FBUyxHQUFHLElBQUksQ0FBQ0MsWUFBWTtJQUduQyxNQUFNZixRQUFRLEdBQUcsTUFBTUMsS0FBSyxDQUMxQiwyREFBMkRXLEtBQUssV0FBV0UsU0FBUyxTQUFTZixRQUFRLENBQUNZLElBQUksZ0NBQzVHLENBQUM7SUFFRCxNQUFNUixJQUFJLEdBQUcsTUFBTUgsUUFBUSxDQUFDSSxJQUFJLENBQUMsQ0FBQztJQUVsQyxJQUFJLENBQUNKLFFBQVEsQ0FBQ0ssRUFBRSxJQUFJRixJQUFJLENBQUNHLE9BQU8sRUFBRTtNQUNoQyxNQUFNLElBQUlDLEtBQUssQ0FBQ0MsS0FBSyxDQUFDRCxLQUFLLENBQUNDLEtBQUssQ0FBQ0MsZ0JBQWdCLEVBQUUsdUNBQXVDLENBQUM7SUFDOUY7SUFFQVYsUUFBUSxDQUFDRyxFQUFFLEdBQUdDLElBQUksQ0FBQ2EsTUFBTTtJQUV6QixPQUFPYixJQUFJLENBQUNMLFlBQVk7RUFDMUI7QUFDRjtBQUFDLElBQUFtQixRQUFBLEdBQUFDLE9BQUEsQ0FBQXpCLE9BQUEsR0FFYyxJQUFJQyxhQUFhLENBQUMsQ0FBQyIsImlnbm9yZUxpc3QiOltdfQ==

package/lib/Adapters/Auth/weibo.js

@@ -1,67 +1,141 @@
-'use strict';
+"use strict";
 
-// Helper functions for accessing the weibo Graph API.
-var https = require('https');
-var Parse = require('parse/node').Parse;
-var querystring = require('querystring');
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _BaseCodeAuthAdapter = _interopRequireDefault(require("./BaseCodeAuthAdapter"));
+var _querystring = _interopRequireDefault(require("querystring"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Parse Server authentication adapter for Weibo.
+ *
+ * @class WeiboAdapter
+ * @param {Object} options - The adapter configuration options.
+ * @param {boolean} [options.enableInsecureAuth=false] - **[DEPRECATED]** Enable insecure authentication (not recommended).
+ * @param {string} options.clientId - Your Weibo client ID.
+ * @param {string} options.clientSecret - Your Weibo client secret.
+ *
+ * @description
+ * ## Parse Server Configuration
+ * To configure Parse Server for Weibo authentication, use the following structure:
+ * ### Secure Configuration
+ * ```json
+ * {
+ *   "auth": {
+ *     "weibo": {
+ *       "clientId": "your-client-id",
+ *       "clientSecret": "your-client-secret"
+ *     }
+ *   }
+ * }
+ * ```
+ * ### Insecure Configuration (Not Recommended)
+ * ```json
+ * {
+ *   "auth": {
+ *     "weibo": {
+ *       "enableInsecureAuth": true
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The adapter requires the following `authData` fields:
+ * - **Secure Authentication**: `code`, `redirect_uri`.
+ * - **Insecure Authentication (Not Recommended)**: `id`, `access_token`.
+ *
+ * ## Auth Payloads
+ * ### Secure Authentication Payload
+ * ```json
+ * {
+ *   "weibo": {
+ *     "code": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+ *     "redirect_uri": "https://example.com/callback"
+ *   }
+ * }
+ * ```
+ * ### Insecure Authentication Payload (Not Recommended)
+ * ```json
+ * {
+ *   "weibo": {
+ *     "id": "1234567",
+ *     "access_token": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * - **Insecure Authentication**: When `enableInsecureAuth` is enabled, the adapter directly validates the `id` and `access_token` provided by the client.
+ * - **Secure Authentication**: When `enableInsecureAuth` is disabled, the adapter exchanges the `code` and `redirect_uri` for an access token using Weibo's OAuth API.
+ * - `enableInsecureAuth` is **deprecated** and may be removed in future versions. Use secure authentication with `code` and `redirect_uri`.
+ *
+ * @example <caption>Auth Data Example (Secure)</caption>
+ * const authData = {
+ *   weibo: {
+ *     code: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+ *     redirect_uri: "https://example.com/callback"
+ *   }
+ * };
+ *
+ * @example <caption>Auth Data Example (Insecure - Not Recommended)</caption>
+ * const authData = {
+ *   weibo: {
+ *     id: "1234567",
+ *     access_token: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+ *   }
+ * };
+ *
+ * @see {@link https://open.weibo.com/wiki/Oauth2/access_token Weibo Authentication Documentation}
+ */
 
-// Returns a promise that fulfills iff this user id is valid.
-function validateAuthData(authData) {
-  return graphRequest(authData.access_token).then(function (data) {
-    if (data && data.uid == authData.id) {
-      return;
-    }
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'weibo auth is invalid for this user.');
-  });
-}
-
-// Returns a promise that fulfills if this app id is valid.
-function validateAppId() {
-  return Promise.resolve();
-}
-
-// A promisey wrapper for weibo graph requests.
-function graphRequest(access_token) {
-  return new Promise(function (resolve, reject) {
-    var postData = querystring.stringify({
-      "access_token": access_token
+class WeiboAdapter extends _BaseCodeAuthAdapter.default {
+  constructor() {
+    super('Weibo');
+  }
+  async getUserFromAccessToken(access_token) {
+    const postData = _querystring.default.stringify({
+      access_token: access_token
     });
-    var options = {
-      hostname: 'api.weibo.com',
-      path: '/oauth2/get_token_info',
+    const response = await fetch('https://api.weibo.com/oauth2/get_token_info', {
       method: 'POST',
       headers: {
-        'Content-Type': 'application/x-www-form-urlencoded',
-        'Content-Length': Buffer.byteLength(postData)
-      }
+        'Content-Type': 'application/x-www-form-urlencoded'
+      },
+      body: postData
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Weibo auth is invalid for this user.');
+    }
+    return {
+      id: data.uid
     };
-    var req = https.request(options, function (res) {
-      var data = '';
-      res.on('data', function (chunk) {
-        data += chunk;
-      });
-      res.on('end', function () {
-        try {
-          data = JSON.parse(data);
-        } catch (e) {
-          return reject(e);
-        }
-        resolve(data);
-      });
-      res.on('error', function () {
-        reject('Failed to validate this access token with weibo.');
-      });
+  }
+  async getAccessTokenFromCode(authData) {
+    if (!authData?.code || !authData?.redirect_uri) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Weibo auth requires code and redirect_uri to be sent.');
+    }
+    const postData = _querystring.default.stringify({
+      client_id: this.clientId,
+      client_secret: this.clientSecret,
+      grant_type: 'authorization_code',
+      code: authData.code,
+      redirect_uri: authData.redirect_uri
     });
-    req.on('error', function () {
-      reject('Failed to validate this access token with weibo.');
+    const response = await fetch('https://api.weibo.com/oauth2/access_token', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded'
+      },
+      body: postData
     });
-    req.write(postData);
-    req.end();
-  });
+    const data = await response.json();
+    if (!response.ok || data.errcode) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Weibo auth is invalid for this user.');
+    }
+    return data.access_token;
+  }
 }
-
-module.exports = {
-  validateAppId,
-  validateAuthData
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+var _default = exports.default = new WeiboAdapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_BaseCodeAuthAdapter","_interopRequireDefault","require","_querystring","e","__esModule","default","WeiboAdapter","BaseAuthCodeAdapter","constructor","getUserFromAccessToken","access_token","postData","querystring","stringify","response","fetch","method","headers","body","data","json","ok","Parse","Error","OBJECT_NOT_FOUND","id","uid","getAccessTokenFromCode","authData","code","redirect_uri","client_id","clientId","client_secret","clientSecret","grant_type","errcode","_default","exports"],"sources":["../../../src/Adapters/Auth/weibo.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for Weibo.\n *\n * @class WeiboAdapter\n * @param {Object} options - The adapter configuration options.\n * @param {boolean} [options.enableInsecureAuth=false] - **[DEPRECATED]** Enable insecure authentication (not recommended).\n * @param {string} options.clientId - Your Weibo client ID.\n * @param {string} options.clientSecret - Your Weibo client secret.\n *\n * @description\n * ## Parse Server Configuration\n * To configure Parse Server for Weibo authentication, use the following structure:\n * ### Secure Configuration\n * ```json\n * {\n *   \"auth\": {\n *     \"weibo\": {\n *       \"clientId\": \"your-client-id\",\n *       \"clientSecret\": \"your-client-secret\"\n *     }\n *   }\n * }\n * ```\n * ### Insecure Configuration (Not Recommended)\n * ```json\n * {\n *   \"auth\": {\n *     \"weibo\": {\n *       \"enableInsecureAuth\": true\n *     }\n *   }\n * }\n * ```\n *\n * The adapter requires the following `authData` fields:\n * - **Secure Authentication**: `code`, `redirect_uri`.\n * - **Insecure Authentication (Not Recommended)**: `id`, `access_token`.\n *\n * ## Auth Payloads\n * ### Secure Authentication Payload\n * ```json\n * {\n *   \"weibo\": {\n *     \"code\": \"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\",\n *     \"redirect_uri\": \"https://example.com/callback\"\n *   }\n * }\n * ```\n * ### Insecure Authentication Payload (Not Recommended)\n * ```json\n * {\n *   \"weibo\": {\n *     \"id\": \"1234567\",\n *     \"access_token\": \"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"\n *   }\n * }\n * ```\n *\n * ## Notes\n * - **Insecure Authentication**: When `enableInsecureAuth` is enabled, the adapter directly validates the `id` and `access_token` provided by the client.\n * - **Secure Authentication**: When `enableInsecureAuth` is disabled, the adapter exchanges the `code` and `redirect_uri` for an access token using Weibo's OAuth API.\n * - `enableInsecureAuth` is **deprecated** and may be removed in future versions. Use secure authentication with `code` and `redirect_uri`.\n *\n * @example <caption>Auth Data Example (Secure)</caption>\n * const authData = {\n *   weibo: {\n *     code: \"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\",\n *     redirect_uri: \"https://example.com/callback\"\n *   }\n * };\n *\n * @example <caption>Auth Data Example (Insecure - Not Recommended)</caption>\n * const authData = {\n *   weibo: {\n *     id: \"1234567\",\n *     access_token: \"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"\n *   }\n * };\n *\n * @see {@link https://open.weibo.com/wiki/Oauth2/access_token Weibo Authentication Documentation}\n */\n\nimport BaseAuthCodeAdapter from './BaseCodeAuthAdapter';\nimport querystring from 'querystring';\n\nclass WeiboAdapter extends BaseAuthCodeAdapter {\n  constructor() {\n    super('Weibo');\n  }\n\n  async getUserFromAccessToken(access_token) {\n    const postData = querystring.stringify({\n      access_token: access_token,\n    });\n\n    const response = await fetch('https://api.weibo.com/oauth2/get_token_info', {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/x-www-form-urlencoded',\n      },\n      body: postData,\n    });\n\n    const data = await response.json();\n\n    if (!response.ok) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Weibo auth is invalid for this user.');\n    }\n\n    return {\n      id: data.uid,\n    }\n  }\n\n  async getAccessTokenFromCode(authData) {\n    if (!authData?.code || !authData?.redirect_uri) {\n      throw new Parse.Error(\n        Parse.Error.OBJECT_NOT_FOUND,\n        'Weibo auth requires code and redirect_uri to be sent.'\n      );\n    }\n\n    const postData = querystring.stringify({\n      client_id: this.clientId,\n      client_secret: this.clientSecret,\n      grant_type: 'authorization_code',\n      code: authData.code,\n      redirect_uri: authData.redirect_uri,\n    });\n\n    const response = await fetch('https://api.weibo.com/oauth2/access_token', {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/x-www-form-urlencoded',\n      },\n      body: postData,\n    });\n\n    const data = await response.json();\n\n    if (!response.ok || data.errcode) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Weibo auth is invalid for this user.');\n    }\n\n    return data.access_token;\n  }\n}\n\nexport default new WeiboAdapter();\n"],"mappings":";;;;;;AAkFA,IAAAA,oBAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,YAAA,GAAAF,sBAAA,CAAAC,OAAA;AAAsC,SAAAD,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAnFtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAKA,MAAMG,YAAY,SAASC,4BAAmB,CAAC;EAC7CC,WAAWA,CAAA,EAAG;IACZ,KAAK,CAAC,OAAO,CAAC;EAChB;EAEA,MAAMC,sBAAsBA,CAACC,YAAY,EAAE;IACzC,MAAMC,QAAQ,GAAGC,oBAAW,CAACC,SAAS,CAAC;MACrCH,YAAY,EAAEA;IAChB,CAAC,CAAC;IAEF,MAAMI,QAAQ,GAAG,MAAMC,KAAK,CAAC,6CAA6C,EAAE;MAC1EC,MAAM,EAAE,MAAM;MACdC,OAAO,EAAE;QACP,cAAc,EAAE;MAClB,CAAC;MACDC,IAAI,EAAEP;IACR,CAAC,CAAC;IAEF,MAAMQ,IAAI,GAAG,MAAML,QAAQ,CAACM,IAAI,CAAC,CAAC;IAElC,IAAI,CAACN,QAAQ,CAACO,EAAE,EAAE;MAChB,MAAM,IAAIC,KAAK,CAACC,KAAK,CAACD,KAAK,CAACC,KAAK,CAACC,gBAAgB,EAAE,sCAAsC,CAAC;IAC7F;IAEA,OAAO;MACLC,EAAE,EAAEN,IAAI,CAACO;IACX,CAAC;EACH;EAEA,MAAMC,sBAAsBA,CAACC,QAAQ,EAAE;IACrC,IAAI,CAACA,QAAQ,EAAEC,IAAI,IAAI,CAACD,QAAQ,EAAEE,YAAY,EAAE;MAC9C,MAAM,IAAIR,KAAK,CAACC,KAAK,CACnBD,KAAK,CAACC,KAAK,CAACC,gBAAgB,EAC5B,uDACF,CAAC;IACH;IAEA,MAAMb,QAAQ,GAAGC,oBAAW,CAACC,SAAS,CAAC;MACrCkB,SAAS,EAAE,IAAI,CAACC,QAAQ;MACxBC,aAAa,EAAE,IAAI,CAACC,YAAY;MAChCC,UAAU,EAAE,oBAAoB;MAChCN,IAAI,EAAED,QAAQ,CAACC,IAAI;MACnBC,YAAY,EAAEF,QAAQ,CAACE;IACzB,CAAC,CAAC;IAEF,MAAMhB,QAAQ,GAAG,MAAMC,KAAK,CAAC,2CAA2C,EAAE;MACxEC,MAAM,EAAE,MAAM;MACdC,OAAO,EAAE;QACP,cAAc,EAAE;MAClB,CAAC;MACDC,IAAI,EAAEP;IACR,CAAC,CAAC;IAEF,MAAMQ,IAAI,GAAG,MAAML,QAAQ,CAACM,IAAI,CAAC,CAAC;IAElC,IAAI,CAACN,QAAQ,CAACO,EAAE,IAAIF,IAAI,CAACiB,OAAO,EAAE;MAChC,MAAM,IAAId,KAAK,CAACC,KAAK,CAACD,KAAK,CAACC,KAAK,CAACC,gBAAgB,EAAE,sCAAsC,CAAC;IAC7F;IAEA,OAAOL,IAAI,CAACT,YAAY;EAC1B;AACF;AAAC,IAAA2B,QAAA,GAAAC,OAAA,CAAAjC,OAAA,GAEc,IAAIC,YAAY,CAAC,CAAC","ignoreList":[]}

package/lib/Adapters/Cache/CacheAdapter.js

@@ -3,26 +3,31 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-/*eslint no-unused-vars: "off"*/
+exports.CacheAdapter = void 0;
+/* eslint-disable unused-imports/no-unused-vars */
+/**
+ * @interface
+ * @memberof module:Adapters
+ */
 class CacheAdapter {
   /**
    * Get a value in the cache
-   * @param key Cache key to get
-   * @return Promise that will eventually resolve to the value in the cache.
+   * @param {String} key Cache key to get
+   * @return {Promise} that will eventually resolve to the value in the cache.
    */
   get(key) {}
 
   /**
    * Set a value in the cache
-   * @param key Cache key to set
-   * @param value Value to set the key
-   * @param ttl Optional TTL
+   * @param {String} key Cache key to set
+   * @param {String} value Value to set the key
+   * @param {String} ttl Optional TTL
    */
   put(key, value, ttl) {}
 
   /**
    * Remove a value from the cache.
-   * @param key Cache key to remove
+   * @param {String} key Cache key to remove
    */
   del(key) {}
 
@@ -32,4 +37,4 @@ class CacheAdapter {
   clear() {}
 }
 exports.CacheAdapter = CacheAdapter;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9DYWNoZS9DYWNoZUFkYXB0ZXIuanMiXSwibmFtZXMiOlsiQ2FjaGVBZGFwdGVyIiwiZ2V0Iiwia2V5IiwicHV0IiwidmFsdWUiLCJ0dGwiLCJkZWwiLCJjbGVhciJdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQTtBQUNPLE1BQU1BLFlBQU4sQ0FBbUI7QUFDeEI7Ozs7O0FBS0FDLE1BQUlDLEdBQUosRUFBUyxDQUFFOztBQUVYOzs7Ozs7QUFNQUMsTUFBSUQsR0FBSixFQUFTRSxLQUFULEVBQWdCQyxHQUFoQixFQUFxQixDQUFFOztBQUV2Qjs7OztBQUlBQyxNQUFJSixHQUFKLEVBQVMsQ0FBRTs7QUFFWDs7O0FBR0FLLFVBQVEsQ0FBRTtBQXpCYztRQUFiUCxZLEdBQUFBLFkiLCJmaWxlIjoiQ2FjaGVBZGFwdGVyLmpzIiwic291cmNlc0NvbnRlbnQiOlsiLyplc2xpbnQgbm8tdW51c2VkLXZhcnM6IFwib2ZmXCIqL1xuZXhwb3J0IGNsYXNzIENhY2hlQWRhcHRlciB7XG4gIC8qKlxuICAgKiBHZXQgYSB2YWx1ZSBpbiB0aGUgY2FjaGVcbiAgICogQHBhcmFtIGtleSBDYWNoZSBrZXkgdG8gZ2V0XG4gICAqIEByZXR1cm4gUHJvbWlzZSB0aGF0IHdpbGwgZXZlbnR1YWxseSByZXNvbHZlIHRvIHRoZSB2YWx1ZSBpbiB0aGUgY2FjaGUuXG4gICAqL1xuICBnZXQoa2V5KSB7fVxuXG4gIC8qKlxuICAgKiBTZXQgYSB2YWx1ZSBpbiB0aGUgY2FjaGVcbiAgICogQHBhcmFtIGtleSBDYWNoZSBrZXkgdG8gc2V0XG4gICAqIEBwYXJhbSB2YWx1ZSBWYWx1ZSB0byBzZXQgdGhlIGtleVxuICAgKiBAcGFyYW0gdHRsIE9wdGlvbmFsIFRUTFxuICAgKi9cbiAgcHV0KGtleSwgdmFsdWUsIHR0bCkge31cblxuICAvKipcbiAgICogUmVtb3ZlIGEgdmFsdWUgZnJvbSB0aGUgY2FjaGUuXG4gICAqIEBwYXJhbSBrZXkgQ2FjaGUga2V5IHRvIHJlbW92ZVxuICAgKi9cbiAgZGVsKGtleSkge31cblxuICAvKipcbiAgICogRW1wdHkgYSBjYWNoZVxuICAgKi9cbiAgY2xlYXIoKSB7fVxufVxuIl19
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJDYWNoZUFkYXB0ZXIiLCJnZXQiLCJrZXkiLCJwdXQiLCJ2YWx1ZSIsInR0bCIsImRlbCIsImNsZWFyIiwiZXhwb3J0cyJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9DYWNoZS9DYWNoZUFkYXB0ZXIuanMiXSwic291cmNlc0NvbnRlbnQiOlsiLyogZXNsaW50LWRpc2FibGUgdW51c2VkLWltcG9ydHMvbm8tdW51c2VkLXZhcnMgKi9cbi8qKlxuICogQGludGVyZmFjZVxuICogQG1lbWJlcm9mIG1vZHVsZTpBZGFwdGVyc1xuICovXG5leHBvcnQgY2xhc3MgQ2FjaGVBZGFwdGVyIHtcbiAgLyoqXG4gICAqIEdldCBhIHZhbHVlIGluIHRoZSBjYWNoZVxuICAgKiBAcGFyYW0ge1N0cmluZ30ga2V5IENhY2hlIGtleSB0byBnZXRcbiAgICogQHJldHVybiB7UHJvbWlzZX0gdGhhdCB3aWxsIGV2ZW50dWFsbHkgcmVzb2x2ZSB0byB0aGUgdmFsdWUgaW4gdGhlIGNhY2hlLlxuICAgKi9cbiAgZ2V0KGtleSkge31cblxuICAvKipcbiAgICogU2V0IGEgdmFsdWUgaW4gdGhlIGNhY2hlXG4gICAqIEBwYXJhbSB7U3RyaW5nfSBrZXkgQ2FjaGUga2V5IHRvIHNldFxuICAgKiBAcGFyYW0ge1N0cmluZ30gdmFsdWUgVmFsdWUgdG8gc2V0IHRoZSBrZXlcbiAgICogQHBhcmFtIHtTdHJpbmd9IHR0bCBPcHRpb25hbCBUVExcbiAgICovXG4gIHB1dChrZXksIHZhbHVlLCB0dGwpIHt9XG5cbiAgLyoqXG4gICAqIFJlbW92ZSBhIHZhbHVlIGZyb20gdGhlIGNhY2hlLlxuICAgKiBAcGFyYW0ge1N0cmluZ30ga2V5IENhY2hlIGtleSB0byByZW1vdmVcbiAgICovXG4gIGRlbChrZXkpIHt9XG5cbiAgLyoqXG4gICAqIEVtcHR5IGEgY2FjaGVcbiAgICovXG4gIGNsZWFyKCkge31cbn1cbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUE7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNPLE1BQU1BLFlBQVksQ0FBQztFQUN4QjtBQUNGO0FBQ0E7QUFDQTtBQUNBO0VBQ0VDLEdBQUdBLENBQUNDLEdBQUcsRUFBRSxDQUFDOztFQUVWO0FBQ0Y7QUFDQTtBQUNBO0FBQ0E7QUFDQTtFQUNFQyxHQUFHQSxDQUFDRCxHQUFHLEVBQUVFLEtBQUssRUFBRUMsR0FBRyxFQUFFLENBQUM7O0VBRXRCO0FBQ0Y7QUFDQTtBQUNBO0VBQ0VDLEdBQUdBLENBQUNKLEdBQUcsRUFBRSxDQUFDOztFQUVWO0FBQ0Y7QUFDQTtFQUNFSyxLQUFLQSxDQUFBLEVBQUcsQ0FBQztBQUNYO0FBQUNDLE9BQUEsQ0FBQVIsWUFBQSxHQUFBQSxZQUFBIiwiaWdub3JlTGlzdCI6W119

package/lib/Adapters/Cache/InMemoryCache.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.default = exports.InMemoryCache = void 0;
 const DEFAULT_CACHE_TTL = 5 * 1000;
-
 class InMemoryCache {
   constructor({
     ttl = DEFAULT_CACHE_TTL
@@ -12,7 +12,6 @@ class InMemoryCache {
     this.ttl = ttl;
     this.cache = Object.create(null);
   }
-
   get(key) {
     const record = this.cache[key];
     if (record == null) {
@@ -28,44 +27,35 @@ class InMemoryCache {
     delete this.cache[key];
     return null;
   }
-
   put(key, value, ttl = this.ttl) {
     if (ttl < 0 || isNaN(ttl)) {
       ttl = NaN;
     }
-
     var record = {
       value: value,
       expire: ttl + Date.now()
     };
-
     if (!isNaN(record.expire)) {
       record.timeout = setTimeout(() => {
         this.del(key);
       }, ttl);
     }
-
     this.cache[key] = record;
   }
-
   del(key) {
     var record = this.cache[key];
     if (record == null) {
       return;
     }
-
     if (record.timeout) {
       clearTimeout(record.timeout);
     }
     delete this.cache[key];
   }
-
   clear() {
     this.cache = Object.create(null);
   }
-
 }
-
 exports.InMemoryCache = InMemoryCache;
-exports.default = InMemoryCache;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+var _default = exports.default = InMemoryCache;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Cache/InMemoryCacheAdapter.js

@@ -1,18 +1,14 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.InMemoryCacheAdapter = undefined;
-
-var _LRUCache = require('./LRUCache');
-
+exports.default = exports.InMemoryCacheAdapter = void 0;
+var _LRUCache = require("./LRUCache");
 class InMemoryCacheAdapter {
-
   constructor(ctx) {
     this.cache = new _LRUCache.LRUCache(ctx);
   }
-
   get(key) {
     const record = this.cache.get(key);
     if (record === null) {
@@ -20,23 +16,19 @@ class InMemoryCacheAdapter {
     }
     return Promise.resolve(record);
   }
-
   put(key, value, ttl) {
     this.cache.put(key, value, ttl);
     return Promise.resolve();
   }
-
   del(key) {
     this.cache.del(key);
     return Promise.resolve();
   }
-
   clear() {
     this.cache.clear();
     return Promise.resolve();
   }
 }
-
 exports.InMemoryCacheAdapter = InMemoryCacheAdapter;
-exports.default = InMemoryCacheAdapter;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+var _default = exports.default = InMemoryCacheAdapter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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