badmfck-api-server 4.1.28 → 4.1.29

package/dist/apiServer/APIService.d.ts

@@ -5,6 +5,7 @@ import { IBaseEndpoint } from './BaseEndpoint';
 import { HTTPRequestVO, IError, TransferPacketVO } from './structures/Interfaces';
 import Signal, { Req } from "badmfck-signal";
 import http from 'http';
+import { IDeployerServiceOptions } from './deployment/DeployerService';
 export interface IMonitorUser {
     login: string;
     password: string;
@@ -12,6 +13,8 @@ export interface IMonitorUser {
 export interface IDocumentationUser extends IMonitorUser {
     endpoints?: string[];
 }
+export interface IDeployerUser extends IMonitorUser {
+}
 export interface APIServiceNetworkLogItem {
     id: number;
     created: number;
@@ -45,6 +48,7 @@ export interface APIServiceOptions<TInterceptor = unknown> {
         monitor?: IMonitorUser[];
         documentation?: IDocumentationUser[];
     };
+    deployer?: IDeployerServiceOptions | null;
     appVersion?: string;
     fileTempDir: string;
     fileLimit: number;
@@ -68,6 +72,7 @@ export declare class APIService<TInterceptorResult = any, TInternalCallParams =
     private version;
     private options;
     private monitor;
+    private deployer;
     private started;
     private requestsCount;
     private noCors;

package/dist/apiServer/APIService.js

@@ -48,6 +48,8 @@ const MysqlAdapter_1 = require("./db/MysqlAdapter");
 const DocumentService_1 = require("./DocumentService");
 const Documentation_1 = require("./documentation/Documentation");
 const MicroserviceHostController_1 = require("./external/MicroserviceHostController");
+const DeployerService_1 = require("./deployment/DeployerService");
+const Deployer_1 = require("./deployment/Deployer");
 let nextLogID = 0;
 function defaultOptions() {
     return {
@@ -110,6 +112,7 @@ class APIService extends BaseService_1.BaseService {
     version = PACKAGE_VERSION;
     options;
     monitor = null;
+    deployer = null;
     started = new Date();
     requestsCount = 0;
     noCors = false;
@@ -146,6 +149,11 @@ class APIService extends BaseService_1.BaseService {
         new DocumentService_1.DocumentGenerator(this.options.endpoints);
         this.monitor = new MonitorService_1.MonitorService();
         this.monitor.init();
+        if (this.options.deployer && this.options.deployer.users.length > 0) {
+            this.options.endpoints.push(new Deployer_1.Deployer());
+            this.deployer = new DeployerService_1.DeployerService(this.options.deployer);
+            this.deployer.init();
+        }
         this.options.endpoints.push(new Liveness_1.Liveness(this.started), new Readiness_1.Readiness(this.started));
         exports.REQ_HTTP_REQUESTS_COUNT.listener = async () => this.requestsCount;
     }

package/dist/apiServer/deployment/ConfigService.d.ts

@@ -0,0 +1,148 @@
+import Signal, { Req } from "badmfck-signal";
+import { BaseService } from "../BaseService";
+import { ValidationModel } from "../helper/Validator";
+import { IError } from "../structures/Interfaces";
+declare const _ProjectState: {
+    readonly active: "";
+    readonly $__active_values: readonly ["blue", "green"];
+    readonly lastDeployed: "";
+    readonly $__lastDeployed_values: readonly ["blue", "green"];
+    readonly history: readonly [{
+        readonly slot: "";
+        readonly $__slot_values: readonly ["blue", "green"];
+        readonly action: "";
+        readonly $__action_values: readonly ["deploy", "switch", "rollback"];
+        readonly user: "";
+        readonly at: 0;
+    }];
+};
+export type IProjectState = ValidationModel<typeof _ProjectState>;
+declare const _TConfig: {
+    readonly name: "";
+    readonly destination: "";
+    readonly description: "";
+    readonly token: "";
+    readonly unpack: true;
+    readonly ignoreDirectoryClean: false;
+    readonly backup: true;
+    readonly install: true;
+    readonly pm2: true;
+    readonly pm2_attributes: readonly [""];
+    readonly $__pm2_attributes_optional: true;
+    readonly chmod: 0;
+    readonly email: readonly [""];
+    readonly phone: readonly [""];
+    readonly liveness: "";
+    readonly $__liveness_optional: true;
+    readonly readiness: "";
+    readonly $__readiness_optional: true;
+    readonly config: {};
+    readonly bluegreen: {
+        readonly blue_config: {};
+        readonly blue_pm2_attributes: readonly [""];
+        readonly $__blue_pm2_attributes_optional: true;
+        readonly green_config: {};
+        readonly green_pm2_attributes: readonly [""];
+        readonly $__green_pm2_attributes_optional: true;
+        readonly on_switch: readonly [""];
+        readonly $__on_switch_optional: true;
+    };
+    readonly $__bluegreen_optional: true;
+    readonly nginx: {};
+    readonly $__nginx_optional: true;
+};
+export type IConfig = ValidationModel<typeof _TConfig>;
+export declare const REQ_DEPLOYMENT_CONFIG: Req<void, Map<string, {
+    pm2_attributes?: string[] | undefined;
+    liveness?: string | undefined;
+    readiness?: string | undefined;
+    bluegreen?: {
+        blue_pm2_attributes?: string[] | undefined;
+        green_pm2_attributes?: string[] | undefined;
+        on_switch?: string[] | undefined;
+        blue_config: {};
+        green_config: {};
+    } | undefined;
+    nginx?: {} | undefined;
+    name: string;
+    destination: string;
+    description: string;
+    token: string;
+    unpack: boolean;
+    ignoreDirectoryClean: boolean;
+    backup: boolean;
+    install: boolean;
+    pm2: boolean;
+    chmod: number;
+    email: string[];
+    phone: string[];
+    config: {};
+}>>;
+export declare const REQ_DEPLOYMENT_CONFIG_ADD: Req<{
+    pm2_attributes?: string[] | undefined;
+    liveness?: string | undefined;
+    readiness?: string | undefined;
+    bluegreen?: {
+        blue_pm2_attributes?: string[] | undefined;
+        green_pm2_attributes?: string[] | undefined;
+        on_switch?: string[] | undefined;
+        blue_config: {};
+        green_config: {};
+    } | undefined;
+    nginx?: {} | undefined;
+    name: string;
+    destination: string;
+    description: string;
+    token: string;
+    unpack: boolean;
+    ignoreDirectoryClean: boolean;
+    backup: boolean;
+    install: boolean;
+    pm2: boolean;
+    chmod: number;
+    email: string[];
+    phone: string[];
+    config: {};
+}, IError | {
+    pm2_attributes?: string[] | undefined;
+    liveness?: string | undefined;
+    readiness?: string | undefined;
+    bluegreen?: {
+        blue_pm2_attributes?: string[] | undefined;
+        green_pm2_attributes?: string[] | undefined;
+        on_switch?: string[] | undefined;
+        blue_config: {};
+        green_config: {};
+    } | undefined;
+    nginx?: {} | undefined;
+    name: string;
+    destination: string;
+    description: string;
+    token: string;
+    unpack: boolean;
+    ignoreDirectoryClean: boolean;
+    backup: boolean;
+    install: boolean;
+    pm2: boolean;
+    chmod: number;
+    email: string[];
+    phone: string[];
+    config: {};
+}>;
+export declare const REQ_DEPLOYMENT_CONFIG_DELETE: Req<string, boolean | IError>;
+export declare const S_CONFIG_UPDATED: Signal<void>;
+export declare class ConfigService extends BaseService {
+    private configurations;
+    private dir;
+    private busy;
+    private retake;
+    private watchDebounceTimer;
+    constructor(dir: string);
+    init(): Promise<void>;
+    configurationDelete(name: string): Promise<IError | boolean>;
+    configurationAdd(req: IConfig): Promise<IError | IConfig>;
+    getConfig(): void;
+    validateRequest(data: IConfig): Promise<IError | undefined>;
+    checkName(name: string): IError | undefined;
+}
+export {};

package/dist/apiServer/deployment/ConfigService.js

@@ -0,0 +1,229 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigService = exports.S_CONFIG_UPDATED = exports.REQ_DEPLOYMENT_CONFIG_DELETE = exports.REQ_DEPLOYMENT_CONFIG_ADD = exports.REQ_DEPLOYMENT_CONFIG = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const badmfck_signal_1 = __importStar(require("badmfck-signal"));
+const BaseService_1 = require("../BaseService");
+const Validator_1 = require("../helper/Validator");
+const LogService_1 = require("../LogService");
+const DefaultErrors_1 = __importStar(require("../structures/DefaultErrors"));
+const _ProjectState = {
+    active: "",
+    $__active_values: ["blue", "green"],
+    lastDeployed: "",
+    $__lastDeployed_values: ["blue", "green"],
+    history: [{
+            slot: "",
+            $__slot_values: ["blue", "green"],
+            action: "",
+            $__action_values: ["deploy", "switch", "rollback"],
+            user: "",
+            at: 0,
+        }],
+};
+const _TConfig = {
+    name: "",
+    destination: "",
+    description: "",
+    token: "",
+    unpack: true,
+    ignoreDirectoryClean: false,
+    backup: true,
+    install: true,
+    pm2: true,
+    pm2_attributes: [""],
+    $__pm2_attributes_optional: true,
+    chmod: 0,
+    email: [""],
+    phone: [""],
+    liveness: "",
+    $__liveness_optional: true,
+    readiness: "",
+    $__readiness_optional: true,
+    config: {},
+    bluegreen: {
+        blue_config: {},
+        blue_pm2_attributes: [""],
+        $__blue_pm2_attributes_optional: true,
+        green_config: {},
+        green_pm2_attributes: [""],
+        $__green_pm2_attributes_optional: true,
+        on_switch: [""],
+        $__on_switch_optional: true,
+    },
+    $__bluegreen_optional: true,
+    nginx: {},
+    $__nginx_optional: true,
+};
+exports.REQ_DEPLOYMENT_CONFIG = new badmfck_signal_1.Req();
+exports.REQ_DEPLOYMENT_CONFIG_ADD = new badmfck_signal_1.Req();
+exports.REQ_DEPLOYMENT_CONFIG_DELETE = new badmfck_signal_1.Req();
+exports.S_CONFIG_UPDATED = new badmfck_signal_1.default();
+class ConfigService extends BaseService_1.BaseService {
+    configurations = new Map();
+    dir;
+    busy = false;
+    retake = false;
+    watchDebounceTimer = null;
+    constructor(dir) {
+        super("ConfigService");
+        this.dir = dir;
+    }
+    async init() {
+        super.init();
+        exports.REQ_DEPLOYMENT_CONFIG.listener = async (req) => this.configurations;
+        exports.REQ_DEPLOYMENT_CONFIG_ADD.listener = async (req) => this.configurationAdd(req);
+        exports.REQ_DEPLOYMENT_CONFIG_DELETE.listener = async (name) => this.configurationDelete(name);
+        if (!fs_1.default.existsSync(this.dir))
+            fs_1.default.mkdirSync(this.dir, { recursive: true });
+        this.getConfig();
+        fs_1.default.watch(this.dir, (_eventType, filename) => {
+            if (!filename || !filename.endsWith(".json"))
+                return;
+            if (this.watchDebounceTimer)
+                clearTimeout(this.watchDebounceTimer);
+            this.watchDebounceTimer = setTimeout(() => {
+                this.watchDebounceTimer = null;
+                this.getConfig();
+            }, 200);
+        });
+        setInterval(() => this.getConfig(), 60_000).unref();
+    }
+    async configurationDelete(name) {
+        try {
+            fs_1.default.unlinkSync(path_1.default.resolve(this.dir, name + ".json"));
+        }
+        catch (e) {
+            return { code: 33, message: "Can't delete configuration file." };
+        }
+        this.getConfig();
+        return true;
+    }
+    async configurationAdd(req) {
+        const err = await this.validateRequest(req);
+        if (DefaultErrors_1.ErrorUtils.isError(err))
+            return err;
+        try {
+            fs_1.default.writeFileSync(path_1.default.resolve(this.dir, req.name + ".json"), JSON.stringify(req));
+        }
+        catch (e) {
+            return { code: 31, message: "Can't write configuration file." };
+        }
+        this.getConfig();
+        const conf = this.configurations.get(req.name);
+        if (!conf)
+            return { code: 32, message: "Can't read configuration file." };
+        return conf;
+    }
+    getConfig() {
+        if (this.busy) {
+            this.retake = true;
+            return;
+        }
+        this.retake = false;
+        this.busy = true;
+        const temp = new Map();
+        let isError = false;
+        try {
+            const files = fs_1.default.readdirSync(this.dir);
+            for (let f of files) {
+                if (f.indexOf(".json") === -1)
+                    continue;
+                try {
+                    const file = fs_1.default.readFileSync(path_1.default.resolve(this.dir, f));
+                    const config = JSON.parse(file.toString());
+                    temp.set(config.name, config);
+                }
+                catch (e) {
+                    isError = true;
+                    (0, LogService_1.logError)("Can't read config file: " + f, e);
+                }
+            }
+            if (!isError) {
+                this.configurations = temp;
+                exports.S_CONFIG_UPDATED.invoke();
+                (0, LogService_1.logWarn)("Configurations updated");
+            }
+        }
+        catch (e) {
+            (0, LogService_1.logError)("Can't read config directory", e);
+        }
+        this.busy = false;
+        if (this.retake) {
+            this.retake = false;
+            this.getConfig();
+        }
+    }
+    async validateRequest(data) {
+        const validationErrors = await Validator_1.Validator.validateStructure(_TConfig, data);
+        if (validationErrors && validationErrors.length > 0)
+            return { ...DefaultErrors_1.default.INVALID_DATA, stack: validationErrors, details: "Invalid configuration data." };
+        const errors = [];
+        const cname = this.checkName(data.name);
+        if (DefaultErrors_1.ErrorUtils.isError(cname))
+            errors.push(cname);
+        let dest = data.destination.replace(/[^a-zA-Z0-9.\/_\-`~!]/g, "");
+        dest = dest.replace("./", "").replace("../", "").replace("..\\", "").replace(".\\", "");
+        if (dest !== data.destination)
+            errors.push({ code: 22, message: "Incorrect destination." });
+        if (data.email) {
+            if (typeof data.email === "string") {
+                if (Validator_1.Validator.validateValue(data.email, { type: "string", min: 5, max: 128 }) !== Validator_1.ValidationReport.OK)
+                    errors.push({ code: 29, message: "Invalid email." });
+            }
+            else if (Array.isArray(data.email)) {
+                for (let i of data.email) {
+                    if (Validator_1.Validator.validateValue(i, { type: "string", min: 5, max: 128 }) !== Validator_1.ValidationReport.OK)
+                        errors.push({ code: 29, message: "Invalid email." });
+                }
+            }
+        }
+        if (data.phone) {
+            if (typeof data.phone === "string") {
+                if (Validator_1.Validator.validateValue(data.phone, { type: "string", min: 9, max: 16 }) !== Validator_1.ValidationReport.OK)
+                    errors.push({ code: 30, message: "Invalid phone." });
+            }
+            else if (Array.isArray(data.phone)) {
+                for (let i of data.phone) {
+                    if (Validator_1.Validator.validateValue(i, { type: "string", min: 9, max: 16 }) !== Validator_1.ValidationReport.OK)
+                        errors.push({ code: 30, message: "Invalid phone." });
+                }
+            }
+        }
+        if (errors.length > 0)
+            return { ...DefaultErrors_1.default.INVALID_DATA, stack: errors, details: "Invalid configuration data." };
+    }
+    checkName(name) {
+        const n = name.replace(/[^a-zA-Z0-9\.\-]/g, "");
+        if (n !== name)
+            return { code: 21, message: "Incorrect name." };
+    }
+}
+exports.ConfigService = ConfigService;

package/dist/apiServer/deployment/Deployer.d.ts

@@ -0,0 +1,8 @@
+import { BaseEndpoint } from "../BaseEndpoint";
+import { HTTPRequestVO, TransferPacketVO } from "../structures/Interfaces";
+export declare class Deployer extends BaseEndpoint {
+    constructor();
+    file(req: HTTPRequestVO): Promise<TransferPacketVO<any>>;
+    switchSlot(req: HTTPRequestVO): Promise<TransferPacketVO<any>>;
+    status(req: HTTPRequestVO): Promise<TransferPacketVO<any>>;
+}

package/dist/apiServer/deployment/Deployer.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deployer = void 0;
+const BaseEndpoint_1 = require("../BaseEndpoint");
+const DeployerService_1 = require("./DeployerService");
+class Deployer extends BaseEndpoint_1.BaseEndpoint {
+    constructor() {
+        super("pckg");
+        this.registerEndpoints([
+            {
+                ignoreInterceptor: true,
+                endpoint: "add",
+                handler: this.file,
+                validationModel: {
+                    token: "",
+                    name: "",
+                }
+            },
+            {
+                ignoreInterceptor: true,
+                endpoint: "switch",
+                handler: this.switchSlot,
+                validationModel: {
+                    token: "",
+                    name: "",
+                    scheme: "",
+                    $__scheme_values: ["blue", "green"],
+                    $__scheme_optional: true
+                }
+            },
+            {
+                ignoreInterceptor: true,
+                endpoint: "status",
+                handler: this.status,
+                validationModel: {
+                    name: "",
+                    $__name_optional: true
+                }
+            }
+        ]);
+    }
+    async file(req) {
+        if (!req.files)
+            return { error: { code: 10, message: "No files were uploaded.", httpStatus: 400 } };
+        const result = await DeployerService_1.REQ_DEPLOYMENT_PROCEED.request({ ...req.data, files: req.files, auth: req.headers.authorization });
+        return { data: result };
+    }
+    async switchSlot(req) {
+        return await DeployerService_1.REQ_DEPLOYMENT_SWITCH.request({ ...req.data, auth: req.headers.authorization });
+    }
+    async status(req) {
+        return await DeployerService_1.REQ_DEPLOYMENT_STATUS.request({ ...req.data, auth: req.headers.authorization });
+    }
+}
+exports.Deployer = Deployer;

package/dist/apiServer/deployment/DeployerService.d.ts

@@ -0,0 +1,109 @@
+import { Req } from "badmfck-signal";
+import { BaseService } from "../BaseService";
+import { IDeployerUser } from "../APIService";
+import { IConfig, IProjectState } from "./ConfigService";
+import { UploadedFile } from "express-fileupload";
+import { IDeploymentNotifier } from "./Notifier";
+import { IError } from "../structures/Interfaces";
+export interface IDeployerServiceOptions {
+    projects_path: string;
+    users: IDeployerUser[];
+    watchdog?: boolean;
+    notifier?: {
+        URL?: string;
+        KEY?: string;
+        controller?: BaseService;
+    } | null;
+}
+export declare const REQ_DEPLOYMENT_PROCEED: Req<{
+    auth: string;
+    name: string;
+    token: string;
+    files: {
+        file: UploadedFile;
+    };
+}, any>;
+export declare const REQ_DEPLOYMENT_SWITCH: Req<{
+    auth?: string | undefined;
+    name: string;
+    token: string;
+    scheme?: "blue" | "green" | undefined;
+}, any>;
+export declare const REQ_DEPLOYMENT_STATUS: Req<{
+    auth?: string | undefined;
+    name?: string | undefined;
+}, any>;
+export declare class DeployerService extends BaseService {
+    options: IDeployerServiceOptions;
+    notifier: IDeploymentNotifier | null;
+    busy: Map<string, boolean>;
+    constructor(options: IDeployerServiceOptions);
+    init(): Promise<void>;
+    proceed(data: {
+        auth?: string;
+        name: string;
+        token: string;
+        files: {
+            file: UploadedFile;
+        };
+    }): Promise<{
+        error: {
+            code: number;
+            message: string;
+            httpStatus: number;
+        };
+        data?: undefined;
+    } | {
+        data: boolean;
+        error?: undefined;
+    }>;
+    switchSlot(data: {
+        auth?: string;
+        name: string;
+        token: string;
+        scheme?: "blue" | "green";
+    }): Promise<{
+        error: {
+            code: number;
+            message: string;
+            httpStatus: number;
+        };
+        data?: undefined;
+    } | {
+        data: {
+            active: "blue" | "green";
+            previousActive: "blue" | "green";
+            action: "rollback" | "switch";
+            hookError: string | null;
+        };
+        error?: undefined;
+    }>;
+    status(data: {
+        auth?: string;
+        name?: string;
+    }): Promise<{
+        error: {
+            code: number;
+            message: string;
+            httpStatus: number;
+        };
+        data?: undefined;
+    } | {
+        data: Record<string, {
+            hasBlueGreen: boolean;
+            state: IProjectState | null;
+            readyToSwitch: boolean;
+        }>;
+        error?: undefined;
+    }>;
+    tokensMatch(a: string | undefined, b: string | undefined): boolean;
+    private _checkUserAuth;
+    runPM2(found: IConfig, projectState?: IProjectState | null): Promise<IError | null>;
+    private static readonly SKIP_DIRS;
+    private static readonly TEMPLATE_EXTENSIONS;
+    applyConfig(dir: string, config: Record<string, string>): Promise<void>;
+    processFile(filePath: string, config: Record<string, string>): Promise<void>;
+    private _isDestinationSafe;
+    unpack(destination: string, uploadedFile: string, install?: boolean, ignoreDirectoryClean?: boolean): Promise<IError | null>;
+    upload(file: UploadedFile, uploadPath: string): Promise<IError | null>;
+}