parse-server 2.8.4 → 8.6.2

package/lib/Adapters/Auth/janraincapture.js

@@ -1,9 +1,53 @@
-'use strict';
+"use strict";
+
+/**
+ * Parse Server authentication adapter for Janrain Capture API.
+ *
+ * @class JanrainCapture
+ * @param {Object} options - The adapter configuration options.
+ * @param {String} options.janrain_capture_host - The Janrain Capture API host.
+ *
+ * @param {Object} authData - The authentication data provided by the client.
+ * @param {String} authData.id - The Janrain Capture user ID.
+ * @param {String} authData.access_token - The Janrain Capture access token.
+ *
+ * @description
+ * ## Parse Server Configuration
+ * To configure Parse Server for Janrain Capture authentication, use the following structure:
+ * ```json
+ * {
+ *   "auth": {
+ *     "janrain": {
+ *       "janrain_capture_host": "your-janrain-capture-host"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The adapter requires the following `authData` fields:
+ * - `id`: The Janrain Capture user ID.
+ * - `access_token`: An authorized Janrain Capture access token for the user.
+ *
+ * ## Auth Payload Example
+ * ```json
+ * {
+ *   "janrain": {
+ *     "id": "user's Janrain Capture ID as a string",
+ *     "access_token": "an authorized Janrain Capture access token for the user"
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * Parse Server validates the provided `authData` using the Janrain Capture API.
+ *
+ * @see {@link https://docs.janrain.com/api/registration/entity/#entity Janrain Capture API Documentation}
+ */
 
 // Helper functions for accessing the Janrain Capture API.
-var https = require('https');
 var Parse = require('parse/node').Parse;
 var querystring = require('querystring');
+const httpsRequest = require('./httpsRequest');
 
 // Returns a promise that fulfills iff this user id is valid.
 function validateAuthData(authData, options) {
@@ -25,32 +69,17 @@ function validateAppId() {
 
 // A promisey wrapper for api requests
 function request(host, access_token) {
-
   var query_string_data = querystring.stringify({
-    'access_token': access_token,
-    'attribute_name': 'uuid' // we only need to pull the uuid for this access token to make sure it matches
+    access_token: access_token,
+    attribute_name: 'uuid' // we only need to pull the uuid for this access token to make sure it matches
   });
-
-  return new Promise(function (resolve, reject) {
-    https.get({
-      host: host,
-      path: '/entity?' + query_string_data
-    }, function (res) {
-      var data = '';
-      res.on('data', function (chunk) {
-        data += chunk;
-      });
-      res.on('end', function () {
-        resolve(JSON.parse(data));
-      });
-    }).on('error', function () {
-      reject('Failed to validate this access token with Janrain capture.');
-    });
+  return httpsRequest.get({
+    host: host,
+    path: '/entity?' + query_string_data
   });
 }
-
 module.exports = {
   validateAppId: validateAppId,
   validateAuthData: validateAuthData
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Auth/janrainengage.js

@@ -1,13 +1,22 @@
-'use strict';
+"use strict";
 
+var _Config = _interopRequireDefault(require("../../Config"));
+var _Deprecator = _interopRequireDefault(require("../../Deprecator/Deprecator"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // Helper functions for accessing the Janrain Engage API.
-var https = require('https');
+var httpsRequest = require('./httpsRequest');
 var Parse = require('parse/node').Parse;
 var querystring = require('querystring');
-
 // Returns a promise that fulfills iff this user id is valid.
 function validateAuthData(authData, options) {
-  return request(options.api_key, authData.auth_token).then(data => {
+  const config = _Config.default.get(Parse.applicationId);
+  _Deprecator.default.logRuntimeDeprecation({
+    usage: 'janrainengage adapter'
+  });
+  if (!config?.auth?.janrainengage?.enableInsecureAuth || !config.enableInsecureAuthAdapters) {
+    throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'janrainengage adapter only works with enableInsecureAuth: true');
+  }
+  return apiRequest(options.api_key, authData.auth_token).then(data => {
     //successful response will have a "stat" (status) of 'ok' and a profile node with an identifier
     //see: http://developers.janrain.com/overview/social-login/identity-providers/user-profile-data/#normalized-user-profile-data
     if (data && data.stat == 'ok' && data.profile.identifier == authData.id) {
@@ -24,14 +33,12 @@ function validateAppId() {
 }
 
 // A promisey wrapper for api requests
-function request(api_key, auth_token) {
-
+function apiRequest(api_key, auth_token) {
   var post_data = querystring.stringify({
-    'token': auth_token,
-    'apiKey': api_key,
-    'format': 'json'
+    token: auth_token,
+    apiKey: api_key,
+    format: 'json'
   });
-
   var post_options = {
     host: 'rpxnow.com',
     path: '/api/v2/auth_info',
@@ -41,34 +48,10 @@ function request(api_key, auth_token) {
       'Content-Length': post_data.length
     }
   };
-
-  return new Promise(function (resolve, reject) {
-    // Create the post request.
-    var post_req = https.request(post_options, function (res) {
-      var data = '';
-      res.setEncoding('utf8');
-      // Append data as we receive it from the Janrain engage server.
-      res.on('data', function (d) {
-        data += d;
-      });
-      // Once we have all the data, we can parse it and return the data we want.
-      res.on('end', function () {
-        try {
-          data = JSON.parse(data);
-        } catch (e) {
-          return reject(e);
-        }
-        resolve(data);
-      });
-    });
-
-    post_req.write(post_data);
-    post_req.end();
-  });
+  return httpsRequest.request(post_options, post_data);
 }
-
 module.exports = {
   validateAppId: validateAppId,
   validateAuthData: validateAuthData
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9BdXRoL2phbnJhaW5lbmdhZ2UuanMiXSwibmFtZXMiOlsiaHR0cHMiLCJyZXF1aXJlIiwiUGFyc2UiLCJxdWVyeXN0cmluZyIsInZhbGlkYXRlQXV0aERhdGEiLCJhdXRoRGF0YSIsIm9wdGlvbnMiLCJyZXF1ZXN0IiwiYXBpX2tleSIsImF1dGhfdG9rZW4iLCJ0aGVuIiwiZGF0YSIsInN0YXQiLCJwcm9maWxlIiwiaWRlbnRpZmllciIsImlkIiwiRXJyb3IiLCJPQkpFQ1RfTk9UX0ZPVU5EIiwidmFsaWRhdGVBcHBJZCIsIlByb21pc2UiLCJyZXNvbHZlIiwicG9zdF9kYXRhIiwic3RyaW5naWZ5IiwicG9zdF9vcHRpb25zIiwiaG9zdCIsInBhdGgiLCJtZXRob2QiLCJoZWFkZXJzIiwibGVuZ3RoIiwicmVqZWN0IiwicG9zdF9yZXEiLCJyZXMiLCJzZXRFbmNvZGluZyIsIm9uIiwiZCIsIkpTT04iLCJwYXJzZSIsImUiLCJ3cml0ZSIsImVuZCIsIm1vZHVsZSIsImV4cG9ydHMiXSwibWFwcGluZ3MiOiI7O0FBQUE7QUFDQSxJQUFJQSxRQUFRQyxRQUFRLE9BQVIsQ0FBWjtBQUNBLElBQUlDLFFBQVFELFFBQVEsWUFBUixFQUFzQkMsS0FBbEM7QUFDQSxJQUFJQyxjQUFjRixRQUFRLGFBQVIsQ0FBbEI7O0FBRUE7QUFDQSxTQUFTRyxnQkFBVCxDQUEwQkMsUUFBMUIsRUFBb0NDLE9BQXBDLEVBQTZDO0FBQzNDLFNBQU9DLFFBQVFELFFBQVFFLE9BQWhCLEVBQXlCSCxTQUFTSSxVQUFsQyxFQUNKQyxJQURJLENBQ0VDLElBQUQsSUFBVTtBQUNkO0FBQ0E7QUFDQSxRQUFJQSxRQUFRQSxLQUFLQyxJQUFMLElBQWEsSUFBckIsSUFBNkJELEtBQUtFLE9BQUwsQ0FBYUMsVUFBYixJQUEyQlQsU0FBU1UsRUFBckUsRUFBeUU7QUFDdkU7QUFDRDtBQUNELFVBQU0sSUFBSWIsTUFBTWMsS0FBVixDQUFnQmQsTUFBTWMsS0FBTixDQUFZQyxnQkFBNUIsRUFBOEMsK0NBQTlDLENBQU47QUFDRCxHQVJJLENBQVA7QUFTRDs7QUFFRDtBQUNBLFNBQVNDLGFBQVQsR0FBeUI7QUFDdkI7QUFDQSxTQUFPQyxRQUFRQyxPQUFSLEVBQVA7QUFDRDs7QUFFRDtBQUNBLFNBQVNiLE9BQVQsQ0FBaUJDLE9BQWpCLEVBQTBCQyxVQUExQixFQUFzQzs7QUFFcEMsTUFBSVksWUFBWWxCLFlBQVltQixTQUFaLENBQXNCO0FBQ3BDLGFBQVNiLFVBRDJCO0FBRXBDLGNBQVVELE9BRjBCO0FBR3BDLGNBQVU7QUFIMEIsR0FBdEIsQ0FBaEI7O0FBTUEsTUFBSWUsZUFBZTtBQUNqQkMsVUFBTSxZQURXO0FBRWpCQyxVQUFNLG1CQUZXO0FBR2pCQyxZQUFRLE1BSFM7QUFJakJDLGFBQVM7QUFDUCxzQkFBZ0IsbUNBRFQ7QUFFUCx3QkFBa0JOLFVBQVVPO0FBRnJCO0FBSlEsR0FBbkI7O0FBVUEsU0FBTyxJQUFJVCxPQUFKLENBQVksVUFBVUMsT0FBVixFQUFtQlMsTUFBbkIsRUFBMkI7QUFDNUM7QUFDQSxRQUFJQyxXQUFXOUIsTUFBTU8sT0FBTixDQUFjZ0IsWUFBZCxFQUE0QixVQUFVUSxHQUFWLEVBQWU7QUFDeEQsVUFBSXBCLE9BQU8sRUFBWDtBQUNBb0IsVUFBSUMsV0FBSixDQUFnQixNQUFoQjtBQUNBO0FBQ0FELFVBQUlFLEVBQUosQ0FBTyxNQUFQLEVBQWUsVUFBVUMsQ0FBVixFQUFhO0FBQzFCdkIsZ0JBQVF1QixDQUFSO0FBQ0QsT0FGRDtBQUdBO0FBQ0FILFVBQUlFLEVBQUosQ0FBTyxLQUFQLEVBQWMsWUFBWTtBQUN4QixZQUFJO0FBQ0Z0QixpQkFBT3dCLEtBQUtDLEtBQUwsQ0FBV3pCLElBQVgsQ0FBUDtBQUNELFNBRkQsQ0FFRSxPQUFNMEIsQ0FBTixFQUFTO0FBQ1QsaUJBQU9SLE9BQU9RLENBQVAsQ0FBUDtBQUNEO0FBQ0RqQixnQkFBUVQsSUFBUjtBQUNELE9BUEQ7QUFRRCxLQWhCYyxDQUFmOztBQWtCQW1CLGFBQVNRLEtBQVQsQ0FBZWpCLFNBQWY7QUFDQVMsYUFBU1MsR0FBVDtBQUNELEdBdEJNLENBQVA7QUF1QkQ7O0FBRURDLE9BQU9DLE9BQVAsR0FBaUI7QUFDZnZCLGlCQUFlQSxhQURBO0FBRWZkLG9CQUFrQkE7QUFGSCxDQUFqQiIsImZpbGUiOiJqYW5yYWluZW5nYWdlLmpzIiwic291cmNlc0NvbnRlbnQiOlsiLy8gSGVscGVyIGZ1bmN0aW9ucyBmb3IgYWNjZXNzaW5nIHRoZSBKYW5yYWluIEVuZ2FnZSBBUEkuXG52YXIgaHR0cHMgPSByZXF1aXJlKCdodHRwcycpO1xudmFyIFBhcnNlID0gcmVxdWlyZSgncGFyc2Uvbm9kZScpLlBhcnNlO1xudmFyIHF1ZXJ5c3RyaW5nID0gcmVxdWlyZSgncXVlcnlzdHJpbmcnKTtcblxuLy8gUmV0dXJucyBhIHByb21pc2UgdGhhdCBmdWxmaWxscyBpZmYgdGhpcyB1c2VyIGlkIGlzIHZhbGlkLlxuZnVuY3Rpb24gdmFsaWRhdGVBdXRoRGF0YShhdXRoRGF0YSwgb3B0aW9ucykge1xuICByZXR1cm4gcmVxdWVzdChvcHRpb25zLmFwaV9rZXksIGF1dGhEYXRhLmF1dGhfdG9rZW4pXG4gICAgLnRoZW4oKGRhdGEpID0+IHtcbiAgICAgIC8vc3VjY2Vzc2Z1bCByZXNwb25zZSB3aWxsIGhhdmUgYSBcInN0YXRcIiAoc3RhdHVzKSBvZiAnb2snIGFuZCBhIHByb2ZpbGUgbm9kZSB3aXRoIGFuIGlkZW50aWZpZXJcbiAgICAgIC8vc2VlOiBodHRwOi8vZGV2ZWxvcGVycy5qYW5yYWluLmNvbS9vdmVydmlldy9zb2NpYWwtbG9naW4vaWRlbnRpdHktcHJvdmlkZXJzL3VzZXItcHJvZmlsZS1kYXRhLyNub3JtYWxpemVkLXVzZXItcHJvZmlsZS1kYXRhXG4gICAgICBpZiAoZGF0YSAmJiBkYXRhLnN0YXQgPT0gJ29rJyAmJiBkYXRhLnByb2ZpbGUuaWRlbnRpZmllciA9PSBhdXRoRGF0YS5pZCkge1xuICAgICAgICByZXR1cm47XG4gICAgICB9XG4gICAgICB0aHJvdyBuZXcgUGFyc2UuRXJyb3IoUGFyc2UuRXJyb3IuT0JKRUNUX05PVF9GT1VORCwgJ0phbnJhaW4gZW5nYWdlIGF1dGggaXMgaW52YWxpZCBmb3IgdGhpcyB1c2VyLicpO1xuICAgIH0pO1xufVxuXG4vLyBSZXR1cm5zIGEgcHJvbWlzZSB0aGF0IGZ1bGZpbGxzIGlmZiB0aGlzIGFwcCBpZCBpcyB2YWxpZC5cbmZ1bmN0aW9uIHZhbGlkYXRlQXBwSWQoKSB7XG4gIC8vbm8tb3BcbiAgcmV0dXJuIFByb21pc2UucmVzb2x2ZSgpO1xufVxuXG4vLyBBIHByb21pc2V5IHdyYXBwZXIgZm9yIGFwaSByZXF1ZXN0c1xuZnVuY3Rpb24gcmVxdWVzdChhcGlfa2V5LCBhdXRoX3Rva2VuKSB7XG5cbiAgdmFyIHBvc3RfZGF0YSA9IHF1ZXJ5c3RyaW5nLnN0cmluZ2lmeSh7XG4gICAgJ3Rva2VuJzogYXV0aF90b2tlbixcbiAgICAnYXBpS2V5JzogYXBpX2tleSxcbiAgICAnZm9ybWF0JzogJ2pzb24nXG4gIH0pO1xuXG4gIHZhciBwb3N0X29wdGlvbnMgPSB7XG4gICAgaG9zdDogJ3JweG5vdy5jb20nLFxuICAgIHBhdGg6ICcvYXBpL3YyL2F1dGhfaW5mbycsXG4gICAgbWV0aG9kOiAnUE9TVCcsXG4gICAgaGVhZGVyczoge1xuICAgICAgJ0NvbnRlbnQtVHlwZSc6ICdhcHBsaWNhdGlvbi94LXd3dy1mb3JtLXVybGVuY29kZWQnLFxuICAgICAgJ0NvbnRlbnQtTGVuZ3RoJzogcG9zdF9kYXRhLmxlbmd0aFxuICAgIH1cbiAgfTtcblxuICByZXR1cm4gbmV3IFByb21pc2UoZnVuY3Rpb24gKHJlc29sdmUsIHJlamVjdCkge1xuICAgIC8vIENyZWF0ZSB0aGUgcG9zdCByZXF1ZXN0LlxuICAgIHZhciBwb3N0X3JlcSA9IGh0dHBzLnJlcXVlc3QocG9zdF9vcHRpb25zLCBmdW5jdGlvbiAocmVzKSB7XG4gICAgICB2YXIgZGF0YSA9ICcnO1xuICAgICAgcmVzLnNldEVuY29kaW5nKCd1dGY4Jyk7XG4gICAgICAvLyBBcHBlbmQgZGF0YSBhcyB3ZSByZWNlaXZlIGl0IGZyb20gdGhlIEphbnJhaW4gZW5nYWdlIHNlcnZlci5cbiAgICAgIHJlcy5vbignZGF0YScsIGZ1bmN0aW9uIChkKSB7XG4gICAgICAgIGRhdGEgKz0gZDtcbiAgICAgIH0pO1xuICAgICAgLy8gT25jZSB3ZSBoYXZlIGFsbCB0aGUgZGF0YSwgd2UgY2FuIHBhcnNlIGl0IGFuZCByZXR1cm4gdGhlIGRhdGEgd2Ugd2FudC5cbiAgICAgIHJlcy5vbignZW5kJywgZnVuY3Rpb24gKCkge1xuICAgICAgICB0cnkge1xuICAgICAgICAgIGRhdGEgPSBKU09OLnBhcnNlKGRhdGEpO1xuICAgICAgICB9IGNhdGNoKGUpIHtcbiAgICAgICAgICByZXR1cm4gcmVqZWN0KGUpO1xuICAgICAgICB9XG4gICAgICAgIHJlc29sdmUoZGF0YSk7XG4gICAgICB9KTtcbiAgICB9KTtcblxuICAgIHBvc3RfcmVxLndyaXRlKHBvc3RfZGF0YSk7XG4gICAgcG9zdF9yZXEuZW5kKCk7XG4gIH0pO1xufVxuXG5tb2R1bGUuZXhwb3J0cyA9IHtcbiAgdmFsaWRhdGVBcHBJZDogdmFsaWRhdGVBcHBJZCxcbiAgdmFsaWRhdGVBdXRoRGF0YTogdmFsaWRhdGVBdXRoRGF0YVxufTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Auth/keycloak.js

@@ -0,0 +1,148 @@
+"use strict";
+
+/**
+ * Parse Server authentication adapter for Keycloak.
+ *
+ * @class KeycloakAdapter
+ * @param {Object} options - The adapter configuration options.
+ * @param {Object} options.config - The Keycloak configuration object, typically loaded from a JSON file.
+ * @param {String} options.config.auth-server-url - The Keycloak authentication server URL.
+ * @param {String} options.config.realm - The Keycloak realm name.
+ * @param {String} options.config.client-id - The Keycloak client ID.
+ *
+ * @param {Object} authData - The authentication data provided by the client.
+ * @param {String} authData.access_token - The Keycloak access token retrieved during client authentication.
+ * @param {String} authData.id - The user ID retrieved from Keycloak during client authentication.
+ * @param {Array} [authData.roles] - The roles assigned to the user in Keycloak (optional).
+ * @param {Array} [authData.groups] - The groups assigned to the user in Keycloak (optional).
+ *
+ * @description
+ * ## Parse Server Configuration
+ * To configure Parse Server for Keycloak authentication, use the following structure:
+ * ```javascript
+ * {
+ *   "auth": {
+ *     "keycloak": {
+ *       "config": require('./auth/keycloak.json')
+ *     }
+ *   }
+ * }
+ * ```
+ * Ensure the `keycloak.json` configuration file is generated from Keycloak's setup guide and includes:
+ * - `auth-server-url`: The Keycloak authentication server URL.
+ * - `realm`: The Keycloak realm name.
+ * - `client-id`: The Keycloak client ID.
+ *
+ * ## Auth Data
+ * The adapter requires the following `authData` fields:
+ * - `access_token`: The Keycloak access token retrieved during client authentication.
+ * - `id`: The user ID retrieved from Keycloak during client authentication.
+ * - `roles` (optional): The roles assigned to the user in Keycloak.
+ * - `groups` (optional): The groups assigned to the user in Keycloak.
+ *
+ * ## Auth Payload Example
+ * ### Example Auth Data
+ * ```json
+ * {
+ *   "keycloak": {
+ *     "access_token": "an authorized Keycloak access token for the user",
+ *     "id": "user's Keycloak ID as a string",
+ *     "roles": ["admin", "user"],
+ *     "groups": ["group1", "group2"]
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * - Parse Server validates the provided `authData` by making a `userinfo` call to Keycloak and ensures the attributes match those returned by Keycloak.
+ *
+ * ## Keycloak Configuration
+ * To configure Keycloak, copy the JSON configuration file generated from Keycloak's setup guide:
+ * - [Keycloak Securing Apps Documentation](https://www.keycloak.org/docs/latest/securing_apps/index.html#_javascript_adapter)
+ *
+ * Place the configuration file on your server, for example:
+ * - `auth/keycloak.json`
+ *
+ * For more information on Keycloak authentication, see:
+ * - [Securing Apps Documentation](https://www.keycloak.org/docs/latest/securing_apps/)
+ * - [Server Administration Documentation](https://www.keycloak.org/docs/latest/server_admin/)
+ */
+
+const {
+  Parse
+} = require('parse/node');
+const httpsRequest = require('./httpsRequest');
+const arraysEqual = (_arr1, _arr2) => {
+  if (!Array.isArray(_arr1) || !Array.isArray(_arr2) || _arr1.length !== _arr2.length) {
+    return false;
+  }
+  var arr1 = _arr1.concat().sort();
+  var arr2 = _arr2.concat().sort();
+  for (var i = 0; i < arr1.length; i++) {
+    if (arr1[i] !== arr2[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+const handleAuth = async ({
+  access_token,
+  id,
+  roles,
+  groups
+} = {}, {
+  config
+} = {}) => {
+  if (!(access_token && id)) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Missing access token and/or User id');
+  }
+  if (!config || !(config['auth-server-url'] && config['realm'])) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Missing keycloak configuration');
+  }
+  try {
+    const response = await httpsRequest.get({
+      host: config['auth-server-url'],
+      path: `/realms/${config['realm']}/protocol/openid-connect/userinfo`,
+      headers: {
+        Authorization: 'Bearer ' + access_token
+      }
+    });
+    if (response && response.data && response.data.sub == id && arraysEqual(response.data.roles, roles) && arraysEqual(response.data.groups, groups)) {
+      return;
+    }
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid authentication');
+  } catch (e) {
+    if (e instanceof Parse.Error) {
+      throw e;
+    }
+    const error = JSON.parse(e.text);
+    if (error.error_description) {
+      throw new Parse.Error(Parse.Error.HOSTING_ERROR, error.error_description);
+    } else {
+      throw new Parse.Error(Parse.Error.HOSTING_ERROR, 'Could not connect to the authentication server');
+    }
+  }
+};
+
+/*
+  @param {Object} authData: the client provided authData
+  @param {string} authData.access_token: the access_token retrieved from client authentication in Keycloak
+  @param {string} authData.id: the id retrieved from client authentication in Keycloak
+  @param {Array}  authData.roles: the roles retrieved from client authentication in Keycloak
+  @param {Array}  authData.groups: the groups retrieved from client authentication in Keycloak
+  @param {Object} options: additional options
+  @param {Object} options.config: the config object passed during Parse Server instantiation
+*/
+function validateAuthData(authData, options = {}) {
+  return handleAuth(authData, options);
+}
+
+// Returns a promise that fulfills if this app id is valid.
+function validateAppId() {
+  return Promise.resolve();
+}
+module.exports = {
+  validateAppId,
+  validateAuthData
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Parse","require","httpsRequest","arraysEqual","_arr1","_arr2","Array","isArray","length","arr1","concat","sort","arr2","i","handleAuth","access_token","id","roles","groups","config","Error","OBJECT_NOT_FOUND","response","get","host","path","headers","Authorization","data","sub","e","error","JSON","parse","text","error_description","HOSTING_ERROR","validateAuthData","authData","options","validateAppId","Promise","resolve","module","exports"],"sources":["../../../src/Adapters/Auth/keycloak.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for Keycloak.\n *\n * @class KeycloakAdapter\n * @param {Object} options - The adapter configuration options.\n * @param {Object} options.config - The Keycloak configuration object, typically loaded from a JSON file.\n * @param {String} options.config.auth-server-url - The Keycloak authentication server URL.\n * @param {String} options.config.realm - The Keycloak realm name.\n * @param {String} options.config.client-id - The Keycloak client ID.\n *\n * @param {Object} authData - The authentication data provided by the client.\n * @param {String} authData.access_token - The Keycloak access token retrieved during client authentication.\n * @param {String} authData.id - The user ID retrieved from Keycloak during client authentication.\n * @param {Array} [authData.roles] - The roles assigned to the user in Keycloak (optional).\n * @param {Array} [authData.groups] - The groups assigned to the user in Keycloak (optional).\n *\n * @description\n * ## Parse Server Configuration\n * To configure Parse Server for Keycloak authentication, use the following structure:\n * ```javascript\n * {\n *   \"auth\": {\n *     \"keycloak\": {\n *       \"config\": require('./auth/keycloak.json')\n *     }\n *   }\n * }\n * ```\n * Ensure the `keycloak.json` configuration file is generated from Keycloak's setup guide and includes:\n * - `auth-server-url`: The Keycloak authentication server URL.\n * - `realm`: The Keycloak realm name.\n * - `client-id`: The Keycloak client ID.\n *\n * ## Auth Data\n * The adapter requires the following `authData` fields:\n * - `access_token`: The Keycloak access token retrieved during client authentication.\n * - `id`: The user ID retrieved from Keycloak during client authentication.\n * - `roles` (optional): The roles assigned to the user in Keycloak.\n * - `groups` (optional): The groups assigned to the user in Keycloak.\n *\n * ## Auth Payload Example\n * ### Example Auth Data\n * ```json\n * {\n *   \"keycloak\": {\n *     \"access_token\": \"an authorized Keycloak access token for the user\",\n *     \"id\": \"user's Keycloak ID as a string\",\n *     \"roles\": [\"admin\", \"user\"],\n *     \"groups\": [\"group1\", \"group2\"]\n *   }\n * }\n * ```\n *\n * ## Notes\n * - Parse Server validates the provided `authData` by making a `userinfo` call to Keycloak and ensures the attributes match those returned by Keycloak.\n *\n * ## Keycloak Configuration\n * To configure Keycloak, copy the JSON configuration file generated from Keycloak's setup guide:\n * - [Keycloak Securing Apps Documentation](https://www.keycloak.org/docs/latest/securing_apps/index.html#_javascript_adapter)\n *\n * Place the configuration file on your server, for example:\n * - `auth/keycloak.json`\n *\n * For more information on Keycloak authentication, see:\n * - [Securing Apps Documentation](https://www.keycloak.org/docs/latest/securing_apps/)\n * - [Server Administration Documentation](https://www.keycloak.org/docs/latest/server_admin/)\n */\n\nconst { Parse } = require('parse/node');\nconst httpsRequest = require('./httpsRequest');\n\nconst arraysEqual = (_arr1, _arr2) => {\n  if (!Array.isArray(_arr1) || !Array.isArray(_arr2) || _arr1.length !== _arr2.length) { return false; }\n\n  var arr1 = _arr1.concat().sort();\n  var arr2 = _arr2.concat().sort();\n\n  for (var i = 0; i < arr1.length; i++) {\n    if (arr1[i] !== arr2[i]) { return false; }\n  }\n\n  return true;\n};\n\nconst handleAuth = async ({ access_token, id, roles, groups } = {}, { config } = {}) => {\n  if (!(access_token && id)) {\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Missing access token and/or User id');\n  }\n  if (!config || !(config['auth-server-url'] && config['realm'])) {\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Missing keycloak configuration');\n  }\n  try {\n    const response = await httpsRequest.get({\n      host: config['auth-server-url'],\n      path: `/realms/${config['realm']}/protocol/openid-connect/userinfo`,\n      headers: {\n        Authorization: 'Bearer ' + access_token,\n      },\n    });\n    if (\n      response &&\n      response.data &&\n      response.data.sub == id &&\n      arraysEqual(response.data.roles, roles) &&\n      arraysEqual(response.data.groups, groups)\n    ) {\n      return;\n    }\n    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Invalid authentication');\n  } catch (e) {\n    if (e instanceof Parse.Error) {\n      throw e;\n    }\n    const error = JSON.parse(e.text);\n    if (error.error_description) {\n      throw new Parse.Error(Parse.Error.HOSTING_ERROR, error.error_description);\n    } else {\n      throw new Parse.Error(\n        Parse.Error.HOSTING_ERROR,\n        'Could not connect to the authentication server'\n      );\n    }\n  }\n};\n\n/*\n  @param {Object} authData: the client provided authData\n  @param {string} authData.access_token: the access_token retrieved from client authentication in Keycloak\n  @param {string} authData.id: the id retrieved from client authentication in Keycloak\n  @param {Array}  authData.roles: the roles retrieved from client authentication in Keycloak\n  @param {Array}  authData.groups: the groups retrieved from client authentication in Keycloak\n  @param {Object} options: additional options\n  @param {Object} options.config: the config object passed during Parse Server instantiation\n*/\nfunction validateAuthData(authData, options = {}) {\n  return handleAuth(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,\n  validateAuthData,\n};\n"],"mappings":"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","ignoreList":[]}

package/lib/Adapters/Auth/ldap.js

@@ -0,0 +1,167 @@
+"use strict";
+
+/**
+ * Parse Server authentication adapter for LDAP.
+ *
+ * @class LDAP
+ * @param {Object} options - The adapter configuration options.
+ * @param {String} options.url - The LDAP server URL. Must start with `ldap://` or `ldaps://`.
+ * @param {String} options.suffix - The LDAP suffix for user distinguished names (DN).
+ * @param {String} [options.dn] - The distinguished name (DN) template for user authentication. Replace `{{id}}` with the username.
+ * @param {Object} [options.tlsOptions] - Options for LDAPS TLS connections.
+ * @param {String} [options.groupCn] - The common name (CN) of the group to verify user membership.
+ * @param {String} [options.groupFilter] - The LDAP search filter for groups, with `{{id}}` replaced by the username.
+ *
+ * @param {Object} authData - The authentication data provided by the client.
+ * @param {String} authData.id - The user's LDAP username.
+ * @param {String} authData.password - The user's LDAP password.
+ *
+ * @description
+ * ## Parse Server Configuration
+ * To configure Parse Server for LDAP authentication, use the following structure:
+ * ```javascript
+ * {
+ *   auth: {
+ *     ldap: {
+ *       url: 'ldaps://ldap.example.com',
+ *       suffix: 'ou=users,dc=example,dc=com',
+ *       groupCn: 'admins',
+ *       groupFilter: '(memberUid={{id}})',
+ *       tlsOptions: {
+ *         rejectUnauthorized: false
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ## Authentication Process
+ * 1. Validates the provided `authData` using an LDAP bind operation.
+ * 2. Optionally, verifies that the user belongs to a specific group by performing an LDAP search using the provided `groupCn` or `groupFilter`.
+ *
+ * ## Auth Payload
+ * The adapter requires the following `authData` fields:
+ * - `id`: The user's LDAP username.
+ * - `password`: The user's LDAP password.
+ *
+ * ### Example Auth Payload
+ * ```json
+ * {
+ *   "ldap": {
+ *     "id": "jdoe",
+ *     "password": "password123"
+ *   }
+ * }
+ * ```
+ *
+ * @example <caption>Configuration Example</caption>
+ * // Example Parse Server configuration:
+ * const config = {
+ *   auth: {
+ *     ldap: {
+ *       url: 'ldaps://ldap.example.com',
+ *       suffix: 'ou=users,dc=example,dc=com',
+ *       groupCn: 'admins',
+ *       groupFilter: '(memberUid={{id}})',
+ *       tlsOptions: {
+ *         rejectUnauthorized: false
+ *       }
+ *     }
+ *   }
+ * };
+ *
+ * @see {@link https://ldap.com/ LDAP Basics}
+ * @see {@link https://ldap.com/ldap-filters/ LDAP Filters}
+ */
+
+const ldapjs = require('ldapjs');
+const Parse = require('parse/node').Parse;
+function validateAuthData(authData, options) {
+  if (!optionsAreValid(options)) {
+    return new Promise((_, reject) => {
+      reject(new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'LDAP auth configuration missing'));
+    });
+  }
+  const clientOptions = options.url.startsWith('ldaps://') ? {
+    url: options.url,
+    tlsOptions: options.tlsOptions
+  } : {
+    url: options.url
+  };
+  const client = ldapjs.createClient(clientOptions);
+  const userCn = typeof options.dn === 'string' ? options.dn.replace('{{id}}', authData.id) : `uid=${authData.id},${options.suffix}`;
+  return new Promise((resolve, reject) => {
+    client.bind(userCn, authData.password, ldapError => {
+      delete authData.password;
+      if (ldapError) {
+        let error;
+        switch (ldapError.code) {
+          case 49:
+            error = new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'LDAP: Wrong username or password');
+            break;
+          case 'DEPTH_ZERO_SELF_SIGNED_CERT':
+            error = new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'LDAPS: Certificate mismatch');
+            break;
+          default:
+            error = new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'LDAP: Somthing went wrong (' + ldapError.code + ')');
+        }
+        reject(error);
+        client.destroy(ldapError);
+        return;
+      }
+      if (typeof options.groupCn === 'string' && typeof options.groupFilter === 'string') {
+        searchForGroup(client, options, authData.id, resolve, reject);
+      } else {
+        client.unbind();
+        client.destroy();
+        resolve();
+      }
+    });
+  });
+}
+function optionsAreValid(options) {
+  return typeof options === 'object' && typeof options.suffix === 'string' && typeof options.url === 'string' && (options.url.startsWith('ldap://') || options.url.startsWith('ldaps://') && typeof options.tlsOptions === 'object');
+}
+function searchForGroup(client, options, id, resolve, reject) {
+  const filter = options.groupFilter.replace(/{{id}}/gi, id);
+  const opts = {
+    scope: 'sub',
+    filter: filter
+  };
+  let found = false;
+  client.search(options.suffix, opts, (searchError, res) => {
+    if (searchError) {
+      client.unbind();
+      client.destroy();
+      return reject(new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'LDAP group search failed'));
+    }
+    res.on('searchEntry', entry => {
+      if (entry.pojo.attributes.find(obj => obj.type === 'cn').values.includes(options.groupCn)) {
+        found = true;
+        client.unbind();
+        client.destroy();
+        return resolve();
+      }
+    });
+    res.on('end', () => {
+      if (!found) {
+        client.unbind();
+        client.destroy();
+        return reject(new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'LDAP: User not in group'));
+      }
+    });
+    res.on('error', () => {
+      client.unbind();
+      client.destroy();
+      return reject(new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'LDAP group search failed'));
+    });
+  });
+}
+function validateAppId() {
+  return Promise.resolve();
+}
+module.exports = {
+  validateAppId,
+  validateAuthData
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ldapjs","require","Parse","validateAuthData","authData","options","optionsAreValid","Promise","_","reject","Error","INTERNAL_SERVER_ERROR","clientOptions","url","startsWith","tlsOptions","client","createClient","userCn","dn","replace","id","suffix","resolve","bind","password","ldapError","error","code","OBJECT_NOT_FOUND","destroy","groupCn","groupFilter","searchForGroup","unbind","filter","opts","scope","found","search","searchError","res","on","entry","pojo","attributes","find","obj","type","values","includes","validateAppId","module","exports"],"sources":["../../../src/Adapters/Auth/ldap.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for LDAP.\n *\n * @class LDAP\n * @param {Object} options - The adapter configuration options.\n * @param {String} options.url - The LDAP server URL. Must start with `ldap://` or `ldaps://`.\n * @param {String} options.suffix - The LDAP suffix for user distinguished names (DN).\n * @param {String} [options.dn] - The distinguished name (DN) template for user authentication. Replace `{{id}}` with the username.\n * @param {Object} [options.tlsOptions] - Options for LDAPS TLS connections.\n * @param {String} [options.groupCn] - The common name (CN) of the group to verify user membership.\n * @param {String} [options.groupFilter] - The LDAP search filter for groups, with `{{id}}` replaced by the username.\n *\n * @param {Object} authData - The authentication data provided by the client.\n * @param {String} authData.id - The user's LDAP username.\n * @param {String} authData.password - The user's LDAP password.\n *\n * @description\n * ## Parse Server Configuration\n * To configure Parse Server for LDAP authentication, use the following structure:\n * ```javascript\n * {\n *   auth: {\n *     ldap: {\n *       url: 'ldaps://ldap.example.com',\n *       suffix: 'ou=users,dc=example,dc=com',\n *       groupCn: 'admins',\n *       groupFilter: '(memberUid={{id}})',\n *       tlsOptions: {\n *         rejectUnauthorized: false\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * ## Authentication Process\n * 1. Validates the provided `authData` using an LDAP bind operation.\n * 2. Optionally, verifies that the user belongs to a specific group by performing an LDAP search using the provided `groupCn` or `groupFilter`.\n *\n * ## Auth Payload\n * The adapter requires the following `authData` fields:\n * - `id`: The user's LDAP username.\n * - `password`: The user's LDAP password.\n *\n * ### Example Auth Payload\n * ```json\n * {\n *   \"ldap\": {\n *     \"id\": \"jdoe\",\n *     \"password\": \"password123\"\n *   }\n * }\n * ```\n *\n * @example <caption>Configuration Example</caption>\n * // Example Parse Server configuration:\n * const config = {\n *   auth: {\n *     ldap: {\n *       url: 'ldaps://ldap.example.com',\n *       suffix: 'ou=users,dc=example,dc=com',\n *       groupCn: 'admins',\n *       groupFilter: '(memberUid={{id}})',\n *       tlsOptions: {\n *         rejectUnauthorized: false\n *       }\n *     }\n *   }\n * };\n *\n * @see {@link https://ldap.com/ LDAP Basics}\n * @see {@link https://ldap.com/ldap-filters/ LDAP Filters}\n */\n\n\nconst ldapjs = require('ldapjs');\nconst Parse = require('parse/node').Parse;\n\nfunction validateAuthData(authData, options) {\n  if (!optionsAreValid(options)) {\n    return new Promise((_, reject) => {\n      reject(new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'LDAP auth configuration missing'));\n    });\n  }\n  const clientOptions = options.url.startsWith('ldaps://')\n    ? { url: options.url, tlsOptions: options.tlsOptions }\n    : { url: options.url };\n\n  const client = ldapjs.createClient(clientOptions);\n  const userCn =\n    typeof options.dn === 'string'\n      ? options.dn.replace('{{id}}', authData.id)\n      : `uid=${authData.id},${options.suffix}`;\n\n  return new Promise((resolve, reject) => {\n    client.bind(userCn, authData.password, ldapError => {\n      delete authData.password;\n      if (ldapError) {\n        let error;\n        switch (ldapError.code) {\n          case 49:\n            error = new Parse.Error(\n              Parse.Error.OBJECT_NOT_FOUND,\n              'LDAP: Wrong username or password'\n            );\n            break;\n          case 'DEPTH_ZERO_SELF_SIGNED_CERT':\n            error = new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'LDAPS: Certificate mismatch');\n            break;\n          default:\n            error = new Parse.Error(\n              Parse.Error.OBJECT_NOT_FOUND,\n              'LDAP: Somthing went wrong (' + ldapError.code + ')'\n            );\n        }\n        reject(error);\n        client.destroy(ldapError);\n        return;\n      }\n\n      if (typeof options.groupCn === 'string' && typeof options.groupFilter === 'string') {\n        searchForGroup(client, options, authData.id, resolve, reject);\n      } else {\n        client.unbind();\n        client.destroy();\n        resolve();\n      }\n    });\n  });\n}\n\nfunction optionsAreValid(options) {\n  return (\n    typeof options === 'object' &&\n    typeof options.suffix === 'string' &&\n    typeof options.url === 'string' &&\n    (options.url.startsWith('ldap://') ||\n      (options.url.startsWith('ldaps://') && typeof options.tlsOptions === 'object'))\n  );\n}\n\nfunction searchForGroup(client, options, id, resolve, reject) {\n  const filter = options.groupFilter.replace(/{{id}}/gi, id);\n  const opts = {\n    scope: 'sub',\n    filter: filter,\n  };\n  let found = false;\n  client.search(options.suffix, opts, (searchError, res) => {\n    if (searchError) {\n      client.unbind();\n      client.destroy();\n      return reject(new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'LDAP group search failed'));\n    }\n    res.on('searchEntry', entry => {\n      if (entry.pojo.attributes.find(obj => obj.type === 'cn').values.includes(options.groupCn)) {\n        found = true;\n        client.unbind();\n        client.destroy();\n        return resolve();\n      }\n    });\n    res.on('end', () => {\n      if (!found) {\n        client.unbind();\n        client.destroy();\n        return reject(\n          new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'LDAP: User not in group')\n        );\n      }\n    });\n    res.on('error', () => {\n      client.unbind();\n      client.destroy();\n      return reject(new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'LDAP group search failed'));\n    });\n  });\n}\n\nfunction validateAppId() {\n  return Promise.resolve();\n}\n\nmodule.exports = {\n  validateAppId,\n  validateAuthData,\n};\n"],"mappings":"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","ignoreList":[]}