@vendit-dev/thirdparty-adapters 0.1.0 → 0.1.3

package/lib/index.js

@@ -1,2 +1,8 @@
-import SanhaWingsAdapter from './adapters/sanhaWings';
-export { SanhaWingsAdapter, };
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SanhaWingsAdapter = void 0;
+var sanhaWings_1 = __importDefault(require("./adapters/sanhaWings"));
+exports.SanhaWingsAdapter = sanhaWings_1.default;

package/lib/utils/mutex.d.ts

@@ -1,15 +1,14 @@
-import { Redis } from 'ioredis';
 export default class MutexLock {
-    redis: Redis;
+    redis: any;
     hashPrefix: string;
     mutexLockInterval: number;
     constructor({ redis, hashPrefix, mutexLockInterval }: {
-        redis: Redis;
+        redis: any;
         hashPrefix: string;
         mutexLockInterval?: number;
     });
     getMutexLockKey: (id: string) => string;
-    tryMutexLock: (streamId: string, lockHash: string) => Promise<"OK" | null>;
+    tryMutexLock: (streamId: string, lockHash: string) => any;
     getMutexLock: (streamId: string) => Promise<string>;
-    unlockMutexLock: (streamId: string, lockHash: string) => Promise<string | null>;
+    unlockMutexLock: (streamId: string, lockHash: string) => Promise<any>;
 }

package/lib/utils/mutex.js

@@ -1,3 +1,4 @@
+"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -7,31 +8,82 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { v4 as uuid } from 'uuid';
-const sleep = (sleepTime) => new Promise(resolve => setTimeout(resolve, sleepTime));
-export default class MutexLock {
-    constructor({ redis, hashPrefix, mutexLockInterval = 50 }) {
-        this.getMutexLockKey = (id) => `${this.hashPrefix}${id}`;
-        this.tryMutexLock = (streamId, lockHash) => this.redis.set(this.getMutexLockKey(streamId), lockHash, 'EX', 60, 'NX');
-        this.getMutexLock = (streamId) => __awaiter(this, void 0, void 0, function* () {
-            const lockHash = uuid();
-            let lock;
-            while (!lock) {
-                lock = yield this.tryMutexLock(streamId, lockHash); // eslint-disable-line
-                yield sleep(this.mutexLockInterval); // eslint-disable-line
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
             }
-            return lockHash;
-        });
-        this.unlockMutexLock = (streamId, lockHash) => __awaiter(this, void 0, void 0, function* () {
-            const existingLockHash = yield this.redis.get(this.getMutexLockKey(streamId));
-            if (existingLockHash === lockHash) {
-                yield this.redis.del(this.getMutexLockKey(streamId));
-                return existingLockHash;
-            }
-            return null;
-        });
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var uuid_1 = require("uuid");
+var sleep = function (sleepTime) { return new Promise(function (resolve) { return setTimeout(resolve, sleepTime); }); };
+var MutexLock = /** @class */ (function () {
+    function MutexLock(_a) {
+        var _this = this;
+        var redis = _a.redis, hashPrefix = _a.hashPrefix, _b = _a.mutexLockInterval, mutexLockInterval = _b === void 0 ? 50 : _b;
+        this.getMutexLockKey = function (id) { return "" + _this.hashPrefix + id; };
+        this.tryMutexLock = function (streamId, lockHash) { return _this.redis.set(_this.getMutexLockKey(streamId), lockHash, 'EX', 60, 'NX'); };
+        this.getMutexLock = function (streamId) { return __awaiter(_this, void 0, void 0, function () {
+            var lockHash, lock;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        lockHash = uuid_1.v4();
+                        _a.label = 1;
+                    case 1:
+                        if (!!lock) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.tryMutexLock(streamId, lockHash)];
+                    case 2:
+                        lock = _a.sent(); // eslint-disable-line
+                        return [4 /*yield*/, sleep(this.mutexLockInterval)];
+                    case 3:
+                        _a.sent(); // eslint-disable-line
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, lockHash];
+                }
+            });
+        }); };
+        this.unlockMutexLock = function (streamId, lockHash) { return __awaiter(_this, void 0, void 0, function () {
+            var existingLockHash;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.redis.get(this.getMutexLockKey(streamId))];
+                    case 1:
+                        existingLockHash = _a.sent();
+                        if (!(existingLockHash === lockHash)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.redis.del(this.getMutexLockKey(streamId))];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, existingLockHash];
+                    case 3: return [2 /*return*/, null];
+                }
+            });
+        }); };
         this.redis = redis;
         this.hashPrefix = hashPrefix;
         this.mutexLockInterval = mutexLockInterval;
     }
-}
+    return MutexLock;
+}());
+exports.default = MutexLock;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vendit-dev/thirdparty-adapters",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Third party adapters between v-cloud and other PMS/CMS providers.",
   "main": "lib/index.js",
   "scripts": {
@@ -13,17 +13,27 @@
   "author": "Vendit <dev@vendit.co.kr> (https://vendit.co.kr)",
   "license": "MIT",
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^5.18.0",
-    "@typescript-eslint/parser": "^5.18.0",
+    "@babel/cli": "^7.10.5",
+    "@babel/core": "^7.10.5",
+    "@babel/node": "^7.10.5",
+    "@babel/plugin-proposal-class-properties": "^7.10.4",
+    "@babel/plugin-proposal-optional-chaining": "^7.10.4",
+    "@babel/preset-env": "^7.10.4",
+    "@babel/preset-flow": "^7.10.4",
+    "@types/node": "^14.11.4",
+    "@typescript-eslint/eslint-plugin": "^3.6.1",
+    "@typescript-eslint/parser": "^3.6.1",
     "@vendit-dev/utility-modules": "^0.10.3",
+    "babel-eslint": "^10.1.0",
+    "babel-plugin-module-resolver": "^4.0.0",
+    "cross-env": "^7.0.2",
+    "eslint": "^7.4.0",
     "eslint-config-airbnb-base": "^13.1.0",
     "eslint-plugin-import": "^2.16.0",
-    "eslint": "^8.12.0",
-    "tslint": "^6.1.3",
-    "typescript": "^4.6.3"
+    "sequelize": "^6.6.2",
+    "typescript": "^3.9.6"
   },
   "dependencies": {
-    "ioredis": "^5.0.4",
     "moment": "^2.29.2",
     "node-fetch": "^3.2.3",
     "uuid": "^8.3.2"

package/readme.md

@@ -1,131 +1,4 @@
-# Passive Promise
+# ThirdParty-Adapters
 
-Promise that's resolvable from outside of executor context.
+adapter modules for third party PMS & CMS providers.
 
-It comes with super light-weighted bundle with 0 dependencies.
-
-## What is this?
-
-This library exports the class named `PassivePromise` which works exactly like normal Promises, but can be resolved outside of promise executor context.
-
-## Installation
-
-`npm install passive-promise`
-
-or
-
-`yarn add passive-promise`
-
-The library exported with esnext module syntax.
-
-## Usage Examples
-
-Just use exactly like normal promise, but returned promise (which is extended Promise class) also comes with the `resolve()` and `reject()` method in it, which you can use them to force resolve or reject the promise from outside.
-
-All the chain methods such as then, catch, finally works as expected, but remind that the both resolve, reject method of any chained PassivePromise instance will propagate to the root PassivePromise instance regardless of its depth.
-
-### Common Usage
-
-```javascript
-import PassivePromise from 'passive-promise';
-
-(async () => {
-  const foo = new PassivePromise((resolve, reject) => setTimeout(() => resolve(1), 1000));
-
-  console.log(await foo); // 1 after 1 sec
-
-  const bar = new PassivePromise((resolve, reject) => setTimeout(() => resolve(1), 1000));
-
-  bar.resolve(-1);
-
-  console.log(await bar); // -1 immedietly
-
-  const baz = new PassivePromise((resolve, reject) => setTimeout(() => resolve(1), 1000));
-
-  baz.reject(0) // Unhandled promise rejection.
-})()
-
-(async () => {
-  const foo = new PassivePromise(() => {})
-    .then((fulfilled) => console.log(fulfilled));
-  
-  foo.resolve(1); // 1
-
-  
-  const bar = new PassivePromise(() => {})
-    .then((fulfilled) => console.log(fulfilled))
-    .catch((errored) => console.log('Promise rejected!', errored));
-  
-  bar.reject(-1); // Promise rejected! -1
-
-  const baz = new PassivePromise(() => {})
-    .then(
-      (fulfilled) => console.log(fulfilled),
-      (errored) => console.log('Promise rejected!', errored),
-    )
-    .finally(() => console.log('Finally.'));
-
-  baz.reject(-1) // Promise rejected! -1 Finally.
-})()
-
-```
-
-### Chain propagation
-
-
-```javascript
-import PassivePromise from 'passive-promise';
-
-(async () => {
-  const chainedPromise = new PassivePromise(() => {})
-    .then((firstRes) => {
-      console.log('first.');
-    })
-    .then((secondRes) => {
-      console.log('second.');
-    })
-    .then((thirdRes) => {
-      console.log('third.');
-    });
-  
-  chainedPromise.resolve(1); 
-
-  await chainedPromise; // first. second. third.
-
-  const middleChain = new PassivePromise(() => {})
-    .then((firstRes) => {
-      console.log('first.');
-    })
-    .then((secondRes) => {
-      console.log('second.');
-    });
-
-  middleChain.then((thirdRes) => {
-    console.log('third.');
-  });
-
-  // Regardless of position of PassivePromise instance in the chained promises, they always resolve root promise in the chain.
-  middleChain.resolve(1);
-
-  await middleChain; // first. second. third.
-  
-  // If you want to resolve the instance itself rather than root instance, use passiveResolve() and passiveReject() instead.
-
-  const anotherChain = new PassivePromise(() => {})
-    .then((firstRes) => {
-      console.log('first.');
-    })
-    .then((secondRes) => {
-      console.log('second.');
-    });
-
-  anotherChain.then((thirdRes) => {
-    console.log('third.');
-  });
-
-  // We want to directly resolve this promise rather than the whole promise chain here.
-  anotherChain.passiveResolve(1);
-
-  await anotherChain; // third.
-})()
-```