@beiguancyc/parse-server 9.9.0-ruixiang.1

package/lib/Adapters/Auth/mfa.js

@@ -0,0 +1,334 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _otpauth = require("otpauth");
+var _cryptoUtils = require("../../cryptoUtils");
+var _AuthAdapter = _interopRequireDefault(require("./AuthAdapter"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Parse Server authentication adapter for Multi-Factor Authentication (MFA).
+ *
+ * @class MFAAdapter
+ * @param {Object} options - The adapter options.
+ * @param {Array<String>} options.options - Supported MFA methods. Must include `"SMS"` or `"TOTP"`.
+ * @param {Number} [options.digits=6] - The number of digits for the one-time password (OTP). Must be between 4 and 10.
+ * @param {Number} [options.period=30] - The validity period of the OTP in seconds. Must be greater than 10.
+ * @param {String} [options.algorithm="SHA1"] - The algorithm used for TOTP generation. Defaults to `"SHA1"`.
+ * @param {Function} [options.sendSMS] - A callback function for sending SMS OTPs. Required if `"SMS"` is included in `options`.
+ *
+ * @description
+ * ## Parse Server Configuration
+ * To configure Parse Server for MFA, use the following structure:
+ * ```javascript
+ * {
+ *   auth: {
+ *     mfa: {
+ *       options: ["SMS", "TOTP"],
+ *       digits: 6,
+ *       period: 30,
+ *       algorithm: "SHA1",
+ *       sendSMS: (token, mobile) => {
+ *         // Send the SMS using your preferred SMS provider.
+ *         console.log(`Sending SMS to ${mobile} with token: ${token}`);
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ## MFA Methods
+ * - **SMS**:
+ *   - Requires a valid mobile number.
+ *   - Sends a one-time password (OTP) via SMS for login or verification.
+ *   - Uses the `sendSMS` callback for sending the OTP.
+ *
+ * - **TOTP**:
+ *   - Requires a secret key for setup.
+ *   - Validates the user's OTP against a time-based one-time password (TOTP) generated using the secret key.
+ *   - Supports configurable digits, period, and algorithm for TOTP generation.
+ *   - Generates two single-use recovery codes during enrollment. Each recovery code can be used once
+ *     in place of a TOTP token and is consumed after use.
+ *
+ * ## MFA Payload
+ * The adapter requires the following `authData` fields:
+ * - **For SMS-based MFA**:
+ *   - `mobile`: The user's mobile number (required for setup).
+ *   - `token`: The OTP provided by the user for login or verification.
+ * - **For TOTP-based MFA**:
+ *   - `secret`: The TOTP secret key for the user (required for setup).
+ *   - `token`: The OTP provided by the user for login or verification.
+ *
+ * ## Example Payloads
+ * ### SMS Setup Payload
+ * ```json
+ * {
+ *   "mobile": "+1234567890"
+ * }
+ * ```
+ *
+ * ### TOTP Setup Payload
+ * ```json
+ * {
+ *   "secret": "BASE32ENCODEDSECRET",
+ *   "token": "123456"
+ * }
+ * ```
+ *
+ * ### Login Payload
+ * ```json
+ * {
+ *   "token": "123456"
+ * }
+ * ```
+ *
+ * @see {@link https://en.wikipedia.org/wiki/Time-based_One-Time_Password_algorithm Time-based One-Time Password Algorithm (TOTP)}
+ * @see {@link https://tools.ietf.org/html/rfc6238 RFC 6238: TOTP: Time-Based One-Time Password Algorithm}
+ */
+
+class MFAAdapter extends _AuthAdapter.default {
+  validateOptions(opts) {
+    const validOptions = opts.options;
+    if (!Array.isArray(validOptions)) {
+      throw 'mfa.options must be an array';
+    }
+    this.sms = validOptions.includes('SMS');
+    this.totp = validOptions.includes('TOTP');
+    if (!this.sms && !this.totp) {
+      throw 'mfa.options must include SMS or TOTP';
+    }
+    const digits = opts.digits || 6;
+    const period = opts.period || 30;
+    if (typeof digits !== 'number') {
+      throw 'mfa.digits must be a number';
+    }
+    if (typeof period !== 'number') {
+      throw 'mfa.period must be a number';
+    }
+    if (digits < 4 || digits > 10) {
+      throw 'mfa.digits must be between 4 and 10';
+    }
+    if (period < 10) {
+      throw 'mfa.period must be greater than 10';
+    }
+    const sendSMS = opts.sendSMS;
+    if (this.sms && typeof sendSMS !== 'function') {
+      throw 'mfa.sendSMS callback must be defined when using SMS OTPs';
+    }
+    this.smsCallback = sendSMS;
+    this.digits = digits;
+    this.period = period;
+    this.algorithm = opts.algorithm || 'SHA1';
+  }
+  validateSetUp(mfaData) {
+    if (mfaData.mobile && this.sms) {
+      return this.setupMobileOTP(mfaData.mobile);
+    }
+    if (this.totp) {
+      return this.setupTOTP(mfaData);
+    }
+    throw 'Invalid MFA data';
+  }
+  async validateLogin(loginData, _, req) {
+    const saveResponse = {
+      doNotSave: true
+    };
+    const token = loginData.token;
+    const auth = req.original.get('authData') || {};
+    const {
+      secret,
+      recovery,
+      mobile,
+      token: saved,
+      expiry
+    } = auth.mfa || {};
+    if (this.sms && mobile) {
+      if (token === 'request') {
+        const {
+          token: sendToken,
+          expiry
+        } = await this.sendSMS(mobile);
+        auth.mfa.token = sendToken;
+        auth.mfa.expiry = expiry;
+        req.object.set('authData', auth);
+        await req.object.save(null, {
+          useMasterKey: true
+        });
+        throw 'Please enter the token';
+      }
+      if (!saved || token !== saved) {
+        throw 'Invalid MFA token 1';
+      }
+      if (new Date() > expiry) {
+        throw 'Invalid MFA token 2';
+      }
+      delete auth.mfa.token;
+      delete auth.mfa.expiry;
+      return {
+        save: auth.mfa
+      };
+    }
+    if (this.totp) {
+      if (typeof token !== 'string') {
+        throw 'Invalid MFA token';
+      }
+      if (!secret) {
+        return saveResponse;
+      }
+      const recoveryIndex = recovery?.indexOf(token) ?? -1;
+      if (recoveryIndex >= 0) {
+        const updatedRecovery = [...recovery];
+        updatedRecovery.splice(recoveryIndex, 1);
+        return {
+          save: {
+            ...auth.mfa,
+            recovery: updatedRecovery
+          }
+        };
+      }
+      const totp = new _otpauth.TOTP({
+        algorithm: this.algorithm,
+        digits: this.digits,
+        period: this.period,
+        secret: _otpauth.Secret.fromBase32(secret)
+      });
+      const valid = totp.validate({
+        token
+      });
+      if (valid === null) {
+        throw 'Invalid MFA token';
+      }
+    }
+    return saveResponse;
+  }
+  async validateUpdate(authData, _, req) {
+    if (req.master) {
+      return;
+    }
+    if (authData.mobile && this.sms) {
+      if (!authData.token) {
+        throw 'MFA is already set up on this account';
+      }
+      return this.confirmSMSOTP(authData, req.original.get('authData')?.mfa || {});
+    }
+    if (this.totp) {
+      await this.validateLogin({
+        token: authData.old
+      }, null, req);
+      return this.validateSetUp(authData);
+    }
+    throw 'Invalid MFA data';
+  }
+  afterFind(authData, options, req) {
+    if (req.master) {
+      return;
+    }
+    if (this.totp && authData.secret) {
+      return {
+        status: 'enabled'
+      };
+    }
+    if (this.sms && authData.mobile) {
+      return {
+        status: 'enabled'
+      };
+    }
+    return {
+      status: 'disabled'
+    };
+  }
+  policy(req, auth) {
+    if (this.sms && auth?.pending && Object.keys(auth).length === 1) {
+      return 'default';
+    }
+    return 'additional';
+  }
+  async setupMobileOTP(mobile) {
+    const {
+      token,
+      expiry
+    } = await this.sendSMS(mobile);
+    return {
+      save: {
+        pending: {
+          [mobile]: {
+            token,
+            expiry
+          }
+        }
+      }
+    };
+  }
+  async sendSMS(mobile) {
+    if (!/^[+]*[(]{0,1}[0-9]{1,3}[)]{0,1}[-\s\./0-9]*$/g.test(mobile)) {
+      throw 'Invalid mobile number.';
+    }
+    let token = '';
+    while (token.length < this.digits) {
+      token += (0, _cryptoUtils.randomString)(10).replace(/\D/g, '');
+    }
+    token = token.substring(0, this.digits);
+    await Promise.resolve(this.smsCallback(token, mobile));
+    const expiry = new Date(new Date().getTime() + this.period * 1000);
+    return {
+      token,
+      expiry
+    };
+  }
+  async confirmSMSOTP(inputData, authData) {
+    const {
+      mobile,
+      token
+    } = inputData;
+    if (!authData.pending?.[mobile]) {
+      throw 'This number is not pending';
+    }
+    const pendingData = authData.pending[mobile];
+    if (token !== pendingData.token) {
+      throw 'Invalid MFA token';
+    }
+    if (new Date() > pendingData.expiry) {
+      throw 'Invalid MFA token';
+    }
+    delete authData.pending[mobile];
+    authData.mobile = mobile;
+    return {
+      save: authData
+    };
+  }
+  setupTOTP(mfaData) {
+    const {
+      secret,
+      token
+    } = mfaData;
+    if (!secret || !token || secret.length < 20) {
+      throw 'Invalid MFA data';
+    }
+    const totp = new _otpauth.TOTP({
+      algorithm: this.algorithm,
+      digits: this.digits,
+      period: this.period,
+      secret: _otpauth.Secret.fromBase32(secret)
+    });
+    const valid = totp.validate({
+      token
+    });
+    if (valid === null) {
+      throw 'Invalid MFA token';
+    }
+    const recovery = [(0, _cryptoUtils.randomString)(30), (0, _cryptoUtils.randomString)(30)];
+    return {
+      response: {
+        recovery: recovery.join(', ')
+      },
+      save: {
+        secret,
+        recovery
+      }
+    };
+  }
+}
+var _default = exports.default = new MFAAdapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_otpauth","require","_cryptoUtils","_AuthAdapter","_interopRequireDefault","e","__esModule","default","MFAAdapter","AuthAdapter","validateOptions","opts","validOptions","options","Array","isArray","sms","includes","totp","digits","period","sendSMS","smsCallback","algorithm","validateSetUp","mfaData","mobile","setupMobileOTP","setupTOTP","validateLogin","loginData","_","req","saveResponse","doNotSave","token","auth","original","get","secret","recovery","saved","expiry","mfa","sendToken","object","set","save","useMasterKey","Date","recoveryIndex","indexOf","updatedRecovery","splice","TOTP","Secret","fromBase32","valid","validate","validateUpdate","authData","master","confirmSMSOTP","old","afterFind","status","policy","pending","Object","keys","length","test","randomString","replace","substring","Promise","resolve","getTime","inputData","pendingData","response","join","_default","exports"],"sources":["../../../src/Adapters/Auth/mfa.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for Multi-Factor Authentication (MFA).\n *\n * @class MFAAdapter\n * @param {Object} options - The adapter options.\n * @param {Array<String>} options.options - Supported MFA methods. Must include `\"SMS\"` or `\"TOTP\"`.\n * @param {Number} [options.digits=6] - The number of digits for the one-time password (OTP). Must be between 4 and 10.\n * @param {Number} [options.period=30] - The validity period of the OTP in seconds. Must be greater than 10.\n * @param {String} [options.algorithm=\"SHA1\"] - The algorithm used for TOTP generation. Defaults to `\"SHA1\"`.\n * @param {Function} [options.sendSMS] - A callback function for sending SMS OTPs. Required if `\"SMS\"` is included in `options`.\n *\n * @description\n * ## Parse Server Configuration\n * To configure Parse Server for MFA, use the following structure:\n * ```javascript\n * {\n *   auth: {\n *     mfa: {\n *       options: [\"SMS\", \"TOTP\"],\n *       digits: 6,\n *       period: 30,\n *       algorithm: \"SHA1\",\n *       sendSMS: (token, mobile) => {\n *         // Send the SMS using your preferred SMS provider.\n *         console.log(`Sending SMS to ${mobile} with token: ${token}`);\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * ## MFA Methods\n * - **SMS**:\n *   - Requires a valid mobile number.\n *   - Sends a one-time password (OTP) via SMS for login or verification.\n *   - Uses the `sendSMS` callback for sending the OTP.\n *\n * - **TOTP**:\n *   - Requires a secret key for setup.\n *   - Validates the user's OTP against a time-based one-time password (TOTP) generated using the secret key.\n *   - Supports configurable digits, period, and algorithm for TOTP generation.\n *   - Generates two single-use recovery codes during enrollment. Each recovery code can be used once\n *     in place of a TOTP token and is consumed after use.\n *\n * ## MFA Payload\n * The adapter requires the following `authData` fields:\n * - **For SMS-based MFA**:\n *   - `mobile`: The user's mobile number (required for setup).\n *   - `token`: The OTP provided by the user for login or verification.\n * - **For TOTP-based MFA**:\n *   - `secret`: The TOTP secret key for the user (required for setup).\n *   - `token`: The OTP provided by the user for login or verification.\n *\n * ## Example Payloads\n * ### SMS Setup Payload\n * ```json\n * {\n *   \"mobile\": \"+1234567890\"\n * }\n * ```\n *\n * ### TOTP Setup Payload\n * ```json\n * {\n *   \"secret\": \"BASE32ENCODEDSECRET\",\n *   \"token\": \"123456\"\n * }\n * ```\n *\n * ### Login Payload\n * ```json\n * {\n *   \"token\": \"123456\"\n * }\n * ```\n *\n * @see {@link https://en.wikipedia.org/wiki/Time-based_One-Time_Password_algorithm Time-based One-Time Password Algorithm (TOTP)}\n * @see {@link https://tools.ietf.org/html/rfc6238 RFC 6238: TOTP: Time-Based One-Time Password Algorithm}\n */\n\nimport { TOTP, Secret } from 'otpauth';\nimport { randomString } from '../../cryptoUtils';\nimport AuthAdapter from './AuthAdapter';\nclass MFAAdapter extends AuthAdapter {\n  validateOptions(opts) {\n    const validOptions = opts.options;\n    if (!Array.isArray(validOptions)) {\n      throw 'mfa.options must be an array';\n    }\n    this.sms = validOptions.includes('SMS');\n    this.totp = validOptions.includes('TOTP');\n    if (!this.sms && !this.totp) {\n      throw 'mfa.options must include SMS or TOTP';\n    }\n    const digits = opts.digits || 6;\n    const period = opts.period || 30;\n    if (typeof digits !== 'number') {\n      throw 'mfa.digits must be a number';\n    }\n    if (typeof period !== 'number') {\n      throw 'mfa.period must be a number';\n    }\n    if (digits < 4 || digits > 10) {\n      throw 'mfa.digits must be between 4 and 10';\n    }\n    if (period < 10) {\n      throw 'mfa.period must be greater than 10';\n    }\n    const sendSMS = opts.sendSMS;\n    if (this.sms && typeof sendSMS !== 'function') {\n      throw 'mfa.sendSMS callback must be defined when using SMS OTPs';\n    }\n    this.smsCallback = sendSMS;\n    this.digits = digits;\n    this.period = period;\n    this.algorithm = opts.algorithm || 'SHA1';\n  }\n  validateSetUp(mfaData) {\n    if (mfaData.mobile && this.sms) {\n      return this.setupMobileOTP(mfaData.mobile);\n    }\n    if (this.totp) {\n      return this.setupTOTP(mfaData);\n    }\n    throw 'Invalid MFA data';\n  }\n  async validateLogin(loginData, _, req) {\n    const saveResponse = {\n      doNotSave: true,\n    };\n    const token = loginData.token;\n    const auth = req.original.get('authData') || {};\n    const { secret, recovery, mobile, token: saved, expiry } = auth.mfa || {};\n    if (this.sms && mobile) {\n      if (token === 'request') {\n        const { token: sendToken, expiry } = await this.sendSMS(mobile);\n        auth.mfa.token = sendToken;\n        auth.mfa.expiry = expiry;\n        req.object.set('authData', auth);\n        await req.object.save(null, { useMasterKey: true });\n        throw 'Please enter the token';\n      }\n      if (!saved || token !== saved) {\n        throw 'Invalid MFA token 1';\n      }\n      if (new Date() > expiry) {\n        throw 'Invalid MFA token 2';\n      }\n      delete auth.mfa.token;\n      delete auth.mfa.expiry;\n      return {\n        save: auth.mfa,\n      };\n    }\n    if (this.totp) {\n      if (typeof token !== 'string') {\n        throw 'Invalid MFA token';\n      }\n      if (!secret) {\n        return saveResponse;\n      }\n      const recoveryIndex = recovery?.indexOf(token) ?? -1;\n      if (recoveryIndex >= 0) {\n        const updatedRecovery = [...recovery];\n        updatedRecovery.splice(recoveryIndex, 1);\n        return {\n          save: { ...auth.mfa, recovery: updatedRecovery },\n        };\n      }\n      const totp = new TOTP({\n        algorithm: this.algorithm,\n        digits: this.digits,\n        period: this.period,\n        secret: Secret.fromBase32(secret),\n      });\n      const valid = totp.validate({\n        token,\n      });\n      if (valid === null) {\n        throw 'Invalid MFA token';\n      }\n    }\n    return saveResponse;\n  }\n  async validateUpdate(authData, _, req) {\n    if (req.master) {\n      return;\n    }\n    if (authData.mobile && this.sms) {\n      if (!authData.token) {\n        throw 'MFA is already set up on this account';\n      }\n      return this.confirmSMSOTP(authData, req.original.get('authData')?.mfa || {});\n    }\n    if (this.totp) {\n      await this.validateLogin({ token: authData.old }, null, req);\n      return this.validateSetUp(authData);\n    }\n    throw 'Invalid MFA data';\n  }\n  afterFind(authData, options, req) {\n    if (req.master) {\n      return;\n    }\n    if (this.totp && authData.secret) {\n      return {\n        status: 'enabled',\n      };\n    }\n    if (this.sms && authData.mobile) {\n      return {\n        status: 'enabled',\n      };\n    }\n    return {\n      status: 'disabled',\n    };\n  }\n\n  policy(req, auth) {\n    if (this.sms && auth?.pending && Object.keys(auth).length === 1) {\n      return 'default';\n    }\n    return 'additional';\n  }\n\n  async setupMobileOTP(mobile) {\n    const { token, expiry } = await this.sendSMS(mobile);\n    return {\n      save: {\n        pending: {\n          [mobile]: {\n            token,\n            expiry,\n          },\n        },\n      },\n    };\n  }\n\n  async sendSMS(mobile) {\n    if (!/^[+]*[(]{0,1}[0-9]{1,3}[)]{0,1}[-\\s\\./0-9]*$/g.test(mobile)) {\n      throw 'Invalid mobile number.';\n    }\n    let token = '';\n    while (token.length < this.digits) {\n      token += randomString(10).replace(/\\D/g, '');\n    }\n    token = token.substring(0, this.digits);\n    await Promise.resolve(this.smsCallback(token, mobile));\n    const expiry = new Date(new Date().getTime() + this.period * 1000);\n    return { token, expiry };\n  }\n\n  async confirmSMSOTP(inputData, authData) {\n    const { mobile, token } = inputData;\n    if (!authData.pending?.[mobile]) {\n      throw 'This number is not pending';\n    }\n    const pendingData = authData.pending[mobile];\n    if (token !== pendingData.token) {\n      throw 'Invalid MFA token';\n    }\n    if (new Date() > pendingData.expiry) {\n      throw 'Invalid MFA token';\n    }\n    delete authData.pending[mobile];\n    authData.mobile = mobile;\n    return {\n      save: authData,\n    };\n  }\n\n  setupTOTP(mfaData) {\n    const { secret, token } = mfaData;\n    if (!secret || !token || secret.length < 20) {\n      throw 'Invalid MFA data';\n    }\n    const totp = new TOTP({\n      algorithm: this.algorithm,\n      digits: this.digits,\n      period: this.period,\n      secret: Secret.fromBase32(secret),\n    });\n    const valid = totp.validate({\n      token,\n    });\n    if (valid === null) {\n      throw 'Invalid MFA token';\n    }\n    const recovery = [randomString(30), randomString(30)];\n    return {\n      response: { recovery: recovery.join(', ') },\n      save: { secret, recovery },\n    };\n  }\n}\nexport default new MFAAdapter();\n"],"mappings":"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","ignoreList":[]}

package/lib/Adapters/Auth/microsoft.js

@@ -0,0 +1,111 @@
+"use strict";
+
+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}
+ */
+
+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.');
+    }
+    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;
+  }
+}
+var _default = exports.default = new MicrosoftAdapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Auth/oauth2.js

@@ -0,0 +1,115 @@
+"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.
+ *
+ * @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='sub'] - The field in the introspection response that contains the user ID. Defaults to `sub` per RFC 7662.
+ * @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.
+ *
+ * @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 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-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 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 || 'sub';
+    this.appidField = options.appidField;
+    this.appIds = options.appIds;
+    this.authorizationHeader = options.authorizationHeader;
+  }
+  async validateAppId(appIds, 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.');
+    }
+  }
+  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 {};
+  }
+  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();
+  }
+}
+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='sub'] - The field in the introspection response that contains the user ID. Defaults to `sub` per RFC 7662.\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 || 'sub';\n    this.appidField = options.appidField;\n    this.appIds = options.appIds;\n    this.authorizationHeader = options.authorizationHeader;\n  }\n\n  async validateAppId(appIds, 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":[]}