@wocker/ws 1.0.22 → 1.0.24

package/lib/makes/FS.js

@@ -1,284 +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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FS = void 0;
-const core_1 = require("@wocker/core");
-const fs = __importStar(require("fs"));
-const Path = __importStar(require("path"));
-const readable_stream_1 = require("readable-stream");
-class FS extends core_1.FS {
-    static async access(path) {
-        return new Promise((resolve, reject) => {
-            fs.access(path, (err) => {
-                if (!err) {
-                    resolve(null);
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    static existsSync(path) {
-        return fs.existsSync(path);
-    }
-    static async mkdir(dirPath, options = {}) {
-        return new Promise((resolve, reject) => {
-            fs.mkdir(dirPath, options, (err) => {
-                if (!err) {
-                    resolve();
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    static mkdirSync(path, options) {
-        return fs.mkdirSync(path, options);
-    }
-    static async readdirFiles(path, options) {
-        const { recursive = false } = options || {};
-        if (recursive) {
-            const names = await FS.readdir(path);
-            let res = [];
-            for (const name of names) {
-                const filePath = Path.join(path, name);
-                let sub = [
-                    name
-                ];
-                const stats = await FS.stat(filePath);
-                if (stats.isDirectory()) {
-                    sub = (await FS.readdirFiles(filePath, { recursive: true })).map((subName) => {
-                        return Path.join(name, subName);
-                    });
-                }
-                res = [
-                    ...res,
-                    ...sub
-                ];
-            }
-            return res;
-        }
-        return new Promise((resolve, reject) => {
-            fs.readdir(path, {
-                withFileTypes: true
-            }, (err, files) => {
-                if (err) {
-                    reject(err);
-                    return;
-                }
-                const names = files.filter((dirent) => {
-                    return dirent.isFile();
-                }).map((dirent) => {
-                    return dirent.name;
-                });
-                resolve(names);
-            });
-        });
-    }
-    static async appendFile(path, data, options) {
-        return new Promise((resolve, reject) => {
-            fs.appendFile(path, data, options, (error) => {
-                if (error) {
-                    reject(error);
-                }
-                else {
-                    resolve(undefined);
-                }
-            });
-        });
-    }
-    static appendFileSync(path, data, options) {
-        return fs.appendFileSync(path, data, options);
-    }
-    static async readBytes(filePath, position = 0, size) {
-        if (position < 0 && typeof size === "undefined") {
-            const stats = await FS.stat(filePath);
-            size = BigInt(position) * -1n;
-            position = BigInt(stats.size) - size;
-            if (position < 0n) {
-                position = 0;
-            }
-        }
-        else if (typeof size === "undefined") {
-            const stats = await FS.stat(filePath);
-            if (typeof stats.size !== "bigint" && typeof position !== "bigint") {
-                size = stats.size - position;
-            }
-            else {
-                size = BigInt(stats.size) - BigInt(position);
-            }
-        }
-        if (size < 0n) {
-            return Buffer.alloc(0);
-        }
-        const buffer = Buffer.alloc(Number(size));
-        return new Promise((resolve, reject) => {
-            fs.open(filePath, (err, file) => {
-                if (err) {
-                    reject(err);
-                    return;
-                }
-                fs.read(file, buffer, 0, buffer.length, position, (err, _, buffer) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve(buffer);
-                });
-            });
-        });
-    }
-    static readFileSync(filePath) {
-        return fs.readFileSync(filePath);
-    }
-    static writeFileSync(path, data, options) {
-        return fs.writeFileSync(path, data, options);
-    }
-    static createWriteStream(path) {
-        return fs.createWriteStream(path);
-    }
-    static async unlink(filePath) {
-        return new Promise((resolve, reject) => {
-            fs.unlink(filePath, (err) => {
-                if (!err) {
-                    resolve();
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-    static watch(filename, options) {
-        return fs.watch(filename, options);
-    }
-    static stat(filename, options) {
-        return new Promise((resolve, reject) => {
-            fs.stat(filename, options, (err, stats) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(stats);
-                }
-            });
-        });
-    }
-    static createReadStream(path, options) {
-        return fs.createReadStream(path, options);
-    }
-    static createReadLinesStream(path, count) {
-        const write = new readable_stream_1.PassThrough();
-        (async () => {
-            if (typeof count === "undefined" || count > 0) {
-                const stats = await FS.stat(path);
-                const resLines = [""];
-                let position = 0n;
-                while (position < stats.size) {
-                    let size = BigInt(count ? 64 * count : 255);
-                    if (position + size > stats.size) {
-                        size = BigInt(stats.size) - position;
-                    }
-                    const buffer = await FS.readBytes(path, position, size);
-                    const lines = buffer.toString("utf-8").split("\n");
-                    position += size;
-                    for (let i = 0; i < lines.length; i++) {
-                        const line = lines[i];
-                        if (i === 0) {
-                            resLines[resLines.length - 1] = (resLines[resLines.length - 1] || "") + line;
-                        }
-                        else {
-                            resLines.push(line);
-                        }
-                    }
-                    if (resLines.length > count + 1) {
-                        break;
-                    }
-                }
-                for (let i = 0; i < (count || resLines.length); i++) {
-                    write.write(resLines[i]);
-                }
-            }
-            else if (count < 0) {
-                const stats = await FS.stat(path);
-                const resLines = [""];
-                let position = BigInt(stats.size);
-                while (position > 0n) {
-                    let size = BigInt(2 * count * -1);
-                    position -= size;
-                    if (position < 0) {
-                        size = position + size;
-                        position = 0n;
-                    }
-                    const buffer = await FS.readBytes(path, position, size);
-                    const lines = buffer.toString("utf-8").split("\n").reverse();
-                    for (let i = 0; i < lines.length; i++) {
-                        const line = lines[i];
-                        if (i === 0) {
-                            resLines[0] = line + (resLines[0] || "");
-                        }
-                        else {
-                            resLines.unshift(line);
-                        }
-                    }
-                    if (resLines.length > count * -1 + 1) {
-                        break;
-                    }
-                }
-                const lines = resLines.slice(count - 1);
-                for (let i = 0; i < lines.length; i++) {
-                    write.write(lines[i]);
-                }
-                write.end();
-            }
-        })();
-        return write;
-    }
-    static async copyFile(src, dest) {
-        new Promise((resolve, reject) => {
-            fs.copyFile(src, dest, (err) => {
-                if (!err) {
-                    resolve(undefined);
-                }
-                else {
-                    reject(err);
-                }
-            });
-        });
-    }
-}
-exports.FS = FS;

package/lib/makes/LineConvertStream.d.ts

@@ -1,11 +0,0 @@
-import { Readable } from "stream";
-import { Mutex } from "async-mutex";
-declare class LineConvertStream extends Readable {
-    protected stream: NodeJS.ReadableStream;
-    protected buf: string;
-    protected mutex: Mutex;
-    constructor(stream: NodeJS.ReadableStream);
-    _read(size: number): void;
-    process(chunk: any): Promise<void>;
-}
-export { LineConvertStream };

package/lib/makes/LineConvertStream.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LineConvertStream = void 0;
-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();
-        }
-    }
-}
-exports.LineConvertStream = LineConvertStream;

package/lib/makes/Logger.d.ts

@@ -1,9 +0,0 @@
-import { LogService } from "../services";
-declare class Logger {
-    static install(ls: LogService): 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,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logger = void 0;
-let logService;
-class Logger {
-    static install(ls) {
-        logService = ls;
-    }
-    static log(...data) {
-        if (!logService) {
-            throw new Error("Dependency is missing");
-        }
-        logService.log(...data);
-    }
-    static info(...data) {
-        if (!logService) {
-            throw new Error("Dependency is missing");
-        }
-        logService.info(...data);
-    }
-    static warn(...data) {
-        if (!logService) {
-            throw new Error("Dependency is missing");
-        }
-        logService.warn(...data);
-    }
-    static error(...data) {
-        if (!logService) {
-            throw new Error("Dependency is missing");
-        }
-        logService.error(...data);
-    }
-}
-exports.Logger = Logger;

package/lib/plugins/MongodbPlugin.d.ts

@@ -1,20 +0,0 @@
-import { DockerService } from "../services";
-export declare class MongodbPlugin {
-    protected readonly dockerService: DockerService;
-    protected container: string;
-    protected adminContainer: string;
-    protected dataDir: string;
-    constructor(dockerService: DockerService);
-    protected dataPath(...parts: string[]): string;
-    getDatabases(): Promise<string[]>;
-    getDatabasesDumps(): Promise<string[]>;
-    start(): Promise<void>;
-    startAdmin(): Promise<void>;
-    stop(): Promise<void>;
-    stopDB(): Promise<void>;
-    stopAdmin(): Promise<void>;
-    restart(): Promise<void>;
-    backup(database?: string): Promise<void>;
-    deleteBackup(database?: string, filename?: string, yes?: boolean): Promise<void>;
-    restore(database?: string, filename?: string): Promise<void>;
-}

package/lib/plugins/MongodbPlugin.js

@@ -1,288 +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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongodbPlugin = void 0;
-const core_1 = require("@wocker/core");
-const utils_1 = require("@wocker/utils");
-const Path = __importStar(require("path"));
-const dateFns = __importStar(require("date-fns"));
-const env_1 = require("../env");
-const makes_1 = require("../makes");
-const services_1 = require("../services");
-let MongodbPlugin = class MongodbPlugin {
-    constructor(dockerService) {
-        this.dockerService = dockerService;
-        this.container = "mongodb.workspace";
-        this.adminContainer = "dbadmin-mongodb.workspace";
-        this.dataDir = Path.join(env_1.DATA_DIR, "db/mongodb");
-    }
-    dataPath(...parts) {
-        return Path.join(this.dataDir, ...parts);
-    }
-    async getDatabases() {
-        const stream = await this.dockerService.exec(this.container, [
-            "mongosh",
-            "--username", "root",
-            "--password", "toor",
-            "--quiet",
-            "--eval", "db.getMongo().getDBNames().forEach(function(i){print(i)})"
-        ], false);
-        let res = "";
-        stream.on("data", (data) => {
-            res += (0, utils_1.demuxOutput)(data).toString();
-        });
-        await new Promise((resolve, reject) => {
-            stream.on("end", resolve);
-            stream.on("error", reject);
-        });
-        return res.split(/\r?\n/).filter((database) => {
-            return !!database;
-        });
-    }
-    async getDatabasesDumps() {
-        const dumpDir = this.dataPath("dump");
-        return makes_1.FS.readdir(dumpDir);
-    }
-    async start() {
-        console.log("Mongidb starting...");
-        await this.dockerService.pullImage("mongo:latest");
-        const container = await this.dockerService.createContainer({
-            name: this.container,
-            restart: "always",
-            image: "mongo:latest",
-            volumes: [
-                `${this.dataPath()}:/data/db`
-            ],
-            ports: ["27017:27017"],
-            env: {
-                MONGO_INITDB_ROOT_USERNAME: "root",
-                MONGO_INITDB_ROOT_PASSWORD: "toor",
-                MONGO_ROOT_USER: "root",
-                MONGO_ROOT_PASSWORD: "toor"
-            }
-        });
-        await container.start();
-        await this.startAdmin();
-    }
-    async startAdmin() {
-        console.log("Mongodb Admin starting...");
-        await this.dockerService.pullImage("mongo-express:latest");
-        const container = await this.dockerService.createContainer({
-            name: this.adminContainer,
-            restart: "always",
-            env: {
-                ME_CONFIG_MONGODB_SERVER: this.container,
-                ME_CONFIG_MONGODB_PORT: "27017",
-                MONGO_ROOT_USER: "root",
-                MONGO_ROOT_PASSWORD: "toor",
-                ME_CONFIG_MONGODB_ADMINUSERNAME: "root",
-                ME_CONFIG_MONGODB_ADMINPASSWORD: "toor",
-                ME_CONFIG_MONGODB_ENABLE_ADMIN: "true",
-                ME_CONFIG_MONGODB_AUTH_DATABASE: "admin",
-                ME_CONFIG_MONGODB_AUTH_USERNAME: "root",
-                ME_CONFIG_MONGODB_AUTH_PASSWORD: "toor",
-                VIRTUAL_HOST: this.adminContainer,
-                VIRTUAL_PORT: "8081"
-            },
-            image: "mongo-express:latest"
-        });
-        await container.start();
-    }
-    async stop() {
-        await this.stopDB();
-        await this.stopAdmin();
-    }
-    async stopDB() {
-        console.log("Mongodb stopping...");
-        const container = await this.dockerService.getContainer(this.container);
-        if (container) {
-            try {
-                await container.stop();
-                await container.remove();
-            }
-            catch (err) {
-                makes_1.Logger.error(err.message);
-            }
-        }
-    }
-    async stopAdmin() {
-        console.log("Mongodb Admin stopping...");
-        await this.dockerService.removeContainer(this.adminContainer);
-    }
-    async restart() {
-        await this.stop();
-        await this.start();
-    }
-    async backup(database) {
-        if (!database) {
-            database = await (0, utils_1.promptSelect)({
-                message: "Database",
-                options: await this.getDatabases()
-            });
-        }
-        const date = dateFns.format(new Date(), "yyyy-MM-dd HH-mm");
-        const dirPath = this.dataPath("dump", database);
-        const filePath = this.dataPath("dump", database, `${date}.gz`);
-        if (!makes_1.FS.existsSync(dirPath)) {
-            makes_1.FS.mkdirSync(dirPath, {
-                recursive: true
-            });
-        }
-        const stream = await this.dockerService.exec(this.container, [
-            "mongodump",
-            "--authenticationDatabase", "admin",
-            "--host", `${this.container}:27017`,
-            "--username", "root",
-            "--password", "toor",
-            "--db", database,
-            "--archive",
-            "--gzip"
-        ], false);
-        const file = makes_1.FS.createWriteStream(filePath);
-        stream.on("data", (data) => {
-            file.write((0, utils_1.demuxOutput)(data));
-        });
-        await new Promise((resolve, reject) => {
-            stream.on("end", resolve);
-            stream.on("error", reject);
-        });
-    }
-    async deleteBackup(database, filename, yes) {
-        if (!database) {
-            database = await (0, utils_1.promptSelect)({
-                message: "Database",
-                options: await this.getDatabasesDumps()
-            });
-        }
-        if (!database) {
-            throw new Error("No database");
-        }
-        const dirPath = this.dataPath("dump", database);
-        if (!makes_1.FS.existsSync(dirPath)) {
-            throw new Error(`Backups dir for database "${database}" not found`);
-        }
-        if (!filename) {
-            const files = await makes_1.FS.readdirFiles(dirPath);
-            if (files.length === 0) {
-                throw new Error(`No backups for ${database}`);
-            }
-            filename = await (0, utils_1.promptSelect)({
-                message: "File",
-                options: files
-            });
-        }
-        const filePath = this.dataPath("dump", database, filename);
-        if (!makes_1.FS.existsSync(filePath)) {
-            throw new Error(`Backup "${filename}" not found`);
-        }
-        if (!yes) {
-            yes = await (0, utils_1.promptConfirm)({
-                message: `Delete ${filename}?`,
-                default: false
-            });
-        }
-        if (!yes) {
-            return;
-        }
-        await makes_1.FS.rm(filePath);
-        const otherFiles = await makes_1.FS.readdir(dirPath);
-        if (otherFiles.length === 0) {
-            await makes_1.FS.rm(dirPath, {
-                force: true,
-                recursive: true
-            });
-        }
-    }
-    async restore(database, filename) {
-        if (!database) {
-            const dumps = await makes_1.FS.readdir(this.dataPath("dump"));
-            if (dumps.length === 0) {
-                throw new Error("No dumps found");
-            }
-            database = await (0, utils_1.promptSelect)({
-                message: "Database",
-                options: dumps
-            });
-        }
-        if (!database) {
-            throw new Error("Need database name");
-        }
-        if (!filename) {
-            const filenames = await makes_1.FS.readdir(this.dataPath("dump", database));
-            filename = await (0, utils_1.promptSelect)({
-                message: "File",
-                options: filenames
-            });
-        }
-        const path = this.dataPath("dump", database, filename);
-        const file = makes_1.FS.createReadStream(path);
-        const stream = await this.dockerService.exec(this.container, [
-            "mongorestore",
-            "--authenticationDatabase", "admin",
-            "--host", `${this.container}:27017`,
-            "--username", "root",
-            "--password", "toor",
-            "--db", database,
-            "--drop",
-            "--gzip",
-            "--archive"
-        ], false);
-        file.on("data", (data) => {
-            stream.write(data);
-        });
-        file.on("end", () => {
-            throw new Error("File end");
-        });
-        stream.on("error", (err) => {
-            file.close();
-            throw err;
-        });
-        console.log(path);
-    }
-};
-exports.MongodbPlugin = MongodbPlugin;
-exports.MongodbPlugin = MongodbPlugin = __decorate([
-    (0, core_1.Controller)(),
-    __metadata("design:paramtypes", [services_1.DockerService])
-], MongodbPlugin);

package/lib/plugins/index.d.ts

@@ -1 +0,0 @@
-export * from "./MongodbPlugin";