parse-server 2.8.4 → 8.6.2

package/lib/Adapters/Auth/spotify.js

@@ -1,63 +1,115 @@
-'use strict';
+"use strict";
 
-// Helper functions for accessing the Spotify 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 Spotify.
+ *
+ * @class SpotifyAdapter
+ * @param {Object} options - The adapter configuration options.
+ * @param {string} options.clientId - Your Spotify application's Client ID. Required for secure authentication.
+ * @param {boolean} [options.enableInsecureAuth=false] - **[DEPRECATED]** Enable insecure authentication (not recommended).
+ *
+ * @description
+ * ## Parse Server Configuration
+ * To configure Parse Server for Spotify authentication, use the following structure:
+ * ### Secure Configuration
+ * ```json
+ * {
+ *   "auth": {
+ *     "spotify": {
+ *       "clientId": "your-client-id"
+ *     }
+ *   }
+ * }
+ * ```
+ * ### Insecure Configuration (Not Recommended)
+ * ```json
+ * {
+ *   "auth": {
+ *     "spotify": {
+ *       "enableInsecureAuth": true
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The adapter requires the following `authData` fields:
+ * - **Secure Authentication**: `code`, `redirect_uri`, and `code_verifier`.
+ * - **Insecure Authentication (Not Recommended)**: `id`, `access_token`.
+ *
+ * ## Auth Payloads
+ * ### Secure Authentication Payload
+ * ```json
+ * {
+ *   "spotify": {
+ *     "code": "abc123def456ghi789",
+ *     "redirect_uri": "https://example.com/callback",
+ *     "code_verifier": "secure-code-verifier"
+ *   }
+ * }
+ * ```
+ * ### Insecure Authentication Payload (Not Recommended)
+ * ```json
+ * {
+ *   "spotify": {
+ *     "id": "1234567",
+ *     "access_token": "abc123def456ghi789"
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * - `enableInsecureAuth` is **not recommended** and bypasses secure flows by validating the user ID and access token directly. This method is not suitable for production environments and may be removed in future versions.
+ * - Secure authentication exchanges the `code` provided by the client for an access token using Spotify's OAuth API. This method ensures greater security and is the recommended approach.
+ *
+ * @see {@link https://developer.spotify.com/documentation/web-api/tutorials/getting-started Spotify OAuth Documentation}
+ */
 
-// Returns a promise that fulfills iff this user id is valid.
-function validateAuthData(authData) {
-  return request('me', authData.access_token).then(data => {
-    if (data && data.id == authData.id) {
-      return;
+class SpotifyAdapter extends _BaseCodeAuthAdapter.default {
+  constructor() {
+    super('spotify');
+  }
+  async getUserFromAccessToken(access_token) {
+    const response = await fetch('https://api.spotify.com/v1/me', {
+      headers: {
+        Authorization: 'Bearer ' + access_token
+      }
+    });
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Spotify API request failed.');
     }
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Spotify auth is invalid for this user.');
-  });
-}
-
-// Returns a promise that fulfills if this app id is valid.
-function validateAppId(appIds, authData) {
-  var access_token = authData.access_token;
-  if (!appIds.length) {
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Spotify auth is not configured.');
+    const user = await response.json();
+    return {
+      id: user.id
+    };
   }
-  return request('me', access_token).then(data => {
-    if (data && appIds.indexOf(data.id) != -1) {
-      return;
+  async getAccessTokenFromCode(authData) {
+    if (!authData.code || !authData.redirect_uri || !authData.code_verifier) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Spotify auth configuration authData.code and/or authData.redirect_uri and/or authData.code_verifier.');
     }
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Spotify auth is invalid for this user.');
-  });
-}
-
-// A promisey wrapper for Spotify API requests.
-function request(path, access_token) {
-  return new Promise(function (resolve, reject) {
-    https.get({
-      host: 'api.spotify.com',
-      path: '/v1/' + path,
+    const response = await fetch('https://accounts.spotify.com/api/token', {
+      method: 'POST',
       headers: {
-        'Authorization': 'Bearer ' + access_token
-      }
-    }, 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 Spotify.');
+        'Content-Type': 'application/x-www-form-urlencoded'
+      },
+      body: new URLSearchParams({
+        grant_type: 'authorization_code',
+        code: authData.code,
+        redirect_uri: authData.redirect_uri,
+        code_verifier: authData.code_verifier,
+        client_id: this.clientId
+      })
     });
-  });
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Spotify API request failed.');
+    }
+    return response.json();
+  }
 }
-
-module.exports = {
-  validateAppId: validateAppId,
-  validateAuthData: validateAuthData
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+var _default = exports.default = new SpotifyAdapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Auth/twitter.js

@@ -1,57 +1,197 @@
-'use strict';
+"use strict";
 
-// Helper functions for accessing the twitter API.
-var OAuth = require('./OAuth1Client');
-var Parse = require('parse/node').Parse;
-var logger = require('../../logger').default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Config = _interopRequireDefault(require("../../Config"));
+var _querystring = _interopRequireDefault(require("querystring"));
+var _AuthAdapter = _interopRequireDefault(require("./AuthAdapter"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Parse Server authentication adapter for Twitter.
+ *
+ * @class TwitterAdapter
+ * @param {Object} options - The adapter configuration options.
+ * @param {string} options.consumerKey - The Twitter App Consumer Key. Required for secure authentication.
+ * @param {string} options.consumerSecret - The Twitter App Consumer Secret. Required for secure authentication.
+ * @param {boolean} [options.enableInsecureAuth=false] - **[DEPRECATED]** Enable insecure authentication (not recommended).
+ *
+ * @description
+ * ## Parse Server Configuration
+ * To configure Parse Server for Twitter authentication, use the following structure:
+ * ### Secure Configuration
+ * ```json
+ * {
+ *   "auth": {
+ *     "twitter": {
+ *       "consumerKey": "your-consumer-key",
+ *       "consumerSecret": "your-consumer-secret"
+ *     }
+ *   }
+ * }
+ * ```
+ * ### Insecure Configuration (Not Recommended)
+ * ```json
+ * {
+ *   "auth": {
+ *     "twitter": {
+ *       "enableInsecureAuth": true
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The adapter requires the following `authData` fields:
+ * - **Secure Authentication**: `oauth_token`, `oauth_verifier`.
+ * - **Insecure Authentication (Not Recommended)**: `id`, `oauth_token`, `oauth_token_secret`.
+ *
+ * ## Auth Payloads
+ * ### Secure Authentication Payload
+ * ```json
+ * {
+ *   "twitter": {
+ *     "oauth_token": "1234567890-abc123def456",
+ *     "oauth_verifier": "abc123def456"
+ *   }
+ * }
+ * ```
+ *
+ * ### Insecure Authentication Payload (Not Recommended)
+ * ```json
+ * {
+ *   "twitter": {
+ *     "id": "1234567890",
+ *     "oauth_token": "1234567890-abc123def456",
+ *     "oauth_token_secret": "1234567890-abc123def456"
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * - **Deprecation Notice**: `enableInsecureAuth` and insecure fields (`id`, `oauth_token_secret`) are **deprecated** and may be removed in future versions. Use secure authentication with `consumerKey` and `consumerSecret`.
+ * - Secure authentication exchanges the `oauth_token` and `oauth_verifier` provided by the client for an access token using Twitter's OAuth API.
+ *
+ * @see {@link https://developer.twitter.com/en/docs/authentication/oauth-1-0a Twitter OAuth Documentation}
+ */
 
-// Returns a promise that fulfills iff this user id is valid.
-function validateAuthData(authData, options) {
-  if (!options) {
-    throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'Twitter auth configuration missing');
-  }
-  options = handleMultipleConfigurations(authData, options);
-  var client = new OAuth(options);
-  client.host = "api.twitter.com";
-  client.auth_token = authData.auth_token;
-  client.auth_token_secret = authData.auth_token_secret;
-
-  return client.get("/1.1/account/verify_credentials.json").then(data => {
-    if (data && data.id_str == '' + authData.id) {
+class TwitterAuthAdapter extends _AuthAdapter.default {
+  validateOptions(options) {
+    if (!options) {
+      throw new Error('Twitter auth options are required.');
+    }
+    this.enableInsecureAuth = options.enableInsecureAuth;
+    if (!this.enableInsecureAuth && (!options.consumer_key || !options.consumer_secret)) {
+      throw new Error('Consumer key and secret are required for secure Twitter auth.');
+    }
+  }
+  async validateAuthData(authData, options) {
+    const config = _Config.default.get(Parse.applicationId);
+    const twitterConfig = config.auth.twitter;
+    if (this.enableInsecureAuth && twitterConfig && config.enableInsecureAuthAdapters) {
+      return this.validateInsecureAuth(authData, options);
+    }
+    if (!options.consumer_key || !options.consumer_secret) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Twitter auth configuration missing consumer_key and/or consumer_secret.');
+    }
+    const accessTokenData = await this.exchangeAccessToken(authData);
+    if (accessTokenData?.oauth_token && accessTokenData?.user_id) {
+      authData.id = accessTokenData.user_id;
+      authData.auth_token = accessTokenData.oauth_token;
       return;
     }
     throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Twitter auth is invalid for this user.');
-  });
-}
-
-// Returns a promise that fulfills iff this app id is valid.
-function validateAppId() {
-  return Promise.resolve();
-}
-
-function handleMultipleConfigurations(authData, options) {
-  if (Array.isArray(options)) {
-    const consumer_key = authData.consumer_key;
-    if (!consumer_key) {
-      logger.error('Twitter Auth', 'Multiple twitter configurations are available, by no consumer_key was sent by the client.');
-      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Twitter auth is invalid for this user.');
-    }
-    options = options.filter(option => {
-      return option.consumer_key == consumer_key;
+  }
+  async validateInsecureAuth(authData, options) {
+    if (!authData.oauth_token || !authData.oauth_token_secret) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Twitter insecure auth requires oauth_token and oauth_token_secret.');
+    }
+    options = this.handleMultipleConfigurations(authData, options);
+    const data = await this.request(authData, options);
+    const parsedData = await data.json();
+    if (parsedData?.id === authData.id) {
+      return;
+    }
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Twitter auth is invalid for this user.');
+  }
+  async exchangeAccessToken(authData) {
+    const accessTokenRequestOptions = {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded'
+      },
+      body: _querystring.default.stringify({
+        oauth_token: authData.oauth_token,
+        oauth_verifier: authData.oauth_verifier
+      })
+    };
+    const response = await fetch('https://api.twitter.com/oauth/access_token', accessTokenRequestOptions);
+    if (!response.ok) {
+      throw new Error('Failed to exchange access token.');
+    }
+    return response.json();
+  }
+  handleMultipleConfigurations(authData, options) {
+    if (Array.isArray(options)) {
+      const consumer_key = authData.consumer_key;
+      if (!consumer_key) {
+        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Twitter auth is invalid for this user.');
+      }
+      options = options.filter(option => option.consumer_key === consumer_key);
+      if (options.length === 0) {
+        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Twitter auth is invalid for this user.');
+      }
+      return options[0];
+    }
+    return options;
+  }
+  async request(authData, options) {
+    const {
+      consumer_key,
+      consumer_secret
+    } = options;
+    const oauth = {
+      consumer_key,
+      consumer_secret,
+      auth_token: authData.oauth_token,
+      auth_token_secret: authData.oauth_token_secret
+    };
+    const url = new URL('https://api.twitter.com/2/users/me');
+    const response = await fetch(url, {
+      headers: {
+        Authorization: 'Bearer ' + oauth.auth_token
+      },
+      body: JSON.stringify(oauth)
     });
-
-    if (options.length == 0) {
-      logger.error('Twitter Auth', 'Cannot find a configuration for the provided consumer_key');
-      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Twitter auth is invalid for this user.');
+    if (!response.ok) {
+      throw new Error('Failed to fetch user data.');
     }
-    options = options[0];
+    return response;
+  }
+  async beforeFind(authData) {
+    if (this.enableInsecureAuth && !authData?.code) {
+      if (!authData?.access_token) {
+        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Twitter auth is invalid for this user.');
+      }
+      const user = await this.getUserFromAccessToken(authData.access_token, authData);
+      if (user.id !== authData.id) {
+        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Twitter auth is invalid for this user.');
+      }
+      return;
+    }
+    if (!authData?.code) {
+      throw new Parse.Error(Parse.Error.VALIDATION_ERROR, 'Twitter code is required.');
+    }
+    const access_token = await this.exchangeAccessToken(authData);
+    const user = await this.getUserFromAccessToken(access_token, authData);
+    authData.access_token = access_token;
+    authData.id = user.id;
+    delete authData.code;
+    delete authData.redirect_uri;
+  }
+  validateAppId() {
+    return Promise.resolve();
   }
-  return options;
 }
-
-module.exports = {
-  validateAppId,
-  validateAuthData,
-  handleMultipleConfigurations
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+var _default = exports.default = new TwitterAuthAdapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_Config","_interopRequireDefault","require","_querystring","_AuthAdapter","e","__esModule","default","TwitterAuthAdapter","AuthAdapter","validateOptions","options","Error","enableInsecureAuth","consumer_key","consumer_secret","validateAuthData","authData","config","Config","get","Parse","applicationId","twitterConfig","auth","twitter","enableInsecureAuthAdapters","validateInsecureAuth","OBJECT_NOT_FOUND","accessTokenData","exchangeAccessToken","oauth_token","user_id","id","auth_token","oauth_token_secret","handleMultipleConfigurations","data","request","parsedData","json","accessTokenRequestOptions","method","headers","body","querystring","stringify","oauth_verifier","response","fetch","ok","Array","isArray","filter","option","length","oauth","auth_token_secret","url","URL","Authorization","JSON","beforeFind","code","access_token","user","getUserFromAccessToken","VALIDATION_ERROR","redirect_uri","validateAppId","Promise","resolve","_default","exports"],"sources":["../../../src/Adapters/Auth/twitter.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for Twitter.\n *\n * @class TwitterAdapter\n * @param {Object} options - The adapter configuration options.\n * @param {string} options.consumerKey - The Twitter App Consumer Key. Required for secure authentication.\n * @param {string} options.consumerSecret - The Twitter App Consumer Secret. Required for secure authentication.\n * @param {boolean} [options.enableInsecureAuth=false] - **[DEPRECATED]** Enable insecure authentication (not recommended).\n *\n * @description\n * ## Parse Server Configuration\n * To configure Parse Server for Twitter authentication, use the following structure:\n * ### Secure Configuration\n * ```json\n * {\n *   \"auth\": {\n *     \"twitter\": {\n *       \"consumerKey\": \"your-consumer-key\",\n *       \"consumerSecret\": \"your-consumer-secret\"\n *     }\n *   }\n * }\n * ```\n * ### Insecure Configuration (Not Recommended)\n * ```json\n * {\n *   \"auth\": {\n *     \"twitter\": {\n *       \"enableInsecureAuth\": true\n *     }\n *   }\n * }\n * ```\n *\n * The adapter requires the following `authData` fields:\n * - **Secure Authentication**: `oauth_token`, `oauth_verifier`.\n * - **Insecure Authentication (Not Recommended)**: `id`, `oauth_token`, `oauth_token_secret`.\n *\n * ## Auth Payloads\n * ### Secure Authentication Payload\n * ```json\n * {\n *   \"twitter\": {\n *     \"oauth_token\": \"1234567890-abc123def456\",\n *     \"oauth_verifier\": \"abc123def456\"\n *   }\n * }\n * ```\n *\n * ### Insecure Authentication Payload (Not Recommended)\n * ```json\n * {\n *   \"twitter\": {\n *     \"id\": \"1234567890\",\n *     \"oauth_token\": \"1234567890-abc123def456\",\n *     \"oauth_token_secret\": \"1234567890-abc123def456\"\n *   }\n * }\n * ```\n *\n * ## Notes\n * - **Deprecation Notice**: `enableInsecureAuth` and insecure fields (`id`, `oauth_token_secret`) are **deprecated** and may be removed in future versions. Use secure authentication with `consumerKey` and `consumerSecret`.\n * - Secure authentication exchanges the `oauth_token` and `oauth_verifier` provided by the client for an access token using Twitter's OAuth API.\n *\n * @see {@link https://developer.twitter.com/en/docs/authentication/oauth-1-0a Twitter OAuth Documentation}\n */\n\nimport Config from '../../Config';\nimport querystring from 'querystring';\nimport AuthAdapter from './AuthAdapter';\n\nclass TwitterAuthAdapter extends AuthAdapter {\n  validateOptions(options) {\n    if (!options) {\n      throw new Error('Twitter auth options are required.');\n    }\n\n    this.enableInsecureAuth = options.enableInsecureAuth;\n\n    if (!this.enableInsecureAuth && (!options.consumer_key || !options.consumer_secret)) {\n      throw new Error('Consumer key and secret are required for secure Twitter auth.');\n    }\n  }\n\n  async validateAuthData(authData, options) {\n    const config = Config.get(Parse.applicationId);\n    const twitterConfig = config.auth.twitter;\n\n    if (this.enableInsecureAuth && twitterConfig && config.enableInsecureAuthAdapters) {\n      return this.validateInsecureAuth(authData, options);\n    }\n\n    if (!options.consumer_key || !options.consumer_secret) {\n      throw new Parse.Error(\n        Parse.Error.OBJECT_NOT_FOUND,\n        'Twitter auth configuration missing consumer_key and/or consumer_secret.'\n      );\n    }\n\n    const accessTokenData = await this.exchangeAccessToken(authData);\n\n    if (accessTokenData?.oauth_token && accessTokenData?.user_id) {\n      authData.id = accessTokenData.user_id;\n      authData.auth_token = accessTokenData.oauth_token;\n      return;\n    }\n\n    throw new Parse.Error(\n      Parse.Error.OBJECT_NOT_FOUND,\n      'Twitter auth is invalid for this user.'\n    );\n  }\n\n  async validateInsecureAuth(authData, options) {\n    if (!authData.oauth_token || !authData.oauth_token_secret) {\n      throw new Parse.Error(\n        Parse.Error.OBJECT_NOT_FOUND,\n        'Twitter insecure auth requires oauth_token and oauth_token_secret.'\n      );\n    }\n\n    options = this.handleMultipleConfigurations(authData, options);\n\n    const data = await this.request(authData, options);\n    const parsedData = await data.json();\n\n    if (parsedData?.id === authData.id) {\n      return;\n    }\n\n    throw new Parse.Error(\n      Parse.Error.OBJECT_NOT_FOUND,\n      'Twitter auth is invalid for this user.'\n    );\n  }\n\n  async exchangeAccessToken(authData) {\n    const accessTokenRequestOptions = {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/x-www-form-urlencoded',\n      },\n      body: querystring.stringify({\n        oauth_token: authData.oauth_token,\n        oauth_verifier: authData.oauth_verifier,\n      }),\n    };\n\n    const response = await fetch('https://api.twitter.com/oauth/access_token', accessTokenRequestOptions);\n    if (!response.ok) {\n      throw new Error('Failed to exchange access token.');\n    }\n\n    return response.json();\n  }\n\n  handleMultipleConfigurations(authData, options) {\n    if (Array.isArray(options)) {\n      const consumer_key = authData.consumer_key;\n\n      if (!consumer_key) {\n        throw new Parse.Error(\n          Parse.Error.OBJECT_NOT_FOUND,\n          'Twitter auth is invalid for this user.'\n        );\n      }\n\n      options = options.filter(option => option.consumer_key === consumer_key);\n\n      if (options.length === 0) {\n        throw new Parse.Error(\n          Parse.Error.OBJECT_NOT_FOUND,\n          'Twitter auth is invalid for this user.'\n        );\n      }\n\n      return options[0];\n    }\n\n    return options;\n  }\n\n  async request(authData, options) {\n    const { consumer_key, consumer_secret } = options;\n\n    const oauth = {\n      consumer_key,\n      consumer_secret,\n      auth_token: authData.oauth_token,\n      auth_token_secret: authData.oauth_token_secret,\n    };\n\n    const url = new URL('https://api.twitter.com/2/users/me');\n\n    const response = await fetch(url, {\n      headers: {\n        Authorization: 'Bearer ' + oauth.auth_token,\n      },\n      body: JSON.stringify(oauth),\n    });\n\n    if (!response.ok) {\n      throw new Error('Failed to fetch user data.');\n    }\n\n    return response;\n  }\n\n  async beforeFind(authData) {\n    if (this.enableInsecureAuth && !authData?.code) {\n      if (!authData?.access_token) {\n        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Twitter auth is invalid for this user.');\n      }\n\n      const user = await this.getUserFromAccessToken(authData.access_token, authData);\n\n      if (user.id !== authData.id) {\n        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Twitter auth is invalid for this user.');\n      }\n\n      return;\n    }\n\n    if (!authData?.code) {\n      throw new Parse.Error(Parse.Error.VALIDATION_ERROR, 'Twitter code is required.');\n    }\n\n    const access_token = await this.exchangeAccessToken(authData);\n    const user = await this.getUserFromAccessToken(access_token, authData);\n\n\n    authData.access_token = access_token;\n    authData.id = user.id;\n\n    delete authData.code;\n    delete authData.redirect_uri;\n  }\n\n  validateAppId() {\n    return Promise.resolve();\n  }\n}\n\nexport default new TwitterAuthAdapter();\n"],"mappings":"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","ignoreList":[]}

package/lib/Adapters/Auth/utils.js

@@ -0,0 +1,28 @@
+"use strict";
+
+const jwt = require('jsonwebtoken');
+const util = require('util');
+const Parse = require('parse/node').Parse;
+const getHeaderFromToken = token => {
+  const decodedToken = jwt.decode(token, {
+    complete: true
+  });
+  if (!decodedToken) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `provided token does not decode as JWT`);
+  }
+  return decodedToken.header;
+};
+
+/**
+ * Returns the signing key from a JWKS client.
+ * @param {Object} client The JWKS client.
+ * @param {String} key The kid.
+ */
+async function getSigningKey(client, key) {
+  return util.promisify(client.getSigningKey)(key);
+}
+module.exports = {
+  getHeaderFromToken,
+  getSigningKey
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Auth/vkontakte.js

@@ -1,36 +1,41 @@
 'use strict';
 
 // Helper functions for accessing the vkontakte API.
-
-var https = require('https');
+var _Config = _interopRequireDefault(require("../../Config"));
+var _Deprecator = _interopRequireDefault(require("../../Deprecator/Deprecator"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const httpsRequest = require('./httpsRequest');
 var Parse = require('parse/node').Parse;
-var logger = require('../../logger').default;
-
 // Returns a promise that fulfills iff this user id is valid.
-function validateAuthData(authData, params) {
-  return vkOAuth2Request(params).then(function (response) {
-    if (response && response.access_token) {
-      return request("api.vk.com", "method/secure.checkToken?token=" + authData.access_token + "&client_secret=" + params.appSecret + "&access_token=" + response.access_token + "&v=5.59").then(function (response) {
-        if (response && response.response && response.response.user_id == authData.id) {
-          return;
-        }
-        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Vk auth is invalid for this user.');
-      });
-    }
-    logger.error('Vk Auth', 'Vk appIds or appSecret is incorrect.');
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Vk appIds or appSecret is incorrect.');
+async function validateAuthData(authData, params) {
+  const config = _Config.default.get(Parse.applicationId);
+  _Deprecator.default.logRuntimeDeprecation({
+    usage: 'vkontakte adapter'
   });
+  const vkConfig = config.auth.vkontakte;
+  if (!vkConfig?.enableInsecureAuth || !config.enableInsecureAuthAdapters) {
+    throw new Parse.Error('Vk only works with enableInsecureAuth: true');
+  }
+  const response = await vkOAuth2Request(params);
+  if (!response?.access_token) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Vk appIds or appSecret is incorrect.');
+  }
+  const vkUser = await request('api.vk.com', `method/users.get?access_token=${authData.access_token}&v=${params.apiVersion}`);
+  if (!vkUser?.response?.length || vkUser.response[0].id !== authData.id) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Vk auth is invalid for this user.');
+  }
 }
-
 function vkOAuth2Request(params) {
   return new Promise(function (resolve) {
     if (!params || !params.appIds || !params.appIds.length || !params.appSecret || !params.appSecret.length) {
-      logger.error('Vk Auth', 'Vk auth is not configured. Missing appIds or appSecret.');
       throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Vk auth is not configured. Missing appIds or appSecret.');
     }
+    if (!params.apiVersion) {
+      params.apiVersion = '5.124';
+    }
     resolve();
   }).then(function () {
-    return request("oauth.vk.com", "access_token?client_id=" + params.appIds + "&client_secret=" + params.appSecret + "&v=5.59&grant_type=client_credentials");
+    return request('oauth.vk.com', 'access_token?client_id=' + params.appIds + '&client_secret=' + params.appSecret + '&v=' + params.apiVersion + '&grant_type=client_credentials');
   });
 }
 
@@ -41,28 +46,10 @@ function validateAppId() {
 
 // A promisey wrapper for api requests
 function request(host, path) {
-  return new Promise(function (resolve, reject) {
-    https.get("https://" + host + "/" + 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 Vk.');
-    });
-  });
+  return httpsRequest.get('https://' + host + '/' + path);
 }
-
 module.exports = {
   validateAppId: validateAppId,
   validateAuthData: validateAuthData
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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