parse-server 2.8.4 → 8.6.2

package/lib/Adapters/Auth/line.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 Line.
+ *
+ * @class LineAdapter
+ * @param {Object} options - The adapter configuration options.
+ * @param {string} options.clientId - Your Line App Client ID. Required for secure authentication.
+ * @param {string} options.clientSecret - Your Line 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 Line authentication, use the following structure:
+ * ### Secure Configuration
+ * ```json
+ * {
+ *   "auth": {
+ *     "line": {
+ *       "clientId": "your-client-id",
+ *       "clientSecret": "your-client-secret"
+ *     }
+ *   }
+ * }
+ * ```
+ * ### Insecure Configuration (Not Recommended)
+ * ```json
+ * {
+ *   "auth": {
+ *     "line": {
+ *       "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
+ * {
+ *   "line": {
+ *     "code": "xxxxxxxxx",
+ *     "redirect_uri": "https://example.com/callback"
+ *   }
+ * }
+ * ```
+ *
+ * ### Insecure Authentication Payload (Not Recommended)
+ * ```json
+ * {
+ *   "line": {
+ *     "id": "1234567",
+ *     "access_token": "xxxxxxxxx"
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * - `enableInsecureAuth` is **not recommended** and will be removed in future versions. Use secure authentication with `clientId` and `clientSecret`.
+ * - Secure authentication exchanges the `code` and `redirect_uri` provided by the client for an access token using Line's OAuth flow.
+ *
+ * @see {@link https://developers.line.biz/en/docs/line-login/integrate-line-login/ Line Login Documentation}
+ */
+
+class LineAdapter extends _BaseCodeAuthAdapter.default {
+  constructor() {
+    super('Line');
+  }
+  async getAccessTokenFromCode(authData) {
+    if (!authData.code) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Line auth is invalid for this user.');
+    }
+    const tokenUrl = 'https://api.line.me/oauth2/v2.1/token';
+    const response = await fetch(tokenUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded'
+      },
+      body: new URLSearchParams({
+        client_id: this.clientId,
+        client_secret: this.clientSecret,
+        grant_type: 'authorization_code',
+        redirect_uri: authData.redirect_uri,
+        code: authData.code
+      })
+    });
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `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) {
+    const userApiUrl = 'https://api.line.me/v2/profile';
+    const response = await fetch(userApiUrl, {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${accessToken}`
+      }
+    });
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, `Failed to fetch Line user: ${response.statusText}`);
+    }
+    const userData = await response.json();
+    if (!userData?.userId) {
+      throw new Parse.Error(Parse.Error.VALIDATION_ERROR, 'Invalid Line user data received.');
+    }
+    return userData;
+  }
+}
+var _default = exports.default = new LineAdapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_BaseCodeAuthAdapter","_interopRequireDefault","require","e","__esModule","default","LineAdapter","BaseCodeAuthAdapter","constructor","getAccessTokenFromCode","authData","code","Parse","Error","OBJECT_NOT_FOUND","tokenUrl","response","fetch","method","headers","body","URLSearchParams","client_id","clientId","client_secret","clientSecret","grant_type","redirect_uri","ok","statusText","data","json","error","error_description","access_token","getUserFromAccessToken","accessToken","userApiUrl","Authorization","userData","userId","VALIDATION_ERROR","_default","exports"],"sources":["../../../src/Adapters/Auth/line.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for Line.\n *\n * @class LineAdapter\n * @param {Object} options - The adapter configuration options.\n * @param {string} options.clientId - Your Line App Client ID. Required for secure authentication.\n * @param {string} options.clientSecret - Your Line 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 Line authentication, use the following structure:\n * ### Secure Configuration\n * ```json\n * {\n *   \"auth\": {\n *     \"line\": {\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 *     \"line\": {\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 *   \"line\": {\n *     \"code\": \"xxxxxxxxx\",\n *     \"redirect_uri\": \"https://example.com/callback\"\n *   }\n * }\n * ```\n *\n * ### Insecure Authentication Payload (Not Recommended)\n * ```json\n * {\n *   \"line\": {\n *     \"id\": \"1234567\",\n *     \"access_token\": \"xxxxxxxxx\"\n *   }\n * }\n * ```\n *\n * ## Notes\n * - `enableInsecureAuth` is **not recommended** and will be removed in future versions. Use secure authentication with `clientId` and `clientSecret`.\n * - Secure authentication exchanges the `code` and `redirect_uri` provided by the client for an access token using Line's OAuth flow.\n *\n * @see {@link https://developers.line.biz/en/docs/line-login/integrate-line-login/ Line Login Documentation}\n */\n\nimport BaseCodeAuthAdapter from './BaseCodeAuthAdapter';\n\nclass LineAdapter extends BaseCodeAuthAdapter {\n  constructor() {\n    super('Line');\n  }\n\n  async getAccessTokenFromCode(authData) {\n    if (!authData.code) {\n      throw new Parse.Error(\n        Parse.Error.OBJECT_NOT_FOUND,\n        'Line auth is invalid for this user.'\n      );\n    }\n\n    const tokenUrl = 'https://api.line.me/oauth2/v2.1/token';\n    const response = await fetch(tokenUrl, {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/x-www-form-urlencoded',\n      },\n      body: new URLSearchParams({\n        client_id: this.clientId,\n        client_secret: this.clientSecret,\n        grant_type: 'authorization_code',\n        redirect_uri: authData.redirect_uri,\n        code: authData.code,\n      }),\n    });\n\n    if (!response.ok) {\n      throw new Parse.Error(\n        Parse.Error.OBJECT_NOT_FOUND,\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) {\n    const userApiUrl = 'https://api.line.me/v2/profile';\n    const response = await fetch(userApiUrl, {\n      method: 'GET',\n      headers: {\n        Authorization: `Bearer ${accessToken}`,\n      },\n    });\n\n    if (!response.ok) {\n      throw new Parse.Error(\n        Parse.Error.OBJECT_NOT_FOUND,\n        `Failed to fetch Line user: ${response.statusText}`\n      );\n    }\n\n    const userData = await response.json();\n    if (!userData?.userId) {\n      throw new Parse.Error(\n        Parse.Error.VALIDATION_ERROR,\n        'Invalid Line user data received.'\n      );\n    }\n\n    return userData;\n  }\n}\n\nexport default new LineAdapter();\n"],"mappings":"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","ignoreList":[]}

package/lib/Adapters/Auth/linkedin.js

@@ -1,61 +1,117 @@
-'use strict';
+"use strict";
 
-// Helper functions for accessing the linkedin 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 LinkedIn.
+ *
+ * @class LinkedInAdapter
+ * @param {Object} options - The adapter configuration options.
+ * @param {string} options.clientId - Your LinkedIn App Client ID. Required for secure authentication.
+ * @param {string} options.clientSecret - Your LinkedIn 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 LinkedIn authentication, use the following structure:
+ * ### Secure Configuration
+ * ```json
+ * {
+ *   "auth": {
+ *     "linkedin": {
+ *       "clientId": "your-client-id",
+ *       "clientSecret": "your-client-secret"
+ *     }
+ *   }
+ * }
+ * ```
+ * ### Insecure Configuration (Not Recommended)
+ * ```json
+ * {
+ *   "auth": {
+ *     "linkedin": {
+ *       "enableInsecureAuth": true
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The adapter requires the following `authData` fields:
+ * - **Secure Authentication**: `code`, `redirect_uri`, and optionally `is_mobile_sdk`.
+ * - **Insecure Authentication (Not Recommended)**: `id`, `access_token`, and optionally `is_mobile_sdk`.
+ *
+ * ## Auth Payloads
+ * ### Secure Authentication Payload
+ * ```json
+ * {
+ *   "linkedin": {
+ *     "code": "lmn789opq012rst345uvw",
+ *     "redirect_uri": "https://your-redirect-uri.com/callback",
+ *     "is_mobile_sdk": true
+ *   }
+ * }
+ * ```
+ *
+ * ### Insecure Authentication Payload (Not Recommended)
+ * ```json
+ * {
+ *   "linkedin": {
+ *     "id": "7654321",
+ *     "access_token": "AQXNnd2hIT6z9bHFzZz2Kp1ghiMz_RtyuvwXYZ123abc",
+ *     "is_mobile_sdk": true
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * - Secure authentication exchanges the `code` and `redirect_uri` provided by the client for an access token using LinkedIn's OAuth API.
+ * - Insecure authentication validates the user ID and access token directly, bypassing OAuth flows. This method is **not recommended** and may introduce security vulnerabilities.
+ * - `enableInsecureAuth` is **deprecated** and may be removed in future versions.
+ *
+ * @see {@link https://learn.microsoft.com/en-us/linkedin/shared/authentication/authentication LinkedIn Authentication Documentation}
+ */
 
-// Returns a promise that fulfills iff this user id is valid.
-function validateAuthData(authData) {
-  return request('people/~:(id)', authData.access_token, authData.is_mobile_sdk).then(data => {
-    if (data && data.id == authData.id) {
-      return;
+class LinkedInAdapter extends _BaseCodeAuthAdapter.default {
+  constructor() {
+    super('LinkedIn');
+  }
+  async getUserFromAccessToken(access_token, authData) {
+    const response = await fetch('https://api.linkedin.com/v2/me', {
+      headers: {
+        Authorization: `Bearer ${access_token}`,
+        'x-li-format': 'json',
+        'x-li-src': authData?.is_mobile_sdk ? 'msdk' : undefined
+      }
+    });
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'LinkedIn API request failed.');
     }
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Linkedin 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, is_mobile_sdk) {
-  var headers = {
-    'Authorization': 'Bearer ' + access_token,
-    'x-li-format': 'json'
-  };
-
-  if (is_mobile_sdk) {
-    headers['x-li-src'] = 'msdk';
+    return response.json();
   }
-
-  return new Promise(function (resolve, reject) {
-    https.get({
-      host: 'api.linkedin.com',
-      path: '/v1/' + path,
-      headers: headers
-    }, 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 Linkedin.');
+  async getAccessTokenFromCode(authData) {
+    const response = await fetch('https://www.linkedin.com/oauth/v2/accessToken', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded'
+      },
+      body: new URLSearchParams({
+        grant_type: 'authorization_code',
+        code: authData.code,
+        redirect_uri: authData.redirect_uri,
+        client_id: this.clientId,
+        client_secret: this.clientSecret
+      })
     });
-  });
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'LinkedIn API request failed.');
+    }
+    const json = await response.json();
+    return json.access_token;
+  }
 }
-
-module.exports = {
-  validateAppId: validateAppId,
-  validateAuthData: validateAuthData
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+var _default = exports.default = new LinkedInAdapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_BaseCodeAuthAdapter","_interopRequireDefault","require","e","__esModule","default","LinkedInAdapter","BaseAuthCodeAdapter","constructor","getUserFromAccessToken","access_token","authData","response","fetch","headers","Authorization","is_mobile_sdk","undefined","ok","Parse","Error","OBJECT_NOT_FOUND","json","getAccessTokenFromCode","method","body","URLSearchParams","grant_type","code","redirect_uri","client_id","clientId","client_secret","clientSecret","_default","exports"],"sources":["../../../src/Adapters/Auth/linkedin.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for LinkedIn.\n *\n * @class LinkedInAdapter\n * @param {Object} options - The adapter configuration options.\n * @param {string} options.clientId - Your LinkedIn App Client ID. Required for secure authentication.\n * @param {string} options.clientSecret - Your LinkedIn 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 LinkedIn authentication, use the following structure:\n * ### Secure Configuration\n * ```json\n * {\n *   \"auth\": {\n *     \"linkedin\": {\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 *     \"linkedin\": {\n *       \"enableInsecureAuth\": true\n *     }\n *   }\n * }\n * ```\n *\n * The adapter requires the following `authData` fields:\n * - **Secure Authentication**: `code`, `redirect_uri`, and optionally `is_mobile_sdk`.\n * - **Insecure Authentication (Not Recommended)**: `id`, `access_token`, and optionally `is_mobile_sdk`.\n *\n * ## Auth Payloads\n * ### Secure Authentication Payload\n * ```json\n * {\n *   \"linkedin\": {\n *     \"code\": \"lmn789opq012rst345uvw\",\n *     \"redirect_uri\": \"https://your-redirect-uri.com/callback\",\n *     \"is_mobile_sdk\": true\n *   }\n * }\n * ```\n *\n * ### Insecure Authentication Payload (Not Recommended)\n * ```json\n * {\n *   \"linkedin\": {\n *     \"id\": \"7654321\",\n *     \"access_token\": \"AQXNnd2hIT6z9bHFzZz2Kp1ghiMz_RtyuvwXYZ123abc\",\n *     \"is_mobile_sdk\": true\n *   }\n * }\n * ```\n *\n * ## Notes\n * - Secure authentication exchanges the `code` and `redirect_uri` provided by the client for an access token using LinkedIn's OAuth API.\n * - Insecure authentication validates the user ID and access token directly, bypassing OAuth flows. This method is **not recommended** and may introduce security vulnerabilities.\n * - `enableInsecureAuth` is **deprecated** and may be removed in future versions.\n *\n * @see {@link https://learn.microsoft.com/en-us/linkedin/shared/authentication/authentication LinkedIn Authentication Documentation}\n */\n\nimport BaseAuthCodeAdapter from './BaseCodeAuthAdapter';\nclass LinkedInAdapter extends BaseAuthCodeAdapter {\n  constructor() {\n    super('LinkedIn');\n  }\n  async getUserFromAccessToken(access_token, authData) {\n    const response = await fetch('https://api.linkedin.com/v2/me', {\n      headers: {\n        Authorization: `Bearer ${access_token}`,\n        'x-li-format': 'json',\n        'x-li-src': authData?.is_mobile_sdk ? 'msdk' : undefined,\n      },\n    });\n\n    if (!response.ok) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'LinkedIn API request failed.');\n    }\n\n    return response.json();\n  }\n\n  async getAccessTokenFromCode(authData) {\n    const response = await fetch('https://www.linkedin.com/oauth/v2/accessToken', {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/x-www-form-urlencoded',\n      },\n      body: new URLSearchParams({\n        grant_type: 'authorization_code',\n        code: authData.code,\n        redirect_uri: authData.redirect_uri,\n        client_id: this.clientId,\n        client_secret: this.clientSecret,\n      }),\n    });\n\n    if (!response.ok) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'LinkedIn API request failed.');\n    }\n\n    const json = await response.json();\n    return json.access_token;\n  }\n}\n\nexport default new LinkedInAdapter();\n"],"mappings":";;;;;;AAqEA,IAAAA,oBAAA,GAAAC,sBAAA,CAAAC,OAAA;AAAwD,SAAAD,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AArExD;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;AACA;AACA;AACA;AACA;;AAGA,MAAMG,eAAe,SAASC,4BAAmB,CAAC;EAChDC,WAAWA,CAAA,EAAG;IACZ,KAAK,CAAC,UAAU,CAAC;EACnB;EACA,MAAMC,sBAAsBA,CAACC,YAAY,EAAEC,QAAQ,EAAE;IACnD,MAAMC,QAAQ,GAAG,MAAMC,KAAK,CAAC,gCAAgC,EAAE;MAC7DC,OAAO,EAAE;QACPC,aAAa,EAAE,UAAUL,YAAY,EAAE;QACvC,aAAa,EAAE,MAAM;QACrB,UAAU,EAAEC,QAAQ,EAAEK,aAAa,GAAG,MAAM,GAAGC;MACjD;IACF,CAAC,CAAC;IAEF,IAAI,CAACL,QAAQ,CAACM,EAAE,EAAE;MAChB,MAAM,IAAIC,KAAK,CAACC,KAAK,CAACD,KAAK,CAACC,KAAK,CAACC,gBAAgB,EAAE,8BAA8B,CAAC;IACrF;IAEA,OAAOT,QAAQ,CAACU,IAAI,CAAC,CAAC;EACxB;EAEA,MAAMC,sBAAsBA,CAACZ,QAAQ,EAAE;IACrC,MAAMC,QAAQ,GAAG,MAAMC,KAAK,CAAC,+CAA+C,EAAE;MAC5EW,MAAM,EAAE,MAAM;MACdV,OAAO,EAAE;QACP,cAAc,EAAE;MAClB,CAAC;MACDW,IAAI,EAAE,IAAIC,eAAe,CAAC;QACxBC,UAAU,EAAE,oBAAoB;QAChCC,IAAI,EAAEjB,QAAQ,CAACiB,IAAI;QACnBC,YAAY,EAAElB,QAAQ,CAACkB,YAAY;QACnCC,SAAS,EAAE,IAAI,CAACC,QAAQ;QACxBC,aAAa,EAAE,IAAI,CAACC;MACtB,CAAC;IACH,CAAC,CAAC;IAEF,IAAI,CAACrB,QAAQ,CAACM,EAAE,EAAE;MAChB,MAAM,IAAIC,KAAK,CAACC,KAAK,CAACD,KAAK,CAACC,KAAK,CAACC,gBAAgB,EAAE,8BAA8B,CAAC;IACrF;IAEA,MAAMC,IAAI,GAAG,MAAMV,QAAQ,CAACU,IAAI,CAAC,CAAC;IAClC,OAAOA,IAAI,CAACZ,YAAY;EAC1B;AACF;AAAC,IAAAwB,QAAA,GAAAC,OAAA,CAAA9B,OAAA,GAEc,IAAIC,eAAe,CAAC,CAAC","ignoreList":[]}

package/lib/Adapters/Auth/meetup.js

@@ -1,17 +1,25 @@
-'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 meetup API.
-var https = require('https');
 var Parse = require('parse/node').Parse;
-
+const httpsRequest = require('./httpsRequest');
 // Returns a promise that fulfills iff this user id is valid.
-function validateAuthData(authData) {
-  return request('member/self', authData.access_token).then(data => {
-    if (data && data.id == authData.id) {
-      return;
-    }
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Meetup auth is invalid for this user.');
+async function validateAuthData(authData) {
+  const config = _Config.default.get(Parse.applicationId);
+  const meetupConfig = config.auth.meetup;
+  _Deprecator.default.logRuntimeDeprecation({
+    usage: 'meetup adapter'
   });
+  if (!meetupConfig?.enableInsecureAuth) {
+    throw new Parse.Error('Meetup only works with enableInsecureAuth: true');
+  }
+  const data = await request('member/self', authData.access_token);
+  if (data?.id !== authData.id) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Meetup auth is invalid for this user.');
+  }
 }
 
 // Returns a promise that fulfills iff this app id is valid.
@@ -21,34 +29,16 @@ function validateAppId() {
 
 // A promisey wrapper for api requests
 function request(path, access_token) {
-  return new Promise(function (resolve, reject) {
-    https.get({
-      host: 'api.meetup.com',
-      path: '/2/' + path,
-      headers: {
-        'Authorization': 'bearer ' + access_token
-      }
-    }, 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 Meetup.');
-    });
+  return httpsRequest.get({
+    host: 'api.meetup.com',
+    path: '/2/' + path,
+    headers: {
+      Authorization: 'bearer ' + access_token
+    }
   });
 }
-
 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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