@beiguancyc/parse-server 9.9.0-ruixiang.1

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

@@ -0,0 +1,117 @@
+"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 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}
+ */
+
+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.');
+    }
+    return response.json();
+  }
+  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;
+  }
+}
+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

@@ -0,0 +1,44 @@
+"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 Parse = require('parse/node').Parse;
+const httpsRequest = require('./httpsRequest');
+// Returns a promise that fulfills iff this user id is valid.
+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.
+function validateAppId() {
+  return Promise.resolve();
+}
+
+// A promisey wrapper for api requests
+function request(path, access_token) {
+  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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