parse-server 8.0.1-alpha.2 → 8.0.2-alpha.1

package/lib/Adapters/Auth/vkontakte.js

@@ -1,22 +1,29 @@
 'use strict';
 
 // Helper functions for accessing the vkontakte API.
+var _Config = _interopRequireDefault(require("../../Config"));
+var _Deprecator = _interopRequireDefault(require("../../Deprecator/Deprecator"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const httpsRequest = require('./httpsRequest');
 var Parse = require('parse/node').Parse;
-
 // Returns a promise that fulfills iff this user id is valid.
-function validateAuthData(authData, params) {
-  return vkOAuth2Request(params).then(function (response) {
-    if (response && response.access_token) {
-      return request('api.vk.com', 'method/users.get?access_token=' + authData.access_token + '&v=' + params.apiVersion).then(function (response) {
-        if (response && response.response && response.response.length && response.response[0].id == authData.id) {
-          return;
-        }
-        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Vk auth is invalid for this user.');
-      });
-    }
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Vk appIds or appSecret is incorrect.');
+async function validateAuthData(authData, params) {
+  const config = _Config.default.get(Parse.applicationId);
+  _Deprecator.default.logRuntimeDeprecation({
+    usage: 'vkontakte adapter'
   });
+  const vkConfig = config.auth.vkontakte;
+  if (!vkConfig?.enableInsecureAuth || !config.enableInsecureAuthAdapters) {
+    throw new Parse.Error('Vk only works with enableInsecureAuth: true');
+  }
+  const response = await vkOAuth2Request(params);
+  if (!response?.access_token) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Vk appIds or appSecret is incorrect.');
+  }
+  const vkUser = await request('api.vk.com', `method/users.get?access_token=${authData.access_token}&v=${params.apiVersion}`);
+  if (!vkUser?.response?.length || vkUser.response[0].id !== authData.id) {
+    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Vk auth is invalid for this user.');
+  }
 }
 function vkOAuth2Request(params) {
   return new Promise(function (resolve) {
@@ -45,4 +52,4 @@ 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/wechat.js

@@ -1,30 +1,110 @@
 "use strict";
 
-// Helper functions for accessing the WeChat Graph API.
-const httpsRequest = require('./httpsRequest');
-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 WeChat.
+ *
+ * @class WeChatAdapter
+ * @param {Object} options - The adapter options object.
+ * @param {boolean} [options.enableInsecureAuth=false] - **[DEPRECATED]** Enable insecure authentication (not recommended).
+ * @param {string} options.clientId - Your WeChat App ID.
+ * @param {string} options.clientSecret - Your WeChat App Secret.
+ *
+ * @description
+ * ## Parse Server Configuration
+ * To configure Parse Server for WeChat authentication, use the following structure:
+ * ### Secure Configuration (Recommended)
+ * ```json
+ * {
+ *   "auth": {
+ *     "wechat": {
+ *       "clientId": "your-client-id",
+ *       "clientSecret": "your-client-secret"
+ *     }
+ *   }
+ * }
+ * ```
+ * ### Insecure Configuration (Not Recommended)
+ * ```json
+ * {
+ *   "auth": {
+ *     "wechat": {
+ *       "enableInsecureAuth": true
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The adapter requires the following `authData` fields:
+ * - **With `enableInsecureAuth` (Not Recommended)**: `id`, `access_token`.
+ * - **Without `enableInsecureAuth`**: `code`.
+ *
+ * ## Auth Payloads
+ * ### Secure Authentication Payload (Recommended)
+ * ```json
+ * {
+ *   "wechat": {
+ *     "code": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+ *   }
+ * }
+ * ```
+ * ### Insecure Authentication Payload (Not Recommended)
+ * ```json
+ * {
+ *   "wechat": {
+ *     "id": "1234567",
+ *     "access_token": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * - With `enableInsecureAuth`, the adapter directly validates the `id` and `access_token` sent by the client.
+ * - Without `enableInsecureAuth`, the adapter uses the `code` provided by the client to exchange for an access token via WeChat's OAuth API.
+ * - The `enableInsecureAuth` flag is **deprecated** and may be removed in future versions. Use secure authentication with the `code` field instead.
+ *
+ * @example <caption>Auth Data Example</caption>
+ * // Example authData provided by the client:
+ * const authData = {
+ *   wechat: {
+ *     code: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+ *   }
+ * };
+ *
+ * @see {@link https://developers.weixin.qq.com/doc/offiaccount/en/OA_Web_Apps/Wechat_webpage_authorization.html WeChat Authentication Documentation}
+ */
 
-// Returns a promise that fulfills iff this user id is valid.
-function validateAuthData(authData) {
-  return graphRequest('auth?access_token=' + authData.access_token + '&openid=' + authData.id).then(function (data) {
-    if (data.errcode == 0) {
-      return;
+class WeChatAdapter extends _BaseCodeAuthAdapter.default {
+  constructor() {
+    super('WeChat');
+  }
+  async getUserFromAccessToken(access_token, authData) {
+    const response = await fetch(`https://api.weixin.qq.com/sns/auth?access_token=${access_token}&openid=${authData.id}`);
+    const data = await response.json();
+    if (!response.ok || data.errcode !== 0) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'WeChat auth is invalid for this user.');
     }
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'wechat auth is invalid for this user.');
-  });
-}
-
-// Returns a promise that fulfills if this app id is valid.
-function validateAppId() {
-  return Promise.resolve();
-}
-
-// A promisey wrapper for WeChat graph requests.
-function graphRequest(path) {
-  return httpsRequest.get('https://api.weixin.qq.com/sns/' + path);
+    return data;
+  }
+  async getAccessTokenFromCode(authData) {
+    if (!authData.code) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'WeChat auth requires a code to be sent.');
+    }
+    const appId = this.clientId;
+    const appSecret = this.clientSecret;
+    const response = await fetch(`https://api.weixin.qq.com/sns/oauth2/access_token?appid=${appId}&secret=${appSecret}&code=${authData.code}&grant_type=authorization_code`);
+    const data = await response.json();
+    if (!response.ok || data.errcode) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'WeChat auth is invalid for this user.');
+    }
+    authData.id = data.openid;
+    return data.access_token;
+  }
 }
-module.exports = {
-  validateAppId,
-  validateAuthData
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+var _default = exports.default = new WeChatAdapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Auth/weibo.js

@@ -1,43 +1,141 @@
 "use strict";
 
-// Helper functions for accessing the weibo Graph API.
-var httpsRequest = require('./httpsRequest');
-var Parse = require('parse/node').Parse;
-var querystring = require('querystring');
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _BaseCodeAuthAdapter = _interopRequireDefault(require("./BaseCodeAuthAdapter"));
+var _querystring = _interopRequireDefault(require("querystring"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Parse Server authentication adapter for Weibo.
+ *
+ * @class WeiboAdapter
+ * @param {Object} options - The adapter configuration options.
+ * @param {boolean} [options.enableInsecureAuth=false] - **[DEPRECATED]** Enable insecure authentication (not recommended).
+ * @param {string} options.clientId - Your Weibo client ID.
+ * @param {string} options.clientSecret - Your Weibo client secret.
+ *
+ * @description
+ * ## Parse Server Configuration
+ * To configure Parse Server for Weibo authentication, use the following structure:
+ * ### Secure Configuration
+ * ```json
+ * {
+ *   "auth": {
+ *     "weibo": {
+ *       "clientId": "your-client-id",
+ *       "clientSecret": "your-client-secret"
+ *     }
+ *   }
+ * }
+ * ```
+ * ### Insecure Configuration (Not Recommended)
+ * ```json
+ * {
+ *   "auth": {
+ *     "weibo": {
+ *       "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
+ * {
+ *   "weibo": {
+ *     "code": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+ *     "redirect_uri": "https://example.com/callback"
+ *   }
+ * }
+ * ```
+ * ### Insecure Authentication Payload (Not Recommended)
+ * ```json
+ * {
+ *   "weibo": {
+ *     "id": "1234567",
+ *     "access_token": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+ *   }
+ * }
+ * ```
+ *
+ * ## Notes
+ * - **Insecure Authentication**: When `enableInsecureAuth` is enabled, the adapter directly validates the `id` and `access_token` provided by the client.
+ * - **Secure Authentication**: When `enableInsecureAuth` is disabled, the adapter exchanges the `code` and `redirect_uri` for an access token using Weibo's OAuth API.
+ * - `enableInsecureAuth` is **deprecated** and may be removed in future versions. Use secure authentication with `code` and `redirect_uri`.
+ *
+ * @example <caption>Auth Data Example (Secure)</caption>
+ * const authData = {
+ *   weibo: {
+ *     code: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+ *     redirect_uri: "https://example.com/callback"
+ *   }
+ * };
+ *
+ * @example <caption>Auth Data Example (Insecure - Not Recommended)</caption>
+ * const authData = {
+ *   weibo: {
+ *     id: "1234567",
+ *     access_token: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+ *   }
+ * };
+ *
+ * @see {@link https://open.weibo.com/wiki/Oauth2/access_token Weibo Authentication Documentation}
+ */
 
-// Returns a promise that fulfills iff this user id is valid.
-function validateAuthData(authData) {
-  return graphRequest(authData.access_token).then(function (data) {
-    if (data && data.uid == authData.id) {
-      return;
+class WeiboAdapter extends _BaseCodeAuthAdapter.default {
+  constructor() {
+    super('Weibo');
+  }
+  async getUserFromAccessToken(access_token) {
+    const postData = _querystring.default.stringify({
+      access_token: access_token
+    });
+    const response = await fetch('https://api.weibo.com/oauth2/get_token_info', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded'
+      },
+      body: postData
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Weibo auth is invalid for this user.');
     }
-    throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'weibo auth is invalid for this user.');
-  });
-}
-
-// Returns a promise that fulfills if this app id is valid.
-function validateAppId() {
-  return Promise.resolve();
-}
-
-// A promisey wrapper for weibo graph requests.
-function graphRequest(access_token) {
-  var postData = querystring.stringify({
-    access_token: access_token
-  });
-  var options = {
-    hostname: 'api.weibo.com',
-    path: '/oauth2/get_token_info',
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/x-www-form-urlencoded',
-      'Content-Length': Buffer.byteLength(postData)
+    return {
+      id: data.uid
+    };
+  }
+  async getAccessTokenFromCode(authData) {
+    if (!authData?.code || !authData?.redirect_uri) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Weibo auth requires code and redirect_uri to be sent.');
+    }
+    const postData = _querystring.default.stringify({
+      client_id: this.clientId,
+      client_secret: this.clientSecret,
+      grant_type: 'authorization_code',
+      code: authData.code,
+      redirect_uri: authData.redirect_uri
+    });
+    const response = await fetch('https://api.weibo.com/oauth2/access_token', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded'
+      },
+      body: postData
+    });
+    const data = await response.json();
+    if (!response.ok || data.errcode) {
+      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Weibo auth is invalid for this user.');
     }
-  };
-  return httpsRequest.request(options, postData);
+    return data.access_token;
+  }
 }
-module.exports = {
-  validateAppId,
-  validateAuthData
-};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+var _default = exports.default = new WeiboAdapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_BaseCodeAuthAdapter","_interopRequireDefault","require","_querystring","e","__esModule","default","WeiboAdapter","BaseAuthCodeAdapter","constructor","getUserFromAccessToken","access_token","postData","querystring","stringify","response","fetch","method","headers","body","data","json","ok","Parse","Error","OBJECT_NOT_FOUND","id","uid","getAccessTokenFromCode","authData","code","redirect_uri","client_id","clientId","client_secret","clientSecret","grant_type","errcode","_default","exports"],"sources":["../../../src/Adapters/Auth/weibo.js"],"sourcesContent":["/**\n * Parse Server authentication adapter for Weibo.\n *\n * @class WeiboAdapter\n * @param {Object} options - The adapter configuration options.\n * @param {boolean} [options.enableInsecureAuth=false] - **[DEPRECATED]** Enable insecure authentication (not recommended).\n * @param {string} options.clientId - Your Weibo client ID.\n * @param {string} options.clientSecret - Your Weibo client secret.\n *\n * @description\n * ## Parse Server Configuration\n * To configure Parse Server for Weibo authentication, use the following structure:\n * ### Secure Configuration\n * ```json\n * {\n *   \"auth\": {\n *     \"weibo\": {\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 *     \"weibo\": {\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 *   \"weibo\": {\n *     \"code\": \"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\",\n *     \"redirect_uri\": \"https://example.com/callback\"\n *   }\n * }\n * ```\n * ### Insecure Authentication Payload (Not Recommended)\n * ```json\n * {\n *   \"weibo\": {\n *     \"id\": \"1234567\",\n *     \"access_token\": \"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"\n *   }\n * }\n * ```\n *\n * ## Notes\n * - **Insecure Authentication**: When `enableInsecureAuth` is enabled, the adapter directly validates the `id` and `access_token` provided by the client.\n * - **Secure Authentication**: When `enableInsecureAuth` is disabled, the adapter exchanges the `code` and `redirect_uri` for an access token using Weibo's OAuth API.\n * - `enableInsecureAuth` is **deprecated** and may be removed in future versions. Use secure authentication with `code` and `redirect_uri`.\n *\n * @example <caption>Auth Data Example (Secure)</caption>\n * const authData = {\n *   weibo: {\n *     code: \"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\",\n *     redirect_uri: \"https://example.com/callback\"\n *   }\n * };\n *\n * @example <caption>Auth Data Example (Insecure - Not Recommended)</caption>\n * const authData = {\n *   weibo: {\n *     id: \"1234567\",\n *     access_token: \"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"\n *   }\n * };\n *\n * @see {@link https://open.weibo.com/wiki/Oauth2/access_token Weibo Authentication Documentation}\n */\n\nimport BaseAuthCodeAdapter from './BaseCodeAuthAdapter';\nimport querystring from 'querystring';\n\nclass WeiboAdapter extends BaseAuthCodeAdapter {\n  constructor() {\n    super('Weibo');\n  }\n\n  async getUserFromAccessToken(access_token) {\n    const postData = querystring.stringify({\n      access_token: access_token,\n    });\n\n    const response = await fetch('https://api.weibo.com/oauth2/get_token_info', {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/x-www-form-urlencoded',\n      },\n      body: postData,\n    });\n\n    const data = await response.json();\n\n    if (!response.ok) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Weibo auth is invalid for this user.');\n    }\n\n    return {\n      id: data.uid,\n    }\n  }\n\n  async getAccessTokenFromCode(authData) {\n    if (!authData?.code || !authData?.redirect_uri) {\n      throw new Parse.Error(\n        Parse.Error.OBJECT_NOT_FOUND,\n        'Weibo auth requires code and redirect_uri to be sent.'\n      );\n    }\n\n    const postData = querystring.stringify({\n      client_id: this.clientId,\n      client_secret: this.clientSecret,\n      grant_type: 'authorization_code',\n      code: authData.code,\n      redirect_uri: authData.redirect_uri,\n    });\n\n    const response = await fetch('https://api.weibo.com/oauth2/access_token', {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/x-www-form-urlencoded',\n      },\n      body: postData,\n    });\n\n    const data = await response.json();\n\n    if (!response.ok || data.errcode) {\n      throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Weibo auth is invalid for this user.');\n    }\n\n    return data.access_token;\n  }\n}\n\nexport default new WeiboAdapter();\n"],"mappings":"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","ignoreList":[]}