@wocker/ws 1.0.7 → 1.0.8

package/lib/makes/Docker.js

@@ -1,320 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Docker = void 0;
-const dockerode_1 = __importDefault(require("dockerode"));
-const image_build_1 = require("../utils/image-build");
-const followProgress_1 = require("../utils/followProgress");
-const FS_1 = require("./FS");
-const Logger_1 = require("./Logger");
-const docker = new dockerode_1.default({
-    socketPath: "/var/run/docker.sock"
-});
-class Docker {
-    static async exec(name, args, tty = true) {
-        const container = docker.getContainer(name);
-        const exec = await container.exec({
-            AttachStdin: true,
-            AttachStdout: true,
-            AttachStderr: tty,
-            Tty: tty,
-            Cmd: args
-        });
-        const stream = await exec.start({
-            hijack: true,
-            stdin: tty,
-            Tty: tty
-        });
-        if (tty) {
-            stream.setEncoding("utf-8");
-            process.stdin.resume();
-            if (process.stdin.setRawMode) {
-                process.stdin.setRawMode(true);
-            }
-            process.stdin.setEncoding("utf-8");
-            process.stdin.pipe(stream);
-            stream.pipe(process.stdout);
-            stream.on("error", (err) => {
-                Logger_1.Logger.error(err.message);
-            });
-            stream.on("end", async () => {
-                process.stdin.setRawMode(false);
-            });
-            stream.on("end", async () => {
-                process.exit();
-            });
-        }
-        return stream;
-    }
-    static async getImage(name) {
-        return docker.getImage(name);
-    }
-    static async getContainer(name) {
-        const containers = await docker.listContainers({
-            all: true,
-            filters: {
-                name: [name]
-            }
-        });
-        const container = containers.find((container) => {
-            return container.Names.indexOf("/" + name) >= 0;
-        });
-        if (container) {
-            return docker.getContainer(container.Id);
-        }
-        return null;
-    }
-    static async removeContainer(name) {
-        const container = await Docker.getContainer(name);
-        if (!container) {
-            return;
-        }
-        const { State: { Status } } = await container.inspect();
-        if (Status === "running") {
-            try {
-                await container.stop();
-            }
-            catch (err) {
-                Logger_1.Logger.error("Docker.removeContainer: ", err.message);
-            }
-        }
-        try {
-            await container.remove();
-        }
-        catch (err) {
-            Logger_1.Logger.error("Docker.removeContainer: ", err.message);
-        }
-    }
-    static async getContainerList(options) {
-        const { name, projectId } = options || {};
-        const filters = {};
-        if (name) {
-            filters.name = [`/${name}`];
-        }
-        if (projectId) {
-            if (!filters.label) {
-                filters.label = [];
-            }
-            filters.label.push(`projectId=${projectId}`);
-        }
-        return docker.listContainers({
-            all: true,
-            filters: JSON.stringify(filters)
-        });
-    }
-    static async attach(name) {
-        const container = await Docker.getContainer(name);
-        const stream = await container.attach({
-            logs: true,
-            stream: true,
-            hijack: true,
-            stdin: true,
-            stdout: true,
-            stderr: true
-        });
-        process.stdin.resume();
-        process.stdin.setEncoding("utf8");
-        process.stdin.setRawMode(true);
-        process.stdin.pipe(stream);
-        process.stdin.on("data", (data) => {
-            if (data.toString() === "\u0003") {
-                process.stdin.setRawMode(false);
-            }
-        });
-        stream.setEncoding("utf8");
-        stream.pipe(process.stdout);
-        const [width, height] = process.stdout.getWindowSize();
-        await container.resize({
-            w: width,
-            h: height
-        });
-        stream.on("end", async () => {
-            process.exit();
-        });
-        process.stdout.on("resize", () => {
-            const [width, height] = process.stdout.getWindowSize();
-            container.resize({
-                w: width,
-                h: height
-            });
-        });
-    }
-    static 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);
-        });
-    }
-    static async imageExists(tag) {
-        const image = docker.getImage(tag);
-        try {
-            await image.inspect();
-            return true;
-        }
-        catch (ignore) {
-            return false;
-        }
-    }
-    static async imageLs(options) {
-        const { tag, reference, labels } = options || {};
-        const filters = {};
-        if (reference) {
-            filters.reference = [
-                ...filters.reference || [],
-                reference
-            ];
-        }
-        if (tag) {
-            filters.reference = [
-                ...filters.reference || [],
-                tag
-            ];
-        }
-        if (labels) {
-            filters.label = [];
-            for (const i in labels) {
-                filters.label.push(`${i}=${labels[i]}`);
-            }
-        }
-        return docker.listImages({
-            filters: JSON.stringify(filters)
-        });
-    }
-    static async imageBuild(options) {
-        await (0, image_build_1.imageBuild)(options);
-    }
-    static async imageBuild2(options) {
-        const { tag, labels = {}, buildArgs = {}, context, src } = options;
-        const files = await FS_1.FS.readdirFiles(context, {
-            recursive: true
-        });
-        const stream = await docker.buildImage({
-            context,
-            src: files
-        }, {
-            t: tag,
-            labels,
-            dockerfile: src,
-            buildargs: buildArgs
-        });
-        return stream;
-    }
-    static async imageRm(name) {
-        const image = await docker.getImage(name);
-        if (!image) {
-            return;
-        }
-        await image.remove();
-    }
-    static async pullImage(tag) {
-        const isExists = await this.imageExists(tag);
-        if (isExists) {
-            return;
-        }
-        const stream = await docker.pull(tag, {});
-        await (0, followProgress_1.followProgress)(stream);
-    }
-    static async createContainer(options) {
-        const { name, tty, image, projectId, restart, extraHosts, networkMode, links = [], env = {}, volumes = [], ports = [], cmd = [] } = options;
-        const network = docker.getNetwork("workspace");
-        try {
-            await network.inspect();
-        }
-        catch (err) {
-            if (err.statusCode === 404) {
-                await docker.createNetwork({
-                    Name: "workspace"
-                });
-            }
-        }
-        await this.pullImage(image);
-        return await 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,
-                ...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
-                    }
-                }
-            }
-        });
-    }
-    static async containerRun(options, attach = false) {
-        const container = await Docker.createContainer(options);
-        if (attach) {
-            const stdout = await container.attach({
-                stream: true,
-                stdin: true,
-                stdout: true,
-                stderr: true
-            });
-            stdout.pipe(process.stdout);
-        }
-        await container.start();
-        return container;
-    }
-}
-exports.Docker = Docker;
-Docker.docker = docker;

package/lib/makes/Plugin.d.ts

@@ -1,13 +0,0 @@
-import { Cli } from "@kearisp/cli";
-import { Controller } from "../makes/Controller";
-declare class Plugin extends Controller {
-    protected certsDir: string;
-    protected dataDir: string;
-    protected pluginDir: string;
-    constructor(name: string);
-    install(cli: Cli): void;
-    certsPath(...paths: string[]): string;
-    dataPath(...paths: string[]): string;
-    pluginPath(...paths: string[]): string;
-}
-export { Plugin };

package/lib/makes/Plugin.js

@@ -1,61 +0,0 @@
-"use strict";
-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;
-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);
-    }
-    pluginPath(...paths) {
-        return Path.join(this.pluginDir, ...paths);
-    }
-}
-exports.Plugin = Plugin;

package/lib/makes/Project.d.ts

@@ -1,45 +0,0 @@
-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

@@ -1,127 +0,0 @@
-"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.d.ts

@@ -1,11 +0,0 @@
-type Entity = {
-    id: number | string;
-};
-export declare class Repository<E extends Entity> {
-    create(data: Partial<E>): Promise<E>;
-    update(id: E["id"], record: Partial<E>): Promise<E>;
-    byId(id: E["id"]): Promise<E>;
-    search(params?: any): Promise<E[]>;
-    searchOne(params?: any): Promise<E>;
-}
-export {};

package/lib/makes/Repository.js

@@ -1,22 +0,0 @@
-"use strict";
-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;
-    }
-}
-exports.Repository = Repository;

package/lib/plugins/PostgresPlugin.d.ts

@@ -1,16 +0,0 @@
-import { Cli } from "@kearisp/cli";
-import { Plugin } from "../makes";
-declare class PostgresPlugin extends Plugin {
-    protected container: string;
-    protected adminContainer: string;
-    constructor();
-    install(cli: Cli): void;
-    start(): Promise<void>;
-    protected startDB(): Promise<void>;
-    protected startAdmin(): Promise<void>;
-    stop(): Promise<void>;
-    protected stopDB(): Promise<void>;
-    protected stopAdmin(): Promise<void>;
-    restart(): Promise<void>;
-}
-export { PostgresPlugin };