parse-server 8.0.1 → 8.0.2-alpha.1

package/lib/Adapters/Auth/microsoft.js

@@ -1,36 +1,111 @@
 "use strict";
 
-// Helper functions for accessing the microsoft graph API.
-var Parse = require('parse/node').Parse;
-const httpsRequest = require('./httpsRequest');
+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 Microsoft.
+ *
+ * @class MicrosoftAdapter
+ * @param {Object} options - The adapter configuration options.
+ * @param {string} options.clientId - Your Microsoft App Client ID. Required for secure authentication.
+ * @param {string} options.clientSecret - Your Microsoft App Client 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 Microsoft authentication, use the following structure:
+ * ### Secure Configuration
+ * ```json
+ * {
+ *   "auth": {
+ *     "microsoft": {
+ *       "clientId": "your-client-id",
+ *       "clientSecret": "your-client-secret"
+ *     }
+ *   }
+ * }
+ * ```
+ * ### Insecure Configuration (Not Recommended)
+ * ```json
+ * {
+ *   "auth": {
+ *     "microsoft": {
+ *       "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
+ * {
+ *   "microsoft": {
+ *     "code": "lmn789opq012rst345uvw",
+ *     "redirect_uri": "https://your-redirect-uri.com/callback"
+ *   }
+ * }
+ * ```
+ * ### Insecure Authentication Payload (Not Recommended)
+ * ```json
+ * {
+ *   "microsoft": {
+ *     "id": "7654321",
+ *     "access_token": "AQXNnd2hIT6z9bHFzZz2Kp1ghiMz_RtyuvwXYZ123abc"
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * - Secure authentication exchanges the `code` and `redirect_uri` provided by the client for an access token using Microsoft's OAuth API.
+ * - **Insecure authentication** validates the user ID and access token directly, bypassing OAuth flows (not recommended). This method is deprecated and may be removed in future versions.
+ *
+ * @see {@link https://docs.microsoft.com/en-us/graph/auth/auth-concepts Microsoft Authentication Documentation}
+ */
 
-// Returns a promise that fulfills if this user mail is valid.
-function validateAuthData(authData) {
-  return request('me', authData.access_token).then(response => {
-    if (response && response.id && response.id == authData.id) {
-      return;
+class MicrosoftAdapter extends _BaseCodeAuthAdapter.default {
+  constructor() {
+    super('Microsoft');
+  }
+  async getUserFromAccessToken(access_token) {
+    const userResponse = await fetch('https://graph.microsoft.com/v1.0/me', {
+      headers: {
+        Authorization: 'Bearer ' + access_token
+      }
+    });
+    if (!userResponse.ok) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Microsoft API request failed.');
     }
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Microsoft Graph 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: 'graph.microsoft.com',
-    path: '/v1.0/' + path,
-    headers: {
-      Authorization: 'Bearer ' + access_token
+    return userResponse.json();
+  }
+  async getAccessTokenFromCode(authData) {
+    const response = await fetch('https://login.microsoftonline.com/common/oauth2/v2.0/token', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded'
+      },
+      body: new URLSearchParams({
+        client_id: this.clientId,
+        client_secret: this.clientSecret,
+        grant_type: 'authorization_code',
+        redirect_uri: authData.redirect_uri,
+        code: authData.code
+      })
+    });
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Microsoft API request failed.');
     }
-  });
+    const json = await response.json();
+    return json.access_token;
+  }
 }
-module.exports = {
-  validateAppId: validateAppId,
-  validateAuthData: validateAuthData
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+var _default = exports.default = new MicrosoftAdapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Auth/oauth2.js

@@ -1,128 +1,115 @@
 "use strict";
 
-/*
- * 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).
+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. "tokenIntrospectionEndpointUrl" (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, required if appidField is defined)
- *      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. It must contain the raw value.
- *      Thus if HTTP Basic authorization is to be used, it must contain the
- *      "Basic" string, followed by whitespace, then by the base64 encoded
- *      version of the concatenated <username> + ":" + <password> string.
- *      Eg. "Basic dXNlcm5hbWU6cGFzc3dvcmQ="
+ * @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
  * {
- *   "someadapter": {
- *     "id": "user's OAuth2 provider-specific id as a string",
- *     "access_token": "an authorized OAuth2 access token for the user",
+ *   "oauth2": {
+ *     "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}
  */
 
-const Parse = require('parse/node').Parse;
-const querystring = require('querystring');
-const httpsRequest = require('./httpsRequest');
-const INVALID_ACCESS = 'OAuth2 access token is invalid for this user.';
-const INVALID_ACCESS_APPID = "OAuth2: the access_token's appID is empty or is not in the list of permitted appIDs in the auth configuration.";
-const MISSING_APPIDS = 'OAuth2 configuration is missing the client app IDs ("appIds" config parameter).';
-const MISSING_URL = 'OAuth2 token introspection endpoint URL is missing from configuration!';
-
-// Returns a promise that fulfills if this user id is valid.
-function validateAuthData(authData, options) {
-  return requestTokenInfo(options, authData.access_token).then(response => {
-    if (!response || !response.active || options.useridField && authData.id !== response[options.useridField]) {
-      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, INVALID_ACCESS);
+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.');
     }
-  });
-}
-function validateAppId(appIds, authData, options) {
-  if (!options || !options.appidField) {
-    return Promise.resolve();
-  }
-  if (!appIds || appIds.length === 0) {
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, MISSING_APPIDS);
+    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;
   }
-  return requestTokenInfo(options, authData.access_token).then(response => {
-    if (!response || !response.active) {
-      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, INVALID_ACCESS);
+  async validateAppId(authData) {
+    if (!this.appidField) {
+      return;
     }
-    const appidField = options.appidField;
-    if (!response[appidField]) {
-      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, INVALID_ACCESS_APPID);
+    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 responseValue = response[appidField];
-    if (!Array.isArray(responseValue) && appIds.includes(responseValue)) {
-      return;
-    } else if (Array.isArray(responseValue) && responseValue.some(appId => appIds.includes(appId))) {
-      return;
-    } else {
-      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, INVALID_ACCESS_APPID);
+  }
+  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.');
     }
-  });
-}
-
-// A promise wrapper for requests to the OAuth2 token introspection endpoint.
-function requestTokenInfo(options, access_token) {
-  if (!options || !options.tokenIntrospectionEndpointUrl) {
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, MISSING_URL);
+    return {};
   }
-  const parsedUrl = new URL(options.tokenIntrospectionEndpointUrl);
-  const postData = querystring.stringify({
-    token: access_token
-  });
-  const headers = {
-    'Content-Type': 'application/x-www-form-urlencoded',
-    'Content-Length': Buffer.byteLength(postData)
-  };
-  if (options.authorizationHeader) {
-    headers['Authorization'] = options.authorizationHeader;
+  async requestTokenInfo(accessToken) {
+    const response = await fetch(this.tokenIntrospectionEndpointUrl, {
+      method: 'POST',
+      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();
   }
-  const postOptions = {
-    hostname: parsedUrl.hostname,
-    path: parsedUrl.pathname,
-    method: 'POST',
-    headers: headers
-  };
-  return httpsRequest.request(postOptions, postData);
 }
-module.exports = {
-  validateAppId: validateAppId,
-  validateAuthData: validateAuthData
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Parse","require","querystring","httpsRequest","INVALID_ACCESS","INVALID_ACCESS_APPID","MISSING_APPIDS","MISSING_URL","validateAuthData","authData","options","requestTokenInfo","access_token","then","response","active","useridField","id","Error","OBJECT_NOT_FOUND","validateAppId","appIds","appidField","Promise","resolve","length","responseValue","Array","isArray","includes","some","appId","tokenIntrospectionEndpointUrl","parsedUrl","URL","postData","stringify","token","headers","Buffer","byteLength","authorizationHeader","postOptions","hostname","path","pathname","method","request","module","exports"],"sources":["../../../src/Adapters/Auth/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. \"tokenIntrospectionEndpointUrl\" (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, required if appidField is defined)\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. It must contain the raw value.\n *      Thus if HTTP Basic authorization is to be used, it must contain the\n *      \"Basic\" string, followed by whitespace, then by the base64 encoded\n *      version of the concatenated <username> + \":\" + <password> string.\n *      Eg. \"Basic dXNlcm5hbWU6cGFzc3dvcmQ=\"\n *\n * The adapter expects requests with the following authData JSON:\n *\n * {\n *   \"someadapter\": {\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\nconst Parse = require('parse/node').Parse;\nconst querystring = require('querystring');\nconst httpsRequest = require('./httpsRequest');\n\nconst INVALID_ACCESS = 'OAuth2 access token is invalid for this user.';\nconst INVALID_ACCESS_APPID =\n  \"OAuth2: the access_token's appID is empty or is not in the list of permitted appIDs in the auth configuration.\";\nconst MISSING_APPIDS =\n  'OAuth2 configuration is missing the client app IDs (\"appIds\" config parameter).';\nconst MISSING_URL = 'OAuth2 token introspection endpoint URL is missing from configuration!';\n\n// Returns a promise that fulfills if this user id is valid.\nfunction validateAuthData(authData, options) {\n  return requestTokenInfo(options, authData.access_token).then(response => {\n    if (\n      !response ||\n      !response.active ||\n      (options.useridField && authData.id !== response[options.useridField])\n    ) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, INVALID_ACCESS);\n    }\n  });\n}\n\nfunction validateAppId(appIds, authData, options) {\n  if (!options || !options.appidField) {\n    return Promise.resolve();\n  }\n  if (!appIds || appIds.length === 0) {\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, MISSING_APPIDS);\n  }\n  return requestTokenInfo(options, authData.access_token).then(response => {\n    if (!response || !response.active) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, INVALID_ACCESS);\n    }\n    const appidField = options.appidField;\n    if (!response[appidField]) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, INVALID_ACCESS_APPID);\n    }\n    const responseValue = response[appidField];\n    if (!Array.isArray(responseValue) && appIds.includes(responseValue)) {\n      return;\n    } else if (\n      Array.isArray(responseValue) &&\n      responseValue.some(appId => appIds.includes(appId))\n    ) {\n      return;\n    } else {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, INVALID_ACCESS_APPID);\n    }\n  });\n}\n\n// A promise wrapper for requests to the OAuth2 token introspection endpoint.\nfunction requestTokenInfo(options, access_token) {\n  if (!options || !options.tokenIntrospectionEndpointUrl) {\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, MISSING_URL);\n  }\n  const parsedUrl = new URL(options.tokenIntrospectionEndpointUrl);\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  if (options.authorizationHeader) {\n    headers['Authorization'] = options.authorizationHeader;\n  }\n  const postOptions = {\n    hostname: parsedUrl.hostname,\n    path: parsedUrl.pathname,\n    method: 'POST',\n    headers: headers,\n  };\n  return httpsRequest.request(postOptions, postData);\n}\n\nmodule.exports = {\n  validateAppId: validateAppId,\n  validateAuthData: validateAuthData,\n};\n"],"mappings":"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","ignoreList":[]}
+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":";;;;;;AAsDA,IAAAA,YAAA,GAAAC,sBAAA,CAAAC,OAAA;AAAwC,SAAAD,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAtDxC;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,aAAa,SAASC,oBAAW,CAAC;EACtCC,eAAeA,CAACC,OAAO,EAAE;IACvB,KAAK,CAACD,eAAe,CAACC,OAAO,CAAC;IAE9B,IAAI,CAACA,OAAO,CAACC,6BAA6B,EAAE;MAC1C,MAAM,IAAIC,KAAK,CAACC,KAAK,CAACD,KAAK,CAACC,KAAK,CAACC,gBAAgB,EAAE,qDAAqD,CAAC;IAC5G;IACA,IAAIJ,OAAO,CAACK,UAAU,IAAI,CAACL,OAAO,CAACM,MAAM,EAAEC,MAAM,EAAE;MACjD,MAAM,IAAIL,KAAK,CAACC,KAAK,CAACD,KAAK,CAACC,KAAK,CAACC,gBAAgB,EAAE,0CAA0C,CAAC;IACjG;IAEA,IAAI,CAACH,6BAA6B,GAAGD,OAAO,CAACC,6BAA6B;IAC1E,IAAI,CAACO,WAAW,GAAGR,OAAO,CAACQ,WAAW;IACtC,IAAI,CAACH,UAAU,GAAGL,OAAO,CAACK,UAAU;IACpC,IAAI,CAACC,MAAM,GAAGN,OAAO,CAACM,MAAM;IAC5B,IAAI,CAACG,mBAAmB,GAAGT,OAAO,CAACS,mBAAmB;EACxD;EAEA,MAAMC,aAAaA,CAACC,QAAQ,EAAE;IAC5B,IAAI,CAAC,IAAI,CAACN,UAAU,EAAE;MACpB;IACF;IAEA,MAAMO,QAAQ,GAAG,MAAM,IAAI,CAACC,gBAAgB,CAACF,QAAQ,CAACG,YAAY,CAAC;IAEnE,MAAMC,eAAe,GAAGH,QAAQ,CAAC,IAAI,CAACP,UAAU,CAAC;IACjD,MAAMW,YAAY,GAAGC,KAAK,CAACC,OAAO,CAACH,eAAe,CAAC,GAC/CA,eAAe,CAACI,IAAI,CAACC,KAAK,IAAI,IAAI,CAACd,MAAM,CAACe,QAAQ,CAACD,KAAK,CAAC,CAAC,GAC1D,IAAI,CAACd,MAAM,CAACe,QAAQ,CAACN,eAAe,CAAC;IAEzC,IAAI,CAACC,YAAY,EAAE;MACjB,MAAM,IAAId,KAAK,CAACC,KAAK,CAACD,KAAK,CAACC,KAAK,CAACC,gBAAgB,EAAE,yBAAyB,CAAC;IAChF;EACF;EAEA,MAAMkB,gBAAgBA,CAACX,QAAQ,EAAE;IAC/B,MAAMC,QAAQ,GAAG,MAAM,IAAI,CAACC,gBAAgB,CAACF,QAAQ,CAACG,YAAY,CAAC;IAEnE,IAAI,CAACF,QAAQ,CAACW,MAAM,IAAK,IAAI,CAACf,WAAW,IAAIG,QAAQ,CAACa,EAAE,KAAKZ,QAAQ,CAAC,IAAI,CAACJ,WAAW,CAAE,EAAE;MACxF,MAAM,IAAIN,KAAK,CAACC,KAAK,CAACD,KAAK,CAACC,KAAK,CAACC,gBAAgB,EAAE,+CAA+C,CAAC;IACtG;IAEA,OAAO,CAAC,CAAC;EACX;EAEA,MAAMS,gBAAgBA,CAACY,WAAW,EAAE;IAClC,MAAMb,QAAQ,GAAG,MAAMc,KAAK,CAAC,IAAI,CAACzB,6BAA6B,EAAE;MAC/D0B,MAAM,EAAE,MAAM;MACdC,OAAO,EAAE;QACP,cAAc,EAAE,mCAAmC;QACnD,IAAI,IAAI,CAACnB,mBAAmB,IAAI;UAAEoB,aAAa,EAAE,IAAI,CAACpB;QAAoB,CAAC;MAC7E,CAAC;MACDqB,IAAI,EAAE,IAAIC,eAAe,CAAC;QAAEC,KAAK,EAAEP;MAAY,CAAC;IAClD,CAAC,CAAC;IAEF,IAAI,CAACb,QAAQ,CAACqB,EAAE,EAAE;MAChB,MAAM,IAAI/B,KAAK,CAACC,KAAK,CAACD,KAAK,CAACC,KAAK,CAACC,gBAAgB,EAAE,4CAA4C,CAAC;IACnG;IAEA,OAAOQ,QAAQ,CAACsB,IAAI,CAAC,CAAC;EACxB;AACF;AAAC,IAAAC,QAAA,GAAAC,OAAA,CAAAxC,OAAA,GAEc,IAAIC,aAAa,CAAC,CAAC","ignoreList":[]}

package/lib/Adapters/Auth/phantauth.js

@@ -1,5 +1,8 @@
 "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.
@@ -11,15 +14,20 @@ const {
   Parse
 } = require('parse/node');
 const httpsRequest = require('./httpsRequest');
-
 // Returns a promise that fulfills if this user id is valid.
-function validateAuthData(authData) {
-  return request('auth/userinfo', authData.access_token).then(data => {
-    if (data && data.sub == authData.id) {
-      return;
-    }
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'PhantAuth auth is invalid for this user.');
+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.
@@ -42,4 +50,4 @@ 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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