@wocker/ws 1.0.8 → 1.0.9

package/lib/main.js

@@ -1,11 +1,30 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.app = void 0;
 const core_1 = require("@wocker/core");
+const chalk_1 = __importDefault(require("chalk"));
 const AppModule_1 = require("./AppModule");
+const services_1 = require("./services");
 exports.app = {
     async run(args) {
-        const factory = await core_1.Factory.create(AppModule_1.AppModule);
-        return factory.run(args);
+        const app = await core_1.Factory.create(AppModule_1.AppModule);
+        const config = app.get(services_1.AppConfigService);
+        const logger = app.get(services_1.LogService);
+        try {
+            const res = await app.run(args);
+            if (res) {
+                process.stdout.write(res);
+            }
+        }
+        catch (err) {
+            console.error(chalk_1.default.red(err.message));
+            const { debug } = await config.getConfig();
+            if (debug) {
+                logger.error(err.stack || err.message);
+            }
+        }
     }
 };

package/lib/makes/FS.d.ts

@@ -2,17 +2,27 @@
 /// <reference types="node" />
 import { FS as CoreFS } from "@wocker/core";
 import * as fs from "fs";
-import { Stats, BigIntStats, PathLike, PathOrFileDescriptor, WriteFileOptions, MakeDirectoryOptions } from "fs";
+import { Stats, BigIntStats, PathLike, PathOrFileDescriptor, WriteFileOptions, ObjectEncodingOptions, MakeDirectoryOptions } from "fs";
 import { PassThrough } from "readable-stream";
+type ReaddirOptions = ObjectEncodingOptions & {
+    recursive?: boolean;
+};
 type ReaddirFilesOptions = {
     recursive?: boolean;
 };
-declare class FS extends CoreFS {
+export declare class FS extends CoreFS {
+    protected source: string;
+    constructor(source: string);
+    path(...parts: string[]): string;
+    exists(...parts: string[]): boolean;
+    stat(...parts: string[]): fs.Stats;
+    mkdir(path: string, options?: MakeDirectoryOptions): void;
+    readdir(...parts: string[]): Promise<string[]>;
+    readdirFiles(path?: string, options?: ReaddirOptions): Promise<string[]>;
     static access(path: PathLike): Promise<any>;
-    static exists(path: PathLike): Promise<boolean>;
     static existsSync(path: PathLike): boolean;
     static mkdir(dirPath: string, options?: MakeDirectoryOptions): Promise<void>;
-    static mkdirSync(path: any, options?: MakeDirectoryOptions): string;
+    static mkdirSync(path: string, options?: MakeDirectoryOptions): string;
     static readdir(path: PathLike): Promise<string[]>;
     static readdirFiles(path: string, options?: ReaddirFilesOptions): Promise<string[]>;
     static appendFile(path: PathOrFileDescriptor, data: any, options?: WriteFileOptions): Promise<unknown>;
@@ -28,4 +38,4 @@ declare class FS extends CoreFS {
     static createReadLinesStream(path: PathLike, count?: number): PassThrough;
     static copyFile(src: PathLike, dest: PathLike): Promise<void>;
 }
-export { FS };
+export {};

package/lib/makes/FS.js

@@ -29,6 +29,45 @@ const fs = __importStar(require("fs"));
 const Path = __importStar(require("path"));
 const readable_stream_1 = require("readable-stream");
 class FS extends core_1.FS {
+    constructor(source) {
+        super();
+        this.source = source;
+    }
+    path(...parts) {
+        return Path.join(this.source, ...parts);
+    }
+    exists(...parts) {
+        const fullPath = this.path(...parts);
+        return FS.existsSync(fullPath);
+    }
+    stat(...parts) {
+        const fullPath = this.path(...parts);
+        return fs.statSync(fullPath);
+    }
+    mkdir(path, options) {
+        const fullPath = this.path(path);
+        fs.mkdirSync(fullPath, options);
+    }
+    async readdir(...parts) {
+        const fullPath = this.path(...parts);
+        return FS.readdir(fullPath);
+    }
+    async readdirFiles(path, options) {
+        const fullPath = this.path(path);
+        return new Promise((resolve, reject) => {
+            fs.readdir(fullPath, options, (err, files) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                files = files.filter((path) => {
+                    const stat = this.stat(path);
+                    return stat.isFile();
+                });
+                resolve(files);
+            });
+        });
+    }
     static async access(path) {
         return new Promise((resolve, reject) => {
             fs.access(path, (err) => {
@@ -41,13 +80,6 @@ class FS extends core_1.FS {
             });
         });
     }
-    static async exists(path) {
-        return new Promise((resolve) => {
-            fs.exists(path, (exists) => {
-                resolve(exists);
-            });
-        });
-    }
     static existsSync(path) {
         return fs.existsSync(path);
     }
@@ -106,7 +138,8 @@ class FS extends core_1.FS {
                 withFileTypes: true
             }, (err, files) => {
                 if (err) {
-                    return reject(err);
+                    reject(err);
+                    return;
                 }
                 const names = files.filter((dirent) => {
                     return dirent.isFile();
@@ -160,7 +193,7 @@ class FS extends core_1.FS {
                     reject(err);
                     return;
                 }
-                fs.read(file, buffer, 0, buffer.length, position, (err, bytesRead, buffer) => {
+                fs.read(file, buffer, 0, buffer.length, position, (err, _, buffer) => {
                     if (err) {
                         reject(err);
                         return;

package/lib/makes/Http.d.ts

@@ -0,0 +1,18 @@
+import { AxiosHeaders, AxiosResponse } from "axios";
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export declare class Http {
+    readonly method: HttpMethod;
+    readonly url: string;
+    body?: any;
+    protected headers: AxiosHeaders;
+    private constructor();
+    withHeader(name: string, value: string): Http;
+    withBody(body: any): Http;
+    send(path: string): Promise<AxiosResponse>;
+    static get(url: string): Http;
+    static post(url: string): Http;
+    static put(url: string): Http;
+    static patch(url: string): Http;
+    static delete(url: string): Http;
+}
+export {};

package/lib/makes/Http.js

@@ -0,0 +1,72 @@
+"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.Http = void 0;
+const axios_1 = __importStar(require("axios"));
+class Http {
+    constructor(method = "GET", url, body) {
+        this.method = method;
+        this.url = url;
+        this.body = body;
+        this.headers = new axios_1.AxiosHeaders();
+    }
+    withHeader(name, value) {
+        this.headers.set(name, value);
+        return this;
+    }
+    withBody(body) {
+        this.body = body;
+        return this;
+    }
+    async send(path) {
+        return axios_1.default.create({
+            method: this.method,
+            baseURL: this.url,
+            headers: this.headers.toJSON(),
+            validateStatus() {
+                return true;
+            }
+        }).request({
+            url: path,
+            data: this.body
+        });
+    }
+    static get(url) {
+        return new Http("GET", url);
+    }
+    static post(url) {
+        return new Http("POST", url);
+    }
+    static put(url) {
+        return new Http("PUT", url);
+    }
+    static patch(url) {
+        return new Http("PATCH", url);
+    }
+    static delete(url) {
+        return new Http("DELETE", url);
+    }
+}
+exports.Http = Http;

package/lib/makes/Preset.d.ts

@@ -39,7 +39,7 @@ declare class Preset {
     save(): Promise<void>;
     getImageName(buildArgs?: EnvConfig): string;
     static install(ps: PresetService): void;
-    static search(options: SearchOptions): Promise<Preset[]>;
-    static searchOne(options: SearchOptions): Promise<Preset>;
+    static search(options: SearchOptions): Promise<import("@wocker/core").Preset[]>;
+    static searchOne(options: SearchOptions): Promise<import("@wocker/core").Preset>;
 }
 export { Preset };

package/lib/makes/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./FS";
+export * from "./Http";
 export * from "./Logger";
 export * from "./Preset";

package/lib/makes/index.js

@@ -15,5 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./FS"), exports);
+__exportStar(require("./Http"), exports);
 __exportStar(require("./Logger"), exports);
 __exportStar(require("./Preset"), exports);

package/lib/services/AppConfigService.d.ts

@@ -1,28 +1,18 @@
-import { AppConfig as Config, EnvConfig } from "@wocker/core";
+import { Config, AppConfigService as CoreAppConfigService } from "@wocker/core";
 type TypeMap = {
     [type: string]: string;
 };
-export declare class AppConfigService {
+export declare class AppConfigService extends CoreAppConfigService {
     protected pwd: string;
     protected mapTypes: TypeMap;
     constructor();
-    dataPath(...args: string[]): string;
-    pluginsPath(...args: string[]): string;
+    dataPath(...parts: string[]): string;
+    pluginsPath(...parts: string[]): string;
+    presetPath(...parts: string[]): string;
     getPWD(): string;
     setPWD(pwd: string): void;
-    getAppConfig(): Promise<Config>;
-    private saveAppConfig;
-    getMeta(name: string, defaultValue?: string): Promise<string>;
-    setMeta(name: string, value?: string | number): Promise<void>;
-    getAllEnvVariables(): Promise<EnvConfig>;
-    getEnvVariable(name: string, defaultValue?: string): Promise<string>;
-    setEnv(env: any): Promise<void>;
-    setEnvVariable(name: string, value: string | number): Promise<void>;
-    unsetEnv(...keys: string[]): Promise<void>;
     getProjectTypes(): TypeMap;
     registerProjectType(name: string, title?: string): void;
-    setProjectConfig(id: string, path: string): Promise<void>;
-    activatePlugin(name: string): Promise<void>;
-    deactivatePlugin(name: string): Promise<void>;
+    protected loadConfig(): Promise<Config>;
 }
 export {};

package/lib/services/AppConfigService.js

@@ -37,19 +37,23 @@ const core_1 = require("@wocker/core");
 const Path = __importStar(require("path"));
 const env_1 = require("../env");
 const makes_1 = require("../makes");
-let AppConfigService = class AppConfigService {
+let AppConfigService = class AppConfigService extends core_1.AppConfigService {
     constructor() {
+        super();
         this.mapTypes = {
             image: "Image",
             dockerfile: "Dockerfile"
         };
         this.pwd = (process.cwd() || process.env.PWD);
     }
-    dataPath(...args) {
-        return Path.join(env_1.DATA_DIR, ...args);
+    dataPath(...parts) {
+        return Path.join(env_1.DATA_DIR, ...parts);
     }
-    pluginsPath(...args) {
-        return Path.join(env_1.PLUGINS_DIR, ...args);
+    pluginsPath(...parts) {
+        return Path.join(env_1.PLUGINS_DIR, ...parts);
+    }
+    presetPath(...parts) {
+        return Path.join(env_1.PRESETS_DIR, ...parts);
     }
     getPWD() {
         return this.pwd;
@@ -57,121 +61,33 @@ let AppConfigService = class AppConfigService {
     setPWD(pwd) {
         this.pwd = pwd;
     }
-    async getAppConfig() {
-        return makes_1.FS.readJSON(env_1.MAP_PATH);
-    }
-    async saveAppConfig(config) {
-        await makes_1.FS.writeJSON(env_1.MAP_PATH, config);
-    }
-    async getMeta(name, defaultValue) {
-        const config = await this.getAppConfig();
-        const value = (config.meta || {})[name];
-        if (!value) {
-            return defaultValue;
-        }
-        return value;
-    }
-    async setMeta(name, value) {
-        const config = await this.getAppConfig();
-        if (!config.meta) {
-            config.meta = {};
-        }
-        config.meta[name] = value ? value.toString() : undefined;
-        await this.saveAppConfig(config);
-    }
-    async getAllEnvVariables() {
-        const { env = {} } = await makes_1.FS.readJSON(env_1.MAP_PATH);
-        return env;
-    }
-    async getEnvVariable(name, defaultValue) {
-        const { [name]: value = defaultValue } = await this.getAllEnvVariables();
-        if (value === null) {
-            return defaultValue;
-        }
-        return value;
-    }
-    async setEnv(env) {
-        const config = await makes_1.FS.readJSON(env_1.MAP_PATH);
-        await makes_1.FS.writeJSON(env_1.MAP_PATH, {
-            ...config,
-            env: {
-                ...config.env || {},
-                ...env
-            }
-        });
-    }
-    async setEnvVariable(name, value) {
-        const config = await makes_1.FS.readJSON(env_1.MAP_PATH);
-        await makes_1.FS.writeJSON(env_1.MAP_PATH, {
-            ...config,
-            env: {
-                ...config.env || {},
-                [name]: value
-            }
-        });
-    }
-    async unsetEnv(...keys) {
-        const config = await makes_1.FS.readJSON(env_1.MAP_PATH);
-        await makes_1.FS.writeJSON(env_1.MAP_PATH, {
-            ...config,
-            env: Object.keys(config.env || {}).reduce((res, key) => {
-                if (!keys.includes(key)) {
-                    res[key] = config.env[key];
-                }
-                return res;
-            }, {})
-        });
-    }
     getProjectTypes() {
         return this.mapTypes;
     }
     registerProjectType(name, title) {
         this.mapTypes[name] = title || name;
     }
-    async setProjectConfig(id, path) {
-        const { projects, ...rest } = await this.getAppConfig();
-        await makes_1.FS.writeJSON(env_1.MAP_PATH, {
-            ...rest,
-            projects: [
-                ...(projects || []).filter((project) => {
-                    return project.id !== id;
-                }).filter((project) => {
-                    return project.src !== path;
-                }),
-                {
-                    id: id,
-                    src: path
+    async loadConfig() {
+        const data = makes_1.FS.existsSync(env_1.MAP_PATH)
+            ? await makes_1.FS.readJSON(env_1.MAP_PATH)
+            : {};
+        return new class extends core_1.Config {
+            constructor(data) {
+                super(data);
+            }
+            addPlugin(plugin) {
+                if (!this.plugins) {
+                    this.plugins = [];
                 }
-            ]
-        });
-    }
-    async activatePlugin(name) {
-        const { default: Plugin } = await Promise.resolve(`${name}`).then(s => __importStar(require(s)));
-        if (!Plugin) {
-            throw new Error("No plugin");
-        }
-        const { plugins = [], ...rest } = await this.getAppConfig();
-        await makes_1.FS.writeJSON(env_1.MAP_PATH, {
-            plugins: [
-                ...plugins.filter((plugin) => {
-                    return plugin !== name;
-                }),
-                name
-            ],
-            ...rest
-        });
-    }
-    async deactivatePlugin(name) {
-        const { plugins = [], ...rest } = await this.getAppConfig();
-        if (!plugins.includes(name)) {
-            return;
-        }
-        await makes_1.FS.writeJSON(env_1.MAP_PATH, {
-            plugins: plugins.filter((plugin) => {
-                return plugin !== name;
-            }),
-            ...rest
-        });
+                if (this.plugins.includes(plugin)) {
+                    return;
+                }
+                this.plugins.push(plugin);
+            }
+            async save() {
+                await makes_1.FS.writeJSON(env_1.MAP_PATH, this.toJson());
+            }
+        }(data);
     }
 };
 exports.AppConfigService = AppConfigService;

package/lib/services/PluginService.d.ts

@@ -1,6 +1,13 @@
 import { Cli } from "@wocker/core";
+import { AppConfigService } from "./AppConfigService";
+import { LogService } from "./LogService";
 export declare class PluginService {
+    protected readonly appConfigService: AppConfigService;
+    protected readonly logService: LogService;
     protected readonly cli: Cli;
-    constructor(cli: Cli);
-    use(): void;
+    constructor(appConfigService: AppConfigService, logService: LogService, cli: Cli);
+    checkPlugin(pluginName: string): Promise<boolean>;
+    import(): Promise<void>;
+    update(): Promise<void>;
+    protected getCurrentVersion(name: string): Promise<string | null>;
 }

package/lib/services/PluginService.js

@@ -1,25 +1,107 @@
 "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 (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;
+};
 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.PluginService = void 0;
 const core_1 = require("@wocker/core");
+const AppConfigService_1 = require("./AppConfigService");
+const LogService_1 = require("./LogService");
+const makes_1 = require("../makes");
+const utils_1 = require("../utils");
 let PluginService = class PluginService {
-    constructor(cli) {
+    constructor(appConfigService, logService, cli) {
+        this.appConfigService = appConfigService;
+        this.logService = logService;
         this.cli = cli;
     }
-    use() {
+    async checkPlugin(pluginName) {
+        try {
+            const { default: Plugin } = await Promise.resolve(`${pluginName}`).then(s => __importStar(require(s)));
+            const name = Reflect.getMetadata(core_1.MODULE_METADATA.NAME, Plugin);
+            if (!name) {
+                console.log("No name");
+            }
+            return !!name;
+        }
+        catch (err) {
+            this.logService.error(err.message);
+        }
+        return false;
+    }
+    async import() {
+    }
+    async update() {
+        const config = await this.appConfigService.getConfig();
+        if (!config.plugins) {
+            return;
+        }
+        for (const name of new Set(config.plugins).values()) {
+            console.info(`Checking ${name}...`);
+            try {
+                const current = await this.getCurrentVersion(name);
+                const res = await makes_1.Http.get("https://registry.npmjs.org")
+                    .send(name);
+                if (res.status !== 200) {
+                    continue;
+                }
+                const { "dist-tags": { latest } } = res.data;
+                this.logService.info(name, current, latest);
+                if (!current || current < latest) {
+                    console.log(`Updating ${name}...`);
+                    await (0, utils_1.spawn)("npm", ["i", "-g", name]);
+                }
+            }
+            catch (err) {
+                this.logService.error(err.message);
+            }
+        }
+        console.info("Done");
+    }
+    async getCurrentVersion(name) {
+        try {
+            const { dependencies: { [name]: { version } } } = JSON.parse(await (0, utils_1.exec)(`npm ls --json -g ${name}`));
+            return version;
+        }
+        catch (err) {
+            this.logService.error(`Failed to get current version of ${name}`);
+        }
+        return null;
     }
 };
 exports.PluginService = PluginService;
 exports.PluginService = PluginService = __decorate([
     (0, core_1.Injectable)(),
-    __metadata("design:paramtypes", [core_1.Cli])
+    __metadata("design:paramtypes", [AppConfigService_1.AppConfigService,
+        LogService_1.LogService,
+        core_1.Cli])
 ], PluginService);

package/lib/services/PresetService.d.ts

@@ -1,5 +1,4 @@
-import { EnvConfig } from "@wocker/core";
-import { Preset } from "../makes";
+import { EnvConfig, Preset } from "@wocker/core";
 type SearchOptions = Partial<{
     name: string;
 }>;

package/lib/services/PresetService.js

@@ -1,16 +1,24 @@
 "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.PresetService = void 0;
+const core_1 = require("@wocker/core");
 const md5_1 = __importDefault(require("md5"));
 const env_1 = require("../env");
 const makes_1 = require("../makes");
-class PresetService {
-    constructor() {
-        makes_1.Preset.install(this);
-    }
+let PresetService = class PresetService {
+    constructor() { }
     getImageName(preset, buildArgs = {}) {
         const rawValues = [];
         const hashValues = [];
@@ -36,7 +44,7 @@ class PresetService {
     }
     async get(name) {
         const config = await makes_1.FS.readJSON(env_1.PRESETS_DIR, name, "config.json");
-        return new class extends makes_1.Preset {
+        return new class extends core_1.Preset {
             constructor(presetService, data) {
                 super(data);
                 this.presetService = presetService;
@@ -57,7 +65,7 @@ class PresetService {
                 continue;
             }
             const config = await makes_1.FS.readJSON(env_1.PRESETS_DIR, dir, "config.json");
-            const preset = new makes_1.Preset({
+            const preset = new core_1.Preset({
                 name: dir,
                 ...config
             });
@@ -69,5 +77,9 @@ class PresetService {
         const [preset] = await this.search(options);
         return preset || null;
     }
-}
+};
 exports.PresetService = PresetService;
+exports.PresetService = PresetService = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], PresetService);