@wocker/ws 1.0.1 → 1.0.2

package/lib/services/DockerService.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { DI, DockerService as CoreDockerService, DockerServiceParams as Params } from "@wocker/core";
+import Docker, { Container } from "dockerode";
+declare class DockerService extends CoreDockerService {
+    protected docker: Docker;
+    constructor(di: DI);
+    createContainer(params: Params.CreateContainer): Promise<Container>;
+    getContainer(name: string): Promise<Container | null>;
+    removeContainer(name: string): Promise<void>;
+    buildImage(params: Params.BuildImage): Promise<void>;
+    imageExists(tag: string): Promise<boolean>;
+    imageRm(tag: string): Promise<void>;
+    pullImage(tag: string): Promise<void>;
+    attachStream(stream: NodeJS.ReadWriteStream): Promise<void>;
+}
+export { DockerService };

package/lib/services/DockerService.js

@@ -0,0 +1,220 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DockerService = void 0;
+var _core = require("@wocker/core");
+var _dockerode = _interopRequireDefault(require("dockerode"));
+var _makes = require("../makes");
+var _utils = require("../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class DockerService extends _core.DockerService {
+  constructor(di) {
+    super();
+    this.docker = new _dockerode.default({
+      socketPath: "/var/run/docker.sock"
+    });
+  }
+  async createContainer(params) {
+    const {
+      name,
+      tty,
+      image,
+      projectId,
+      restart,
+      ulimits,
+      extraHosts,
+      networkMode,
+      links = [],
+      env = {},
+      volumes = [],
+      ports = [],
+      cmd = []
+    } = params;
+    const network = this.docker.getNetwork("workspace");
+    try {
+      await network.inspect();
+    } catch (err) {
+      if (err.statusCode === 404) {
+        await this.docker.createNetwork({
+          Name: "workspace"
+        });
+      }
+    }
+    await this.pullImage(image);
+    return this.docker.createContainer({
+      name,
+      Image: image,
+      Hostname: name,
+      Labels: {
+        ...(projectId ? {
+          projectId
+        } : {})
+      },
+      AttachStdin: true,
+      AttachStdout: true,
+      AttachStderr: true,
+      OpenStdin: true,
+      StdinOnce: false,
+      Tty: tty,
+      Cmd: cmd,
+      Env: Object.keys(env).map(key => {
+        const value = env[key];
+        return `${key}=${value}`;
+      }),
+      ExposedPorts: ports.reduce((res, value) => {
+        const [,, containerPort] = /(\d+):(\d+)/.exec(value) || [];
+        if (containerPort) {
+          res[`${containerPort}/tcp`] = {};
+        }
+        return res;
+      }, {}),
+      HostConfig: {
+        NetworkMode: networkMode,
+        ExtraHosts: extraHosts,
+        Ulimits: ulimits ? Object.keys(ulimits).reduce((res, name) => {
+          return [...res, {
+            Name: name,
+            Hard: ulimits[name].hard,
+            Soft: ulimits[name].soft
+          }];
+        }, []) : [],
+        ...(restart ? {
+          RestartPolicy: {
+            Name: restart
+          }
+        } : {}),
+        Binds: volumes,
+        PortBindings: ports.reduce((res, value) => {
+          const [, hostPort, containerPort] = /(\d+):(\d+)/.exec(value) || [];
+          if (hostPort && containerPort) {
+            res[`${containerPort}/tcp`] = [{
+              HostPort: hostPort
+            }];
+          }
+          return res;
+        }, {})
+      },
+      NetworkingConfig: {
+        EndpointsConfig: networkMode === "host" ? {} : {
+          workspace: {
+            Links: links
+          }
+        }
+      }
+    });
+  }
+  async getContainer(name) {
+    const containers = await this.docker.listContainers({
+      all: true,
+      filters: {
+        name: [name]
+      }
+    });
+    const container = containers.find(container => {
+      return container.Names.indexOf("/" + name) >= 0;
+    });
+    if (container) {
+      return this.docker.getContainer(container.Id);
+    }
+    return null;
+  }
+  async removeContainer(name) {
+    const container = await this.getContainer(name);
+    if (!container) {
+      return;
+    }
+    const {
+      State: {
+        Status
+      }
+    } = await container.inspect();
+    if (Status === "running" || Status === "restarting") {
+      try {
+        await container.stop();
+      } catch (err) {
+        _core.Logger.error("DockerService.removeContainer", err.message);
+      }
+    }
+    try {
+      await container.remove();
+    } catch (err) {
+      _core.Logger.error("DockerService.removeContainer: ", err.message);
+    }
+  }
+  async buildImage(params) {
+    const {
+      tag,
+      labels = {},
+      buildArgs = {},
+      context,
+      src
+    } = params;
+    const files = await _makes.FS.readdirFiles(context, {
+      recursive: true
+    });
+    const stream = await this.docker.buildImage({
+      context,
+      src: files
+    }, {
+      t: tag,
+      labels,
+      buildargs: Object.keys(buildArgs).reduce((res, key) => {
+        res[key] = typeof buildArgs[key] !== "string" ? buildArgs[key].toString() : buildArgs[key];
+        return res;
+      }, {}),
+      dockerfile: src
+    });
+    await (0, _utils.followProgress)(stream);
+  }
+  async imageExists(tag) {
+    const image = this.docker.getImage(tag);
+    try {
+      await image.inspect();
+      return true;
+    } catch (ignore) {
+      return false;
+    }
+  }
+  async imageRm(tag) {
+    const image = await this.docker.getImage(tag);
+    if (!image) {
+      return;
+    }
+    await image.remove();
+  }
+  async pullImage(tag) {
+    const exists = await this.imageExists(tag);
+    if (exists) {
+      return;
+    }
+    const stream = await this.docker.pull(tag);
+    await (0, _utils.followProgress)(stream);
+  }
+  async attachStream(stream) {
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    process.stdin.pipe(stream);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    stream.setEncoding("utf8");
+    stream.pipe(process.stdout);
+    const end = () => {
+      process.stdin.pause();
+      process.stdin.unpipe(stream);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      stream.unpipe(process.stdout);
+    };
+    await new Promise((resolve, reject) => {
+      stream.on("end", end);
+      stream.on("error", end);
+      stream.on("end", resolve);
+      stream.on("error", reject);
+    });
+  }
+}
+exports.DockerService = DockerService;

package/lib/services/LogService.d.ts

@@ -0,0 +1,11 @@
+import { DI, AppConfigService } from "@wocker/core";
+declare class LogService {
+    protected appConfigService: AppConfigService;
+    constructor(di: DI);
+    log(...data: any[]): void;
+    info(...data: any[]): void;
+    warning(...data: any[]): void;
+    error(...data: any[]): void;
+    protected _log(type: string, ...data: any[]): void;
+}
+export { LogService };

package/lib/services/LogService.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LogService = void 0;
+var _core = require("@wocker/core");
+var _format = _interopRequireDefault(require("date-fns/format"));
+var _makes = require("../makes");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class LogService {
+  constructor(di) {
+    this.appConfigService = di.resolveService(_core.AppConfigService);
+  }
+  log(...data) {
+    this._log("log", ...data);
+  }
+  info(...data) {
+    this._log("info", ...data);
+  }
+  warning(...data) {
+    this._log("warning", ...data);
+  }
+  error(...data) {
+    this._log("error", ...data);
+  }
+  _log(type, ...data) {
+    const time = (0, _format.default)(new Date(), "yyyy-MM-dd hh:mm:ss");
+    const logPath = this.appConfigService.dataPath("ws.log");
+    const logData = data.map(item => {
+      return typeof item !== "string" ? JSON.stringify(item) : item;
+    }).join(" ");
+    if (!_makes.FS.existsSync(logPath)) {
+      _makes.FS.writeFileSync(logPath, "");
+    }
+    _makes.FS.appendFileSync(logPath, `[${time}] ${type}: ${logData}\n`);
+  }
+}
+exports.LogService = LogService;

package/lib/services/PluginService.d.ts

@@ -0,0 +1,10 @@
+import { DI, Cli, Controller } from "@wocker/core";
+declare class PluginService {
+    protected di: DI;
+    protected cli: Cli;
+    constructor(di: DI);
+    use(Constructor: {
+        new (...params: any[]): Controller;
+    }): void;
+}
+export { PluginService };

package/lib/services/PluginService.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PluginService = void 0;
+var _core = require("@wocker/core");
+class PluginService {
+  constructor(di) {
+    this.di = di;
+    this.cli = di.resolveService(_core.Cli);
+  }
+  use(Constructor) {
+    const controller = new Constructor(this.di);
+    controller.install(this.cli);
+  }
+}
+exports.PluginService = PluginService;

package/lib/services/PresetService.d.ts

@@ -0,0 +1,9 @@
+import { DI, PresetService as CorePresetService, PresetServiceSearchOptions as SearchOptions, Preset, EnvConfig } from "@wocker/core";
+declare class PresetService extends CorePresetService {
+    constructor(di: DI);
+    getImageName(preset: Preset, buildArgs?: EnvConfig): string;
+    save(preset: Preset): Promise<void>;
+    get(name: string): Promise<Preset>;
+    search(options?: SearchOptions): Promise<Preset[]>;
+}
+export { PresetService };

package/lib/services/PresetService.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PresetService = void 0;
+var _core = require("@wocker/core");
+var _md = _interopRequireDefault(require("md5"));
+var _makes = require("../makes");
+var _env = require("../env");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class PresetService extends _core.PresetService {
+  constructor(di) {
+    super();
+  }
+  getImageName(preset, buildArgs = {}) {
+    const rawValues = [];
+    const hashValues = [];
+    Object.keys(preset.buildArgsOptions || {}).forEach(key => {
+      const hash = (preset.buildArgsOptions[key] || {}).hash || true;
+      const value = buildArgs[key];
+      if (hash) {
+        hashValues.push(value);
+      } else {
+        rawValues.push(value);
+      }
+    });
+    const version = [...rawValues, (0, _md.default)(hashValues.join(",")).substr(0, 6)].filter(value => {
+      return !!value;
+    }).join("-");
+    return `ws-preset-${preset.name}:${version}`;
+  }
+  async save(preset) {
+    //
+  }
+  async get(name) {
+    const config = await _makes.FS.readJSON(_env.PRESETS_DIR, name, "config.json");
+    return new _core.Preset({
+      name,
+      ...config
+    });
+  }
+  async search(options = {}) {
+    const {
+      name
+    } = options;
+    const presets = [];
+    const dirs = await _makes.FS.readdir(_env.PRESETS_DIR);
+    for (const dir of dirs) {
+      if (name && name !== dir) {
+        continue;
+      }
+      const config = await _makes.FS.readJSON(_env.PRESETS_DIR, dir, "config.json");
+      const preset = new _core.Preset({
+        name: dir,
+        ...config
+      });
+      presets.push(preset);
+    }
+    return presets;
+  }
+}
+exports.PresetService = PresetService;

package/lib/services/ProjectService.d.ts

@@ -1,13 +1,14 @@
-import { Project } from "src/models";
-import { AppConfigService } from "./AppConfigService";
-import { AppEventsService } from "./AppEventsService";
-declare class ProjectService {
-    protected appConfigService: AppConfigService;
-    protected appEventsService: AppEventsService;
-    constructor(appConfigService: AppConfigService, appEventsService: AppEventsService);
+import { DI, AppConfigService as CoreAppConfigService, AppEventsService as CoreAppEventsService, DockerService, ProjectService as CoreProjectService, ProjectServiceSearchParams as SearchParams, Project } from "@wocker/core";
+declare class ProjectService extends CoreProjectService {
+    protected appConfigService: CoreAppConfigService;
+    protected appEventsService: CoreAppEventsService;
+    protected dockerService: DockerService;
+    constructor(di: DI);
     cdProject(name: string): Promise<void>;
     get(): Promise<Project>;
     start(): Promise<void>;
     stop(): Promise<void>;
+    save(project: Project): Promise<void>;
+    search(params?: Partial<SearchParams>): Promise<Project[]>;
 }
 export { ProjectService };

package/lib/services/ProjectService.js

@@ -4,18 +4,20 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ProjectService = void 0;
+var _core = require("@wocker/core");
 var Path = _interopRequireWildcard(require("path"));
 var _makes = require("../makes");
-var _models = require("../models");
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-class ProjectService {
-  constructor(appConfigService, appEventsService) {
-    this.appConfigService = appConfigService;
-    this.appEventsService = appEventsService;
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+class ProjectService extends _core.ProjectService {
+  constructor(di) {
+    super();
+    this.appConfigService = di.resolveService(_core.AppConfigService);
+    this.appEventsService = di.resolveService(_core.AppEventsService);
+    this.dockerService = di.resolveService(_core.DockerService);
   }
   async cdProject(name) {
-    const project = await _models.Project.searchOne({
+    const project = await _core.Project.searchOne({
       name
     });
     if (!project) {
@@ -24,8 +26,8 @@ class ProjectService {
     this.appConfigService.setPWD(project.path);
   }
   async get() {
-    const project = await _models.Project.searchOne({
-      src: this.appConfigService.getPWD()
+    const project = await _core.Project.searchOne({
+      path: this.appConfigService.getPWD()
     });
     if (!project) {
       throw new Error("Project not found");
@@ -49,7 +51,7 @@ class ProjectService {
     }
     await this.appEventsService.emit("project:beforeStart", project);
     const containerName = `${project.name}.workspace`;
-    let container = await _makes.Docker.getContainer(containerName);
+    let container = await this.dockerService.getContainer(containerName);
     if (!container) {
       container = await _makes.Docker.createContainer({
         name: containerName,
@@ -62,7 +64,8 @@ class ProjectService {
           const regVolume = /^([^:]+):([^:]+)(?::([^:]+))?$/;
           const [, source, destination, options] = regVolume.exec(volume);
           return `${Path.join(this.appConfigService.getPWD(), source)}:${destination}` + (options ? `:${options}` : "");
-        })
+        }),
+        ports: project.ports || []
       });
     } else {
       process.stdout.write("Container already exists\n");
@@ -87,5 +90,54 @@ class ProjectService {
       await _makes.Docker.removeContainer(`${project.name}.workspace`);
     }
   }
+  async save(project) {
+    if (!project.name) {
+      throw new Error("Project should has a name");
+    }
+    if (!project.path) {
+      throw new Error("Project should has a path");
+    }
+    if (!project.id) {
+      project.id = project.name;
+    }
+    const projectDirPath = this.appConfigService.dataPath("projects", project.id);
+    const configPath = this.appConfigService.dataPath("projects", project.id, "config.json");
+    if (!_makes.FS.existsSync(projectDirPath)) {
+      await _makes.FS.mkdir(projectDirPath, {
+        recursive: true
+      });
+    }
+    await this.appConfigService.setProjectConfig(project.id, project.path);
+    await _makes.FS.writeJSON(configPath, project);
+  }
+  async search(params = {}) {
+    const {
+      id,
+      name,
+      path
+    } = params;
+    const {
+      projects: configs
+    } = await this.appConfigService.getAppConfig();
+    const projects = [];
+    for (const config of configs) {
+      if (id && config.id !== id) {
+        continue;
+      }
+      if (path && config.src !== path) {
+        continue;
+      }
+      const projectData = await _makes.FS.readJSON(this.appConfigService.dataPath("projects", config.id, "config.json"));
+      if (name && projectData.name !== name) {
+        continue;
+      }
+      const project = _core.Project.fromObject({
+        id: config.id,
+        ...projectData
+      });
+      projects.push(project);
+    }
+    return projects;
+  }
 }
 exports.ProjectService = ProjectService;

package/lib/services/index.d.ts

@@ -1,3 +1,7 @@
 export * from "./AppConfigService";
 export * from "./AppEventsService";
+export * from "./DockerService";
+export * from "./LogService";
+export * from "./PluginService";
+export * from "./PresetService";
 export * from "./ProjectService";

package/lib/services/index.js

@@ -25,6 +25,50 @@ Object.keys(_AppEventsService).forEach(function (key) {
     }
   });
 });
+var _DockerService = require("./DockerService");
+Object.keys(_DockerService).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _DockerService[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _DockerService[key];
+    }
+  });
+});
+var _LogService = require("./LogService");
+Object.keys(_LogService).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _LogService[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _LogService[key];
+    }
+  });
+});
+var _PluginService = require("./PluginService");
+Object.keys(_PluginService).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _PluginService[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _PluginService[key];
+    }
+  });
+});
+var _PresetService = require("./PresetService");
+Object.keys(_PresetService).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _PresetService[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _PresetService[key];
+    }
+  });
+});
 var _ProjectService = require("./ProjectService");
 Object.keys(_ProjectService).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/lib/utils/demuxOutput.js

@@ -8,8 +8,6 @@ const demuxOutput = buffer => {
   let nextDataLength = null,
     output = Buffer.from([]);
   while (buffer.length > 0) {
-    // Logger.info(buffer.length, buffer.toString("utf8"));
-
     const header = bufferSlice(8);
     nextDataLength = header.readUInt32BE(4);
     const content = bufferSlice(nextDataLength);

package/lib/utils/exec.d.ts

@@ -1,2 +1,2 @@
-declare const exec: (command: any) => Promise<unknown>;
+declare const exec: (command: string) => Promise<unknown>;
 export { exec };

package/lib/utils/exec.js

@@ -4,12 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.exec = void 0;
+var _core = require("@wocker/core");
 var _child_process = require("child_process");
 var _chalk = _interopRequireDefault(require("chalk"));
-var _Logger = require("../makes/Logger");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const exec = async command => {
-  _Logger.Logger.info(` > ${command.trim().replace(/\s+/g, " ")}`);
+  _core.Logger.info(` > ${command.trim().replace(/\s+/g, " ")}`);
   return new Promise((resolve, reject) => {
     const worker = (0, _child_process.exec)(command, {
       maxBuffer: Infinity
@@ -29,15 +29,14 @@ const exec = async command => {
     }
     if (worker.stderr) {
       worker.stderr.on("data", data => {
-        // process.stdout.write(chalk.red(data));
         process.stderr.write(data);
       });
     }
     worker.on("close", code => {
-      _Logger.Logger.info("close", _chalk.default.red(code));
+      _core.Logger.info("close", _chalk.default.red(code));
     });
     worker.on("exit", code => {
-      _Logger.Logger.info("exit", _chalk.default.red(code));
+      _core.Logger.info("exit", _chalk.default.red(code));
     });
   });
 };

package/lib/utils/fetch.js

@@ -5,8 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.fetch = void 0;
 var https = _interopRequireWildcard(require("https"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 const fetch = async (url, options) => {
   const {
     method = "GET"
@@ -33,5 +33,4 @@ const fetch = async (url, options) => {
     req.end();
   });
 };
-exports.fetch = fetch;
-class Response {}
+exports.fetch = fetch;