@wocker/ws 1.0.2 → 1.0.3

package/lib/services/AppEventsService.js

@@ -1,28 +1,30 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppEventsService = void 0;
-var _core = require("@wocker/core");
-class AppEventsService extends _core.AppEventsService {
-  handles = {};
-  on(event, handle) {
-    this.handles[event] = [...(this.handles[event] || []), handle];
-    return () => {
-      this.handles[event] = this.handles[event].filter(filterHandle => {
-        return filterHandle !== handle;
-      });
-    };
-  }
-  off(event, handle) {
-    //
-  }
-  async emit(event, ...args) {
-    const handles = this.handles[event] || [];
-    for (const i in handles) {
-      await handles[i](...args);
+const core_1 = require("@wocker/core");
+class AppEventsService extends core_1.AppEventsService {
+    constructor() {
+        super(...arguments);
+        this.handles = {};
+    }
+    on(event, handle) {
+        this.handles[event] = [
+            ...this.handles[event] || [],
+            handle
+        ];
+        return () => {
+            this.handles[event] = this.handles[event].filter((filterHandle) => {
+                return filterHandle !== handle;
+            });
+        };
+    }
+    off(event, handle) {
+    }
+    async emit(event, ...args) {
+        const handles = this.handles[event] || [];
+        for (const i in handles) {
+            await handles[i](...args);
+        }
     }
-  }
 }
-exports.AppEventsService = AppEventsService;
+exports.AppEventsService = AppEventsService;

package/lib/services/DockerService.d.ts

@@ -1,7 +1,42 @@
 /// <reference types="node" />
-import { DI, DockerService as CoreDockerService, DockerServiceParams as Params } from "@wocker/core";
 import Docker, { Container } from "dockerode";
-declare class DockerService extends CoreDockerService {
+import { DI } from "../makes";
+declare namespace Params {
+    type CreateContainer = {
+        name: string;
+        image: string;
+        restart?: "always";
+        projectId?: string;
+        tty?: boolean;
+        ulimits?: {
+            [key: string]: {
+                hard?: number;
+                soft?: number;
+            };
+        };
+        links?: string[];
+        env?: {
+            [key: string]: string;
+        };
+        networkMode?: string;
+        extraHosts?: any;
+        volumes?: string[];
+        ports?: string[];
+        cmd?: string[];
+    };
+    type BuildImage = {
+        tag: string;
+        buildArgs?: {
+            [key: string]: string;
+        };
+        labels?: {
+            [key: string]: string;
+        };
+        context: string;
+        src: string;
+    };
+}
+declare class DockerService {
     protected docker: Docker;
     constructor(di: DI);
     createContainer(params: Params.CreateContainer): Promise<Container>;

package/lib/services/DockerService.js

@@ -1,220 +1,200 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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"
+const dockerode_1 = __importDefault(require("dockerode"));
+const utils_1 = require("../utils");
+const makes_1 = require("../makes");
+class DockerService {
+    constructor(di) {
+        this.docker = new dockerode_1.default({
+            socketPath: "/var/run/docker.sock"
         });
-      }
     }
-    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`] = {};
+    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();
         }
-        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
-          }
+        catch (err) {
+            if (err.statusCode === 404) {
+                await this.docker.createNetwork({
+                    Name: "workspace"
+                });
+            }
         }
-      }
-    });
-  }
-  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);
+        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
+                    }
+                }
+            }
+        });
     }
-    return null;
-  }
-  async removeContainer(name) {
-    const container = await this.getContainer(name);
-    if (!container) {
-      return;
+    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;
     }
-    const {
-      State: {
-        Status
-      }
-    } = await container.inspect();
-    if (Status === "running" || Status === "restarting") {
-      try {
-        await container.stop();
-      } catch (err) {
-        _core.Logger.error("DockerService.removeContainer", err.message);
-      }
+    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) {
+                makes_1.Logger.error("DockerService.removeContainer", err.message);
+            }
+        }
+        try {
+            await container.remove();
+        }
+        catch (err) {
+            makes_1.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_1.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_1.followProgress)(stream);
     }
-  }
-  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 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;
+    async imageRm(tag) {
+        const image = await this.docker.getImage(tag);
+        if (!image) {
+            return;
+        }
+        await image.remove();
     }
-    await image.remove();
-  }
-  async pullImage(tag) {
-    const exists = await this.imageExists(tag);
-    if (exists) {
-      return;
+    async pullImage(tag) {
+        const exists = await this.imageExists(tag);
+        if (exists) {
+            return;
+        }
+        const stream = await this.docker.pull(tag);
+        await (0, utils_1.followProgress)(stream);
     }
-    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);
+    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);
+        });
     }
-    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;
+exports.DockerService = DockerService;

package/lib/services/LogService.d.ts

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

package/lib/services/LogService.js

@@ -1,39 +1,38 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 }; }
+const format_1 = __importDefault(require("date-fns/format"));
+const makes_1 = require("../makes");
+const AppConfigService_1 = require("./AppConfigService");
 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, "");
+    constructor(di) {
+        this.appConfigService = di.resolveService(AppConfigService_1.AppConfigService);
+    }
+    log(...data) {
+        this._log("log", ...data);
+    }
+    info(...data) {
+        this._log("info", ...data);
+    }
+    warn(...data) {
+        this._log("warn", ...data);
+    }
+    error(...data) {
+        this._log("error", ...data);
+    }
+    _log(type, ...data) {
+        const time = (0, format_1.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_1.FS.existsSync(logPath)) {
+            makes_1.FS.writeFileSync(logPath, "");
+        }
+        makes_1.FS.appendFileSync(logPath, `[${time}] ${type}: ${logData}\n`);
     }
-    _makes.FS.appendFileSync(logPath, `[${time}] ${type}: ${logData}\n`);
-  }
 }
-exports.LogService = LogService;
+exports.LogService = LogService;

package/lib/services/PluginService.d.ts

@@ -1,4 +1,5 @@
-import { DI, Cli, Controller } from "@wocker/core";
+import { Cli } from "@wocker/core";
+import { DI, Controller } from "../makes";
 declare class PluginService {
     protected di: DI;
     protected cli: Cli;

package/lib/services/PluginService.js

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

package/lib/services/PresetService.d.ts

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