parse-server 8.0.1-alpha.2 → 8.0.2-alpha.1

package/lib/Adapters/Auth/qq.js

@@ -1,42 +1,113 @@
 "use strict";
 
-// Helper functions for accessing the qq Graph API.
-const httpsRequest = require('./httpsRequest');
-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 QQ.
+ *
+ * @class QqAdapter
+ * @param {Object} options - The adapter configuration options.
+ * @param {string} options.clientId - Your QQ App ID. Required for secure authentication.
+ * @param {string} options.clientSecret - Your QQ App 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 QQ authentication, use the following structure:
+ * ### Secure Configuration
+ * ```json
+ * {
+ *   "auth": {
+ *     "qq": {
+ *       "clientId": "your-app-id",
+ *       "clientSecret": "your-app-secret"
+ *     }
+ *   }
+ * }
+ * ```
+ * ### Insecure Configuration (Not Recommended)
+ * ```json
+ * {
+ *   "auth": {
+ *     "qq": {
+ *       "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
+ * {
+ *   "qq": {
+ *     "code": "abcd1234",
+ *     "redirect_uri": "https://your-redirect-uri.com/callback"
+ *   }
+ * }
+ * ```
+ * ### Insecure Authentication Payload (Not Recommended)
+ * ```json
+ * {
+ *   "qq": {
+ *     "id": "1234567",
+ *     "access_token": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * - Secure authentication exchanges the `code` and `redirect_uri` provided by the client for an access token using QQ's OAuth API.
+ * - **Insecure authentication** validates the `id` and `access_token` directly, bypassing OAuth flows. This approach is not recommended and may be deprecated in future versions.
+ *
+ * @see {@link https://wiki.connect.qq.com/ QQ Authentication Documentation}
+ */
 
-// Returns a promise that fulfills iff this user id is valid.
-function validateAuthData(authData) {
-  return graphRequest('me?access_token=' + authData.access_token).then(function (data) {
-    if (data && data.openid == authData.id) {
-      return;
+class QqAdapter extends _BaseCodeAuthAdapter.default {
+  constructor() {
+    super('qq');
+  }
+  async getUserFromAccessToken(access_token) {
+    const response = await fetch('https://graph.qq.com/oauth2.0/me', {
+      headers: {
+        Authorization: `Bearer ${access_token}`
+      }
+    });
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'qq API request failed.');
     }
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'qq 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 qq graph requests.
-function graphRequest(path) {
-  return httpsRequest.get('https://graph.qq.com/oauth2.0/' + path, true).then(data => {
-    return parseResponseData(data);
-  });
-}
-function parseResponseData(data) {
-  const starPos = data.indexOf('(');
-  const endPos = data.indexOf(')');
-  if (starPos == -1 || endPos == -1) {
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'qq auth is invalid for this user.');
+    const data = await response.text();
+    return this.parseResponseData(data);
+  }
+  async getAccessTokenFromCode(authData) {
+    const response = await fetch('https://graph.qq.com/oauth2.0/token', {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded'
+      },
+      body: new URLSearchParams({
+        grant_type: 'authorization_code',
+        client_id: this.clientId,
+        client_secret: this.clientSecret,
+        redirect_uri: authData.redirect_uri,
+        code: authData.code
+      }).toString()
+    });
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'qq API request failed.');
+    }
+    const text = await response.text();
+    const data = this.parseResponseData(text);
+    return data.access_token;
   }
-  data = data.substring(starPos + 1, endPos - 1);
-  return JSON.parse(data);
 }
-module.exports = {
-  validateAppId,
-  validateAuthData,
-  parseResponseData
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+var _default = exports.default = new QqAdapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Auth/spotify.js

@@ -1,46 +1,115 @@
 "use strict";
 
-// Helper functions for accessing the Spotify API.
-const httpsRequest = require('./httpsRequest');
-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;
-    }
-    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.
-async function validateAppId(appIds, authData) {
-  const access_token = authData.access_token;
-  if (!Array.isArray(appIds)) {
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'appIds must be an array.');
+class SpotifyAdapter extends _BaseCodeAuthAdapter.default {
+  constructor() {
+    super('spotify');
   }
-  if (!appIds.length) {
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Spotify auth is not configured.');
-  }
-  const data = await request('me', access_token);
-  if (!data || !appIds.includes(data.id)) {
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Spotify auth is invalid for this user.');
+  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.');
+    }
+    const user = await response.json();
+    return {
+      id: user.id
+    };
   }
-}
-
-// A promisey wrapper for Spotify API requests.
-function request(path, access_token) {
-  return httpsRequest.get({
-    host: 'api.spotify.com',
-    path: '/v1/' + path,
-    headers: {
-      Authorization: 'Bearer ' + access_token
+  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.');
     }
-  });
+    const response = await fetch('https://accounts.spotify.com/api/token', {
+      method: 'POST',
+      headers: {
+        '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,50 +1,197 @@
 "use strict";
 
-// Helper functions for accessing the twitter API.
-var OAuth = require('./OAuth1Client');
-var Parse = require('parse/node').Parse;
+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) {
-      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) {
-      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":[]}