parse-server 2.8.4 → 8.6.2

package/lib/Adapters/Auth/github.js

@@ -1,55 +1,125 @@
-'use strict';
+"use strict";
 
-// Helper functions for accessing the github API.
-var https = require('https');
-var Parse = require('parse/node').Parse;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _BaseCodeAuthAdapter = _interopRequireDefault(require("./BaseCodeAuthAdapter"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Parse Server authentication adapter for GitHub.
+ * @class GitHubAdapter
+ * @param {Object} options - The adapter configuration options.
+ * @param {string} options.clientId - The GitHub App Client ID. Required for secure authentication.
+ * @param {string} options.clientSecret - The GitHub App Client Secret. Required for secure authentication.
+ * @param {boolean} [options.enableInsecureAuth=false] - **[DEPRECATED]** Enable insecure authentication (not recommended).
+ *
+ * @param {Object} authData - The authentication data provided by the client.
+ * @param {string} authData.code - The authorization code from GitHub. Required for secure authentication.
+ * @param {string} [authData.id] - **[DEPRECATED]** The GitHub user ID (required for insecure authentication).
+ * @param {string} [authData.access_token] - **[DEPRECATED]** The GitHub access token (required for insecure authentication).
+ *
+ * @description
+ * ## Parse Server Configuration
+ * * To configure Parse Server for GitHub authentication, use the following structure:
+ * ```json
+ * {
+ *  "auth": {
+ *   "github": {
+ *     "clientId": "12345",
+ *     "clientSecret": "abcde"
+ *   }
+ * }
+ * ```
+ *
+ * The GitHub adapter exchanges the `authData.code` provided by the client for an access token using GitHub's OAuth API. The following `authData` field is required:
+ * - `code`
+ *
+ * ## Insecure Authentication (Not Recommended)
+ * Insecure authentication uses the `authData.id` and `authData.access_token` provided by the client. This flow is insecure, deprecated, and poses potential security risks. The following `authData` fields are required:
+ * - `id` (**[DEPRECATED]**): The GitHub user ID.
+ * - `access_token` (**[DEPRECATED]**): The GitHub access token.
+ * To configure Parse Server for insecure authentication, use the following structure:
+ * ```json
+ * {
+ *  "auth": {
+ *    "github": {
+ *    "enableInsecureAuth": true
+ *  }
+ * }
+ * ```
+ *
+ * ### Deprecation Notice
+ * The `enableInsecureAuth` option and insecure `authData` fields (`id`, `access_token`) are deprecated and will be removed in future versions. Use secure authentication with `clientId` and `clientSecret`.
+ *
+ * @example <caption>Secure Authentication Example</caption>
+ * // Example authData for secure authentication:
+ * const authData = {
+ *   github: {
+ *     code: "abc123def456ghi789"
+ *   }
+ * };
+ *
+ * @example <caption>Insecure Authentication Example (Not Recommended)</caption>
+ * // Example authData for insecure authentication:
+ * const authData = {
+ *   github: {
+ *     id: "1234567",
+ *     access_token: "abc123def456ghi789" // Deprecated.
+ *   }
+ * };
+ *
+ * @note `enableInsecureAuth` will be removed in future versions. Use secure authentication with `clientId` and `clientSecret`.
+ * @note Secure authentication exchanges the `code` provided by the client for an access token using GitHub's OAuth API.
+ *
+ * @see {@link https://docs.github.com/en/developers/apps/authorizing-oauth-apps GitHub OAuth Documentation}
+ */
 
-// Returns a promise that fulfills iff this user id is valid.
-function validateAuthData(authData) {
-  return request('user', authData.access_token).then(data => {
-    if (data && data.id == authData.id) {
-      return;
+class GitHubAdapter extends _BaseCodeAuthAdapter.default {
+  constructor() {
+    super('GitHub');
+  }
+  async getAccessTokenFromCode(authData) {
+    const tokenUrl = 'https://github.com/login/oauth/access_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
+      })
+    });
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.VALIDATION_ERROR, `Failed to exchange code for token: ${response.statusText}`);
     }
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Github auth is invalid for this user.');
-  });
-}
-
-// Returns a promise that fulfills iff this app id is valid.
-function validateAppId() {
-  return Promise.resolve();
-}
-
-// A promisey wrapper for api requests
-function request(path, access_token) {
-  return new Promise(function (resolve, reject) {
-    https.get({
-      host: 'api.github.com',
-      path: '/' + path,
+    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) {
+    const userApiUrl = 'https://api.github.com/user';
+    const response = await fetch(userApiUrl, {
+      method: 'GET',
       headers: {
-        'Authorization': 'bearer ' + access_token,
-        'User-Agent': 'parse-server'
+        Authorization: `Bearer ${accessToken}`,
+        Accept: 'application/json'
       }
-    }, function (res) {
-      var data = '';
-      res.on('data', function (chunk) {
-        data += chunk;
-      });
-      res.on('end', function () {
-        try {
-          data = JSON.parse(data);
-        } catch (e) {
-          return reject(e);
-        }
-        resolve(data);
-      });
-    }).on('error', function () {
-      reject('Failed to validate this access token with Github.');
     });
-  });
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.VALIDATION_ERROR, `Failed to fetch GitHub user: ${response.statusText}`);
+    }
+    const userData = await response.json();
+    if (!userData.id || !userData.login) {
+      throw new Parse.Error(Parse.Error.VALIDATION_ERROR, 'Invalid GitHub user data received.');
+    }
+    return userData;
+  }
 }
-
-module.exports = {
-  validateAppId: validateAppId,
-  validateAuthData: validateAuthData
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9BdXRoL2dpdGh1Yi5qcyJdLCJuYW1lcyI6WyJodHRwcyIsInJlcXVpcmUiLCJQYXJzZSIsInZhbGlkYXRlQXV0aERhdGEiLCJhdXRoRGF0YSIsInJlcXVlc3QiLCJhY2Nlc3NfdG9rZW4iLCJ0aGVuIiwiZGF0YSIsImlkIiwiRXJyb3IiLCJPQkpFQ1RfTk9UX0ZPVU5EIiwidmFsaWRhdGVBcHBJZCIsIlByb21pc2UiLCJyZXNvbHZlIiwicGF0aCIsInJlamVjdCIsImdldCIsImhvc3QiLCJoZWFkZXJzIiwicmVzIiwib24iLCJjaHVuayIsIkpTT04iLCJwYXJzZSIsImUiLCJtb2R1bGUiLCJleHBvcnRzIl0sIm1hcHBpbmdzIjoiOztBQUFBO0FBQ0EsSUFBSUEsUUFBUUMsUUFBUSxPQUFSLENBQVo7QUFDQSxJQUFJQyxRQUFRRCxRQUFRLFlBQVIsRUFBc0JDLEtBQWxDOztBQUVBO0FBQ0EsU0FBU0MsZ0JBQVQsQ0FBMEJDLFFBQTFCLEVBQW9DO0FBQ2xDLFNBQU9DLFFBQVEsTUFBUixFQUFnQkQsU0FBU0UsWUFBekIsRUFDSkMsSUFESSxDQUNFQyxJQUFELElBQVU7QUFDZCxRQUFJQSxRQUFRQSxLQUFLQyxFQUFMLElBQVdMLFNBQVNLLEVBQWhDLEVBQW9DO0FBQ2xDO0FBQ0Q7QUFDRCxVQUFNLElBQUlQLE1BQU1RLEtBQVYsQ0FDSlIsTUFBTVEsS0FBTixDQUFZQyxnQkFEUixFQUVKLHVDQUZJLENBQU47QUFHRCxHQVJJLENBQVA7QUFTRDs7QUFFRDtBQUNBLFNBQVNDLGFBQVQsR0FBeUI7QUFDdkIsU0FBT0MsUUFBUUMsT0FBUixFQUFQO0FBQ0Q7O0FBRUQ7QUFDQSxTQUFTVCxPQUFULENBQWlCVSxJQUFqQixFQUF1QlQsWUFBdkIsRUFBcUM7QUFDbkMsU0FBTyxJQUFJTyxPQUFKLENBQVksVUFBU0MsT0FBVCxFQUFrQkUsTUFBbEIsRUFBMEI7QUFDM0NoQixVQUFNaUIsR0FBTixDQUFVO0FBQ1JDLFlBQU0sZ0JBREU7QUFFUkgsWUFBTSxNQUFNQSxJQUZKO0FBR1JJLGVBQVM7QUFDUCx5QkFBaUIsWUFBWWIsWUFEdEI7QUFFUCxzQkFBYztBQUZQO0FBSEQsS0FBVixFQU9HLFVBQVNjLEdBQVQsRUFBYztBQUNmLFVBQUlaLE9BQU8sRUFBWDtBQUNBWSxVQUFJQyxFQUFKLENBQU8sTUFBUCxFQUFlLFVBQVNDLEtBQVQsRUFBZ0I7QUFDN0JkLGdCQUFRYyxLQUFSO0FBQ0QsT0FGRDtBQUdBRixVQUFJQyxFQUFKLENBQU8sS0FBUCxFQUFjLFlBQVc7QUFDdkIsWUFBSTtBQUNGYixpQkFBT2UsS0FBS0MsS0FBTCxDQUFXaEIsSUFBWCxDQUFQO0FBQ0QsU0FGRCxDQUVFLE9BQU1pQixDQUFOLEVBQVM7QUFDVCxpQkFBT1QsT0FBT1MsQ0FBUCxDQUFQO0FBQ0Q7QUFDRFgsZ0JBQVFOLElBQVI7QUFDRCxPQVBEO0FBUUQsS0FwQkQsRUFvQkdhLEVBcEJILENBb0JNLE9BcEJOLEVBb0JlLFlBQVc7QUFDeEJMLGFBQU8sbURBQVA7QUFDRCxLQXRCRDtBQXVCRCxHQXhCTSxDQUFQO0FBeUJEOztBQUVEVSxPQUFPQyxPQUFQLEdBQWlCO0FBQ2ZmLGlCQUFlQSxhQURBO0FBRWZULG9CQUFrQkE7QUFGSCxDQUFqQiIsImZpbGUiOiJnaXRodWIuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBIZWxwZXIgZnVuY3Rpb25zIGZvciBhY2Nlc3NpbmcgdGhlIGdpdGh1YiBBUEkuXG52YXIgaHR0cHMgPSByZXF1aXJlKCdodHRwcycpO1xudmFyIFBhcnNlID0gcmVxdWlyZSgncGFyc2Uvbm9kZScpLlBhcnNlO1xuXG4vLyBSZXR1cm5zIGEgcHJvbWlzZSB0aGF0IGZ1bGZpbGxzIGlmZiB0aGlzIHVzZXIgaWQgaXMgdmFsaWQuXG5mdW5jdGlvbiB2YWxpZGF0ZUF1dGhEYXRhKGF1dGhEYXRhKSB7XG4gIHJldHVybiByZXF1ZXN0KCd1c2VyJywgYXV0aERhdGEuYWNjZXNzX3Rva2VuKVxuICAgIC50aGVuKChkYXRhKSA9PiB7XG4gICAgICBpZiAoZGF0YSAmJiBkYXRhLmlkID09IGF1dGhEYXRhLmlkKSB7XG4gICAgICAgIHJldHVybjtcbiAgICAgIH1cbiAgICAgIHRocm93IG5ldyBQYXJzZS5FcnJvcihcbiAgICAgICAgUGFyc2UuRXJyb3IuT0JKRUNUX05PVF9GT1VORCxcbiAgICAgICAgJ0dpdGh1YiBhdXRoIGlzIGludmFsaWQgZm9yIHRoaXMgdXNlci4nKTtcbiAgICB9KTtcbn1cblxuLy8gUmV0dXJucyBhIHByb21pc2UgdGhhdCBmdWxmaWxscyBpZmYgdGhpcyBhcHAgaWQgaXMgdmFsaWQuXG5mdW5jdGlvbiB2YWxpZGF0ZUFwcElkKCkge1xuICByZXR1cm4gUHJvbWlzZS5yZXNvbHZlKCk7XG59XG5cbi8vIEEgcHJvbWlzZXkgd3JhcHBlciBmb3IgYXBpIHJlcXVlc3RzXG5mdW5jdGlvbiByZXF1ZXN0KHBhdGgsIGFjY2Vzc190b2tlbikge1xuICByZXR1cm4gbmV3IFByb21pc2UoZnVuY3Rpb24ocmVzb2x2ZSwgcmVqZWN0KSB7XG4gICAgaHR0cHMuZ2V0KHtcbiAgICAgIGhvc3Q6ICdhcGkuZ2l0aHViLmNvbScsXG4gICAgICBwYXRoOiAnLycgKyBwYXRoLFxuICAgICAgaGVhZGVyczoge1xuICAgICAgICAnQXV0aG9yaXphdGlvbic6ICdiZWFyZXIgJyArIGFjY2Vzc190b2tlbixcbiAgICAgICAgJ1VzZXItQWdlbnQnOiAncGFyc2Utc2VydmVyJ1xuICAgICAgfVxuICAgIH0sIGZ1bmN0aW9uKHJlcykge1xuICAgICAgdmFyIGRhdGEgPSAnJztcbiAgICAgIHJlcy5vbignZGF0YScsIGZ1bmN0aW9uKGNodW5rKSB7XG4gICAgICAgIGRhdGEgKz0gY2h1bms7XG4gICAgICB9KTtcbiAgICAgIHJlcy5vbignZW5kJywgZnVuY3Rpb24oKSB7XG4gICAgICAgIHRyeSB7XG4gICAgICAgICAgZGF0YSA9IEpTT04ucGFyc2UoZGF0YSk7XG4gICAgICAgIH0gY2F0Y2goZSkge1xuICAgICAgICAgIHJldHVybiByZWplY3QoZSk7XG4gICAgICAgIH1cbiAgICAgICAgcmVzb2x2ZShkYXRhKTtcbiAgICAgIH0pO1xuICAgIH0pLm9uKCdlcnJvcicsIGZ1bmN0aW9uKCkge1xuICAgICAgcmVqZWN0KCdGYWlsZWQgdG8gdmFsaWRhdGUgdGhpcyBhY2Nlc3MgdG9rZW4gd2l0aCBHaXRodWIuJyk7XG4gICAgfSk7XG4gIH0pO1xufVxuXG5tb2R1bGUuZXhwb3J0cyA9IHtcbiAgdmFsaWRhdGVBcHBJZDogdmFsaWRhdGVBcHBJZCxcbiAgdmFsaWRhdGVBdXRoRGF0YTogdmFsaWRhdGVBdXRoRGF0YVxufTtcbiJdfQ==
+var _default = exports.default = new GitHubAdapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_BaseCodeAuthAdapter","_interopRequireDefault","require","e","__esModule","default","GitHubAdapter","BaseCodeAuthAdapter","constructor","getAccessTokenFromCode","authData","tokenUrl","response","fetch","method","headers","Accept","body","JSON","stringify","client_id","clientId","client_secret","clientSecret","code","ok","Parse","Error","VALIDATION_ERROR","statusText","data","json","error","OBJECT_NOT_FOUND","error_description","access_token","getUserFromAccessToken","accessToken","userApiUrl","Authorization","userData","id","login","_default","exports"],"sources":["../../../src/Adapters/Auth/github.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for GitHub.\n * @class GitHubAdapter\n * @param {Object} options - The adapter configuration options.\n * @param {string} options.clientId - The GitHub App Client ID. Required for secure authentication.\n * @param {string} options.clientSecret - The GitHub App Client Secret. Required for secure authentication.\n * @param {boolean} [options.enableInsecureAuth=false] - **[DEPRECATED]** Enable insecure authentication (not recommended).\n *\n * @param {Object} authData - The authentication data provided by the client.\n * @param {string} authData.code - The authorization code from GitHub. Required for secure authentication.\n * @param {string} [authData.id] - **[DEPRECATED]** The GitHub user ID (required for insecure authentication).\n * @param {string} [authData.access_token] - **[DEPRECATED]** The GitHub access token (required for insecure authentication).\n *\n * @description\n * ## Parse Server Configuration\n * * To configure Parse Server for GitHub authentication, use the following structure:\n * ```json\n * {\n *  \"auth\": {\n *   \"github\": {\n *     \"clientId\": \"12345\",\n *     \"clientSecret\": \"abcde\"\n *   }\n * }\n * ```\n *\n * The GitHub adapter exchanges the `authData.code` provided by the client for an access token using GitHub's OAuth API. The following `authData` field is required:\n * - `code`\n *\n * ## Insecure Authentication (Not Recommended)\n * Insecure authentication uses the `authData.id` and `authData.access_token` provided by the client. This flow is insecure, deprecated, and poses potential security risks. The following `authData` fields are required:\n * - `id` (**[DEPRECATED]**): The GitHub user ID.\n * - `access_token` (**[DEPRECATED]**): The GitHub access token.\n * To configure Parse Server for insecure authentication, use the following structure:\n * ```json\n * {\n *  \"auth\": {\n *    \"github\": {\n *    \"enableInsecureAuth\": true\n *  }\n * }\n * ```\n *\n * ### Deprecation Notice\n * The `enableInsecureAuth` option and insecure `authData` fields (`id`, `access_token`) are deprecated and will be removed in future versions. Use secure authentication with `clientId` and `clientSecret`.\n *\n * @example <caption>Secure Authentication Example</caption>\n * // Example authData for secure authentication:\n * const authData = {\n *   github: {\n *     code: \"abc123def456ghi789\"\n *   }\n * };\n *\n * @example <caption>Insecure Authentication Example (Not Recommended)</caption>\n * // Example authData for insecure authentication:\n * const authData = {\n *   github: {\n *     id: \"1234567\",\n *     access_token: \"abc123def456ghi789\" // Deprecated.\n *   }\n * };\n *\n * @note `enableInsecureAuth` will be removed in future versions. Use secure authentication with `clientId` and `clientSecret`.\n * @note Secure authentication exchanges the `code` provided by the client for an access token using GitHub's OAuth API.\n *\n * @see {@link https://docs.github.com/en/developers/apps/authorizing-oauth-apps GitHub OAuth Documentation}\n */\n\nimport BaseCodeAuthAdapter from './BaseCodeAuthAdapter';\nclass GitHubAdapter extends BaseCodeAuthAdapter {\n  constructor() {\n    super('GitHub');\n  }\n  async getAccessTokenFromCode(authData) {\n    const tokenUrl = 'https://github.com/login/oauth/access_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      }),\n    });\n\n    if (!response.ok) {\n      throw new Parse.Error(Parse.Error.VALIDATION_ERROR, `Failed to exchange code for token: ${response.statusText}`);\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) {\n    const userApiUrl = 'https://api.github.com/user';\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(Parse.Error.VALIDATION_ERROR, `Failed to fetch GitHub user: ${response.statusText}`);\n    }\n\n    const userData = await response.json();\n    if (!userData.id || !userData.login) {\n      throw new Parse.Error(Parse.Error.VALIDATION_ERROR, 'Invalid GitHub user data received.');\n    }\n\n    return userData;\n  }\n\n}\n\nexport default new GitHubAdapter();\n\n"],"mappings":"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","ignoreList":[]}

package/lib/Adapters/Auth/google.js

@@ -1,71 +1,180 @@
+/**
+ * Parse Server authentication adapter for Google.
+ *
+ * @class GoogleAdapter
+ * @param {Object} options - The adapter configuration options.
+ * @param {string} options.clientId - Your Google application Client ID. Required for authentication.
+ *
+ * @description
+ * ## Parse Server Configuration
+ * To configure Parse Server for Google authentication, use the following structure:
+ * ```json
+ * {
+ *   "auth": {
+ *     "google": {
+ *       "clientId": "your-client-id"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The adapter requires the following `authData` fields:
+ * - **id**: The Google user ID.
+ * - **id_token**: The Google ID token.
+ * - **access_token**: The Google access token.
+ *
+ * ## Auth Payload
+ * ### Example Auth Data Payload
+ * ```json
+ * {
+ *   "google": {
+ *     "id": "1234567",
+ *     "id_token": "xxxxx.yyyyy.zzzzz",
+ *     "access_token": "abc123def456ghi789"
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * - Ensure your Google Client ID is configured properly in the Parse Server configuration.
+ * - The `id_token` and `access_token` are validated against Google's authentication services.
+ *
+ * @see {@link https://developers.google.com/identity/sign-in/web/backend-auth Google Authentication Documentation}
+ */
+
 'use strict';
 
 // Helper functions for accessing the google API.
-var https = require('https');
 var Parse = require('parse/node').Parse;
+const https = require('https');
+const jwt = require('jsonwebtoken');
+const authUtils = require('./utils');
+const TOKEN_ISSUER = 'accounts.google.com';
+const HTTPS_TOKEN_ISSUER = 'https://accounts.google.com';
+let cache = {};
 
-function validateIdToken(id, token) {
-  return request("tokeninfo?id_token=" + token).then(response => {
-    if (response && (response.sub == id || response.user_id == id)) {
-      return;
-    }
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Google auth is invalid for this user.');
+// Retrieve Google Signin Keys (with cache control)
+function getGoogleKeyByKeyId(keyId) {
+  if (cache[keyId] && cache.expiresAt > new Date()) {
+    return cache[keyId];
+  }
+  return new Promise((resolve, reject) => {
+    https.get(`https://www.googleapis.com/oauth2/v3/certs`, res => {
+      let data = '';
+      res.on('data', chunk => {
+        data += chunk.toString('utf8');
+      });
+      res.on('end', () => {
+        const {
+          keys
+        } = JSON.parse(data);
+        const pems = keys.reduce((pems, {
+          n: modulus,
+          e: exposant,
+          kid
+        }) => Object.assign(pems, {
+          [kid]: rsaPublicKeyToPEM(modulus, exposant)
+        }), {});
+        if (res.headers['cache-control']) {
+          var expire = res.headers['cache-control'].match(/max-age=([0-9]+)/);
+          if (expire) {
+            cache = Object.assign({}, pems, {
+              expiresAt: new Date(new Date().getTime() + Number(expire[1]) * 1000)
+            });
+          }
+        }
+        resolve(pems[keyId]);
+      });
+    }).on('error', reject);
   });
 }
-
-function validateAuthToken(id, token) {
-  return request("tokeninfo?access_token=" + token).then(response => {
-    if (response && (response.sub == id || response.user_id == id)) {
-      return;
-    }
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Google auth is invalid for this user.');
-  });
+async function verifyIdToken({
+  id_token: token,
+  id
+}, {
+  clientId
+}) {
+  if (!token) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `id token is invalid for this user.`);
+  }
+  const {
+    kid: keyId,
+    alg: algorithm
+  } = authUtils.getHeaderFromToken(token);
+  let jwtClaims;
+  const googleKey = await getGoogleKeyByKeyId(keyId);
+  try {
+    jwtClaims = jwt.verify(token, googleKey, {
+      algorithms: algorithm,
+      audience: clientId
+    });
+  } catch (exception) {
+    const message = exception.message;
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `${message}`);
+  }
+  if (jwtClaims.iss !== TOKEN_ISSUER && jwtClaims.iss !== HTTPS_TOKEN_ISSUER) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `id token not issued by correct provider - expected: ${TOKEN_ISSUER} or ${HTTPS_TOKEN_ISSUER} | from: ${jwtClaims.iss}`);
+  }
+  if (jwtClaims.sub !== id) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `auth data is invalid for this user.`);
+  }
+  if (clientId && jwtClaims.aud !== clientId) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `id token not authorized for this clientId.`);
+  }
+  return jwtClaims;
 }
 
 // Returns a promise that fulfills if this user id is valid.
-function validateAuthData(authData) {
-  if (authData.id_token) {
-    return validateIdToken(authData.id, authData.id_token);
-  } else {
-    return validateAuthToken(authData.id, authData.access_token).then(() => {
-      // Validation with auth token worked
-      return;
-    }, () => {
-      // Try with the id_token param
-      return validateIdToken(authData.id, authData.access_token);
-    });
-  }
+function validateAuthData(authData, options = {}) {
+  return verifyIdToken(authData, options);
 }
 
 // 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) {
-  return new Promise(function (resolve, reject) {
-    https.get("https://www.googleapis.com/oauth2/v3/" + path, function (res) {
-      var data = '';
-      res.on('data', function (chunk) {
-        data += chunk;
-      });
-      res.on('end', function () {
-        try {
-          data = JSON.parse(data);
-        } catch (e) {
-          return reject(e);
-        }
-        resolve(data);
-      });
-    }).on('error', function () {
-      reject('Failed to validate this access token with Google.');
-    });
-  });
-}
-
 module.exports = {
   validateAppId: validateAppId,
   validateAuthData: validateAuthData
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+
+// Helpers functions to convert the RSA certs to PEM (from jwks-rsa)
+function rsaPublicKeyToPEM(modulusB64, exponentB64) {
+  const modulus = new Buffer(modulusB64, 'base64');
+  const exponent = new Buffer(exponentB64, 'base64');
+  const modulusHex = prepadSigned(modulus.toString('hex'));
+  const exponentHex = prepadSigned(exponent.toString('hex'));
+  const modlen = modulusHex.length / 2;
+  const explen = exponentHex.length / 2;
+  const encodedModlen = encodeLengthHex(modlen);
+  const encodedExplen = encodeLengthHex(explen);
+  const encodedPubkey = '30' + encodeLengthHex(modlen + explen + encodedModlen.length / 2 + encodedExplen.length / 2 + 2) + '02' + encodedModlen + modulusHex + '02' + encodedExplen + exponentHex;
+  const der = new Buffer(encodedPubkey, 'hex').toString('base64');
+  let pem = '-----BEGIN RSA PUBLIC KEY-----\n';
+  pem += `${der.match(/.{1,64}/g).join('\n')}`;
+  pem += '\n-----END RSA PUBLIC KEY-----\n';
+  return pem;
+}
+function prepadSigned(hexStr) {
+  const msb = hexStr[0];
+  if (msb < '0' || msb > '7') {
+    return `00${hexStr}`;
+  }
+  return hexStr;
+}
+function toHex(number) {
+  const nstr = number.toString(16);
+  if (nstr.length % 2) {
+    return `0${nstr}`;
+  }
+  return nstr;
+}
+function encodeLengthHex(n) {
+  if (n <= 127) {
+    return toHex(n);
+  }
+  const nHex = toHex(n);
+  const lengthOfLengthByte = 128 + nHex.length / 2;
+  return toHex(lengthOfLengthByte) + nHex;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Parse","require","https","jwt","authUtils","TOKEN_ISSUER","HTTPS_TOKEN_ISSUER","cache","getGoogleKeyByKeyId","keyId","expiresAt","Date","Promise","resolve","reject","get","res","data","on","chunk","toString","keys","JSON","parse","pems","reduce","n","modulus","e","exposant","kid","Object","assign","rsaPublicKeyToPEM","headers","expire","match","getTime","Number","verifyIdToken","id_token","token","id","clientId","Error","OBJECT_NOT_FOUND","alg","algorithm","getHeaderFromToken","jwtClaims","googleKey","verify","algorithms","audience","exception","message","iss","sub","aud","validateAuthData","authData","options","validateAppId","module","exports","modulusB64","exponentB64","Buffer","exponent","modulusHex","prepadSigned","exponentHex","modlen","length","explen","encodedModlen","encodeLengthHex","encodedExplen","encodedPubkey","der","pem","join","hexStr","msb","toHex","number","nstr","nHex","lengthOfLengthByte"],"sources":["../../../src/Adapters/Auth/google.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for Google.\n *\n * @class GoogleAdapter\n * @param {Object} options - The adapter configuration options.\n * @param {string} options.clientId - Your Google application Client ID. Required for authentication.\n *\n * @description\n * ## Parse Server Configuration\n * To configure Parse Server for Google authentication, use the following structure:\n * ```json\n * {\n *   \"auth\": {\n *     \"google\": {\n *       \"clientId\": \"your-client-id\"\n *     }\n *   }\n * }\n * ```\n *\n * The adapter requires the following `authData` fields:\n * - **id**: The Google user ID.\n * - **id_token**: The Google ID token.\n * - **access_token**: The Google access token.\n *\n * ## Auth Payload\n * ### Example Auth Data Payload\n * ```json\n * {\n *   \"google\": {\n *     \"id\": \"1234567\",\n *     \"id_token\": \"xxxxx.yyyyy.zzzzz\",\n *     \"access_token\": \"abc123def456ghi789\"\n *   }\n * }\n * ```\n *\n * ## Notes\n * - Ensure your Google Client ID is configured properly in the Parse Server configuration.\n * - The `id_token` and `access_token` are validated against Google's authentication services.\n *\n * @see {@link https://developers.google.com/identity/sign-in/web/backend-auth Google Authentication Documentation}\n */\n\n'use strict';\n\n// Helper functions for accessing the google API.\nvar Parse = require('parse/node').Parse;\n\nconst https = require('https');\nconst jwt = require('jsonwebtoken');\nconst authUtils = require('./utils');\n\nconst TOKEN_ISSUER = 'accounts.google.com';\nconst HTTPS_TOKEN_ISSUER = 'https://accounts.google.com';\n\nlet cache = {};\n\n// Retrieve Google Signin Keys (with cache control)\nfunction getGoogleKeyByKeyId(keyId) {\n  if (cache[keyId] && cache.expiresAt > new Date()) {\n    return cache[keyId];\n  }\n\n  return new Promise((resolve, reject) => {\n    https\n      .get(`https://www.googleapis.com/oauth2/v3/certs`, res => {\n        let data = '';\n        res.on('data', chunk => {\n          data += chunk.toString('utf8');\n        });\n        res.on('end', () => {\n          const { keys } = JSON.parse(data);\n          const pems = keys.reduce(\n            (pems, { n: modulus, e: exposant, kid }) =>\n              Object.assign(pems, {\n                [kid]: rsaPublicKeyToPEM(modulus, exposant),\n              }),\n            {}\n          );\n\n          if (res.headers['cache-control']) {\n            var expire = res.headers['cache-control'].match(/max-age=([0-9]+)/);\n\n            if (expire) {\n              cache = Object.assign({}, pems, {\n                expiresAt: new Date(new Date().getTime() + Number(expire[1]) * 1000),\n              });\n            }\n          }\n\n          resolve(pems[keyId]);\n        });\n      })\n      .on('error', reject);\n  });\n}\n\nasync function verifyIdToken({ id_token: token, id }, { clientId }) {\n  if (!token) {\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `id token is invalid for this user.`);\n  }\n\n  const { kid: keyId, alg: algorithm } = authUtils.getHeaderFromToken(token);\n  let jwtClaims;\n  const googleKey = await getGoogleKeyByKeyId(keyId);\n\n  try {\n    jwtClaims = jwt.verify(token, googleKey, {\n      algorithms: algorithm,\n      audience: clientId,\n    });\n  } catch (exception) {\n    const message = exception.message;\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `${message}`);\n  }\n\n  if (jwtClaims.iss !== TOKEN_ISSUER && jwtClaims.iss !== HTTPS_TOKEN_ISSUER) {\n    throw new Parse.Error(\n      Parse.Error.OBJECT_NOT_FOUND,\n      `id token not issued by correct provider - expected: ${TOKEN_ISSUER} or ${HTTPS_TOKEN_ISSUER} | from: ${jwtClaims.iss}`\n    );\n  }\n\n  if (jwtClaims.sub !== id) {\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `auth data is invalid for this user.`);\n  }\n\n  if (clientId && jwtClaims.aud !== clientId) {\n    throw new Parse.Error(\n      Parse.Error.OBJECT_NOT_FOUND,\n      `id token not authorized for this clientId.`\n    );\n  }\n\n  return jwtClaims;\n}\n\n// Returns a promise that fulfills if this user id is valid.\nfunction validateAuthData(authData, options = {}) {\n  return verifyIdToken(authData, options);\n}\n\n// Returns a promise that fulfills if this app id is valid.\nfunction validateAppId() {\n  return Promise.resolve();\n}\n\nmodule.exports = {\n  validateAppId: validateAppId,\n  validateAuthData: validateAuthData,\n};\n\n// Helpers functions to convert the RSA certs to PEM (from jwks-rsa)\nfunction rsaPublicKeyToPEM(modulusB64, exponentB64) {\n  const modulus = new Buffer(modulusB64, 'base64');\n  const exponent = new Buffer(exponentB64, 'base64');\n  const modulusHex = prepadSigned(modulus.toString('hex'));\n  const exponentHex = prepadSigned(exponent.toString('hex'));\n  const modlen = modulusHex.length / 2;\n  const explen = exponentHex.length / 2;\n\n  const encodedModlen = encodeLengthHex(modlen);\n  const encodedExplen = encodeLengthHex(explen);\n  const encodedPubkey =\n    '30' +\n    encodeLengthHex(modlen + explen + encodedModlen.length / 2 + encodedExplen.length / 2 + 2) +\n    '02' +\n    encodedModlen +\n    modulusHex +\n    '02' +\n    encodedExplen +\n    exponentHex;\n\n  const der = new Buffer(encodedPubkey, 'hex').toString('base64');\n\n  let pem = '-----BEGIN RSA PUBLIC KEY-----\\n';\n  pem += `${der.match(/.{1,64}/g).join('\\n')}`;\n  pem += '\\n-----END RSA PUBLIC KEY-----\\n';\n  return pem;\n}\n\nfunction prepadSigned(hexStr) {\n  const msb = hexStr[0];\n  if (msb < '0' || msb > '7') {\n    return `00${hexStr}`;\n  }\n  return hexStr;\n}\n\nfunction toHex(number) {\n  const nstr = number.toString(16);\n  if (nstr.length % 2) {\n    return `0${nstr}`;\n  }\n  return nstr;\n}\n\nfunction encodeLengthHex(n) {\n  if (n <= 127) {\n    return toHex(n);\n  }\n  const nHex = toHex(n);\n  const lengthOfLengthByte = 128 + nHex.length / 2;\n  return toHex(lengthOfLengthByte) + nHex;\n}\n"],"mappings":"AAAA;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;;AAEA,YAAY;;AAEZ;AACA,IAAIA,KAAK,GAAGC,OAAO,CAAC,YAAY,CAAC,CAACD,KAAK;AAEvC,MAAME,KAAK,GAAGD,OAAO,CAAC,OAAO,CAAC;AAC9B,MAAME,GAAG,GAAGF,OAAO,CAAC,cAAc,CAAC;AACnC,MAAMG,SAAS,GAAGH,OAAO,CAAC,SAAS,CAAC;AAEpC,MAAMI,YAAY,GAAG,qBAAqB;AAC1C,MAAMC,kBAAkB,GAAG,6BAA6B;AAExD,IAAIC,KAAK,GAAG,CAAC,CAAC;;AAEd;AACA,SAASC,mBAAmBA,CAACC,KAAK,EAAE;EAClC,IAAIF,KAAK,CAACE,KAAK,CAAC,IAAIF,KAAK,CAACG,SAAS,GAAG,IAAIC,IAAI,CAAC,CAAC,EAAE;IAChD,OAAOJ,KAAK,CAACE,KAAK,CAAC;EACrB;EAEA,OAAO,IAAIG,OAAO,CAAC,CAACC,OAAO,EAAEC,MAAM,KAAK;IACtCZ,KAAK,CACFa,GAAG,CAAC,4CAA4C,EAAEC,GAAG,IAAI;MACxD,IAAIC,IAAI,GAAG,EAAE;MACbD,GAAG,CAACE,EAAE,CAAC,MAAM,EAAEC,KAAK,IAAI;QACtBF,IAAI,IAAIE,KAAK,CAACC,QAAQ,CAAC,MAAM,CAAC;MAChC,CAAC,CAAC;MACFJ,GAAG,CAACE,EAAE,CAAC,KAAK,EAAE,MAAM;QAClB,MAAM;UAAEG;QAAK,CAAC,GAAGC,IAAI,CAACC,KAAK,CAACN,IAAI,CAAC;QACjC,MAAMO,IAAI,GAAGH,IAAI,CAACI,MAAM,CACtB,CAACD,IAAI,EAAE;UAAEE,CAAC,EAAEC,OAAO;UAAEC,CAAC,EAAEC,QAAQ;UAAEC;QAAI,CAAC,KACrCC,MAAM,CAACC,MAAM,CAACR,IAAI,EAAE;UAClB,CAACM,GAAG,GAAGG,iBAAiB,CAACN,OAAO,EAAEE,QAAQ;QAC5C,CAAC,CAAC,EACJ,CAAC,CACH,CAAC;QAED,IAAIb,GAAG,CAACkB,OAAO,CAAC,eAAe,CAAC,EAAE;UAChC,IAAIC,MAAM,GAAGnB,GAAG,CAACkB,OAAO,CAAC,eAAe,CAAC,CAACE,KAAK,CAAC,kBAAkB,CAAC;UAEnE,IAAID,MAAM,EAAE;YACV5B,KAAK,GAAGwB,MAAM,CAACC,MAAM,CAAC,CAAC,CAAC,EAAER,IAAI,EAAE;cAC9Bd,SAAS,EAAE,IAAIC,IAAI,CAAC,IAAIA,IAAI,CAAC,CAAC,CAAC0B,OAAO,CAAC,CAAC,GAAGC,MAAM,CAACH,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;YACrE,CAAC,CAAC;UACJ;QACF;QAEAtB,OAAO,CAACW,IAAI,CAACf,KAAK,CAAC,CAAC;MACtB,CAAC,CAAC;IACJ,CAAC,CAAC,CACDS,EAAE,CAAC,OAAO,EAAEJ,MAAM,CAAC;EACxB,CAAC,CAAC;AACJ;AAEA,eAAeyB,aAAaA,CAAC;EAAEC,QAAQ,EAAEC,KAAK;EAAEC;AAAG,CAAC,EAAE;EAAEC;AAAS,CAAC,EAAE;EAClE,IAAI,CAACF,KAAK,EAAE;IACV,MAAM,IAAIzC,KAAK,CAAC4C,KAAK,CAAC5C,KAAK,CAAC4C,KAAK,CAACC,gBAAgB,EAAE,oCAAoC,CAAC;EAC3F;EAEA,MAAM;IAAEf,GAAG,EAAErB,KAAK;IAAEqC,GAAG,EAAEC;EAAU,CAAC,GAAG3C,SAAS,CAAC4C,kBAAkB,CAACP,KAAK,CAAC;EAC1E,IAAIQ,SAAS;EACb,MAAMC,SAAS,GAAG,MAAM1C,mBAAmB,CAACC,KAAK,CAAC;EAElD,IAAI;IACFwC,SAAS,GAAG9C,GAAG,CAACgD,MAAM,CAACV,KAAK,EAAES,SAAS,EAAE;MACvCE,UAAU,EAAEL,SAAS;MACrBM,QAAQ,EAAEV;IACZ,CAAC,CAAC;EACJ,CAAC,CAAC,OAAOW,SAAS,EAAE;IAClB,MAAMC,OAAO,GAAGD,SAAS,CAACC,OAAO;IACjC,MAAM,IAAIvD,KAAK,CAAC4C,KAAK,CAAC5C,KAAK,CAAC4C,KAAK,CAACC,gBAAgB,EAAE,GAAGU,OAAO,EAAE,CAAC;EACnE;EAEA,IAAIN,SAAS,CAACO,GAAG,KAAKnD,YAAY,IAAI4C,SAAS,CAACO,GAAG,KAAKlD,kBAAkB,EAAE;IAC1E,MAAM,IAAIN,KAAK,CAAC4C,KAAK,CACnB5C,KAAK,CAAC4C,KAAK,CAACC,gBAAgB,EAC5B,uDAAuDxC,YAAY,OAAOC,kBAAkB,YAAY2C,SAAS,CAACO,GAAG,EACvH,CAAC;EACH;EAEA,IAAIP,SAAS,CAACQ,GAAG,KAAKf,EAAE,EAAE;IACxB,MAAM,IAAI1C,KAAK,CAAC4C,KAAK,CAAC5C,KAAK,CAAC4C,KAAK,CAACC,gBAAgB,EAAE,qCAAqC,CAAC;EAC5F;EAEA,IAAIF,QAAQ,IAAIM,SAAS,CAACS,GAAG,KAAKf,QAAQ,EAAE;IAC1C,MAAM,IAAI3C,KAAK,CAAC4C,KAAK,CACnB5C,KAAK,CAAC4C,KAAK,CAACC,gBAAgB,EAC5B,4CACF,CAAC;EACH;EAEA,OAAOI,SAAS;AAClB;;AAEA;AACA,SAASU,gBAAgBA,CAACC,QAAQ,EAAEC,OAAO,GAAG,CAAC,CAAC,EAAE;EAChD,OAAOtB,aAAa,CAACqB,QAAQ,EAAEC,OAAO,CAAC;AACzC;;AAEA;AACA,SAASC,aAAaA,CAAA,EAAG;EACvB,OAAOlD,OAAO,CAACC,OAAO,CAAC,CAAC;AAC1B;AAEAkD,MAAM,CAACC,OAAO,GAAG;EACfF,aAAa,EAAEA,aAAa;EAC5BH,gBAAgB,EAAEA;AACpB,CAAC;;AAED;AACA,SAAS1B,iBAAiBA,CAACgC,UAAU,EAAEC,WAAW,EAAE;EAClD,MAAMvC,OAAO,GAAG,IAAIwC,MAAM,CAACF,UAAU,EAAE,QAAQ,CAAC;EAChD,MAAMG,QAAQ,GAAG,IAAID,MAAM,CAACD,WAAW,EAAE,QAAQ,CAAC;EAClD,MAAMG,UAAU,GAAGC,YAAY,CAAC3C,OAAO,CAACP,QAAQ,CAAC,KAAK,CAAC,CAAC;EACxD,MAAMmD,WAAW,GAAGD,YAAY,CAACF,QAAQ,CAAChD,QAAQ,CAAC,KAAK,CAAC,CAAC;EAC1D,MAAMoD,MAAM,GAAGH,UAAU,CAACI,MAAM,GAAG,CAAC;EACpC,MAAMC,MAAM,GAAGH,WAAW,CAACE,MAAM,GAAG,CAAC;EAErC,MAAME,aAAa,GAAGC,eAAe,CAACJ,MAAM,CAAC;EAC7C,MAAMK,aAAa,GAAGD,eAAe,CAACF,MAAM,CAAC;EAC7C,MAAMI,aAAa,GACjB,IAAI,GACJF,eAAe,CAACJ,MAAM,GAAGE,MAAM,GAAGC,aAAa,CAACF,MAAM,GAAG,CAAC,GAAGI,aAAa,CAACJ,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC,GAC1F,IAAI,GACJE,aAAa,GACbN,UAAU,GACV,IAAI,GACJQ,aAAa,GACbN,WAAW;EAEb,MAAMQ,GAAG,GAAG,IAAIZ,MAAM,CAACW,aAAa,EAAE,KAAK,CAAC,CAAC1D,QAAQ,CAAC,QAAQ,CAAC;EAE/D,IAAI4D,GAAG,GAAG,kCAAkC;EAC5CA,GAAG,IAAI,GAAGD,GAAG,CAAC3C,KAAK,CAAC,UAAU,CAAC,CAAC6C,IAAI,CAAC,IAAI,CAAC,EAAE;EAC5CD,GAAG,IAAI,kCAAkC;EACzC,OAAOA,GAAG;AACZ;AAEA,SAASV,YAAYA,CAACY,MAAM,EAAE;EAC5B,MAAMC,GAAG,GAAGD,MAAM,CAAC,CAAC,CAAC;EACrB,IAAIC,GAAG,GAAG,GAAG,IAAIA,GAAG,GAAG,GAAG,EAAE;IAC1B,OAAO,KAAKD,MAAM,EAAE;EACtB;EACA,OAAOA,MAAM;AACf;AAEA,SAASE,KAAKA,CAACC,MAAM,EAAE;EACrB,MAAMC,IAAI,GAAGD,MAAM,CAACjE,QAAQ,CAAC,EAAE,CAAC;EAChC,IAAIkE,IAAI,CAACb,MAAM,GAAG,CAAC,EAAE;IACnB,OAAO,IAAIa,IAAI,EAAE;EACnB;EACA,OAAOA,IAAI;AACb;AAEA,SAASV,eAAeA,CAAClD,CAAC,EAAE;EAC1B,IAAIA,CAAC,IAAI,GAAG,EAAE;IACZ,OAAO0D,KAAK,CAAC1D,CAAC,CAAC;EACjB;EACA,MAAM6D,IAAI,GAAGH,KAAK,CAAC1D,CAAC,CAAC;EACrB,MAAM8D,kBAAkB,GAAG,GAAG,GAAGD,IAAI,CAACd,MAAM,GAAG,CAAC;EAChD,OAAOW,KAAK,CAACI,kBAAkB,CAAC,GAAGD,IAAI;AACzC","ignoreList":[]}

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":[]}