@wocker/ws 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Kris Papercut
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,155 @@
+# Wocker
+
+###### Docker workspace for web projects
+
+## Requirements
+
+- [node.js](https://nodejs.org)
+- [docker](https://www.docker.com)
+
+
+## Usage
+
+### Installation
+
+```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
+
+```bash
+source <(ws completion script)
+```
+
+
+## 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 
+```

package/bin/ws.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+const chalk = require("chalk");
+const {app} = require("../lib/index.js");
+
+
+app.run().then((res) => {
+    if(res) {
+        process.stdout.write(res);
+    }
+}).catch((err) => {
+    console.error(chalk.red(err.message));
+});

package/lib/App.d.ts

@@ -0,0 +1,13 @@
+import { Cli } from "@kearisp/cli";
+import { Controller, Plugin } from "src/makes";
+import { AppConfigService } from "src/services";
+export declare class App {
+    protected config: AppConfigService;
+    protected cli: Cli;
+    constructor(config: AppConfigService);
+    install(): void;
+    useController(controller: Controller): void;
+    usePlugin(plugin: Plugin): void;
+    setDebug(status: string): Promise<void>;
+    run(): Promise<string>;
+}

package/lib/App.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.App = void 0;
+var Path = _interopRequireWildcard(require("path"));
+var _cli = require("@kearisp/cli");
+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; }
+class App {
+  constructor(config) {
+    this.config = config;
+    this.cli = new _cli.Cli(_makes.Logger);
+    this.install();
+  }
+  install() {
+    this.cli.command("completion script").help(false).action(() => this.cli.completionScript());
+    this.cli.command("debug <status>").completion("status", () => ["on", "off"]).action(async (options, status) => this.setDebug(status));
+  }
+  useController(controller) {
+    controller.install(this.cli);
+  }
+  usePlugin(plugin) {
+    plugin.install(this.cli);
+  }
+  async setDebug(status) {
+    _makes.Logger.info(`Set debug ${status}`);
+    await (0, _utils.setConfig)({
+      debug: status === "on"
+    });
+  }
+  async run() {
+    const mapDir = Path.dirname(_env.MAP_PATH);
+    if (!_makes.FS.existsSync(mapDir)) {
+      await _makes.FS.mkdir(mapDir);
+    }
+    if (!_makes.FS.existsSync(_env.MAP_PATH)) {
+      await _makes.FS.writeJSON(_env.MAP_PATH, {
+        projects: []
+      });
+    }
+    if (!_makes.FS.existsSync(`${_env.DATA_DIR}/projects`)) {
+      await _makes.FS.mkdir(`${_env.DATA_DIR}/projects`);
+    }
+    return this.cli.run(process.argv);
+  }
+}
+exports.App = App;

package/lib/controllers/ImageController.d.ts

@@ -0,0 +1,8 @@
+import { Cli } from "@kearisp/cli";
+import { Controller } from "src/makes";
+declare class ImageController extends Controller {
+    constructor();
+    install(cli: Cli): void;
+    list(): Promise<string>;
+}
+export { ImageController };

package/lib/controllers/ImageController.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ImageController = void 0;
+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() {
+    super();
+  }
+  install(cli) {
+    super.install(cli);
+    cli.command("images").action(() => this.list());
+  }
+  async list() {
+    const images = await _makes.Docker.imageLs({});
+    const table = new _cliTable.default({
+      head: ["Name"]
+    });
+    for (const image of images) {
+      table.push([image.Id]);
+    }
+    return table.toString() + "\n";
+  }
+}
+exports.ImageController = ImageController;

package/lib/controllers/ProjectController.d.ts

@@ -0,0 +1,64 @@
+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 StartOptions = {
+    name?: string;
+    rebuild?: boolean;
+    detach?: boolean;
+};
+type StopOptions = {
+    name?: string;
+};
+type AttachOptions = {
+    name?: string;
+};
+type ConfigOptions = {
+    name?: string;
+    global?: boolean;
+};
+type BuildArgsOptions = {
+    name?: string;
+};
+type VolumeOptions = {
+    name?: string;
+};
+type LogsOptions = {
+    name?: string;
+    global?: boolean;
+    detach?: boolean;
+    follow?: boolean;
+};
+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);
+    install(cli: Cli): void;
+    protected getProjectNames(): Promise<string[]>;
+    init(options: InitOptions): Promise<void>;
+    start(options: StartOptions): Promise<void>;
+    stop(options: StopOptions): Promise<void>;
+    attach(options: AttachOptions): Promise<void>;
+    configList(options: ConfigOptions): Promise<string>;
+    configGet(options: ConfigOptions, key: string): Promise<string>;
+    configSet(options: ConfigOptions, configs: string[]): Promise<void>;
+    configUnset(options: ConfigOptions, configs: string[]): Promise<void>;
+    buildArgsList(options: BuildArgsOptions): Promise<string>;
+    buildArgsGet(options: BuildArgsOptions, args: string[]): Promise<string>;
+    buildArgsSet(options: BuildArgsOptions, args: string[]): Promise<void>;
+    buildArgsUnset(options: BuildArgsOptions, args: string[]): Promise<void>;
+    volumeList(options: VolumeOptions): Promise<string>;
+    volumeMount(options: VolumeOptions, volumes: string[]): Promise<void>;
+    volumeUnmount(options: VolumeOptions, volumes: string[]): Promise<void>;
+    logs(options: LogsOptions): Promise<void>;
+    exec(options: ExecOptions, command: string[]): Promise<void>;
+}
+export { ProjectController };