@beiguancyc/parse-server 9.9.0-ruixiang.1

package/lib/Adapters/Auth/wechat.js

@@ -0,0 +1,110 @@
+"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 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}
+ */
+
+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.');
+    }
+    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;
+  }
+}
+var _default = exports.default = new WeChatAdapter();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Auth/weibo.js

@@ -0,0 +1,141 @@
+"use strict";
+
+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}
+ */
+
+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.');
+    }
+    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 data.access_token;
+  }
+}
+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":[]}

package/lib/Adapters/Cache/CacheAdapter.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CacheAdapter = void 0;
+/* eslint-disable unused-imports/no-unused-vars */
+/**
+ * @interface
+ * @memberof module:Adapters
+ */
+class CacheAdapter {
+  /**
+   * Get a value in the cache
+   * @param {String} key Cache key to get
+   * @return {Promise} that will eventually resolve to the value in the cache.
+   */
+  get(key) {}
+
+  /**
+   * Set a value in the cache
+   * @param {String} key Cache key to set
+   * @param {String} value Value to set the key
+   * @param {String} ttl Optional TTL
+   */
+  put(key, value, ttl) {}
+
+  /**
+   * Remove a value from the cache.
+   * @param {String} key Cache key to remove
+   */
+  del(key) {}
+
+  /**
+   * Empty a cache
+   */
+  clear() {}
+}
+exports.CacheAdapter = CacheAdapter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJDYWNoZUFkYXB0ZXIiLCJnZXQiLCJrZXkiLCJwdXQiLCJ2YWx1ZSIsInR0bCIsImRlbCIsImNsZWFyIiwiZXhwb3J0cyJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9DYWNoZS9DYWNoZUFkYXB0ZXIuanMiXSwic291cmNlc0NvbnRlbnQiOlsiLyogZXNsaW50LWRpc2FibGUgdW51c2VkLWltcG9ydHMvbm8tdW51c2VkLXZhcnMgKi9cbi8qKlxuICogQGludGVyZmFjZVxuICogQG1lbWJlcm9mIG1vZHVsZTpBZGFwdGVyc1xuICovXG5leHBvcnQgY2xhc3MgQ2FjaGVBZGFwdGVyIHtcbiAgLyoqXG4gICAqIEdldCBhIHZhbHVlIGluIHRoZSBjYWNoZVxuICAgKiBAcGFyYW0ge1N0cmluZ30ga2V5IENhY2hlIGtleSB0byBnZXRcbiAgICogQHJldHVybiB7UHJvbWlzZX0gdGhhdCB3aWxsIGV2ZW50dWFsbHkgcmVzb2x2ZSB0byB0aGUgdmFsdWUgaW4gdGhlIGNhY2hlLlxuICAgKi9cbiAgZ2V0KGtleSkge31cblxuICAvKipcbiAgICogU2V0IGEgdmFsdWUgaW4gdGhlIGNhY2hlXG4gICAqIEBwYXJhbSB7U3RyaW5nfSBrZXkgQ2FjaGUga2V5IHRvIHNldFxuICAgKiBAcGFyYW0ge1N0cmluZ30gdmFsdWUgVmFsdWUgdG8gc2V0IHRoZSBrZXlcbiAgICogQHBhcmFtIHtTdHJpbmd9IHR0bCBPcHRpb25hbCBUVExcbiAgICovXG4gIHB1dChrZXksIHZhbHVlLCB0dGwpIHt9XG5cbiAgLyoqXG4gICAqIFJlbW92ZSBhIHZhbHVlIGZyb20gdGhlIGNhY2hlLlxuICAgKiBAcGFyYW0ge1N0cmluZ30ga2V5IENhY2hlIGtleSB0byByZW1vdmVcbiAgICovXG4gIGRlbChrZXkpIHt9XG5cbiAgLyoqXG4gICAqIEVtcHR5IGEgY2FjaGVcbiAgICovXG4gIGNsZWFyKCkge31cbn1cbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUE7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNPLE1BQU1BLFlBQVksQ0FBQztFQUN4QjtBQUNGO0FBQ0E7QUFDQTtBQUNBO0VBQ0VDLEdBQUdBLENBQUNDLEdBQUcsRUFBRSxDQUFDOztFQUVWO0FBQ0Y7QUFDQTtBQUNBO0FBQ0E7QUFDQTtFQUNFQyxHQUFHQSxDQUFDRCxHQUFHLEVBQUVFLEtBQUssRUFBRUMsR0FBRyxFQUFFLENBQUM7O0VBRXRCO0FBQ0Y7QUFDQTtBQUNBO0VBQ0VDLEdBQUdBLENBQUNKLEdBQUcsRUFBRSxDQUFDOztFQUVWO0FBQ0Y7QUFDQTtFQUNFSyxLQUFLQSxDQUFBLEVBQUcsQ0FBQztBQUNYO0FBQUNDLE9BQUEsQ0FBQVIsWUFBQSxHQUFBQSxZQUFBIiwiaWdub3JlTGlzdCI6W119

package/lib/Adapters/Cache/InMemoryCache.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.InMemoryCache = void 0;
+const DEFAULT_CACHE_TTL = 5 * 1000;
+class InMemoryCache {
+  constructor({
+    ttl = DEFAULT_CACHE_TTL
+  }) {
+    this.ttl = ttl;
+    this.cache = Object.create(null);
+  }
+  get(key) {
+    const record = this.cache[key];
+    if (record == null) {
+      return null;
+    }
+
+    // Has Record and isnt expired
+    if (isNaN(record.expire) || record.expire >= Date.now()) {
+      return record.value;
+    }
+
+    // Record has expired
+    delete this.cache[key];
+    return null;
+  }
+  put(key, value, ttl = this.ttl) {
+    if (ttl < 0 || isNaN(ttl)) {
+      ttl = NaN;
+    }
+    var record = {
+      value: value,
+      expire: ttl + Date.now()
+    };
+    if (!isNaN(record.expire)) {
+      record.timeout = setTimeout(() => {
+        this.del(key);
+      }, ttl);
+    }
+    this.cache[key] = record;
+  }
+  del(key) {
+    var record = this.cache[key];
+    if (record == null) {
+      return;
+    }
+    if (record.timeout) {
+      clearTimeout(record.timeout);
+    }
+    delete this.cache[key];
+  }
+  clear() {
+    this.cache = Object.create(null);
+  }
+}
+exports.InMemoryCache = InMemoryCache;
+var _default = exports.default = InMemoryCache;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Cache/InMemoryCacheAdapter.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.InMemoryCacheAdapter = void 0;
+var _LRUCache = require("./LRUCache");
+class InMemoryCacheAdapter {
+  constructor(ctx) {
+    this.cache = new _LRUCache.LRUCache(ctx);
+  }
+  get(key) {
+    const record = this.cache.get(key);
+    if (record === null) {
+      return Promise.resolve(null);
+    }
+    return Promise.resolve(record);
+  }
+  put(key, value, ttl) {
+    this.cache.put(key, value, ttl);
+    return Promise.resolve();
+  }
+  del(key) {
+    this.cache.del(key);
+    return Promise.resolve();
+  }
+  clear() {
+    this.cache.clear();
+    return Promise.resolve();
+  }
+}
+exports.InMemoryCacheAdapter = InMemoryCacheAdapter;
+var _default = exports.default = InMemoryCacheAdapter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Cache/LRUCache.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.LRUCache = void 0;
+var _lruCache = require("lru-cache");
+var _defaults = _interopRequireDefault(require("../../defaults"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class LRUCache {
+  constructor({
+    ttl = _defaults.default.cacheTTL,
+    maxSize = _defaults.default.cacheMaxSize
+  }) {
+    this.cache = new _lruCache.LRUCache({
+      max: maxSize,
+      ttl
+    });
+  }
+  get(key) {
+    return this.cache.get(key) || null;
+  }
+  put(key, value, ttl = this.ttl) {
+    this.cache.set(key, value, ttl);
+  }
+  del(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+}
+exports.LRUCache = LRUCache;
+var _default = exports.default = LRUCache;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Cache/NullCacheAdapter.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.NullCacheAdapter = void 0;
+class NullCacheAdapter {
+  constructor() {}
+  get() {
+    return new Promise(resolve => {
+      return resolve(null);
+    });
+  }
+  put() {
+    return Promise.resolve();
+  }
+  del() {
+    return Promise.resolve();
+  }
+  clear() {
+    return Promise.resolve();
+  }
+}
+exports.NullCacheAdapter = NullCacheAdapter;
+var _default = exports.default = NullCacheAdapter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJOdWxsQ2FjaGVBZGFwdGVyIiwiY29uc3RydWN0b3IiLCJnZXQiLCJQcm9taXNlIiwicmVzb2x2ZSIsInB1dCIsImRlbCIsImNsZWFyIiwiZXhwb3J0cyIsIl9kZWZhdWx0IiwiZGVmYXVsdCJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9BZGFwdGVycy9DYWNoZS9OdWxsQ2FjaGVBZGFwdGVyLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBOdWxsQ2FjaGVBZGFwdGVyIHtcbiAgY29uc3RydWN0b3IoKSB7fVxuXG4gIGdldCgpIHtcbiAgICByZXR1cm4gbmV3IFByb21pc2UocmVzb2x2ZSA9PiB7XG4gICAgICByZXR1cm4gcmVzb2x2ZShudWxsKTtcbiAgICB9KTtcbiAgfVxuXG4gIHB1dCgpIHtcbiAgICByZXR1cm4gUHJvbWlzZS5yZXNvbHZlKCk7XG4gIH1cblxuICBkZWwoKSB7XG4gICAgcmV0dXJuIFByb21pc2UucmVzb2x2ZSgpO1xuICB9XG5cbiAgY2xlYXIoKSB7XG4gICAgcmV0dXJuIFByb21pc2UucmVzb2x2ZSgpO1xuICB9XG59XG5cbmV4cG9ydCBkZWZhdWx0IE51bGxDYWNoZUFkYXB0ZXI7XG4iXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFPLE1BQU1BLGdCQUFnQixDQUFDO0VBQzVCQyxXQUFXQSxDQUFBLEVBQUcsQ0FBQztFQUVmQyxHQUFHQSxDQUFBLEVBQUc7SUFDSixPQUFPLElBQUlDLE9BQU8sQ0FBQ0MsT0FBTyxJQUFJO01BQzVCLE9BQU9BLE9BQU8sQ0FBQyxJQUFJLENBQUM7SUFDdEIsQ0FBQyxDQUFDO0VBQ0o7RUFFQUMsR0FBR0EsQ0FBQSxFQUFHO0lBQ0osT0FBT0YsT0FBTyxDQUFDQyxPQUFPLENBQUMsQ0FBQztFQUMxQjtFQUVBRSxHQUFHQSxDQUFBLEVBQUc7SUFDSixPQUFPSCxPQUFPLENBQUNDLE9BQU8sQ0FBQyxDQUFDO0VBQzFCO0VBRUFHLEtBQUtBLENBQUEsRUFBRztJQUNOLE9BQU9KLE9BQU8sQ0FBQ0MsT0FBTyxDQUFDLENBQUM7RUFDMUI7QUFDRjtBQUFDSSxPQUFBLENBQUFSLGdCQUFBLEdBQUFBLGdCQUFBO0FBQUEsSUFBQVMsUUFBQSxHQUFBRCxPQUFBLENBQUFFLE9BQUEsR0FFY1YsZ0JBQWdCIiwiaWdub3JlTGlzdCI6W119

package/lib/Adapters/Cache/RedisCacheAdapter.js

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.RedisCacheAdapter = void 0;
+var _redis = require("redis");
+var _logger = _interopRequireDefault(require("../../logger"));
+var _KeyPromiseQueue = require("../../KeyPromiseQueue");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const DEFAULT_REDIS_TTL = 30 * 1000; // 30 seconds in milliseconds
+const FLUSH_DB_KEY = '__flush_db__';
+function debug(...args) {
+  const message = ['RedisCacheAdapter: ' + arguments[0]].concat(args.slice(1, args.length));
+  _logger.default.debug.apply(_logger.default, message);
+}
+const isValidTTL = ttl => typeof ttl === 'number' && ttl > 0;
+class RedisCacheAdapter {
+  constructor(redisCtx, ttl = DEFAULT_REDIS_TTL) {
+    this.ttl = isValidTTL(ttl) ? ttl : DEFAULT_REDIS_TTL;
+    this.client = (0, _redis.createClient)(redisCtx);
+    this.queue = new _KeyPromiseQueue.KeyPromiseQueue();
+    this.client.on('error', err => {
+      _logger.default.error('RedisCacheAdapter client error', {
+        error: err
+      });
+    });
+    this.client.on('connect', () => {});
+    this.client.on('reconnecting', () => {});
+    this.client.on('ready', () => {});
+  }
+  async connect() {
+    if (this.client.isOpen) {
+      return;
+    }
+    return await this.client.connect();
+  }
+  async handleShutdown() {
+    if (!this.client) {
+      return;
+    }
+    try {
+      await this.client.close();
+    } catch (err) {
+      _logger.default.error('RedisCacheAdapter error on shutdown', {
+        error: err
+      });
+    }
+  }
+  async get(key) {
+    debug('get', {
+      key
+    });
+    try {
+      await this.queue.enqueue(key);
+      const res = await this.client.get(key);
+      if (!res) {
+        return null;
+      }
+      return JSON.parse(res);
+    } catch (err) {
+      _logger.default.error('RedisCacheAdapter error on get', {
+        error: err
+      });
+    }
+  }
+  async put(key, value, ttl = this.ttl) {
+    value = JSON.stringify(value);
+    debug('put', {
+      key,
+      value,
+      ttl
+    });
+    await this.queue.enqueue(key);
+    if (ttl === 0) {
+      // ttl of zero is a logical no-op, but redis cannot set expire time of zero
+      return;
+    }
+    if (ttl === Infinity) {
+      return this.client.set(key, value);
+    }
+    if (!isValidTTL(ttl)) {
+      ttl = this.ttl;
+    }
+    return this.client.set(key, value, {
+      PX: ttl
+    });
+  }
+  async del(key) {
+    debug('del', {
+      key
+    });
+    await this.queue.enqueue(key);
+    return this.client.del(key);
+  }
+  async clear() {
+    debug('clear');
+    await this.queue.enqueue(FLUSH_DB_KEY);
+    return this.client.sendCommand(['FLUSHDB']);
+  }
+
+  // Used for testing
+  getAllKeys() {
+    return this.client.keys('*');
+  }
+}
+exports.RedisCacheAdapter = RedisCacheAdapter;
+var _default = exports.default = RedisCacheAdapter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_redis","require","_logger","_interopRequireDefault","_KeyPromiseQueue","e","__esModule","default","DEFAULT_REDIS_TTL","FLUSH_DB_KEY","debug","args","message","arguments","concat","slice","length","logger","apply","isValidTTL","ttl","RedisCacheAdapter","constructor","redisCtx","client","createClient","queue","KeyPromiseQueue","on","err","error","connect","isOpen","handleShutdown","close","get","key","enqueue","res","JSON","parse","put","value","stringify","Infinity","set","PX","del","clear","sendCommand","getAllKeys","keys","exports","_default"],"sources":["../../../src/Adapters/Cache/RedisCacheAdapter.js"],"sourcesContent":["import { createClient } from 'redis';\nimport logger from '../../logger';\nimport { KeyPromiseQueue } from '../../KeyPromiseQueue';\n\nconst DEFAULT_REDIS_TTL = 30 * 1000; // 30 seconds in milliseconds\nconst FLUSH_DB_KEY = '__flush_db__';\n\nfunction debug(...args: any) {\n  const message = ['RedisCacheAdapter: ' + arguments[0]].concat(args.slice(1, args.length));\n  logger.debug.apply(logger, message);\n}\n\nconst isValidTTL = ttl => typeof ttl === 'number' && ttl > 0;\n\nexport class RedisCacheAdapter {\n  constructor(redisCtx, ttl = DEFAULT_REDIS_TTL) {\n    this.ttl = isValidTTL(ttl) ? ttl : DEFAULT_REDIS_TTL;\n    this.client = createClient(redisCtx);\n    this.queue = new KeyPromiseQueue();\n    this.client.on('error', err => { logger.error('RedisCacheAdapter client error', { error: err }) });\n    this.client.on('connect', () => {});\n    this.client.on('reconnecting', () => {});\n    this.client.on('ready', () => {});\n  }\n\n  async connect() {\n    if (this.client.isOpen) {\n      return;\n    }\n    return await this.client.connect();\n  }\n\n  async handleShutdown() {\n    if (!this.client) {\n      return;\n    }\n    try {\n      await this.client.close();\n    } catch (err) {\n      logger.error('RedisCacheAdapter error on shutdown', { error: err });\n    }\n  }\n\n  async get(key) {\n    debug('get', { key });\n    try {\n      await this.queue.enqueue(key);\n      const res = await this.client.get(key);\n      if (!res) {\n        return null;\n      }\n      return JSON.parse(res);\n    } catch (err) {\n      logger.error('RedisCacheAdapter error on get', { error: err });\n    }\n  }\n\n  async put(key, value, ttl = this.ttl) {\n    value = JSON.stringify(value);\n    debug('put', { key, value, ttl });\n    await this.queue.enqueue(key);\n    if (ttl === 0) {\n      // ttl of zero is a logical no-op, but redis cannot set expire time of zero\n      return;\n    }\n\n    if (ttl === Infinity) {\n      return this.client.set(key, value);\n    }\n\n    if (!isValidTTL(ttl)) {\n      ttl = this.ttl;\n    }\n    return this.client.set(key, value, { PX: ttl });\n  }\n\n  async del(key) {\n    debug('del', { key });\n    await this.queue.enqueue(key);\n    return this.client.del(key);\n  }\n\n  async clear() {\n    debug('clear');\n    await this.queue.enqueue(FLUSH_DB_KEY);\n    return this.client.sendCommand(['FLUSHDB']);\n  }\n\n  // Used for testing\n  getAllKeys() {\n    return this.client.keys('*');\n  }\n}\n\nexport default RedisCacheAdapter;\n"],"mappings":"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","ignoreList":[]}

package/lib/Adapters/Cache/SchemaCache.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const SchemaCache = {};
+var _default = exports.default = {
+  all() {
+    return [...(SchemaCache.allClasses || [])];
+  },
+  get(className) {
+    return this.all().find(cached => cached.className === className);
+  },
+  put(allSchema) {
+    SchemaCache.allClasses = allSchema;
+  },
+  del(className) {
+    this.put(this.all().filter(cached => cached.className !== className));
+  },
+  clear() {
+    delete SchemaCache.allClasses;
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJTY2hlbWFDYWNoZSIsIl9kZWZhdWx0IiwiZXhwb3J0cyIsImRlZmF1bHQiLCJhbGwiLCJhbGxDbGFzc2VzIiwiZ2V0IiwiY2xhc3NOYW1lIiwiZmluZCIsImNhY2hlZCIsInB1dCIsImFsbFNjaGVtYSIsImRlbCIsImZpbHRlciIsImNsZWFyIl0sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL0FkYXB0ZXJzL0NhY2hlL1NjaGVtYUNhY2hlLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImNvbnN0IFNjaGVtYUNhY2hlID0ge307XG5cbmV4cG9ydCBkZWZhdWx0IHtcbiAgYWxsKCkge1xuICAgIHJldHVybiBbLi4uKFNjaGVtYUNhY2hlLmFsbENsYXNzZXMgfHwgW10pXTtcbiAgfSxcblxuICBnZXQoY2xhc3NOYW1lKSB7XG4gICAgcmV0dXJuIHRoaXMuYWxsKCkuZmluZChjYWNoZWQgPT4gY2FjaGVkLmNsYXNzTmFtZSA9PT0gY2xhc3NOYW1lKTtcbiAgfSxcblxuICBwdXQoYWxsU2NoZW1hKSB7XG4gICAgU2NoZW1hQ2FjaGUuYWxsQ2xhc3NlcyA9IGFsbFNjaGVtYTtcbiAgfSxcblxuICBkZWwoY2xhc3NOYW1lKSB7XG4gICAgdGhpcy5wdXQodGhpcy5hbGwoKS5maWx0ZXIoY2FjaGVkID0+IGNhY2hlZC5jbGFzc05hbWUgIT09IGNsYXNzTmFtZSkpO1xuICB9LFxuXG4gIGNsZWFyKCkge1xuICAgIGRlbGV0ZSBTY2hlbWFDYWNoZS5hbGxDbGFzc2VzO1xuICB9LFxufTtcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUEsTUFBTUEsV0FBVyxHQUFHLENBQUMsQ0FBQztBQUFDLElBQUFDLFFBQUEsR0FBQUMsT0FBQSxDQUFBQyxPQUFBLEdBRVI7RUFDYkMsR0FBR0EsQ0FBQSxFQUFHO0lBQ0osT0FBTyxDQUFDLElBQUlKLFdBQVcsQ0FBQ0ssVUFBVSxJQUFJLEVBQUUsQ0FBQyxDQUFDO0VBQzVDLENBQUM7RUFFREMsR0FBR0EsQ0FBQ0MsU0FBUyxFQUFFO0lBQ2IsT0FBTyxJQUFJLENBQUNILEdBQUcsQ0FBQyxDQUFDLENBQUNJLElBQUksQ0FBQ0MsTUFBTSxJQUFJQSxNQUFNLENBQUNGLFNBQVMsS0FBS0EsU0FBUyxDQUFDO0VBQ2xFLENBQUM7RUFFREcsR0FBR0EsQ0FBQ0MsU0FBUyxFQUFFO0lBQ2JYLFdBQVcsQ0FBQ0ssVUFBVSxHQUFHTSxTQUFTO0VBQ3BDLENBQUM7RUFFREMsR0FBR0EsQ0FBQ0wsU0FBUyxFQUFFO0lBQ2IsSUFBSSxDQUFDRyxHQUFHLENBQUMsSUFBSSxDQUFDTixHQUFHLENBQUMsQ0FBQyxDQUFDUyxNQUFNLENBQUNKLE1BQU0sSUFBSUEsTUFBTSxDQUFDRixTQUFTLEtBQUtBLFNBQVMsQ0FBQyxDQUFDO0VBQ3ZFLENBQUM7RUFFRE8sS0FBS0EsQ0FBQSxFQUFHO0lBQ04sT0FBT2QsV0FBVyxDQUFDSyxVQUFVO0VBQy9CO0FBQ0YsQ0FBQyIsImlnbm9yZUxpc3QiOltdfQ==