parse-server 2.8.4 → 8.6.2

package/lib/Adapters/Auth/oauth2.js

@@ -1,180 +1,115 @@
-'use strict';
-
-var _https = require('https');
-
-var _https2 = _interopRequireDefault(_https);
-
-var _url = require('url');
-
-var _url2 = _interopRequireDefault(_url);
-
-var _querystring = require('querystring');
-
-var _querystring2 = _interopRequireDefault(_querystring);
-
-var _node = require('parse/node');
-
-var _node2 = _interopRequireDefault(_node);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/*
- * This auth adapter is based on the OAuth 2.0 Token Introspection specification.
- * See RFC 7662 for details (https://tools.ietf.org/html/rfc7662).
- * It's purpose is to validate OAuth2 access tokens using the OAuth2 provider's
- * token introspection endpoint (if implemented by the provider).
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _AuthAdapter = _interopRequireDefault(require("./AuthAdapter"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Parse Server authentication adapter for OAuth2 Token Introspection.
  *
- * The adapter accepts the following config parameters:
+ * @class OAuth2Adapter
+ * @param {Object} options - The adapter configuration options.
+ * @param {string} options.tokenIntrospectionEndpointUrl - The URL of the token introspection endpoint. Required.
+ * @param {boolean} options.oauth2 - Indicates that the request should be handled by the OAuth2 adapter. Required.
+ * @param {string} [options.useridField] - The field in the introspection response that contains the user ID. Optional.
+ * @param {string} [options.appidField] - The field in the introspection response that contains the app ID. Optional.
+ * @param {string[]} [options.appIds] - List of allowed app IDs. Required if `appidField` is defined.
+ * @param {string} [options.authorizationHeader] - The Authorization header value for the introspection request. Optional.
  *
- * 1. "endpoint" (string, required)
- *      The URL of the token introspection endpoint of the OAuth2 provider that
- *      issued the access token to the client that is to be validated.
- *
- * 2. "useridField" (string, optional)
- *      The name of the field in the token introspection response that contains
- *      the userid. If specified, it will be used to verify the value of the "id"
- *      field in the "authData" JSON that is coming from the client.
- *      This can be the "aud" (i.e. audience), the "sub" (i.e. subject) or the
- *      "username" field in the introspection response, but since only the
- *      "active" field is required and all other reponse fields are optional
- *      in the RFC, it has to be optional in this adapter as well.
- *      Default: - (undefined)
- *
- * 3. "appidField" (string, optional)
- *      The name of the field in the token introspection response that contains
- *      the appId of the client. If specified, it will be used to verify it's
- *      value against the set of appIds in the adapter config. The concept of
- *      appIds comes from the two major social login providers
- *      (Google and Facebook). They have not yet implemented the token
- *      introspection endpoint, but the concept can be valid for any OAuth2
- *      provider.
- *      Default: - (undefined)
- *
- * 4. "appIds" (array of strings, optional)
- *      A set of appIds that are used to restrict accepted access tokens based
- *      on a specific field's value in the token introspection response.
- *      Default: - (undefined)
- *
- * 5. "authorizationHeader" (string, optional)
- *      The value of the "Authorization" HTTP header in requests sent to the
- *      introspection endpoint.
- *      Eg. "Basic dXNlcm5hbWU6cGFzc3dvcmQ="
- *
- * 6. "debug" (boolean, optional)
- *      Enables extensive logging using the "verbose" level.
+ * @description
+ * ## Parse Server Configuration
+ * To configure Parse Server for OAuth2 Token Introspection, use the following structure:
+ * ```json
+ * {
+ *   "auth": {
+ *     "oauth2Provider": {
+ *       "tokenIntrospectionEndpointUrl": "https://provider.com/introspect",
+ *       "useridField": "sub",
+ *       "appidField": "aud",
+ *       "appIds": ["my-app-id"],
+ *       "authorizationHeader": "Basic dXNlcm5hbWU6cGFzc3dvcmQ=",
+ *       "oauth2": true
+ *     }
+ *   }
+ * }
+ * ```
  *
- * The adapter expects requests with the following authData JSON:
+ * The adapter requires the following `authData` fields:
+ * - `id`: The user ID provided by the client.
+ * - `access_token`: The access token provided by the client.
  *
+ * ## Auth Payload
+ * ### Example Auth Payload
+ * ```json
  * {
  *   "oauth2": {
- *     "id": "user's OAuth2 provider-specific id as a string",
- *     "access_token": "an authorized OAuth2 access token for the user",
+ *     "id": "user-id",
+ *     "access_token": "access-token"
  *   }
  * }
+ * ```
+ *
+ * ## Notes
+ * - `tokenIntrospectionEndpointUrl` is mandatory and should point to a valid OAuth2 provider's introspection endpoint.
+ * - If `appidField` is defined, `appIds` must also be specified to validate the app ID in the introspection response.
+ * - `authorizationHeader` can be used to authenticate requests to the token introspection endpoint.
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc7662 OAuth 2.0 Token Introspection Specification}
  */
 
-class OAuth2AuthAdapter {
-  constructor(name) {
-    this.name = name;
-  }
-
-  // Returns a promise that fulfills if this user id is valid.
-  validateAuthData(authData, options) {
-    return requestJson(options, authData.access_token).then(response => {
-      if (response && response.active && (!options || !options.hasOwnProperty('useridField') || !options.useridField || authData.id == response[options.useridField])) {
-        return Promise.resolve();
-      }
-      return Promise.reject(new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'OAuth2 access token is invalid for this user.'));
-    });
-  }
-
-  validateAppId(appIds, authData, options) {
-    if (options && options.hasOwnProperty('appidField') && options.appidField) {
-      if (!appIds.length) {
-        return Promise.reject(new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'OAuth2 configuration is missing the client app IDs ("appIds" config parameter).'));
-      }
-      return requestJson(options, authData.access_token).then(response => {
-        const appidField = options.appidField;
-        return validateAppIdResponse(response, appidField, appIds);
-      });
-    } else {
-      return Promise.resolve();
+class OAuth2Adapter extends _AuthAdapter.default {
+  validateOptions(options) {
+    super.validateOptions(options);
+    if (!options.tokenIntrospectionEndpointUrl) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'OAuth2 token introspection endpoint URL is missing.');
     }
+    if (options.appidField && !options.appIds?.length) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'OAuth2 configuration is missing app IDs.');
+    }
+    this.tokenIntrospectionEndpointUrl = options.tokenIntrospectionEndpointUrl;
+    this.useridField = options.useridField;
+    this.appidField = options.appidField;
+    this.appIds = options.appIds;
+    this.authorizationHeader = options.authorizationHeader;
   }
-}
-
-function getRequestOptions(config, access_token) {
-  if (!config || !config.endpoint) {
-    throw new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'OAuth2 token introspection endpoint URL is missing from configuration!');
+  async validateAppId(authData) {
+    if (!this.appidField) {
+      return;
+    }
+    const response = await this.requestTokenInfo(authData.access_token);
+    const appIdFieldValue = response[this.appidField];
+    const isValidAppId = Array.isArray(appIdFieldValue) ? appIdFieldValue.some(appId => this.appIds.includes(appId)) : this.appIds.includes(appIdFieldValue);
+    if (!isValidAppId) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'OAuth2: Invalid app ID.');
+    }
   }
-  const { endpoint } = config;
-  const parsedUrl = _url2.default.config(endpoint);
-  const postData = _querystring2.default.stringify({
-    'token': access_token
-  });
-  const headers = {
-    'Content-Type': 'application/x-www-form-urlencoded',
-    'Content-Length': Buffer.byteLength(postData)
-    // Note: the "authorizationHeader" adapter config must contain the raw value.
-    //   Thus if HTTP Basic authorization is to be used, it must contain the
-    //   base64 encoded version of the concatenated <username> + ":" + <password> string.
-  };if (config.authorizationHeader) {
-    headers['Authorization'] = config.authorizationHeader;
+  async validateAuthData(authData) {
+    const response = await this.requestTokenInfo(authData.access_token);
+    if (!response.active || this.useridField && authData.id !== response[this.useridField]) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'OAuth2 access token is invalid for this user.');
+    }
+    return {};
   }
-  return {
-    data: postData,
-    options: {
-      hostname: parsedUrl.hostname,
-      path: parsedUrl.pathname,
+  async requestTokenInfo(accessToken) {
+    const response = await fetch(this.tokenIntrospectionEndpointUrl, {
       method: 'POST',
-      headers: headers
-    }
-  };
-}
-
-function validateAppIdResponse(response, appidField, appIds) {
-  if (response && response[appidField]) {
-    const responseValue = response[appidField];
-    if (Array.isArray(responseValue)) {
-      if (responseValue.find((value, index) => {
-        return appIds.includes(index);
-      })) {
-        return Promise.resolve();
-      }
-    } else {
-      if (appIds.includes(responseValue)) {
-        return Promise.resolve();
-      }
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        ...(this.authorizationHeader && {
+          Authorization: this.authorizationHeader
+        })
+      },
+      body: new URLSearchParams({
+        token: accessToken
+      })
+    });
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'OAuth2 token introspection request failed.');
     }
+    return response.json();
   }
-  return Promise.reject(new _node2.default.Error(_node2.default.Error.OBJECT_NOT_FOUND, 'OAuth2: the access_token\'s appID is empty or is not in the list of permitted appIDs in the auth configuration.'));
 }
-
-// A promise wrapper for api requests
-function requestJson(config, access_token) {
-  return new Promise(function (resolve, reject) {
-    const { data, options } = getRequestOptions(config, access_token);
-    const postRequest = _https2.default.request(options, function (res) {
-      let data = '';
-      res.setEncoding('utf8');
-      res.on('data', function (chunk) {
-        data += chunk;
-      });
-      res.on('end', function () {
-        try {
-          return resolve(JSON.parse(data));
-        } catch (e) {
-          return reject(e);
-        }
-      });
-    }).on('error', function () {
-      return reject('Failed to validate access token %s with OAuth2 provider (url = %s, headers = %s)', access_token, options.tokenIntrospectionEndpointUrl, JSON.stringify(options.headers));
-    });
-
-    postRequest.write(data);
-    postRequest.end();
-  });
-}
-
-module.exports = { OAuth2AuthAdapter, requestJson, getRequestOptions };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/Adapters/Auth/oauth2.js"],"names":["OAuth2AuthAdapter","constructor","name","validateAuthData","authData","options","requestJson","access_token","then","response","active","hasOwnProperty","useridField","id","Promise","resolve","reject","Parse","Error","OBJECT_NOT_FOUND","validateAppId","appIds","appidField","length","validateAppIdResponse","getRequestOptions","config","endpoint","parsedUrl","url","postData","querystring","stringify","headers","Buffer","byteLength","authorizationHeader","data","hostname","path","pathname","method","responseValue","Array","isArray","find","value","index","includes","postRequest","https","request","res","setEncoding","on","chunk","JSON","parse","e","tokenIntrospectionEndpointUrl","write","end","module","exports"],"mappings":"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","file":"oauth2.js","sourcesContent":["/*\n * This auth adapter is based on the OAuth 2.0 Token Introspection specification.\n * See RFC 7662 for details (https://tools.ietf.org/html/rfc7662).\n * It's purpose is to validate OAuth2 access tokens using the OAuth2 provider's\n * token introspection endpoint (if implemented by the provider).\n *\n * The adapter accepts the following config parameters:\n *\n * 1. \"endpoint\" (string, required)\n *      The URL of the token introspection endpoint of the OAuth2 provider that\n *      issued the access token to the client that is to be validated.\n *\n * 2. \"useridField\" (string, optional)\n *      The name of the field in the token introspection response that contains\n *      the userid. If specified, it will be used to verify the value of the \"id\"\n *      field in the \"authData\" JSON that is coming from the client.\n *      This can be the \"aud\" (i.e. audience), the \"sub\" (i.e. subject) or the\n *      \"username\" field in the introspection response, but since only the\n *      \"active\" field is required and all other reponse fields are optional\n *      in the RFC, it has to be optional in this adapter as well.\n *      Default: - (undefined)\n *\n * 3. \"appidField\" (string, optional)\n *      The name of the field in the token introspection response that contains\n *      the appId of the client. If specified, it will be used to verify it's\n *      value against the set of appIds in the adapter config. The concept of\n *      appIds comes from the two major social login providers\n *      (Google and Facebook). They have not yet implemented the token\n *      introspection endpoint, but the concept can be valid for any OAuth2\n *      provider.\n *      Default: - (undefined)\n *\n * 4. \"appIds\" (array of strings, optional)\n *      A set of appIds that are used to restrict accepted access tokens based\n *      on a specific field's value in the token introspection response.\n *      Default: - (undefined)\n *\n * 5. \"authorizationHeader\" (string, optional)\n *      The value of the \"Authorization\" HTTP header in requests sent to the\n *      introspection endpoint.\n *      Eg. \"Basic dXNlcm5hbWU6cGFzc3dvcmQ=\"\n *\n * 6. \"debug\" (boolean, optional)\n *      Enables extensive logging using the \"verbose\" level.\n *\n * The adapter expects requests with the following authData JSON:\n *\n * {\n *   \"oauth2\": {\n *     \"id\": \"user's OAuth2 provider-specific id as a string\",\n *     \"access_token\": \"an authorized OAuth2 access token for the user\",\n *   }\n * }\n */\n\nimport https from 'https';\nimport url from 'url';\nimport querystring from 'querystring'\nimport Parse from 'parse/node';\n\n\nclass OAuth2AuthAdapter {\n  constructor(name) {\n    this.name = name;\n  }\n\n  // Returns a promise that fulfills if this user id is valid.\n  validateAuthData(authData, options) {\n    return requestJson(options, authData.access_token).then((response) => {\n      if (response &&\n        response.active &&\n        (!options || !options.hasOwnProperty('useridField') || !options.useridField || authData.id == response[options.useridField])) {\n        return Promise.resolve();\n      }\n      return Promise.reject(new Parse.Error(\n        Parse.Error.OBJECT_NOT_FOUND,\n        'OAuth2 access token is invalid for this user.'));\n    });\n  }\n\n  validateAppId(appIds, authData, options) {\n    if (options && options.hasOwnProperty('appidField') && options.appidField) {\n      if (!appIds.length) {\n        return Promise.reject(new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'OAuth2 configuration is missing the client app IDs (\"appIds\" config parameter).'));\n      }\n      return requestJson(options, authData.access_token).then((response) => {\n        const appidField = options.appidField;\n        return validateAppIdResponse(response, appidField, appIds);\n      });\n    } else {\n      return Promise.resolve();\n    }\n  }\n}\n\nfunction getRequestOptions(config, access_token) {\n  if (!config || !config.endpoint) {\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'OAuth2 token introspection endpoint URL is missing from configuration!');\n  }\n  const { endpoint } = config;\n  const parsedUrl = url.config(endpoint);\n  const postData = querystring.stringify({\n    'token': access_token\n  });\n  const headers = {\n    'Content-Type': 'application/x-www-form-urlencoded',\n    'Content-Length': Buffer.byteLength(postData)\n  }\n  // Note: the \"authorizationHeader\" adapter config must contain the raw value.\n  //   Thus if HTTP Basic authorization is to be used, it must contain the\n  //   base64 encoded version of the concatenated <username> + \":\" + <password> string.\n  if (config.authorizationHeader) {\n    headers['Authorization'] = config.authorizationHeader;\n  }\n  return {\n    data: postData,\n    options: {\n      hostname: parsedUrl.hostname,\n      path: parsedUrl.pathname,\n      method: 'POST',\n      headers: headers\n    }\n  }\n}\n\nfunction validateAppIdResponse(response, appidField, appIds) {\n  if (response && response[appidField]) {\n    const responseValue = response[appidField];\n    if (Array.isArray(responseValue)) {\n      if (responseValue.find((value, index) => {\n        return appIds.includes(index);\n      })) {\n        return Promise.resolve();\n      }\n    } else {\n      if (appIds.includes(responseValue)) {\n        return Promise.resolve();\n      }\n    }\n  }\n  return Promise.reject(new Parse.Error(\n    Parse.Error.OBJECT_NOT_FOUND,\n    'OAuth2: the access_token\\'s appID is empty or is not in the list of permitted appIDs in the auth configuration.'));\n}\n\n// A promise wrapper for api requests\nfunction requestJson(config, access_token) {\n  return new Promise(function(resolve, reject) {\n    const { data, options } = getRequestOptions(config, access_token);\n    const postRequest = https.request(options, function(res) {\n      let data = '';\n      res.setEncoding('utf8');\n      res.on('data', function(chunk) {\n        data += chunk;\n      });\n      res.on('end', function() {\n        try {\n          return resolve(JSON.parse(data))\n        } catch (e) {\n          return reject(e);\n        }\n      });\n    }).on('error', function() {\n      return reject('Failed to validate access token %s with OAuth2 provider (url = %s, headers = %s)', access_token, options.tokenIntrospectionEndpointUrl, JSON.stringify(options.headers));\n    });\n\n    postRequest.write(data);\n    postRequest.end();\n  });\n}\n\nmodule.exports = { OAuth2AuthAdapter, requestJson, getRequestOptions };\n"]}
+var _default = exports.default = new OAuth2Adapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_AuthAdapter","_interopRequireDefault","require","e","__esModule","default","OAuth2Adapter","AuthAdapter","validateOptions","options","tokenIntrospectionEndpointUrl","Parse","Error","OBJECT_NOT_FOUND","appidField","appIds","length","useridField","authorizationHeader","validateAppId","authData","response","requestTokenInfo","access_token","appIdFieldValue","isValidAppId","Array","isArray","some","appId","includes","validateAuthData","active","id","accessToken","fetch","method","headers","Authorization","body","URLSearchParams","token","ok","json","_default","exports"],"sources":["../../../src/Adapters/Auth/oauth2.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for OAuth2 Token Introspection.\n *\n * @class OAuth2Adapter\n * @param {Object} options - The adapter configuration options.\n * @param {string} options.tokenIntrospectionEndpointUrl - The URL of the token introspection endpoint. Required.\n * @param {boolean} options.oauth2 - Indicates that the request should be handled by the OAuth2 adapter. Required.\n * @param {string} [options.useridField] - The field in the introspection response that contains the user ID. Optional.\n * @param {string} [options.appidField] - The field in the introspection response that contains the app ID. Optional.\n * @param {string[]} [options.appIds] - List of allowed app IDs. Required if `appidField` is defined.\n * @param {string} [options.authorizationHeader] - The Authorization header value for the introspection request. Optional.\n *\n * @description\n * ## Parse Server Configuration\n * To configure Parse Server for OAuth2 Token Introspection, use the following structure:\n * ```json\n * {\n *   \"auth\": {\n *     \"oauth2Provider\": {\n *       \"tokenIntrospectionEndpointUrl\": \"https://provider.com/introspect\",\n *       \"useridField\": \"sub\",\n *       \"appidField\": \"aud\",\n *       \"appIds\": [\"my-app-id\"],\n *       \"authorizationHeader\": \"Basic dXNlcm5hbWU6cGFzc3dvcmQ=\",\n *       \"oauth2\": true\n *     }\n *   }\n * }\n * ```\n *\n * The adapter requires the following `authData` fields:\n * - `id`: The user ID provided by the client.\n * - `access_token`: The access token provided by the client.\n *\n * ## Auth Payload\n * ### Example Auth Payload\n * ```json\n * {\n *   \"oauth2\": {\n *     \"id\": \"user-id\",\n *     \"access_token\": \"access-token\"\n *   }\n * }\n * ```\n *\n * ## Notes\n * - `tokenIntrospectionEndpointUrl` is mandatory and should point to a valid OAuth2 provider's introspection endpoint.\n * - If `appidField` is defined, `appIds` must also be specified to validate the app ID in the introspection response.\n * - `authorizationHeader` can be used to authenticate requests to the token introspection endpoint.\n *\n * @see {@link https://datatracker.ietf.org/doc/html/rfc7662 OAuth 2.0 Token Introspection Specification}\n */\n\n\nimport AuthAdapter from './AuthAdapter';\n\nclass OAuth2Adapter extends AuthAdapter {\n  validateOptions(options) {\n    super.validateOptions(options);\n\n    if (!options.tokenIntrospectionEndpointUrl) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'OAuth2 token introspection endpoint URL is missing.');\n    }\n    if (options.appidField && !options.appIds?.length) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'OAuth2 configuration is missing app IDs.');\n    }\n\n    this.tokenIntrospectionEndpointUrl = options.tokenIntrospectionEndpointUrl;\n    this.useridField = options.useridField;\n    this.appidField = options.appidField;\n    this.appIds = options.appIds;\n    this.authorizationHeader = options.authorizationHeader;\n  }\n\n  async validateAppId(authData) {\n    if (!this.appidField) {\n      return;\n    }\n\n    const response = await this.requestTokenInfo(authData.access_token);\n\n    const appIdFieldValue = response[this.appidField];\n    const isValidAppId = Array.isArray(appIdFieldValue)\n      ? appIdFieldValue.some(appId => this.appIds.includes(appId))\n      : this.appIds.includes(appIdFieldValue);\n\n    if (!isValidAppId) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'OAuth2: Invalid app ID.');\n    }\n  }\n\n  async validateAuthData(authData) {\n    const response = await this.requestTokenInfo(authData.access_token);\n\n    if (!response.active || (this.useridField && authData.id !== response[this.useridField])) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'OAuth2 access token is invalid for this user.');\n    }\n\n    return {};\n  }\n\n  async requestTokenInfo(accessToken) {\n    const response = await fetch(this.tokenIntrospectionEndpointUrl, {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/x-www-form-urlencoded',\n        ...(this.authorizationHeader && { Authorization: this.authorizationHeader })\n      },\n      body: new URLSearchParams({ token: accessToken })\n    });\n\n    if (!response.ok) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'OAuth2 token introspection request failed.');\n    }\n\n    return response.json();\n  }\n}\n\nexport default new OAuth2Adapter();\n\n"],"mappings":"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","ignoreList":[]}

package/lib/Adapters/Auth/phantauth.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _Config = _interopRequireDefault(require("../../Config"));
+var _Deprecator = _interopRequireDefault(require("../../Deprecator/Deprecator"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/*
+ * PhantAuth was designed to simplify testing for applications using OpenID Connect
+ * authentication by making use of random generated users.
+ *
+ * To learn more, please go to: https://www.phantauth.net
+ */
+
+const {
+  Parse
+} = require('parse/node');
+const httpsRequest = require('./httpsRequest');
+// Returns a promise that fulfills if this user id is valid.
+async function validateAuthData(authData) {
+  const config = _Config.default.get(Parse.applicationId);
+  _Deprecator.default.logRuntimeDeprecation({
+    usage: 'phantauth adapter'
+  });
+  const phantauthConfig = config.auth.phantauth;
+  if (!phantauthConfig?.enableInsecureAuth) {
+    throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'PhantAuth only works with enableInsecureAuth: true');
+  }
+  const data = await request('auth/userinfo', authData.access_token);
+  if (data?.sub !== authData.id) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'PhantAuth 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 api requests
+function request(path, access_token) {
+  return httpsRequest.get({
+    host: 'phantauth.net',
+    path: '/' + path,
+    headers: {
+      Authorization: 'bearer ' + access_token,
+      'User-Agent': 'parse-server'
+    }
+  });
+}
+module.exports = {
+  validateAppId: validateAppId,
+  validateAuthData: validateAuthData
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Auth/qq.js

@@ -1,54 +1,113 @@
-'use strict';
+"use strict";
 
-// Helper functions for accessing the qq 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 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 new Promise(function (resolve, reject) {
-    https.get('https://graph.qq.com/oauth2.0/' + path, function (res) {
-      var data = '';
-      res.on('data', function (chunk) {
-        data += chunk;
-      });
-      res.on('end', function () {
-        var starPos = data.indexOf("(");
-        var endPos = data.indexOf(")");
-        if (starPos == -1 || endPos == -1) {
-          throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'qq auth is invalid for this user.');
-        }
-        data = data.substring(starPos + 1, endPos - 1);
-        try {
-          data = JSON.parse(data);
-        } catch (e) {
-          return reject(e);
-        }
-        resolve(data);
-      });
-    }).on('error', function () {
-      reject('Failed to validate this access token with qq.');
+    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;
+  }
 }
-
-module.exports = {
-  validateAppId,
-  validateAuthData
-};
-//# 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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