@wocker/ws 1.0.1 → 1.0.2

package/.github/workflows/publish.yml

@@ -0,0 +1,31 @@
+name: Publish
+
+on:
+    release:
+        types:
+            - published
+
+jobs:
+    publish:
+        runs-on: ubuntu-latest
+        environment: publish
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v3
+
+            - name: Set up Node.js
+              uses: actions/setup-node@v3
+              with:
+                node-version: '18'
+                registry-url: 'https://registry.npmjs.org'
+
+            - name: Install dependencies
+              run: npm install
+
+            - name: Build
+              run: npm run build
+
+            - name: Publish to NPM
+              env:
+                NODE_AUTH_TOKEN: ${{ secrets.NODE_AUTH_TOKEN }}
+              run: npm publish

package/README.md

@@ -1,155 +1,29 @@
-# Wocker
+# @wocker/ws
 
 ###### Docker workspace for web projects
 
-## Requirements
+## Installation
 
-- [node.js](https://nodejs.org)
-- [docker](https://www.docker.com)
-
-
-## Usage
-
-### Installation
+**Note:** It is recommended to install Wocker globally to ensure accessibility from any directory in your terminal.
 
 ```shell
 npm i -g @wocker/ws
 ```
 
-### Project initialization
-
-```text
-127.0.0.1 <domain>
-```
-
-```shell
-cd /project-dir
-ws init
-ws domain:add <domain>
-```
-
-### Starting project container
-
-```shell
-ws start -d
-```
-
-Options:
-- --detach, -d -
-
-[//]: # (TODO)
-
-
-### Proxy
-
-```shell
-ws proxy:start
-```
-
-#### Logs
-
-```shell
-ws proxy:logs
-```
-
-
-### Mariadb
-
-#### Installation
-
-To access the following services within the workspace, please add the following entries to your hosts file:
-
-```text
-127.0.0.1 maildev.workspace
-127.0.0.1 dbadmin-mariadb.workspace
-```
-
-
-#### Start Mariadb
-
-```shell
-ws maridb:start
-```
-
-### Backup db
-
-The `mariadb:backup` command is used to create a backup of a MariaDB database.
-
-```shell
-ws mariadb:backup [database]
-```
-
-#### Backup Location
-
-The backup file will be saved in the following directory:
-
-> $WS_DIR/plugins/mariadb/dump/**\[dbname]**/yyyy-MM-dd HH-mm.sql
-
-
-### Delete backup
-
-The `mariadb:delete-backup` command will remove file from `$WS_DIR` directory.
-
-```shell
-ws mariadb:delete-backup [database] [filename]
-```
-
-### Dump
-
-The `mariadb:dump` command is used to dump a MariaDB database to a file.
-
-```shell
-ws mairadb:dump [database] > dump.sql
-```
-
-
-## Technologies
-
-- [typescript](https://www.typescriptlang.org)
-- [dockerode](https://npmjs.org/package/dockerode)
-
-
-## Environments
-
-You can add `WS_DIR` into `.bashrc` for changing ws data path.
-
-```shell
-export WS_DIR="$HOME/.workspace"
-```
-
 
 ### Completion
 
+Wocker comes with shell completion support to enhance your development workflow. To enable shell completion, run the following command:
+
 ```bash
 source <(ws completion script)
 ```
 
+This will enable tab completion for `ws` commands, providing a more convenient and efficient way to interact with the tool.
 
-## Folders structure
 
-```text
-├── bin/
-├── plugins/
-│   ├── localtunnel/
-│   ├── maildev/
-│   ├── mariadb/
-│   └── ngrok/
-├── presets/
-│   ├── apache/
-│   ├── go/
-│   ├── node/
-│   └── shopify/
-├── plugins/
-└── src/
-    ├── makes/
-    │   └── index.ts
-    ├── models/
-    │   └── index.ts
-    ├── types/
-    │   └── index.ts
-    ├── utils/
-    │   └── index.ts
-    ├── App.ts
-    ├── env.ts
-    └── index.ts 
-```
+## Documentation
+
+Wocker is a powerful tool for managing your web project's Docker workspace. It provides a convenient and efficient way to set up and manage your Docker containers.
+
+For more information and detailed usage, please refer to the [documentation](https://kearisp.github.io/wocker)

package/bin/ws.js

@@ -4,10 +4,14 @@ const chalk = require("chalk");
 const {app} = require("../lib/index.js");
 
 
-app.run().then((res) => {
-    if(res) {
-        process.stdout.write(res);
+app.run(process.argv).then((res) => {
+    if(!res) {
+        return;
     }
+
+    process.stdout.write(res);
 }).catch((err) => {
     console.error(chalk.red(err.message));
+
+    // throw err;
 });

package/lib/App.d.ts

@@ -1,13 +1,15 @@
+import { DI, Controller } from "@wocker/core";
 import { Cli } from "@kearisp/cli";
-import { Controller, Plugin } from "src/makes";
 import { AppConfigService } from "src/services";
 export declare class App {
-    protected config: AppConfigService;
+    protected di: DI;
     protected cli: Cli;
-    constructor(config: AppConfigService);
+    protected appConfigService: AppConfigService;
+    constructor();
     install(): void;
-    useController(controller: Controller): void;
-    usePlugin(plugin: Plugin): void;
+    use(Constructor: {
+        new (...params: any[]): Controller;
+    }): void;
     setDebug(status: string): Promise<void>;
     run(): Promise<string>;
 }

package/lib/App.js

@@ -4,31 +4,52 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.App = void 0;
-var Path = _interopRequireWildcard(require("path"));
+var _core = require("@wocker/core");
 var _cli = require("@kearisp/cli");
+var Path = _interopRequireWildcard(require("path"));
 var _env = require("./env");
 var _utils = require("./utils");
 var _makes = require("./makes");
-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; }
+var _services = require("./services");
+var _controllers = require("./controllers");
+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 App {
-  constructor(config) {
-    this.config = config;
-    this.cli = new _cli.Cli(_makes.Logger);
+  constructor() {
+    this.di = new _core.DI();
+    this.appConfigService = new _services.AppConfigService();
+    this.di.registerService(_core.AppConfigService, this.appConfigService);
+    this.di.registerService(_core.AppEventsService, new _services.AppEventsService());
+    this.di.registerService(_core.DockerService, new _services.DockerService(this.di));
+    this.di.registerService(_core.PresetService, new _services.PresetService(this.di));
+    this.di.registerService(_services.PluginService, new _services.PluginService(this.di));
+    this.di.registerService(_core.ProjectService, new _services.ProjectService(this.di));
+    this.di.registerService(_core.LogService, new _services.LogService(this.di));
+    this.di.registerService(_cli.Cli, this.cli);
+    this.cli = new _cli.Cli(_core.Logger);
+    _core.Preset.install(this.di);
+    _core.Project.install(this.di);
+    _core.Logger.install(this.di);
     this.install();
+    this.use(_controllers.ImageController);
+    this.use(_controllers.PluginController);
+    this.use(_controllers.PresetController);
+    this.use(_controllers.ProjectController);
+    this.use(_controllers.ProxyController);
   }
   install() {
     this.cli.command("completion script").help(false).action(() => this.cli.completionScript());
+    this.cli.command("log [...items]").action((options, items) => {
+      _core.Logger.log(...items);
+    });
     this.cli.command("debug <status>").completion("status", () => ["on", "off"]).action(async (options, status) => this.setDebug(status));
   }
-  useController(controller) {
+  use(Constructor) {
+    const controller = new Constructor(this.di);
     controller.install(this.cli);
   }
-  usePlugin(plugin) {
-    plugin.install(this.cli);
-  }
   async setDebug(status) {
-    _makes.Logger.info(`Set debug ${status}`);
+    _core.Logger.info(`Set debug ${status}`);
     await (0, _utils.setConfig)({
       debug: status === "on"
     });
@@ -46,6 +67,19 @@ class App {
     if (!_makes.FS.existsSync(`${_env.DATA_DIR}/projects`)) {
       await _makes.FS.mkdir(`${_env.DATA_DIR}/projects`);
     }
+    const {
+      plugins = []
+    } = await this.appConfigService.getAppConfig();
+    for (const plugin of plugins) {
+      try {
+        const {
+          default: Plugin
+        } = await (specifier => new Promise(r => r(`${specifier}`)).then(s => _interopRequireWildcard(require(s))))(plugin);
+        this.use(Plugin);
+      } catch (err) {
+        _core.Logger.error(err.message);
+      }
+    }
     return this.cli.run(process.argv);
   }
 }

package/lib/controllers/ImageController.d.ts

@@ -1,7 +1,9 @@
+import { AppConfigService, DI } from "@wocker/core";
 import { Cli } from "@kearisp/cli";
 import { Controller } from "src/makes";
 declare class ImageController extends Controller {
-    constructor();
+    protected appConfigService: AppConfigService;
+    constructor(di: DI);
     install(cli: Cli): void;
     list(): Promise<string>;
 }

package/lib/controllers/ImageController.js

@@ -4,12 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ImageController = void 0;
+var _core = require("@wocker/core");
 var _cliTable = _interopRequireDefault(require("cli-table3"));
 var _makes = require("../makes");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class ImageController extends _makes.Controller {
-  constructor() {
+  constructor(di) {
     super();
+    this.appConfigService = di.resolveService(_core.AppConfigService);
   }
   install(cli) {
     super.install(cli);

package/lib/controllers/PluginController.d.ts

@@ -0,0 +1,14 @@
+import { DI, AppConfigService, Controller } from "@wocker/core";
+import { Cli } from "@kearisp/cli";
+import { PluginService } from "src/services";
+type AddOptions = {};
+type RemoveOptions = {};
+declare class PluginController extends Controller {
+    protected appConfigService: AppConfigService;
+    protected pluginService: PluginService;
+    constructor(di: DI);
+    install(cli: Cli): void;
+    add(options: AddOptions, addName: string): Promise<void>;
+    remove(options: RemoveOptions, removeName: string): Promise<void>;
+}
+export { PluginController };

package/lib/controllers/PluginController.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PluginController = void 0;
+var _core = require("@wocker/core");
+var _axios = _interopRequireDefault(require("axios"));
+var _chalk = _interopRequireDefault(require("chalk"));
+var _services = require("../services");
+var _utils = require("../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+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 PluginController extends _core.Controller {
+  constructor(di) {
+    super();
+    this.appConfigService = di.resolveService(_core.AppConfigService);
+    this.pluginService = di.resolveService(_services.PluginService);
+  }
+  install(cli) {
+    super.install(cli);
+    cli.command("plugin:add <name>").action((options, name) => this.add(options, name));
+    cli.command("plugin:remove <name>").action((options, name) => this.remove(options, name));
+  }
+  async add(options, addName) {
+    const [, prefix = "@wocker/", name, suffix = "-plugin"] = /^(@wocker\/)?(\w+)(-plugin)?$/.exec(addName) || [];
+    const fullName = `${prefix}${name}${suffix}`;
+    try {
+      const {
+        default: Plugin
+      } = await (specifier => new Promise(r => r(`${specifier}`)).then(s => _interopRequireWildcard(require(s))))(fullName);
+      this.pluginService.use(Plugin);
+      await this.appConfigService.activatePlugin(fullName);
+      console.info(`Plugin ${fullName} activated`);
+      return;
+    } catch (err) {
+      _core.Logger.error(err.message);
+    }
+    try {
+      const res = await _axios.default.get(`https://registry.npmjs.org/${encodeURIComponent(fullName)}`, {
+        validateStatus: () => true
+      });
+      if (res.status !== 200) {
+        console.error(_chalk.default.red(`Plugin ${fullName} not found`));
+        return;
+      }
+      console.info(`Installing ${fullName}`);
+      await (0, _utils.exec)(`npm install -g ${fullName}`);
+      await this.appConfigService.activatePlugin(fullName);
+    } catch (err) {
+      _core.Logger.error(err.message);
+    }
+  }
+  async remove(options, removeName) {
+    const [, prefix = "@wocker/", name, suffix = "-plugin"] = /^(@wocker\/)?(\w+)(-plugin)?$/.exec(removeName) || [];
+    const fullName = `${prefix}${name}${suffix}`;
+    await this.appConfigService.deactivatePlugin(fullName);
+    console.info(`Plugin ${fullName} deactivated`);
+  }
+}
+exports.PluginController = PluginController;

package/lib/controllers/PresetController.d.ts

@@ -0,0 +1,19 @@
+import { DI, Controller, Cli, AppConfigService, AppEventsService, ProjectService, PresetService, DockerService, Project } from "@wocker/core";
+type BuildParams = {
+    rebuild?: boolean;
+};
+declare class PresetController extends Controller {
+    protected appConfigService: AppConfigService;
+    protected appEventsService: AppEventsService;
+    protected projectService: ProjectService;
+    protected presetService: PresetService;
+    protected dockerService: DockerService;
+    constructor(di: DI);
+    install(cli: Cli): void;
+    presets(): Promise<string[]>;
+    protected onInit(project: Project): Promise<void>;
+    protected onRebuild(project: Project): Promise<void>;
+    protected onBeforeStart(project: Project): Promise<void>;
+    build(options: BuildParams, presetName: string): Promise<void>;
+}
+export { PresetController };

package/lib/controllers/PresetController.js

@@ -0,0 +1,150 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PresetController = void 0;
+var _core = require("@wocker/core");
+var _utils = require("@wocker/utils");
+var Path = _interopRequireWildcard(require("path"));
+var _env = require("../env");
+var _utils2 = require("../utils");
+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 PresetController extends _core.Controller {
+  constructor(di) {
+    super();
+    this.appConfigService = di.resolveService(_core.AppConfigService);
+    this.appEventsService = di.resolveService(_core.AppEventsService);
+    this.projectService = di.resolveService(_core.ProjectService);
+    this.presetService = di.resolveService(_core.PresetService);
+    this.dockerService = di.resolveService(_core.DockerService);
+  }
+  install(cli) {
+    super.install(cli);
+    this.appConfigService.registerProjectType("preset", "Preset");
+    this.appEventsService.on("project:init", project => this.onInit(project));
+    this.appEventsService.on("project:beforeStart", project => this.onBeforeStart(project));
+    this.appEventsService.on("project:rebuild", project => this.onRebuild(project));
+    cli.command("preset:build <preset>").completion("preset", () => this.presets()).option("rebuild", {
+      type: "boolean",
+      alias: "r",
+      description: "Rebuild image"
+    }).action((options, preset) => this.build(options, preset));
+  }
+  async presets() {
+    const presets = await this.presetService.search();
+    return presets.map(preset => {
+      return preset.name;
+    });
+  }
+  async onInit(project) {
+    if (project.type !== "preset") {
+      return;
+    }
+    const presets = await this.presetService.search();
+    if (presets.length === 0) {
+      throw new Error("No presets");
+    }
+    project.preset = await (0, _utils.promptSelect)({
+      message: "Choose preset:",
+      options: presets.map(preset => {
+        return {
+          label: preset.name,
+          value: preset.name
+        };
+      }),
+      default: project.preset
+    });
+    const preset = await this.presetService.get(project.preset);
+    if (!preset) {
+      throw new Error("Preset not found");
+    }
+    if (preset.buildArgsOptions) {
+      project.buildArgs = await (0, _utils.promptConfig)(preset.buildArgsOptions, project.buildArgs);
+    }
+    if (preset.envOptions) {
+      project.env = await (0, _utils.promptConfig)(preset.envOptions, project.env);
+    }
+    if (preset.volumeOptions) {
+      for (let volume of preset.volumeOptions) {
+        volume = (0, _utils2.injectVariables)(volume, {
+          ...(project.buildArgs || {}),
+          ...(project.env || {})
+        });
+        const {
+          destination,
+          options
+        } = (0, _utils2.volumeParse)(volume);
+        let projectVolume = project.getVolumeByDestination(destination);
+        const source = await (0, _utils.promptText)({
+          message: "Volume",
+          suffix: `:${destination}`,
+          default: projectVolume ? (0, _utils2.volumeParse)(projectVolume).source : "./"
+        });
+        projectVolume = (0, _utils2.volumeFormat)({
+          source,
+          destination,
+          options
+        });
+        project.volumeMount(projectVolume);
+      }
+    }
+    if (preset.dockerfile) {
+      project.imageName = preset.getImageName(project.buildArgs);
+    }
+  }
+  async onRebuild(project) {
+    if (project.type !== "preset") {
+      return;
+    }
+    const preset = await this.presetService.get(project.preset);
+    if (!preset) {
+      throw new Error(`Preset ${project.preset} not found`);
+    }
+    const imageName = preset.getImageName(project.buildArgs || {});
+    const exists = await this.dockerService.imageExists(imageName);
+    if (exists) {
+      console.info(`Removing image: ${imageName}`);
+      await this.dockerService.imageRm(imageName);
+    }
+  }
+  async onBeforeStart(project) {
+    if (project.type !== "preset") {
+      return;
+    }
+    const preset = await this.presetService.get(project.preset);
+    if (preset.dockerfile) {
+      project.imageName = preset.getImageName(project.buildArgs);
+      if (!(await this.dockerService.imageExists(project.imageName))) {
+        await this.dockerService.buildImage({
+          tag: project.imageName,
+          labels: {
+            presetName: preset.name
+          },
+          buildArgs: project.buildArgs,
+          context: Path.join(_env.PRESETS_DIR, preset.name),
+          src: preset.dockerfile
+        });
+      }
+    }
+  }
+  async build(options, presetName) {
+    const preset = await this.presetService.get(presetName);
+    let buildArgs = {};
+    if (preset.buildArgsOptions) {
+      buildArgs = await (0, _utils.promptGroup)(preset.buildArgsOptions);
+    }
+    const imageName = preset.getImageName(buildArgs);
+    await this.dockerService.buildImage({
+      tag: imageName,
+      labels: {
+        presetName: preset.name
+      },
+      buildArgs: buildArgs,
+      context: Path.join(_env.PRESETS_DIR, preset.name),
+      src: preset.dockerfile
+    });
+  }
+}
+exports.PresetController = PresetController;

package/lib/controllers/ProjectController.d.ts

@@ -1,11 +1,14 @@
+import { DI, AppConfigService as CoreAppConfigService, AppEventsService as CoreAppEventsService, ProjectService as CoreProjectService, DockerService } from "@wocker/core";
 import { Cli } from "@kearisp/cli";
 import { Controller } from "src/makes";
-import { AppConfigService, AppEventsService, ProjectService } from "src/services";
 type InitOptions = {
     name?: string;
     type?: string;
     preset?: string;
 };
+type ListOptions = {
+    all?: boolean;
+};
 type StartOptions = {
     name?: string;
     rebuild?: boolean;
@@ -37,15 +40,20 @@ type ExecOptions = {
     name?: string;
 };
 declare class ProjectController extends Controller {
-    protected appConfigService: AppConfigService;
-    protected appEventsService: AppEventsService;
-    protected projectService: ProjectService;
-    constructor(appConfigService: AppConfigService, appEventsService: AppEventsService, projectService: ProjectService);
+    protected di: DI;
+    protected appConfigService: CoreAppConfigService;
+    protected appEventsService: CoreAppEventsService;
+    protected projectService: CoreProjectService;
+    protected dockerService: DockerService;
+    constructor(di: DI);
     install(cli: Cli): void;
     protected getProjectNames(): Promise<string[]>;
+    protected getScripts(): Promise<string[]>;
     init(options: InitOptions): Promise<void>;
+    projectList(options: ListOptions): Promise<string>;
     start(options: StartOptions): Promise<void>;
     stop(options: StopOptions): Promise<void>;
+    run(script: string): Promise<void>;
     attach(options: AttachOptions): Promise<void>;
     configList(options: ConfigOptions): Promise<string>;
     configGet(options: ConfigOptions, key: string): Promise<string>;