tnp-helpers 18.0.13 → 18.0.15

package/websql/fesm2022/tnp-helpers.mjs

@@ -1,8 +1,10 @@
 import * as core from 'tnp-core/websql';
-import { _, CoreModels, Utils, CoreHelpers, crossPlatformPath, path, chalk } from 'tnp-core/websql';
+import { _, CoreModels, Utils, CoreHelpers, chalk, crossPlatformPath, path } from 'tnp-core/websql';
 import { Subject } from 'rxjs';
 import * as fuzzy from 'fuzzy';
 import { CLASS } from 'typescript-class-helpers/websql';
+import { __decorate, __param, __metadata } from 'tslib';
+import { Taon, BaseContext } from 'taon/websql';
 import { config } from 'tnp-config/websql';
 import { IncCompiler, ChangeOfFile } from 'incremental-compiler/websql';
 
@@ -1621,6 +1623,7 @@ applyMixins(HelpersTaon, [
 /* */
 /* */
 /* */
+/* */
 class BaseDb {
     constructor(ins, dbName, defaultDb) {
         this.ins = ins;
@@ -1629,7 +1632,7 @@ class BaseDb {
     }
     /* */
     /* */
-    get isUnsingDB() {
+    get isUsingDB() {
         /* */
         /* */
         return (void 0);
@@ -1706,6 +1709,524 @@ class ProjectDatabase extends BaseDb {
 ;
 ({}); // @--end-of-file-for-module=tnp-helpers lib/base/project-database.ts
 
+const WORKER_INIT_START_TIME_LIMIT = 15; // 15 seconds max to start worker
+const START_PORT_FOR_SERVICES = 3600;
+class BaseCliWorker {
+    constructor(
+    /**
+     * unique id for service
+     */
+    serviceID, 
+    /**
+     * external command that will start service
+     */
+    startCommand) {
+        this.serviceID = serviceID;
+        this.startCommand = startCommand;
+    }
+    get pathToProcessLocalInfoJson() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    get processLocalInfoObj() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    async startDetachedIfNeedsToBeStarted() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    /**
+     * stop if started
+     */
+    async kill() {
+        Helpers.log(`Killing service "${this.serviceID}"...`);
+        if (this.processLocalInfoObj.isEmpty) {
+            Helpers.log(`Service "${this.serviceID}" not started - nothing to kill...`);
+            return;
+        }
+        const ctrl = await this.getControllerForRemoteConnection();
+        try {
+            Helpers.removeFileIfExists(this.pathToProcessLocalInfoJson);
+            await ctrl.baseCLiWorkerCommand_kill().received;
+            Helpers.log(`Service "${this.serviceID}" killed...`);
+        }
+        catch (error) {
+            Helpers.log(error);
+            Helpers.log(`Service "${this.serviceID}" not killed...   `);
+        }
+    }
+    /**
+     * kill detached process and start again
+     */
+    async restart() {
+        await this.kill();
+        await this.startDetached();
+    }
+    async isServiceHealthy(options) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    /**
+     * start if not started detached process
+     */
+    async startDetached() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    async _infoScreen() {
+        while (true) {
+            Helpers.clearConsole();
+            const cfonts = require('cfonts');
+            const output = cfonts.render(`TAON.DEV`, {
+                font: 'block',
+                align: 'left',
+                colors: ['system'],
+                background: 'transparent',
+                letterSpacing: 1,
+                lineHeight: 1,
+                space: true,
+                maxLength: '0',
+                gradient: false,
+                independentGradient: false,
+                transitionGradient: false,
+                env: 'node',
+            });
+            console.log(output.string);
+            Helpers.info(`
+
+        Service ${chalk.bold.red(this.serviceID)} started..
+        Check info here http://localhost:${chalk.bold(this.processLocalInfoObj?.port?.toString())}/${'info'}
+
+          `);
+            const choices = {
+                openBrowser: {
+                    name: 'Open browser with service info',
+                },
+                exit: {
+                    name: `Shut down service`,
+                },
+            };
+            const choice = await UtilsTerminal.select({
+                choices,
+                question: 'Choose action',
+            });
+            if (choice === 'openBrowser') {
+                const openInBrowser = require('open');
+                openInBrowser(`http://localhost:${this.processLocalInfoObj.port}/info`);
+            }
+            if (choice === 'exit') {
+                process.exit(0);
+            }
+            switch (choice) {
+            }
+        }
+    }
+    saveProcessInfo(processConfig) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    async initializeWorkerMetadata() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    async waitForProcessPortSavedToDisk() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    async getServicePort() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+}
+;
+({}); // @--end-of-file-for-module=tnp-helpers lib/base/base-cli-worker.ts
+
+/* */
+/* */
+class BaseCliWorkerConfig {
+    static from(opt) {
+        return _.merge(new BaseCliWorkerConfig(), opt);
+    }
+    isEquals(other) {
+        other = BaseCliWorkerConfig.from(other);
+        return (!!this.serviceID &&
+            !!this.port &&
+            !!this.pid &&
+            this.serviceID === other.serviceID &&
+            this.port === other.port &&
+            this.pid === other.pid);
+    }
+    get isEmpty() {
+        return !this.serviceID && !this.port && !this.pid;
+    }
+    toString() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+}
+;
+({}); // @--end-of-file-for-module=tnp-helpers lib/base/base-cli-worker-config.ts
+
+let BaseCliWorkerController = class BaseCliWorkerController extends Taon.Base
+    .CrudController {
+    constructor() {
+        super(...arguments);
+        /**
+         * service id
+         */
+        this.cliWorkerServiceId = null;
+    }
+    baseCLiWorkerCommand_initializeMetadata(serviceId) {
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    baseCLiWorkerCommand_kill() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    info() {
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    baseCLiWorkerCommand_isHealthy(configWorker) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+};
+__decorate([
+    Taon.Http.PUT(),
+    __param(0, Taon.Http.Param.Body('serviceId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Object)
+], BaseCliWorkerController.prototype, "baseCLiWorkerCommand_initializeMetadata", null);
+__decorate([
+    Taon.Http.GET(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Object)
+], BaseCliWorkerController.prototype, "baseCLiWorkerCommand_kill", null);
+__decorate([
+    Taon.Http.GET({
+        pathIsGlobal: true,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Object)
+], BaseCliWorkerController.prototype, "info", null);
+__decorate([
+    Taon.Http.POST(),
+    __param(0, Taon.Http.Param.Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [BaseCliWorkerConfig]),
+    __metadata("design:returntype", Object)
+], BaseCliWorkerController.prototype, "baseCLiWorkerCommand_isHealthy", null);
+BaseCliWorkerController = __decorate([
+    Taon.Controller({
+        className: 'BaseCliWorkerController',
+    })
+], BaseCliWorkerController);
+;
+({}); // @--end-of-file-for-module=tnp-helpers lib/base/base-cli-worker-controller.ts
+
+var Port_1;
+let Port = Port_1 = class Port extends Taon.Base.AbstractEntity {
+    static from(opt) {
+        return _.merge(new Port_1(), opt);
+    }
+};
+__decorate([
+    Taon.Orm.Column.Custom({
+        type: 'int',
+        unique: true,
+    }),
+    __metadata("design:type", Number)
+], Port.prototype, "port", void 0);
+__decorate([
+    Taon.Orm.Column.String(),
+    __metadata("design:type", String)
+], Port.prototype, "type", void 0);
+__decorate([
+    Taon.Orm.Column.Custom({
+        type: 'varchar',
+        length: 150,
+    }),
+    __metadata("design:type", String)
+], Port.prototype, "serviceId", void 0);
+Port = Port_1 = __decorate([
+    Taon.Entity({
+        className: 'Port',
+    })
+], Port);
+let PortsController = class PortsController extends BaseCliWorkerController {
+    constructor() {
+        super(...arguments);
+        this.entityClassResolveFn = () => Port;
+    }
+    async initExampleDbData() {
+        await this.db.save(Port.from({
+            port: 4200,
+            type: 'in-use-by-os-or-other-apps',
+            serviceId: 'angular dev server',
+        }));
+        await this.db.save(Port.from({
+            port: 3000,
+            type: 'in-use-by-os-or-other-apps',
+            serviceId: 'standard nodejs server',
+        }));
+    }
+};
+PortsController = __decorate([
+    Taon.Controller({
+        className: 'PortsController',
+    })
+], PortsController);
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+/* */
+var PortsContext = Taon.createContext(() => ({
+    contextName: 'PortsContext',
+    contexts: { BaseContext },
+    controllers: { PortsController },
+    entities: { Port },
+    /* */
+    /* */
+    /* */
+    /* */
+    logs: {},
+}));
+class PortsWorker extends BaseCliWorker {
+    async getControllerForRemoteConnection() {
+        await this.waitForProcessPortSavedToDisk();
+        const refRemote = await PortsContext.initialize({
+            overrideRemoteHost: `http://localhost:${this.processLocalInfoObj.port}`,
+        });
+        return refRemote.getInstanceBy(PortsController);
+    }
+    /**
+     * start normally process
+     * this will crash if process already started
+     */
+    async startNormallyInCurrentProcess() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+}
+;
+({}); // @--end-of-file-for-module=tnp-helpers lib/base/ports-worker.ts
+
 /* */
 /* */
 /* */
@@ -1716,12 +2237,9 @@ class ProjectDatabase extends BaseDb {
 /* */
 /* */
 class BaseProjectResolver {
-    constructor(classFn) {
+    constructor(classFn, cliToolName) {
         this.classFn = classFn;
-        /**
-         * general name for project company
-         */
-        this.orgName = 'taon';
+        this.cliToolName = cliToolName;
         this.configDb = new ConfigDatabase(this);
         this.projectsDb = new ProjectDatabase(this);
         this.NPM_PROJECT_KEY = 'npm';
@@ -1731,6 +2249,11 @@ class BaseProjectResolver {
          * This may break things that are creating new projects
          */
         this.emptyLocations = [];
+        this.cliToolName = cliToolName;
+        if (!this.cliToolName) {
+            Helpers.throw(`cliToolName is not provided`);
+        }
+        this.portsWorker = new PortsWorker('ports-worker', `${this.cliToolName} startCliServicePortsWorker --skipCoreCheck`);
     }
     get allowedTypes() {
         return [this.NPM_PROJECT_KEY];
@@ -1987,7 +2510,7 @@ class BaseProjectResolver {
 /* */
 const takenPorts = [];
 class BaseProject {
-    static { this.ins = new BaseProjectResolver(BaseProject); }
+    static { this.ins = new BaseProjectResolver(BaseProject, 'taon'); }
     static { this.cache = {}; }
     get globalCache() {
         return BaseProject.cache;