@wocker/ws 1.0.2 → 1.0.4

package/lib/makes/LineConvertStream.js

@@ -1,45 +1,42 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.LineConvertStream = void 0;
-var _stream = require("stream");
-var _asyncMutex = require("async-mutex");
-class LineConvertStream extends _stream.Readable {
-  buf = "";
-  mutex = new _asyncMutex.Mutex();
-  constructor(stream) {
-    super();
-    this.stream = stream;
-    this.stream.on("data", chunk => this.process(chunk));
-    this.stream.on("end", () => {
-      this.push(null);
-    });
-    this.stream.on("close", () => {
-      this.destroy();
-    });
-  }
-  _read(size) {
-    //
-  }
-  async process(chunk) {
-    await this.mutex.acquire();
-    this.buf += chunk.toString();
-    try {
-      let pos;
-      while ((pos = this.buf.indexOf("\n")) >= 0) {
-        if (pos === 0) {
-          this.buf = this.buf.slice(0);
-          continue;
+const stream_1 = require("stream");
+const async_mutex_1 = require("async-mutex");
+class LineConvertStream extends stream_1.Readable {
+    constructor(stream) {
+        super();
+        this.buf = "";
+        this.mutex = new async_mutex_1.Mutex();
+        this.stream = stream;
+        this.stream.on("data", (chunk) => this.process(chunk));
+        this.stream.on("end", () => {
+            this.push(null);
+        });
+        this.stream.on("close", () => {
+            this.destroy();
+        });
+    }
+    _read(size) {
+    }
+    async process(chunk) {
+        await this.mutex.acquire();
+        this.buf += chunk.toString();
+        try {
+            let pos;
+            while ((pos = this.buf.indexOf("\n")) >= 0) {
+                if (pos === 0) {
+                    this.buf = this.buf.slice(0);
+                    continue;
+                }
+                const line = this.buf.slice(0, pos);
+                this.buf = this.buf.slice(pos + 1);
+                this.push(line);
+            }
+        }
+        finally {
+            this.mutex.release();
         }
-        const line = this.buf.slice(0, pos);
-        this.buf = this.buf.slice(pos + 1);
-        this.push(line);
-      }
-    } finally {
-      this.mutex.release();
     }
-  }
 }
-exports.LineConvertStream = LineConvertStream;
+exports.LineConvertStream = LineConvertStream;

package/lib/makes/Logger.d.ts

@@ -1 +1,9 @@
-export { Logger } from "@wocker/core";
+import { DI } from "./DI";
+declare class Logger {
+    static install(di: DI): void;
+    static log(...data: any[]): void;
+    static info(...data: any[]): void;
+    static warn(...data: any[]): void;
+    static error(...data: any[]): void;
+}
+export { Logger };

package/lib/makes/Logger.js

@@ -1,12 +1,23 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "Logger", {
-  enumerable: true,
-  get: function () {
-    return _core.Logger;
-  }
-});
-var _core = require("@wocker/core");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const LogService_1 = require("../services/LogService");
+let _di;
+class Logger {
+    static install(di) {
+        _di = di;
+    }
+    static log(...data) {
+        _di.resolveService(LogService_1.LogService).log(...data);
+    }
+    static info(...data) {
+        _di.resolveService(LogService_1.LogService).info(...data);
+    }
+    static warn(...data) {
+        _di.resolveService(LogService_1.LogService).warn(...data);
+    }
+    static error(...data) {
+        _di.resolveService(LogService_1.LogService).error(...data);
+    }
+}
+exports.Logger = Logger;

package/lib/makes/Model.js

@@ -1,16 +1,12 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.Model = void 0;
 class Model {
-  attributes = {};
-  constructor(attributes = {}) {
-    this.attributes = attributes;
-  }
-  async save() {
-    //
-  }
+    constructor(attributes = {}) {
+        this.attributes = {};
+        this.attributes = attributes;
+    }
+    async save() {
+    }
 }
-exports.Model = Model;
+exports.Model = Model;

package/lib/makes/MySQL.js

@@ -1,31 +1,10 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.MySQL = void 0;
-// import {createConnection} from "mysql";
-
 class MySQL {
-  constructor(options) {
-    // this.connection = createConnection(options);
-  }
-  async query(sql) {
-    // this.connection.connect();
-    //
-    // const res = await new Promise((resolve, reject) => {
-    //     this.connection.query(sql, (err, res) => {
-    //         if(err) {
-    //             return reject(err);
-    //         }
-    //
-    //         return resolve(res);
-    //     });
-    // });
-    //
-    // this.connection.end();
-    //
-    // return res;
-  }
+    constructor(options) {
+    }
+    async query(sql) {
+    }
 }
-exports.MySQL = MySQL;
+exports.MySQL = MySQL;

package/lib/makes/Plugin.d.ts

@@ -1,5 +1,5 @@
 import { Cli } from "@kearisp/cli";
-import { Controller } from "src/makes/Controller";
+import { Controller } from "../makes/Controller";
 declare class Plugin extends Controller {
     protected certsDir: string;
     protected dataDir: string;

package/lib/makes/Plugin.js

@@ -1,43 +1,61 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
 });
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.Plugin = void 0;
-var Path = _interopRequireWildcard(require("path"));
-var _env = require("../env");
-var _Controller = require("./Controller");
-var _FS = require("./FS");
-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 Plugin extends _Controller.Controller {
-  constructor(name) {
-    super();
-    this.certsDir = Path.join(_env.DATA_DIR, "certs");
-    this.dataDir = Path.join(_env.DATA_DIR, "plugins", name);
-    this.pluginDir = Path.join(_env.PLUGINS_DIR, name);
-  }
-  install(cli) {
-    super.install(cli);
-    if (!_FS.FS.existsSync(this.certsDir)) {
-      _FS.FS.mkdirSync(this.certsDir, {
-        recursive: true
-      });
+const Path = __importStar(require("path"));
+const env_1 = require("../env");
+const Controller_1 = require("../makes/Controller");
+const FS_1 = require("../makes/FS");
+class Plugin extends Controller_1.Controller {
+    constructor(name) {
+        super();
+        this.certsDir = Path.join(env_1.DATA_DIR, "certs");
+        this.dataDir = Path.join(env_1.DATA_DIR, "plugins", name);
+        this.pluginDir = Path.join(env_1.PLUGINS_DIR, name);
+    }
+    install(cli) {
+        super.install(cli);
+        if (!FS_1.FS.existsSync(this.certsDir)) {
+            FS_1.FS.mkdirSync(this.certsDir, {
+                recursive: true
+            });
+        }
+        if (!FS_1.FS.existsSync(this.dataDir)) {
+            FS_1.FS.mkdirSync(this.dataDir, {
+                recursive: true
+            });
+        }
+    }
+    certsPath(...paths) {
+        return Path.join(this.certsDir, ...paths);
+    }
+    dataPath(...paths) {
+        return Path.join(this.dataDir, ...paths);
     }
-    if (!_FS.FS.existsSync(this.dataDir)) {
-      _FS.FS.mkdirSync(this.dataDir, {
-        recursive: true
-      });
+    pluginPath(...paths) {
+        return Path.join(this.pluginDir, ...paths);
     }
-  }
-  certsPath(...paths) {
-    return Path.join(this.certsDir, ...paths);
-  }
-  dataPath(...paths) {
-    return Path.join(this.dataDir, ...paths);
-  }
-  pluginPath(...paths) {
-    return Path.join(this.pluginDir, ...paths);
-  }
 }
-exports.Plugin = Plugin;
+exports.Plugin = Plugin;

package/lib/makes/Preset.d.ts

@@ -0,0 +1,46 @@
+import { EnvConfig } from "../types";
+import { DI } from "../makes";
+import { PresetServiceSearchOptions as SearchOptions } from "../services/PresetService";
+type TextOption = {
+    type: "string" | "number" | "int";
+    message?: string;
+    default?: string | number;
+};
+type ConfirmOption = {
+    type: "boolean";
+    message?: string;
+    default?: boolean;
+};
+type SelectOption = {
+    type: "select";
+    options: string[] | {
+        label?: string;
+        value: string;
+    }[] | {
+        [name: string]: string;
+    };
+    message?: string;
+    default?: string;
+};
+type AnyOption = TextOption | ConfirmOption | SelectOption;
+declare class Preset {
+    id: string;
+    name: string;
+    version: string;
+    dockerfile?: string;
+    buildArgsOptions?: {
+        [name: string]: AnyOption;
+    };
+    envOptions?: {
+        [name: string]: AnyOption;
+    };
+    volumes?: string[];
+    volumeOptions?: string[];
+    constructor(data: any);
+    save(): Promise<void>;
+    getImageName(buildArgs?: EnvConfig): string;
+    static install(di: DI): void;
+    static search(options: SearchOptions): Promise<Preset[]>;
+    static searchOne(options: SearchOptions): Promise<Preset>;
+}
+export { Preset };

package/lib/makes/Preset.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Preset = void 0;
+const PresetService_1 = require("../services/PresetService");
+let _di;
+class Preset {
+    constructor(data) {
+        this.id = data.id;
+        this.name = data.name;
+        this.version = data.version;
+        this.dockerfile = data.dockerfile;
+        this.buildArgsOptions = data.buildArgsOptions;
+        this.envOptions = data.envOptions;
+        this.volumes = data.volumes;
+        this.volumeOptions = data.volumeOptions;
+    }
+    async save() {
+        return _di.resolveService(PresetService_1.PresetService).save(this);
+    }
+    getImageName(buildArgs) {
+        return _di.resolveService(PresetService_1.PresetService).getImageName(this, buildArgs);
+    }
+    static install(di) {
+        _di = di;
+    }
+    static search(options) {
+        return _di.resolveService(PresetService_1.PresetService).search(options);
+    }
+    static searchOne(options) {
+        return _di.resolveService(PresetService_1.PresetService).searchOne(options);
+    }
+}
+exports.Preset = Preset;

package/lib/makes/Project.d.ts

@@ -0,0 +1,45 @@
+import "reflect-metadata";
+import { DI } from "../makes/DI";
+import { EnvConfig } from "../types";
+type SearchOptions = {
+    id: string;
+    name: string;
+    path: string;
+};
+declare class Project {
+    id: string;
+    name: string;
+    type: string;
+    path: string;
+    preset?: string;
+    imageName?: string;
+    dockerfile?: string;
+    scripts?: string[];
+    buildArgs?: EnvConfig;
+    env: EnvConfig;
+    ports?: string[];
+    volumes?: string[];
+    metadata?: EnvConfig;
+    constructor(data: any);
+    get containerName(): string;
+    hasEnv(name: string): boolean;
+    getEnv(name: string, defaultValue?: string): string | undefined;
+    setEnv(name: string, value: string | boolean): void;
+    unsetEnv(name: string): void;
+    hasMeta(name: string): boolean;
+    getMeta<D = string | undefined>(name: string, defaultValue?: D): D;
+    setMeta(name: string, value: string | boolean): void;
+    unsetMeta(name: string): void;
+    volumeMount(...volumes: string[]): void;
+    getVolumeBySource(source: string): string | undefined;
+    getVolumeByDestination(destination: string): string | undefined;
+    volumeUnmount(...volumes: string[]): void;
+    save(): Promise<void>;
+    static install(di: DI): void;
+    static fromObject(data: any): Project;
+    static search(params?: Partial<SearchOptions>): Promise<Project[]>;
+    static searchOne(params: Partial<SearchOptions>): Promise<Project | null>;
+}
+export { Project };
+export declare const PROJECT_TYPE_DOCKERFILE = "dockerfile";
+export declare const PROJECT_TYPE_IMAGE = "image";

package/lib/makes/Project.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROJECT_TYPE_IMAGE = exports.PROJECT_TYPE_DOCKERFILE = exports.Project = void 0;
+require("reflect-metadata");
+const ProjectService_1 = require("../services/ProjectService");
+const volumeParse_1 = require("../utils/volumeParse");
+let projectService;
+class Project {
+    constructor(data) {
+        this.id = data.id;
+        this.name = data.name;
+        this.type = data.type;
+        this.path = data.path;
+        this.preset = data.preset;
+        this.dockerfile = data.dockerfile;
+        this.imageName = data.imageName;
+        this.scripts = data.scripts;
+        this.buildArgs = data.buildArgs;
+        this.env = data.env || {};
+        this.ports = data.ports;
+        this.volumes = data.volumes;
+        this.metadata = data.metadata;
+    }
+    get containerName() {
+        return `${this.name}.workspace`;
+    }
+    hasEnv(name) {
+        if (!this.env) {
+            return false;
+        }
+        return this.env.hasOwnProperty(name);
+    }
+    getEnv(name, defaultValue) {
+        const { [name]: value = defaultValue } = this.env;
+        return value;
+    }
+    setEnv(name, value) {
+        this.env = {
+            ...this.env,
+            [name]: typeof value === "boolean"
+                ? (value ? "true" : "false")
+                : value
+        };
+    }
+    unsetEnv(name) {
+        if (name in this.env) {
+            delete this.env[name];
+        }
+    }
+    hasMeta(name) {
+        return !!this.metadata && this.metadata.hasOwnProperty(name);
+    }
+    getMeta(name, defaultValue) {
+        const { [name]: value = defaultValue } = this.metadata || {};
+        return value;
+    }
+    setMeta(name, value) {
+        if (!this.metadata) {
+            this.metadata = {};
+        }
+        this.metadata[name] = typeof value === "boolean"
+            ? (value ? "true" : "false")
+            : value;
+    }
+    unsetMeta(name) {
+        if (this.metadata && name in this.metadata) {
+            delete this.metadata[name];
+        }
+        if (this.metadata && Object.keys(this.metadata).length === 0) {
+            delete this.metadata;
+        }
+    }
+    volumeMount(...volumes) {
+        if (volumes.length === 0) {
+            return;
+        }
+        const [volume, ...restVolumes] = volumes;
+        const { destination } = (0, volumeParse_1.volumeParse)(volume);
+        this.volumes = [
+            ...(this.volumes || []).filter((v) => {
+                return v !== this.getVolumeByDestination(destination);
+            }),
+            volume
+        ];
+        this.volumeMount(...restVolumes);
+    }
+    getVolumeBySource(source) {
+        return (this.volumes || []).find((volume) => {
+            return (0, volumeParse_1.volumeParse)(volume).source === source;
+        });
+    }
+    getVolumeByDestination(destination) {
+        return (this.volumes || []).find((volume) => {
+            return (0, volumeParse_1.volumeParse)(volume).destination === destination;
+        });
+    }
+    volumeUnmount(...volumes) {
+        this.volumes = (this.volumes || []).filter((mounted) => {
+            return !volumes.includes(mounted);
+        });
+    }
+    async save() {
+        if (!projectService) {
+            throw new Error("Dependency is missing");
+        }
+        await projectService.save(this);
+    }
+    static install(di) {
+        projectService = di.resolveService(ProjectService_1.ProjectService);
+    }
+    static fromObject(data) {
+        return new Project(data);
+    }
+    static async search(params = {}) {
+        if (!projectService) {
+            throw new Error("Dependency is missing");
+        }
+        return projectService.search(params);
+    }
+    static async searchOne(params) {
+        const [project] = await Project.search(params);
+        return project || null;
+    }
+}
+exports.Project = Project;
+exports.PROJECT_TYPE_DOCKERFILE = "dockerfile";
+exports.PROJECT_TYPE_IMAGE = "image";

package/lib/makes/Repository.js

@@ -1,25 +1,22 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.Repository = void 0;
 class Repository {
-  async create(data) {
-    return null;
-  }
-  async update(id, record) {
-    return null;
-  }
-  async byId(id) {
-    return null;
-  }
-  async search(params) {
-    return [];
-  }
-  async searchOne(params) {
-    const [item] = await this.search(params);
-    return item;
-  }
+    async create(data) {
+        return null;
+    }
+    async update(id, record) {
+        return null;
+    }
+    async byId(id) {
+        return null;
+    }
+    async search(params) {
+        return [];
+    }
+    async searchOne(params) {
+        const [item] = await this.search(params);
+        return item;
+    }
 }
-exports.Repository = Repository;
+exports.Repository = Repository;

package/lib/makes/index.d.ts

@@ -1,6 +1,9 @@
 export * from "./Controller";
+export * from "./DI";
 export * from "./Docker";
 export * from "./FS";
 export * from "./Logger";
 export * from "./Plugin";
+export * from "./Preset";
+export * from "./Project";
 export * from "./Repository";