@wocker/ws 1.0.21 → 1.0.23

package/lib/controllers/ImageController.js

@@ -1,46 +0,0 @@
-"use strict";
-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 __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImageController = void 0;
-const core_1 = require("@wocker/core");
-const cli_table3_1 = __importDefault(require("cli-table3"));
-const services_1 = require("../services");
-let ImageController = class ImageController {
-    constructor(appConfigService, dockerService) {
-        this.appConfigService = appConfigService;
-        this.dockerService = dockerService;
-    }
-    async list() {
-        const images = await this.dockerService.imageLs({});
-        const table = new cli_table3_1.default({
-            head: ["Name"]
-        });
-        for (const image of images) {
-            table.push([image.Id]);
-        }
-        return table.toString();
-    }
-};
-exports.ImageController = ImageController;
-__decorate([
-    (0, core_1.Command)("images"),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], ImageController.prototype, "list", null);
-exports.ImageController = ImageController = __decorate([
-    (0, core_1.Controller)(),
-    __metadata("design:paramtypes", [services_1.AppConfigService,
-        services_1.DockerService])
-], ImageController);

package/lib/makes/FS.d.ts

@@ -1,27 +0,0 @@
-import { FS as CoreFS } from "@wocker/core";
-import * as fs from "fs";
-import { Stats, BigIntStats, PathLike, PathOrFileDescriptor, WriteFileOptions, MakeDirectoryOptions } from "fs";
-import { PassThrough } from "readable-stream";
-type ReaddirFilesOptions = {
-    recursive?: boolean;
-};
-export declare class FS extends CoreFS {
-    static access(path: PathLike): Promise<any>;
-    static existsSync(path: PathLike): boolean;
-    static mkdir(dirPath: string, options?: MakeDirectoryOptions): Promise<void>;
-    static mkdirSync(path: string, options?: MakeDirectoryOptions): string;
-    static readdirFiles(path: string, options?: ReaddirFilesOptions): Promise<string[]>;
-    static appendFile(path: PathOrFileDescriptor, data: any, options?: WriteFileOptions): Promise<void>;
-    static appendFileSync(path: PathOrFileDescriptor, data: any, options?: WriteFileOptions): void;
-    static readBytes(filePath: PathLike, position?: number | bigint, size?: number | bigint): Promise<Buffer>;
-    static readFileSync(filePath: PathLike): Buffer<ArrayBufferLike>;
-    static writeFileSync(path: PathLike, data: any, options?: WriteFileOptions): void;
-    static createWriteStream(path: PathLike): fs.WriteStream;
-    static unlink(filePath: PathLike): Promise<void>;
-    static watch(filename: PathLike, options?: any): fs.FSWatcher;
-    static stat(filename: PathLike, options?: Parameters<typeof fs.stat>[1]): Promise<Stats | BigIntStats>;
-    static createReadStream(path: PathLike, options?: Parameters<typeof fs.createReadStream>[1]): fs.ReadStream;
-    static createReadLinesStream(path: PathLike, count?: number): PassThrough;
-    static copyFile(src: PathLike, dest: PathLike): Promise<void>;
-}
-export {};

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/Model.d.ts

@@ -1,5 +0,0 @@
-export declare class Model {
-    attributes: {};
-    constructor(attributes?: any);
-    save(): Promise<void>;
-}

package/lib/makes/Model.js

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

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>;
-}