@jujulego/jill 1.1.15 → 1.1.19

package/dist/myr/myr-client.js

@@ -5,72 +5,225 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.MyrClient = void 0;
 
+var _jillCore = require("@jujulego/jill-core");
+
 var _jillMyr = require("@jujulego/jill-myr");
 
+var _repeater = require("@repeaterjs/repeater");
+
 var _child_process = require("child_process");
 
+var _graphql = require("graphql");
+
 var _graphqlRequest = require("graphql-request");
 
+var _graphqlWs = require("graphql-ws");
+
+var _graphqlTag = _interopRequireDefault(require("graphql-tag"));
+
 var _path = _interopRequireDefault(require("path"));
 
-var _logger = require("../logger");
+var _ws = _interopRequireDefault(require("ws"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+var __awaiter = void 0 && (void 0).__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) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+
+var __asyncValues = void 0 && (void 0).__asyncValues || function (o) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator],
+      i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () {
+    return this;
+  }, i);
+
+  function verb(n) {
+    i[n] = o[n] && function (v) {
+      return new Promise(function (resolve, reject) {
+        v = o[n](v), settle(resolve, reject, v.done, v.value);
+      });
+    };
+  }
+
+  function settle(resolve, reject, d, v) {
+    Promise.resolve(v).then(function (v) {
+      resolve({
+        value: v,
+        done: d
+      });
+    }, reject);
+  }
+};
+
+var __await = void 0 && (void 0).__await || function (v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+};
+
+var __asyncGenerator = void 0 && (void 0).__asyncGenerator || function (thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []),
+      i,
+      q = [];
+  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () {
+    return this;
+  }, i;
+
+  function verb(n) {
+    if (g[n]) i[n] = function (v) {
+      return new Promise(function (a, b) {
+        q.push([n, v, a, b]) > 1 || resume(n, v);
+      });
+    };
+  }
+
+  function resume(n, v) {
+    try {
+      step(g[n](v));
+    } catch (e) {
+      settle(q[0][3], e);
+    }
+  }
+
+  function step(r) {
+    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+  }
+
+  function fulfill(value) {
+    resume("next", value);
+  }
+
+  function reject(value) {
+    resume("throw", value);
+  }
+
+  function settle(f, v) {
+    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+  }
+};
 
 // Class
 class MyrClient {
-  // Attributes
   // Constructor
   constructor(project) {
-    this.project = project;
+    this.project = project; // Attributes
 
-    _defineProperty(this, "_logger", _logger.logger.child({
+    this._logger = _jillCore.logger.child({
       context: MyrClient.name
-    }));
+    });
+    this._endpoint = 'http://localhost:5001/graphql';
+    this._qclient = new _graphqlRequest.GraphQLClient(this._endpoint);
+    this._sclient = (0, _graphqlWs.createClient)({
+      url: this._endpoint.replace(/^http/, 'ws'),
+      webSocketImpl: _ws.default,
+      lazy: true
+    });
+  } // Methods
 
-    _defineProperty(this, "_endpoint", 'http://localhost:5001/graphql');
 
-    _defineProperty(this, "_qclient", new _graphqlRequest.GraphQLClient(this._endpoint));
-  } // Methods
+  _autoStart(fn) {
+    return __awaiter(this, void 0, void 0, function* () {
+      try {
+        return yield fn();
+      } catch (error) {
+        if (error.code !== 'ECONNREFUSED') throw error; // Start myr if connection impossible
 
+        this._logger.verbose('Unable to connect to myr server, trying to start it');
 
-  async _autoStart(fn) {
-    try {
-      return await fn();
-    } catch (error) {
-      if (error.code !== 'ECONNREFUSED') throw error; // Start myr if connection impossible
+        yield this.start(); // Retry
+
+        return yield fn();
+      }
+    });
+  }
 
-      this._logger.verbose('Unable to connect to myr server, trying to start it');
+  _subscription(query, variables) {
+    return new _repeater.Repeater((push, stop) => {
+      this._sclient.subscribe({
+        query: (0, _graphql.print)(query),
+        variables
+      }, {
+        next(value) {
+          push(value.data).then();
+        },
 
-      await this.start(); // Retry
+        error(error) {
+          stop(error);
+        },
 
-      return await fn();
-    }
+        complete() {
+          stop();
+        }
+
+      });
+    });
   }
 
   start() {
+    var _a, _b;
+
     const child = (0, _child_process.fork)(_path.default.resolve(__dirname, './myr.process'), [], {
       cwd: this.project.root,
       detached: true,
       stdio: ['ignore', 'pipe', 'pipe', 'ipc']
     }); // Transmit logs to logger
 
-    child.stdout?.on('data', msg => {
+    (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', msg => {
       for (const line of msg.toString('utf-8').split('\n')) {
         if (!line) continue;
-        const {
+
+        const _a = JSON.parse(line),
+              {
           level,
-          message,
-          ...meta
-        } = JSON.parse(line);
+          message
+        } = _a,
+              meta = __rest(_a, ["level", "message"]);
 
-        _logger.logger.log(level, message, meta);
+        _jillCore.logger.log(level, message, meta);
       }
     });
-    child.stderr?.on('data', msg => {
-      _logger.logger.error(msg.toString('utf-8'));
+    (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', msg => {
+      _jillCore.logger.error(msg.toString('utf-8'));
     }); // Start server
 
     return new Promise((resolve, reject) => {
@@ -88,368 +241,138 @@ class MyrClient {
     });
   }
 
-  async stop() {
-    try {
-      await this._qclient.request({
-        "kind": "Document",
-        "definitions": [{
-          "kind": "OperationDefinition",
-          "operation": "mutation",
-          "name": {
-            "kind": "Name",
-            "value": "Shutdown"
-          },
-          "variableDefinitions": [],
-          "directives": [],
-          "selectionSet": {
-            "kind": "SelectionSet",
-            "selections": [{
-              "kind": "Field",
-              "name": {
-                "kind": "Name",
-                "value": "shutdown"
-              },
-              "arguments": [],
-              "directives": []
-            }]
-          }
-        }],
-        "loc": {
-          "start": 0,
-          "end": 64,
-          "source": {
-            "body": "\n        mutation Shutdown {\n            shutdown\n        }\n    ",
-            "name": "GraphQL request",
-            "locationOffset": {
-              "line": 1,
-              "column": 1
-            }
-          }
+  stop() {
+    return __awaiter(this, void 0, void 0, function* () {
+      try {
+        yield this._qclient.request((0, _graphqlTag.default)`
+        mutation Shutdown {
+            shutdown
         }
-      });
-      return true;
-    } catch (error) {
-      if (error.code !== 'ECONNREFUSED') throw error;
-      return false;
-    }
+    `);
+        return true;
+      } catch (error) {
+        if (error.code !== 'ECONNREFUSED') throw error;
+        return false;
+      }
+    });
   }
 
-  async tasks() {
-    return await this._autoStart(async () => {
-      const {
-        tasks
-      } = await this._qclient.request({
-        "kind": "Document",
-        "definitions": [{
-          "kind": "OperationDefinition",
-          "operation": "query",
-          "name": {
-            "kind": "Name",
-            "value": "Tasks"
-          },
-          "variableDefinitions": [],
-          "directives": [],
-          "selectionSet": {
-            "kind": "SelectionSet",
-            "selections": [{
-              "kind": "Field",
-              "name": {
-                "kind": "Name",
-                "value": "tasks"
-              },
-              "arguments": [],
-              "directives": [],
-              "selectionSet": {
-                "kind": "SelectionSet",
-                "selections": [{
-                  "kind": "FragmentSpread",
-                  "name": {
-                    "kind": "Name",
-                    "value": "Task"
-                  },
-                  "directives": []
-                }]
+  tasks() {
+    return __awaiter(this, void 0, void 0, function* () {
+      return yield this._autoStart(() => __awaiter(this, void 0, void 0, function* () {
+        const {
+          tasks
+        } = yield this._qclient.request((0, _graphqlTag.default)`
+          query Tasks {
+              tasks {
+                  ...Task
               }
-            }]
-          }
-        }].concat(_jillMyr.TaskFragment.definitions).reduce((acc, definition) => definition.kind === 'FragmentDefinition' && acc.find(curDef => curDef.kind === 'FragmentDefinition' && curDef.name.value === definition.name.value) ? acc : acc.concat(definition), []),
-        "loc": {
-          "start": 0,
-          "end": 119,
-          "source": {
-            "body": "\n          query Tasks {\n              tasks {\n                  ...Task\n              }\n          }\n\n          \n      ",
-            "name": "GraphQL request",
-            "locationOffset": {
-              "line": 1,
-              "column": 1
-            }
           }
-        }
-      });
-      return tasks;
+
+          ${_jillMyr.TaskFragment}
+      `);
+        return tasks;
+      }));
     });
   }
 
-  async spawn(cwd, cmd, args = []) {
-    return await this._autoStart(async () => {
-      const {
-        spawn
-      } = await this._qclient.request({
-        "kind": "Document",
-        "definitions": [{
-          "kind": "OperationDefinition",
-          "operation": "mutation",
-          "name": {
-            "kind": "Name",
-            "value": "Spawn"
-          },
-          "variableDefinitions": [{
-            "kind": "VariableDefinition",
-            "variable": {
-              "kind": "Variable",
-              "name": {
-                "kind": "Name",
-                "value": "cwd"
-              }
-            },
-            "type": {
-              "kind": "NonNullType",
-              "type": {
-                "kind": "NamedType",
-                "name": {
-                  "kind": "Name",
-                  "value": "String"
-                }
-              }
-            },
-            "directives": []
-          }, {
-            "kind": "VariableDefinition",
-            "variable": {
-              "kind": "Variable",
-              "name": {
-                "kind": "Name",
-                "value": "cmd"
-              }
-            },
-            "type": {
-              "kind": "NonNullType",
-              "type": {
-                "kind": "NamedType",
-                "name": {
-                  "kind": "Name",
-                  "value": "String"
-                }
-              }
-            },
-            "directives": []
-          }, {
-            "kind": "VariableDefinition",
-            "variable": {
-              "kind": "Variable",
-              "name": {
-                "kind": "Name",
-                "value": "args"
-              }
-            },
-            "type": {
-              "kind": "NonNullType",
-              "type": {
-                "kind": "ListType",
-                "type": {
-                  "kind": "NonNullType",
-                  "type": {
-                    "kind": "NamedType",
-                    "name": {
-                      "kind": "Name",
-                      "value": "String"
-                    }
-                  }
-                }
-              }
-            },
-            "directives": []
-          }],
-          "directives": [],
-          "selectionSet": {
-            "kind": "SelectionSet",
-            "selections": [{
-              "kind": "Field",
-              "name": {
-                "kind": "Name",
-                "value": "spawn"
-              },
-              "arguments": [{
-                "kind": "Argument",
-                "name": {
-                  "kind": "Name",
-                  "value": "cwd"
-                },
-                "value": {
-                  "kind": "Variable",
-                  "name": {
-                    "kind": "Name",
-                    "value": "cwd"
-                  }
-                }
-              }, {
-                "kind": "Argument",
-                "name": {
-                  "kind": "Name",
-                  "value": "cmd"
-                },
-                "value": {
-                  "kind": "Variable",
-                  "name": {
-                    "kind": "Name",
-                    "value": "cmd"
-                  }
-                }
-              }, {
-                "kind": "Argument",
-                "name": {
-                  "kind": "Name",
-                  "value": "args"
-                },
-                "value": {
-                  "kind": "Variable",
-                  "name": {
-                    "kind": "Name",
-                    "value": "args"
-                  }
-                }
-              }],
-              "directives": [],
-              "selectionSet": {
-                "kind": "SelectionSet",
-                "selections": [{
-                  "kind": "FragmentSpread",
-                  "name": {
-                    "kind": "Name",
-                    "value": "Task"
-                  },
-                  "directives": []
-                }]
+  spawn(cwd, cmd, args = []) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return yield this._autoStart(() => __awaiter(this, void 0, void 0, function* () {
+        const {
+          spawn
+        } = yield this._qclient.request((0, _graphqlTag.default)`
+          mutation Spawn($cwd: String!, $cmd: String!, $args: [String!]!) {
+              spawn(cwd: $cwd, cmd: $cmd, args: $args) {
+                  ...Task
               }
-            }]
-          }
-        }].concat(_jillMyr.TaskFragment.definitions).reduce((acc, definition) => definition.kind === 'FragmentDefinition' && acc.find(curDef => curDef.kind === 'FragmentDefinition' && curDef.name.value === definition.name.value) ? acc : acc.concat(definition), []),
-        "loc": {
-          "start": 0,
-          "end": 206,
-          "source": {
-            "body": "\n          mutation Spawn($cwd: String!, $cmd: String!, $args: [String!]!) {\n              spawn(cwd: $cwd, cmd: $cmd, args: $args) {\n                  ...Task\n              }\n          }\n\n          \n      ",
-            "name": "GraphQL request",
-            "locationOffset": {
-              "line": 1,
-              "column": 1
-            }
           }
-        }
-      }, {
-        cwd,
-        cmd,
-        args
-      });
-      return spawn;
+
+          ${_jillMyr.TaskFragment}
+      `, {
+          cwd,
+          cmd,
+          args
+        });
+        return spawn;
+      }));
     });
   }
 
-  async spawnScript(wks, script, args = []) {
-    return await this.spawn(wks.cwd, await wks.project.packageManager(), [script, ...args]);
+  spawnScript(wks, script, args = []) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return yield this.spawn(wks.cwd, yield wks.project.packageManager(), [script, ...args]);
+    });
   }
 
-  async kill(id) {
-    return await this._autoStart(async () => {
-      const {
-        kill
-      } = await this._qclient.request({
-        "kind": "Document",
-        "definitions": [{
-          "kind": "OperationDefinition",
-          "operation": "mutation",
-          "name": {
-            "kind": "Name",
-            "value": "Kill"
-          },
-          "variableDefinitions": [{
-            "kind": "VariableDefinition",
-            "variable": {
-              "kind": "Variable",
-              "name": {
-                "kind": "Name",
-                "value": "id"
-              }
-            },
-            "type": {
-              "kind": "NonNullType",
-              "type": {
-                "kind": "NamedType",
-                "name": {
-                  "kind": "Name",
-                  "value": "ID"
-                }
-              }
-            },
-            "directives": []
-          }],
-          "directives": [],
-          "selectionSet": {
-            "kind": "SelectionSet",
-            "selections": [{
-              "kind": "Field",
-              "name": {
-                "kind": "Name",
-                "value": "kill"
-              },
-              "arguments": [{
-                "kind": "Argument",
-                "name": {
-                  "kind": "Name",
-                  "value": "id"
-                },
-                "value": {
-                  "kind": "Variable",
-                  "name": {
-                    "kind": "Name",
-                    "value": "id"
-                  }
-                }
-              }],
-              "directives": [],
-              "selectionSet": {
-                "kind": "SelectionSet",
-                "selections": [{
-                  "kind": "FragmentSpread",
-                  "name": {
-                    "kind": "Name",
-                    "value": "Task"
-                  },
-                  "directives": []
-                }]
-              }
-            }]
+  logs() {
+    return __awaiter(this, void 0, void 0, function* () {
+      try {
+        const res = yield this._qclient.request((0, _graphqlTag.default)`
+          query Logs {
+              logs
+          }
+      `);
+        return res.logs;
+      } catch (error) {
+        if (error.code !== 'ECONNREFUSED') throw error;
+        return [];
+      }
+    });
+  }
+
+  logs$() {
+    return __asyncGenerator(this, arguments, function* logs$_1() {
+      var e_1, _a;
+
+      try {
+        try {
+          for (var _b = __asyncValues(this._subscription((0, _graphqlTag.default)`subscription Logs { log }`, {})), _c; _c = yield __await(_b.next()), !_c.done;) {
+            const {
+              log
+            } = _c.value;
+            yield yield __await(log);
           }
-        }].concat(_jillMyr.TaskFragment.definitions).reduce((acc, definition) => definition.kind === 'FragmentDefinition' && acc.find(curDef => curDef.kind === 'FragmentDefinition' && curDef.name.value === definition.name.value) ? acc : acc.concat(definition), []),
-        "loc": {
-          "start": 0,
-          "end": 139,
-          "source": {
-            "body": "\n          mutation Kill($id: ID!) {\n              kill(id: $id) {\n                  ...Task\n              }\n          }\n\n          \n      ",
-            "name": "GraphQL request",
-            "locationOffset": {
-              "line": 1,
-              "column": 1
-            }
+        } catch (e_1_1) {
+          e_1 = {
+            error: e_1_1
+          };
+        } finally {
+          try {
+            if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
+          } finally {
+            if (e_1) throw e_1.error;
           }
         }
-      }, {
-        id
-      });
-      return kill;
+      } catch (error) {
+        if (error.code !== 'ECONNREFUSED') throw error;
+        return yield __await(void 0);
+      }
+    });
+  }
+
+  kill(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return yield this._autoStart(() => __awaiter(this, void 0, void 0, function* () {
+        const {
+          kill
+        } = yield this._qclient.request((0, _graphqlTag.default)`
+          mutation Kill($id: ID!) {
+              kill(id: $id) {
+                  ...Task
+              }
+          }
+
+          ${_jillMyr.TaskFragment}
+      `, {
+          id
+        });
+        return kill;
+      }));
     });
   }
 
 }
 
-exports.MyrClient = MyrClient;
+exports.MyrClient = MyrClient;
+//# sourceMappingURL=myr-client.js.map