@beiguancyc/parse-server 9.9.0-ruixiang.1

package/lib/Adapters/Auth/gpgames.js

@@ -0,0 +1,125 @@
+"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 Google Play Games Services.
+ *
+ * @class GooglePlayGamesServicesAdapter
+ * @param {Object} options - The adapter configuration options.
+ * @param {string} options.clientId - Your Google Play Games Services App Client ID. Required for secure authentication.
+ * @param {string} options.clientSecret - Your Google Play Games Services 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 Google Play Games Services authentication, use the following structure:
+ * ```json
+ * {
+ *   "auth": {
+ *     "gpgames": {
+ *       "clientId": "your-client-id",
+ *       "clientSecret": "your-client-secret"
+ *     }
+ *   }
+ * }
+ * ```
+ * ### Insecure Configuration (Not Recommended)
+ * ```json
+ * {
+ *   "auth": {
+ *     "gpgames": {
+ *       "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
+ * {
+ *   "gpgames": {
+ *     "code": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+ *     "redirect_uri": "https://example.com/callback"
+ *   }
+ * }
+ * ```
+ *
+ * ### Insecure Authentication Payload (Not Recommended)
+ * ```json
+ * {
+ *   "gpgames": {
+ *     "id": "123456789",
+ *     "access_token": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * - `enableInsecureAuth` is **not recommended** and may be removed in future versions. Use secure authentication with `code` and `redirect_uri`.
+ * - Secure authentication exchanges the `code` provided by the client for an access token using Google Play Games Services' OAuth API.
+ *
+ * @see {@link https://developers.google.com/games/services/console/enabling Google Play Games Services Authentication Documentation}
+ */
+
+class GooglePlayGamesServicesAdapter extends _BaseCodeAuthAdapter.default {
+  constructor() {
+    super("gpgames");
+  }
+  async getAccessTokenFromCode(authData) {
+    const tokenUrl = 'https://oauth2.googleapis.com/token';
+    const response = await fetch(tokenUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json'
+      },
+      body: JSON.stringify({
+        client_id: this.clientId,
+        client_secret: this.clientSecret,
+        code: authData.code,
+        redirect_uri: authData.redirectUri,
+        grant_type: 'authorization_code'
+      })
+    });
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.VALIDATION_ERROR, `Failed to exchange code for token: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, data.error_description || data.error);
+    }
+    return data.access_token;
+  }
+  async getUserFromAccessToken(accessToken, authData) {
+    const userApiUrl = `https://www.googleapis.com/games/v1/players/${authData.id}`;
+    const response = await fetch(userApiUrl, {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: 'application/json'
+      }
+    });
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.VALIDATION_ERROR, `Failed to fetch Google Play Games Services user: ${response.statusText}`);
+    }
+    const userData = await response.json();
+    if (!userData.playerId || userData.playerId !== authData.id) {
+      throw new Parse.Error(Parse.Error.VALIDATION_ERROR, 'Invalid Google Play Games Services user data received.');
+    }
+    return {
+      id: userData.playerId
+    };
+  }
+}
+var _default = exports.default = new GooglePlayGamesServicesAdapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_BaseCodeAuthAdapter","_interopRequireDefault","require","e","__esModule","default","GooglePlayGamesServicesAdapter","BaseCodeAuthAdapter","constructor","getAccessTokenFromCode","authData","tokenUrl","response","fetch","method","headers","Accept","body","JSON","stringify","client_id","clientId","client_secret","clientSecret","code","redirect_uri","redirectUri","grant_type","ok","Parse","Error","VALIDATION_ERROR","statusText","data","json","error","OBJECT_NOT_FOUND","error_description","access_token","getUserFromAccessToken","accessToken","userApiUrl","id","Authorization","userData","playerId","_default","exports"],"sources":["../../../src/Adapters/Auth/gpgames.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for Google Play Games Services.\n *\n * @class GooglePlayGamesServicesAdapter\n * @param {Object} options - The adapter configuration options.\n * @param {string} options.clientId - Your Google Play Games Services App Client ID. Required for secure authentication.\n * @param {string} options.clientSecret - Your Google Play Games Services App Client Secret. Required for secure authentication.\n * @param {boolean} [options.enableInsecureAuth=false] - **[DEPRECATED]** Enable insecure authentication (not recommended).\n *\n * @description\n * ## Parse Server Configuration\n * To configure Parse Server for Google Play Games Services authentication, use the following structure:\n * ```json\n * {\n *   \"auth\": {\n *     \"gpgames\": {\n *       \"clientId\": \"your-client-id\",\n *       \"clientSecret\": \"your-client-secret\"\n *     }\n *   }\n * }\n * ```\n * ### Insecure Configuration (Not Recommended)\n * ```json\n * {\n *   \"auth\": {\n *     \"gpgames\": {\n *       \"enableInsecureAuth\": true\n *     }\n *   }\n * }\n * ```\n *\n * The adapter requires the following `authData` fields:\n * - **Secure Authentication**: `code`, `redirect_uri`.\n * - **Insecure Authentication (Not Recommended)**: `id`, `access_token`.\n *\n * ## Auth Payloads\n * ### Secure Authentication Payload\n * ```json\n * {\n *   \"gpgames\": {\n *     \"code\": \"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\",\n *     \"redirect_uri\": \"https://example.com/callback\"\n *   }\n * }\n * ```\n *\n * ### Insecure Authentication Payload (Not Recommended)\n * ```json\n * {\n *   \"gpgames\": {\n *     \"id\": \"123456789\",\n *     \"access_token\": \"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"\n *   }\n * }\n * ```\n *\n * ## Notes\n * - `enableInsecureAuth` is **not recommended** and may be removed in future versions. Use secure authentication with `code` and `redirect_uri`.\n * - Secure authentication exchanges the `code` provided by the client for an access token using Google Play Games Services' OAuth API.\n *\n * @see {@link https://developers.google.com/games/services/console/enabling Google Play Games Services Authentication Documentation}\n */\n\nimport BaseCodeAuthAdapter from './BaseCodeAuthAdapter';\nclass GooglePlayGamesServicesAdapter extends BaseCodeAuthAdapter {\n  constructor() {\n    super(\"gpgames\");\n  }\n\n  async getAccessTokenFromCode(authData) {\n    const tokenUrl = 'https://oauth2.googleapis.com/token';\n    const response = await fetch(tokenUrl, {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/json',\n        Accept: 'application/json',\n      },\n      body: JSON.stringify({\n        client_id: this.clientId,\n        client_secret: this.clientSecret,\n        code: authData.code,\n        redirect_uri: authData.redirectUri,\n        grant_type: 'authorization_code',\n      }),\n    });\n\n    if (!response.ok) {\n      throw new Parse.Error(\n        Parse.Error.VALIDATION_ERROR,\n        `Failed to exchange code for token: ${response.statusText}`\n      );\n    }\n\n    const data = await response.json();\n    if (data.error) {\n      throw new Parse.Error(\n        Parse.Error.OBJECT_NOT_FOUND,\n        data.error_description || data.error\n      );\n    }\n\n    return data.access_token;\n  }\n\n  async getUserFromAccessToken(accessToken, authData) {\n    const userApiUrl = `https://www.googleapis.com/games/v1/players/${authData.id}`;\n    const response = await fetch(userApiUrl, {\n      method: 'GET',\n      headers: {\n        Authorization: `Bearer ${accessToken}`,\n        Accept: 'application/json',\n      },\n    });\n\n    if (!response.ok) {\n      throw new Parse.Error(\n        Parse.Error.VALIDATION_ERROR,\n        `Failed to fetch Google Play Games Services user: ${response.statusText}`\n      );\n    }\n\n    const userData = await response.json();\n    if (!userData.playerId || userData.playerId !== authData.id) {\n      throw new Parse.Error(\n        Parse.Error.VALIDATION_ERROR,\n        'Invalid Google Play Games Services user data received.'\n      );\n    }\n\n    return {\n      id: userData.playerId\n    };\n  }\n\n}\n\nexport default new GooglePlayGamesServicesAdapter();\n"],"mappings":"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","ignoreList":[]}

package/lib/Adapters/Auth/httpsRequest.js

@@ -0,0 +1,41 @@
+"use strict";
+
+const https = require('https');
+function makeCallback(resolve, reject, noJSON) {
+  return function (res) {
+    let data = '';
+    res.on('data', chunk => {
+      data += chunk;
+    });
+    res.on('end', () => {
+      if (noJSON) {
+        return resolve(data);
+      }
+      try {
+        data = JSON.parse(data);
+      } catch (e) {
+        return reject(e);
+      }
+      resolve(data);
+    });
+    res.on('error', reject);
+  };
+}
+function get(options, noJSON = false) {
+  return new Promise((resolve, reject) => {
+    https.get(options, makeCallback(resolve, reject, noJSON)).on('error', reject);
+  });
+}
+function request(options, postData) {
+  return new Promise((resolve, reject) => {
+    const req = https.request(options, makeCallback(resolve, reject));
+    req.on('error', reject);
+    req.write(postData);
+    req.end();
+  });
+}
+module.exports = {
+  get,
+  request
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Auth/index.js

@@ -0,0 +1,248 @@
+"use strict";
+
+var _AdapterLoader = _interopRequireDefault(require("../AdapterLoader"));
+var _node = _interopRequireDefault(require("parse/node"));
+var _AuthAdapter = _interopRequireDefault(require("./AuthAdapter"));
+var _gcenter = _interopRequireDefault(require("./gcenter"));
+var _github = _interopRequireDefault(require("./github"));
+var _gpgames = _interopRequireDefault(require("./gpgames"));
+var _instagram = _interopRequireDefault(require("./instagram"));
+var _line = _interopRequireDefault(require("./line"));
+var _linkedin = _interopRequireDefault(require("./linkedin"));
+var _mfa = _interopRequireDefault(require("./mfa"));
+var _microsoft = _interopRequireDefault(require("./microsoft"));
+var _oauth = _interopRequireDefault(require("./oauth2"));
+var _qq = _interopRequireDefault(require("./qq"));
+var _spotify = _interopRequireDefault(require("./spotify"));
+var _twitter = _interopRequireDefault(require("./twitter"));
+var _wechat = _interopRequireDefault(require("./wechat"));
+var _weibo = _interopRequireDefault(require("./weibo"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const apple = require('./apple');
+const digits = require('./twitter'); // digits tokens are validated by twitter
+const facebook = require('./facebook');
+const google = require('./google');
+const janraincapture = require('./janraincapture');
+const janrainengage = require('./janrainengage');
+const keycloak = require('./keycloak');
+const ldap = require('./ldap');
+const meetup = require('./meetup');
+const phantauth = require('./phantauth');
+const vkontakte = require('./vkontakte');
+const anonymous = {
+  validateAuthData: () => {
+    return Promise.resolve();
+  },
+  validateAppId: () => {
+    return Promise.resolve();
+  }
+};
+const providers = {
+  apple,
+  gcenter: _gcenter.default,
+  gpgames: _gpgames.default,
+  facebook,
+  instagram: _instagram.default,
+  linkedin: _linkedin.default,
+  meetup,
+  mfa: _mfa.default,
+  google,
+  github: _github.default,
+  twitter: _twitter.default,
+  spotify: _spotify.default,
+  anonymous,
+  digits,
+  janrainengage,
+  janraincapture,
+  line: _line.default,
+  vkontakte,
+  qq: _qq.default,
+  wechat: _wechat.default,
+  weibo: _weibo.default,
+  phantauth,
+  microsoft: _microsoft.default,
+  keycloak,
+  ldap
+};
+
+// Indexed auth policies
+const authAdapterPolicies = {
+  default: true,
+  solo: true,
+  additional: true
+};
+function authDataValidator(provider, adapter, appIds, options) {
+  return async function (authData, req, user, requestObject) {
+    if (appIds && typeof adapter.validateAppId === 'function') {
+      await Promise.resolve(adapter.validateAppId(appIds, authData, options, requestObject));
+    }
+    if (adapter.policy && !authAdapterPolicies[adapter.policy] && typeof adapter.policy !== 'function') {
+      throw new _node.default.Error(_node.default.Error.OTHER_CAUSE, 'AuthAdapter policy is not configured correctly. The value must be either "solo", "additional", "default" or undefined (will be handled as "default")');
+    }
+    if (typeof adapter.validateAuthData === 'function') {
+      return adapter.validateAuthData(authData, options, requestObject);
+    }
+    if (typeof adapter.validateSetUp !== 'function' || typeof adapter.validateLogin !== 'function' || typeof adapter.validateUpdate !== 'function') {
+      throw new _node.default.Error(_node.default.Error.OTHER_CAUSE, 'Adapter is not configured. Implement either validateAuthData or all of the following: validateSetUp, validateLogin and validateUpdate');
+    }
+    // When masterKey is detected, we should trigger a logged in user
+    const isLoggedIn = req.auth.user && user && req.auth.user.id === user.id || user && req.auth.isMaster;
+    let hasAuthDataConfigured = false;
+    if (user && user.get('authData') && user.get('authData')[provider]) {
+      hasAuthDataConfigured = true;
+    }
+    if (isLoggedIn) {
+      // User is updating their authData
+      if (hasAuthDataConfigured) {
+        return {
+          method: 'validateUpdate',
+          validator: () => adapter.validateUpdate(authData, options, requestObject)
+        };
+      }
+      // Set up if the user does not have the provider configured
+      return {
+        method: 'validateSetUp',
+        validator: () => adapter.validateSetUp(authData, options, requestObject)
+      };
+    }
+
+    // Not logged in and authData is configured on the user
+    if (hasAuthDataConfigured) {
+      return {
+        method: 'validateLogin',
+        validator: () => adapter.validateLogin(authData, options, requestObject)
+      };
+    }
+
+    // User not logged in and the provider is not set up, for example when a new user
+    // signs up or an existing user uses a new auth provider
+    return {
+      method: 'validateSetUp',
+      validator: () => adapter.validateSetUp(authData, options, requestObject)
+    };
+  };
+}
+function loadAuthAdapter(provider, authOptions) {
+  // providers are auth providers implemented by default
+  let defaultAdapter = providers[provider];
+  // authOptions can contain complete custom auth adapters or
+  // a default auth adapter like Facebook
+  const providerOptions = authOptions[provider];
+  if (providerOptions && Object.prototype.hasOwnProperty.call(providerOptions, 'oauth2') && providerOptions['oauth2'] === true) {
+    defaultAdapter = _oauth.default;
+  }
+
+  // Default provider not found and a custom auth provider was not provided
+  if (!defaultAdapter && !providerOptions) {
+    return;
+  }
+  const adapter = defaultAdapter instanceof _AuthAdapter.default ? new defaultAdapter.constructor() : Object.assign({}, defaultAdapter);
+  const keys = ['validateAuthData', 'validateAppId', 'validateSetUp', 'validateLogin', 'validateUpdate', 'challenge', 'validateOptions', 'policy', 'afterFind'];
+  const defaultAuthAdapter = new _AuthAdapter.default();
+  keys.forEach(key => {
+    const existing = adapter?.[key];
+    if (existing && typeof existing === 'function' && existing.toString() === defaultAuthAdapter[key].toString()) {
+      adapter[key] = null;
+    }
+  });
+  const appIds = providerOptions ? providerOptions.appIds : undefined;
+
+  // Try the configuration methods
+  if (providerOptions) {
+    const optionalAdapter = (0, _AdapterLoader.default)(providerOptions, undefined, providerOptions);
+    if (optionalAdapter) {
+      keys.forEach(key => {
+        if (optionalAdapter[key]) {
+          adapter[key] = optionalAdapter[key];
+        }
+      });
+    }
+  }
+  if (adapter.validateOptions) {
+    adapter.validateOptions(providerOptions);
+  }
+  return {
+    adapter,
+    appIds,
+    providerOptions
+  };
+}
+module.exports = function (authOptions = {}, enableAnonymousUsers = true) {
+  let _enableAnonymousUsers = enableAnonymousUsers;
+  const setEnableAnonymousUsers = function (enable) {
+    _enableAnonymousUsers = enable;
+  };
+  // To handle the test cases on configuration
+  const getValidatorForProvider = function (provider) {
+    if (provider === 'anonymous' && !_enableAnonymousUsers) {
+      return {
+        validator: undefined
+      };
+    }
+    const authAdapter = loadAuthAdapter(provider, authOptions);
+    if (!authAdapter) {
+      return;
+    }
+    const {
+      adapter,
+      appIds,
+      providerOptions
+    } = authAdapter;
+    return {
+      validator: authDataValidator(provider, adapter, appIds, providerOptions),
+      adapter
+    };
+  };
+  const runAfterFind = async (req, authData) => {
+    if (!authData) {
+      return;
+    }
+    const adapters = Object.keys(authData);
+    await Promise.all(adapters.map(async provider => {
+      const authAdapter = getValidatorForProvider(provider);
+      if (!authAdapter) {
+        return;
+      }
+      const {
+        adapter,
+        providerOptions
+      } = authAdapter;
+      const afterFind = adapter.afterFind;
+      if (afterFind && typeof afterFind === 'function') {
+        const requestObject = {
+          ip: req.config.ip,
+          user: req.auth.user,
+          master: req.auth.isMaster
+        };
+        const result = afterFind.call(adapter, authData[provider], providerOptions, requestObject);
+        if (result) {
+          authData[provider] = result;
+        }
+      }
+    }));
+  };
+
+  // Returns the list of auth provider names that have a valid adapter configured.
+  // This includes both built-in providers and custom providers from authOptions.
+  const getProviders = function () {
+    const allProviders = new Set([...Object.keys(providers), ...Object.keys(authOptions)]);
+    if (!_enableAnonymousUsers) {
+      allProviders.delete('anonymous');
+    }
+    return [...allProviders].filter(provider => {
+      try {
+        return !!loadAuthAdapter(provider, authOptions);
+      } catch {
+        return false;
+      }
+    });
+  };
+  return Object.freeze({
+    getValidatorForProvider,
+    getProviders,
+    setEnableAnonymousUsers,
+    runAfterFind
+  });
+};
+module.exports.loadAuthAdapter = loadAuthAdapter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_AdapterLoader","_interopRequireDefault","require","_node","_AuthAdapter","_gcenter","_github","_gpgames","_instagram","_line","_linkedin","_mfa","_microsoft","_oauth","_qq","_spotify","_twitter","_wechat","_weibo","e","__esModule","default","apple","digits","facebook","google","janraincapture","janrainengage","keycloak","ldap","meetup","phantauth","vkontakte","anonymous","validateAuthData","Promise","resolve","validateAppId","providers","gcenter","gpgames","instagram","linkedin","mfa","github","twitter","spotify","line","qq","wechat","weibo","microsoft","authAdapterPolicies","solo","additional","authDataValidator","provider","adapter","appIds","options","authData","req","user","requestObject","policy","Parse","Error","OTHER_CAUSE","validateSetUp","validateLogin","validateUpdate","isLoggedIn","auth","id","isMaster","hasAuthDataConfigured","get","method","validator","loadAuthAdapter","authOptions","defaultAdapter","providerOptions","Object","prototype","hasOwnProperty","call","oauth2","AuthAdapter","constructor","assign","keys","defaultAuthAdapter","forEach","key","existing","toString","undefined","optionalAdapter","loadAdapter","validateOptions","module","exports","enableAnonymousUsers","_enableAnonymousUsers","setEnableAnonymousUsers","enable","getValidatorForProvider","authAdapter","runAfterFind","adapters","all","map","afterFind","ip","config","master","result","getProviders","allProviders","Set","delete","filter","freeze"],"sources":["../../../src/Adapters/Auth/index.js"],"sourcesContent":["import loadAdapter from '../AdapterLoader';\nimport Parse from 'parse/node';\nimport AuthAdapter from './AuthAdapter';\n\nconst apple = require('./apple');\nconst digits = require('./twitter'); // digits tokens are validated by twitter\nconst facebook = require('./facebook');\nimport gcenter from './gcenter';\nimport github from './github';\nconst google = require('./google');\nimport gpgames from './gpgames';\nimport instagram from './instagram';\nconst janraincapture = require('./janraincapture');\nconst janrainengage = require('./janrainengage');\nconst keycloak = require('./keycloak');\nconst ldap = require('./ldap');\nimport line from './line';\nimport linkedin from './linkedin';\nconst meetup = require('./meetup');\nimport mfa from './mfa';\nimport microsoft from './microsoft';\nimport oauth2 from './oauth2';\nconst phantauth = require('./phantauth');\nimport qq from './qq';\nimport spotify from './spotify';\nimport twitter from './twitter';\nconst vkontakte = require('./vkontakte');\nimport wechat from './wechat';\nimport weibo from './weibo';\n\n\nconst anonymous = {\n  validateAuthData: () => {\n    return Promise.resolve();\n  },\n  validateAppId: () => {\n    return Promise.resolve();\n  },\n};\n\nconst providers = {\n  apple,\n  gcenter,\n  gpgames,\n  facebook,\n  instagram,\n  linkedin,\n  meetup,\n  mfa,\n  google,\n  github,\n  twitter,\n  spotify,\n  anonymous,\n  digits,\n  janrainengage,\n  janraincapture,\n  line,\n  vkontakte,\n  qq,\n  wechat,\n  weibo,\n  phantauth,\n  microsoft,\n  keycloak,\n  ldap,\n};\n\n// Indexed auth policies\nconst authAdapterPolicies = {\n  default: true,\n  solo: true,\n  additional: true,\n};\n\nfunction authDataValidator(provider, adapter, appIds, options) {\n  return async function (authData, req, user, requestObject) {\n    if (appIds && typeof adapter.validateAppId === 'function') {\n      await Promise.resolve(adapter.validateAppId(appIds, authData, options, requestObject));\n    }\n    if (\n      adapter.policy &&\n      !authAdapterPolicies[adapter.policy] &&\n      typeof adapter.policy !== 'function'\n    ) {\n      throw new Parse.Error(\n        Parse.Error.OTHER_CAUSE,\n        'AuthAdapter policy is not configured correctly. The value must be either \"solo\", \"additional\", \"default\" or undefined (will be handled as \"default\")'\n      );\n    }\n    if (typeof adapter.validateAuthData === 'function') {\n      return adapter.validateAuthData(authData, options, requestObject);\n    }\n    if (\n      typeof adapter.validateSetUp !== 'function' ||\n      typeof adapter.validateLogin !== 'function' ||\n      typeof adapter.validateUpdate !== 'function'\n    ) {\n      throw new Parse.Error(\n        Parse.Error.OTHER_CAUSE,\n        'Adapter is not configured. Implement either validateAuthData or all of the following: validateSetUp, validateLogin and validateUpdate'\n      );\n    }\n    // When masterKey is detected, we should trigger a logged in user\n    const isLoggedIn =\n      (req.auth.user && user && req.auth.user.id === user.id) || (user && req.auth.isMaster);\n    let hasAuthDataConfigured = false;\n\n    if (user && user.get('authData') && user.get('authData')[provider]) {\n      hasAuthDataConfigured = true;\n    }\n\n    if (isLoggedIn) {\n      // User is updating their authData\n      if (hasAuthDataConfigured) {\n        return {\n          method: 'validateUpdate',\n          validator: () => adapter.validateUpdate(authData, options, requestObject),\n        };\n      }\n      // Set up if the user does not have the provider configured\n      return {\n        method: 'validateSetUp',\n        validator: () => adapter.validateSetUp(authData, options, requestObject),\n      };\n    }\n\n    // Not logged in and authData is configured on the user\n    if (hasAuthDataConfigured) {\n      return {\n        method: 'validateLogin',\n        validator: () => adapter.validateLogin(authData, options, requestObject),\n      };\n    }\n\n    // User not logged in and the provider is not set up, for example when a new user\n    // signs up or an existing user uses a new auth provider\n    return {\n      method: 'validateSetUp',\n      validator: () => adapter.validateSetUp(authData, options, requestObject),\n    };\n  };\n}\n\nfunction loadAuthAdapter(provider, authOptions) {\n  // providers are auth providers implemented by default\n  let defaultAdapter = providers[provider];\n  // authOptions can contain complete custom auth adapters or\n  // a default auth adapter like Facebook\n  const providerOptions = authOptions[provider];\n  if (\n    providerOptions &&\n    Object.prototype.hasOwnProperty.call(providerOptions, 'oauth2') &&\n    providerOptions['oauth2'] === true\n  ) {\n    defaultAdapter = oauth2;\n  }\n\n  // Default provider not found and a custom auth provider was not provided\n  if (!defaultAdapter && !providerOptions) {\n    return;\n  }\n\n  const adapter =\n    defaultAdapter instanceof AuthAdapter ? new defaultAdapter.constructor() : Object.assign({}, defaultAdapter);\n  const keys = [\n    'validateAuthData',\n    'validateAppId',\n    'validateSetUp',\n    'validateLogin',\n    'validateUpdate',\n    'challenge',\n    'validateOptions',\n    'policy',\n    'afterFind',\n  ];\n  const defaultAuthAdapter = new AuthAdapter();\n  keys.forEach(key => {\n    const existing = adapter?.[key];\n    if (\n      existing &&\n      typeof existing === 'function' &&\n      existing.toString() === defaultAuthAdapter[key].toString()\n    ) {\n      adapter[key] = null;\n    }\n  });\n  const appIds = providerOptions ? providerOptions.appIds : undefined;\n\n  // Try the configuration methods\n  if (providerOptions) {\n    const optionalAdapter = loadAdapter(providerOptions, undefined, providerOptions);\n    if (optionalAdapter) {\n      keys.forEach(key => {\n        if (optionalAdapter[key]) {\n          adapter[key] = optionalAdapter[key];\n        }\n      });\n    }\n  }\n  if (adapter.validateOptions) {\n    adapter.validateOptions(providerOptions);\n  }\n\n  return { adapter, appIds, providerOptions };\n}\n\nmodule.exports = function (authOptions = {}, enableAnonymousUsers = true) {\n  let _enableAnonymousUsers = enableAnonymousUsers;\n  const setEnableAnonymousUsers = function (enable) {\n    _enableAnonymousUsers = enable;\n  };\n  // To handle the test cases on configuration\n  const getValidatorForProvider = function (provider) {\n    if (provider === 'anonymous' && !_enableAnonymousUsers) {\n      return { validator: undefined };\n    }\n    const authAdapter = loadAuthAdapter(provider, authOptions);\n    if (!authAdapter) { return; }\n    const { adapter, appIds, providerOptions } = authAdapter;\n    return { validator: authDataValidator(provider, adapter, appIds, providerOptions), adapter };\n  };\n\n  const runAfterFind = async (req, authData) => {\n    if (!authData) {\n      return;\n    }\n    const adapters = Object.keys(authData);\n    await Promise.all(\n      adapters.map(async provider => {\n        const authAdapter = getValidatorForProvider(provider);\n        if (!authAdapter) {\n          return;\n        }\n        const { adapter, providerOptions } = authAdapter;\n        const afterFind = adapter.afterFind;\n        if (afterFind && typeof afterFind === 'function') {\n          const requestObject = {\n            ip: req.config.ip,\n            user: req.auth.user,\n            master: req.auth.isMaster,\n          };\n          const result = afterFind.call(\n            adapter,\n            authData[provider],\n            providerOptions,\n            requestObject,\n          );\n          if (result) {\n            authData[provider] = result;\n          }\n        }\n      })\n    );\n  };\n\n  // Returns the list of auth provider names that have a valid adapter configured.\n  // This includes both built-in providers and custom providers from authOptions.\n  const getProviders = function () {\n    const allProviders = new Set([...Object.keys(providers), ...Object.keys(authOptions)]);\n    if (!_enableAnonymousUsers) {\n      allProviders.delete('anonymous');\n    }\n    return [...allProviders].filter(provider => {\n      try {\n        return !!loadAuthAdapter(provider, authOptions);\n      } catch {\n        return false;\n      }\n    });\n  };\n\n  return Object.freeze({\n    getValidatorForProvider,\n    getProviders,\n    setEnableAnonymousUsers,\n    runAfterFind,\n  });\n};\n\nmodule.exports.loadAuthAdapter = loadAuthAdapter;\n"],"mappings":"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","ignoreList":[]}

package/lib/Adapters/Auth/instagram.js

@@ -0,0 +1,118 @@
+"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 Instagram.
+ *
+ * @class InstagramAdapter
+ * @param {Object} options - The adapter configuration options.
+ * @param {string} options.clientId - Your Instagram App Client ID. Required for secure authentication.
+ * @param {string} options.clientSecret - Your Instagram 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 Instagram authentication, use the following structure:
+ * ```json
+ * {
+ *   "auth": {
+ *     "instagram": {
+ *       "clientId": "your-client-id",
+ *       "clientSecret": "your-client-secret"
+ *     }
+ *   }
+ * }
+ * ```
+ * ### Insecure Configuration (Not Recommended)
+ * ```json
+ * {
+ *   "auth": {
+ *     "instagram": {
+ *       "enableInsecureAuth": true
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The adapter requires the following `authData` fields:
+ * - **Secure Authentication**: `code`, `redirect_uri`.
+ * - **Insecure Authentication (Deprecated)**: `id`, `access_token`.
+ *
+ * ## Auth Payloads
+ * ### Secure Authentication Payload
+ * ```json
+ * {
+ *   "instagram": {
+ *     "code": "lmn789opq012rst345uvw",
+ *     "redirect_uri": "https://example.com/callback"
+ *   }
+ * }
+ * ```
+ *
+ * ### Insecure Authentication Payload (Deprecated)
+ * ```json
+ * {
+ *   "instagram": {
+ *     "id": "1234567",
+ *     "access_token": "AQXNnd2hIT6z9bHFzZz2Kp1ghiMz_RtyuvwXYZ123abc"
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * - `enableInsecureAuth` is **deprecated** and will be removed in future versions. Use secure authentication with `code` and `redirect_uri`.
+ * - Secure authentication exchanges the `code` and `redirect_uri` provided by the client for an access token using Instagram's OAuth flow.
+ *
+ * @see {@link https://developers.facebook.com/docs/instagram-basic-display-api/getting-started Instagram Basic Display API - Getting Started}
+ */
+
+class InstagramAdapter extends _BaseCodeAuthAdapter.default {
+  constructor() {
+    super('Instagram');
+  }
+  async getAccessTokenFromCode(authData) {
+    const response = await fetch('https://api.instagram.com/oauth/access_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: this.redirectUri,
+        code: authData.code
+      })
+    });
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Instagram API request failed.');
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, data.error_description || data.error);
+    }
+    return data.access_token;
+  }
+  async getUserFromAccessToken(accessToken, authData) {
+    const apiURL = 'https://graph.instagram.com/';
+    const path = `${apiURL}me?fields=id&access_token=${accessToken}`;
+    const response = await fetch(path);
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Instagram API request failed.');
+    }
+    const user = await response.json();
+    if (user?.id !== authData.id) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Instagram auth is invalid for this user.');
+    }
+    return {
+      id: user.id
+    };
+  }
+}
+var _default = exports.default = new InstagramAdapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_BaseCodeAuthAdapter","_interopRequireDefault","require","e","__esModule","default","InstagramAdapter","BaseAuthCodeAdapter","constructor","getAccessTokenFromCode","authData","response","fetch","method","headers","body","URLSearchParams","client_id","clientId","client_secret","clientSecret","grant_type","redirect_uri","redirectUri","code","ok","Parse","Error","OBJECT_NOT_FOUND","data","json","error","error_description","access_token","getUserFromAccessToken","accessToken","apiURL","path","user","id","_default","exports"],"sources":["../../../src/Adapters/Auth/instagram.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for Instagram.\n *\n * @class InstagramAdapter\n * @param {Object} options - The adapter configuration options.\n * @param {string} options.clientId - Your Instagram App Client ID. Required for secure authentication.\n * @param {string} options.clientSecret - Your Instagram App Client Secret. Required for secure authentication.\n * @param {boolean} [options.enableInsecureAuth=false] - **[DEPRECATED]** Enable insecure authentication (not recommended).\n *\n * @description\n * ## Parse Server Configuration\n * To configure Parse Server for Instagram authentication, use the following structure:\n * ```json\n * {\n *   \"auth\": {\n *     \"instagram\": {\n *       \"clientId\": \"your-client-id\",\n *       \"clientSecret\": \"your-client-secret\"\n *     }\n *   }\n * }\n * ```\n * ### Insecure Configuration (Not Recommended)\n * ```json\n * {\n *   \"auth\": {\n *     \"instagram\": {\n *       \"enableInsecureAuth\": true\n *     }\n *   }\n * }\n * ```\n *\n * The adapter requires the following `authData` fields:\n * - **Secure Authentication**: `code`, `redirect_uri`.\n * - **Insecure Authentication (Deprecated)**: `id`, `access_token`.\n *\n * ## Auth Payloads\n * ### Secure Authentication Payload\n * ```json\n * {\n *   \"instagram\": {\n *     \"code\": \"lmn789opq012rst345uvw\",\n *     \"redirect_uri\": \"https://example.com/callback\"\n *   }\n * }\n * ```\n *\n * ### Insecure Authentication Payload (Deprecated)\n * ```json\n * {\n *   \"instagram\": {\n *     \"id\": \"1234567\",\n *     \"access_token\": \"AQXNnd2hIT6z9bHFzZz2Kp1ghiMz_RtyuvwXYZ123abc\"\n *   }\n * }\n * ```\n *\n * ## Notes\n * - `enableInsecureAuth` is **deprecated** and will be removed in future versions. Use secure authentication with `code` and `redirect_uri`.\n * - Secure authentication exchanges the `code` and `redirect_uri` provided by the client for an access token using Instagram's OAuth flow.\n *\n * @see {@link https://developers.facebook.com/docs/instagram-basic-display-api/getting-started Instagram Basic Display API - Getting Started}\n */\n\n\nimport BaseAuthCodeAdapter from './BaseCodeAuthAdapter';\nclass InstagramAdapter extends BaseAuthCodeAdapter {\n  constructor() {\n    super('Instagram');\n  }\n\n  async getAccessTokenFromCode(authData) {\n    const response = await fetch('https://api.instagram.com/oauth/access_token', {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },\n      body: new URLSearchParams({\n        client_id: this.clientId,\n        client_secret: this.clientSecret,\n        grant_type: 'authorization_code',\n        redirect_uri: this.redirectUri,\n        code: authData.code\n      })\n    });\n\n    if (!response.ok) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Instagram API request failed.');\n    }\n\n    const data = await response.json();\n    if (data.error) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, data.error_description || data.error);\n    }\n\n    return data.access_token;\n  }\n\n  async getUserFromAccessToken(accessToken, authData) {\n    const apiURL = 'https://graph.instagram.com/';\n    const path = `${apiURL}me?fields=id&access_token=${accessToken}`;\n\n    const response = await fetch(path);\n\n    if (!response.ok) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Instagram API request failed.');\n    }\n\n    const user = await response.json();\n    if (user?.id !== authData.id) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Instagram auth is invalid for this user.');\n    }\n\n    return {\n      id: user.id,\n    }\n\n  }\n}\n\nexport default new InstagramAdapter();\n"],"mappings":";;;;;;AAkEA,IAAAA,oBAAA,GAAAC,sBAAA,CAAAC,OAAA;AAAwD,SAAAD,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAlExD;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA,MAAMG,gBAAgB,SAASC,4BAAmB,CAAC;EACjDC,WAAWA,CAAA,EAAG;IACZ,KAAK,CAAC,WAAW,CAAC;EACpB;EAEA,MAAMC,sBAAsBA,CAACC,QAAQ,EAAE;IACrC,MAAMC,QAAQ,GAAG,MAAMC,KAAK,CAAC,8CAA8C,EAAE;MAC3EC,MAAM,EAAE,MAAM;MACdC,OAAO,EAAE;QAAE,cAAc,EAAE;MAAoC,CAAC;MAChEC,IAAI,EAAE,IAAIC,eAAe,CAAC;QACxBC,SAAS,EAAE,IAAI,CAACC,QAAQ;QACxBC,aAAa,EAAE,IAAI,CAACC,YAAY;QAChCC,UAAU,EAAE,oBAAoB;QAChCC,YAAY,EAAE,IAAI,CAACC,WAAW;QAC9BC,IAAI,EAAEd,QAAQ,CAACc;MACjB,CAAC;IACH,CAAC,CAAC;IAEF,IAAI,CAACb,QAAQ,CAACc,EAAE,EAAE;MAChB,MAAM,IAAIC,KAAK,CAACC,KAAK,CAACD,KAAK,CAACC,KAAK,CAACC,gBAAgB,EAAE,+BAA+B,CAAC;IACtF;IAEA,MAAMC,IAAI,GAAG,MAAMlB,QAAQ,CAACmB,IAAI,CAAC,CAAC;IAClC,IAAID,IAAI,CAACE,KAAK,EAAE;MACd,MAAM,IAAIL,KAAK,CAACC,KAAK,CAACD,KAAK,CAACC,KAAK,CAACC,gBAAgB,EAAEC,IAAI,CAACG,iBAAiB,IAAIH,IAAI,CAACE,KAAK,CAAC;IAC3F;IAEA,OAAOF,IAAI,CAACI,YAAY;EAC1B;EAEA,MAAMC,sBAAsBA,CAACC,WAAW,EAAEzB,QAAQ,EAAE;IAClD,MAAM0B,MAAM,GAAG,8BAA8B;IAC7C,MAAMC,IAAI,GAAG,GAAGD,MAAM,6BAA6BD,WAAW,EAAE;IAEhE,MAAMxB,QAAQ,GAAG,MAAMC,KAAK,CAACyB,IAAI,CAAC;IAElC,IAAI,CAAC1B,QAAQ,CAACc,EAAE,EAAE;MAChB,MAAM,IAAIC,KAAK,CAACC,KAAK,CAACD,KAAK,CAACC,KAAK,CAACC,gBAAgB,EAAE,+BAA+B,CAAC;IACtF;IAEA,MAAMU,IAAI,GAAG,MAAM3B,QAAQ,CAACmB,IAAI,CAAC,CAAC;IAClC,IAAIQ,IAAI,EAAEC,EAAE,KAAK7B,QAAQ,CAAC6B,EAAE,EAAE;MAC5B,MAAM,IAAIb,KAAK,CAACC,KAAK,CAACD,KAAK,CAACC,KAAK,CAACC,gBAAgB,EAAE,0CAA0C,CAAC;IACjG;IAEA,OAAO;MACLW,EAAE,EAAED,IAAI,CAACC;IACX,CAAC;EAEH;AACF;AAAC,IAAAC,QAAA,GAAAC,OAAA,CAAApC,OAAA,GAEc,IAAIC,gBAAgB,CAAC,CAAC","ignoreList":[]}