@hubspot/local-dev-lib 0.0.7 → 0.0.9

package/utils/PortManagerServer.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { Express, Request, Response } from 'express';
+import { Server } from 'http';
+import { RequestPortsData } from '../types/PortManager';
+type ServerPortMap = {
+    [instanceId: string]: number;
+};
+declare class PortManagerServer {
+    app?: Express;
+    server?: Server;
+    serverPortMap: ServerPortMap;
+    constructor();
+    init(): Promise<void>;
+    reset(): void;
+    listen(): Promise<Server>;
+    setupRoutes(): void;
+    setPort(instanceId: string, port: number): void;
+    deletePort(instanceId: string): void;
+    send404(res: Response, instanceId: string): void;
+    getServers: (req: Request, res: Response) => Promise<void>;
+    getServerPortByInstanceId: (req: Request, res: Response) => void;
+    assignPortsToServers: (req: Request<never, never, {
+        portData: Array<RequestPortsData>;
+    }>, res: Response) => Promise<void>;
+    deleteServerInstance: (req: Request, res: Response) => void;
+    closeServer: (req: Request, res: Response) => void;
+}
+declare const _default: PortManagerServer;
+export default _default;

package/utils/PortManagerServer.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const detectPort_1 = require("./detectPort");
+const ports_1 = require("../constants/ports");
+const standardErrors_1 = require("../errors/standardErrors");
+const logger_1 = require("./logger");
+const lang_1 = require("./lang");
+const i18nKey = 'utils.PortManagerServer';
+class PortManagerServer {
+    app;
+    server;
+    serverPortMap;
+    constructor() {
+        this.serverPortMap = {};
+    }
+    async init() {
+        if (this.app) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.duplicateInstance`);
+        }
+        this.app = (0, express_1.default)();
+        this.app.use(express_1.default.json());
+        this.app.use((0, cors_1.default)());
+        this.setupRoutes();
+        try {
+            this.server = await this.listen();
+        }
+        catch (e) {
+            const error = e;
+            if (error.code === 'EADDRINUSE') {
+                (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.portInUse`, {
+                    port: ports_1.PORT_MANAGER_SERVER_PORT,
+                }, error);
+            }
+            throw error;
+        }
+    }
+    reset() {
+        this.app = undefined;
+        this.server = undefined;
+        this.serverPortMap = {};
+    }
+    listen() {
+        return new Promise((resolve, reject) => {
+            const server = this.app.listen(ports_1.PORT_MANAGER_SERVER_PORT, () => {
+                (0, logger_1.debug)(`${i18nKey}.started`, {
+                    port: ports_1.PORT_MANAGER_SERVER_PORT,
+                });
+                resolve(server);
+            }).on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+    setupRoutes() {
+        if (!this.app) {
+            return;
+        }
+        this.app.get('/servers', this.getServers);
+        this.app.get('/servers/:instanceId', this.getServerPortByInstanceId);
+        this.app.post('/servers', this.assignPortsToServers);
+        this.app.delete('/servers/:instanceId', this.deleteServerInstance);
+        this.app.post('/close', this.closeServer);
+    }
+    setPort(instanceId, port) {
+        (0, logger_1.debug)(`${i18nKey}.setPort`, { instanceId, port });
+        this.serverPortMap[instanceId] = port;
+    }
+    deletePort(instanceId) {
+        (0, logger_1.debug)(`${i18nKey}.deletedPort`, {
+            instanceId,
+            port: this.serverPortMap[instanceId],
+        });
+        delete this.serverPortMap[instanceId];
+    }
+    send404(res, instanceId) {
+        res
+            .status(404)
+            .send((0, lang_1.i18n)(`${i18nKey}.errors.404`, { instanceId: instanceId }));
+    }
+    getServers = async (req, res) => {
+        res.send({
+            servers: this.serverPortMap,
+            count: Object.keys(this.serverPortMap).length,
+        });
+    };
+    getServerPortByInstanceId = (req, res) => {
+        const { instanceId } = req.params;
+        const port = this.serverPortMap[instanceId];
+        if (port) {
+            res.send({ port });
+        }
+        else {
+            this.send404(res, instanceId);
+        }
+    };
+    assignPortsToServers = async (req, res) => {
+        const { portData } = req.body;
+        const portPromises = [];
+        for (let i = 0; i < portData.length; i++) {
+            const { port, instanceId } = portData[i];
+            if (this.serverPortMap[instanceId]) {
+                res.status(409).send((0, lang_1.i18n)(`${i18nKey}.errors.409`, {
+                    instanceId,
+                    port: this.serverPortMap[instanceId],
+                }));
+                return;
+            }
+            else if (port && (port < ports_1.MIN_PORT_NUMBER || port > ports_1.MAX_PORT_NUMBER)) {
+                res.status(400).send((0, lang_1.i18n)(`${i18nKey}.errors.400`, {
+                    minPort: ports_1.MIN_PORT_NUMBER,
+                    maxPort: ports_1.MAX_PORT_NUMBER,
+                }));
+                return;
+            }
+            else {
+                const promise = new Promise(resolve => {
+                    (0, detectPort_1.detectPort)(port, Object.values(this.serverPortMap)).then(resolvedPort => {
+                        resolve({
+                            [instanceId]: resolvedPort,
+                        });
+                    });
+                });
+                portPromises.push(promise);
+            }
+        }
+        const portList = await Promise.all(portPromises);
+        const ports = portList.reduce((a, c) => Object.assign(a, c));
+        for (const instanceId in ports) {
+            this.setPort(instanceId, ports[instanceId]);
+        }
+        res.send({ ports });
+    };
+    deleteServerInstance = (req, res) => {
+        const { instanceId } = req.params;
+        const port = this.serverPortMap[instanceId];
+        if (port) {
+            this.deletePort(instanceId);
+            res.send(200);
+        }
+        else {
+            this.send404(res, instanceId);
+        }
+    };
+    closeServer = (req, res) => {
+        if (this.server) {
+            (0, logger_1.debug)(`${i18nKey}.close`);
+            res.send(200);
+            this.server.close();
+            this.reset();
+        }
+    };
+}
+exports.default = new PortManagerServer();

package/utils/cms/modules.js

@@ -8,6 +8,7 @@ const path_1 = __importDefault(require("path"));
 const path_2 = require("../../lib/path");
 const extensions_1 = require("../../constants/extensions");
 const standardErrors_1 = require("../../errors/standardErrors");
+const i18nKey = 'utils.cms.modules';
 const isBool = (x) => !!x === x;
 function isPathInput(pathInput) {
     return !!(pathInput &&
@@ -18,7 +19,7 @@ exports.isPathInput = isPathInput;
 function throwInvalidPathInput(pathInput) {
     if (isPathInput(pathInput))
         return;
-    (0, standardErrors_1.throwTypeErrorWithMessage)('modules.throwInvalidPathInput');
+    (0, standardErrors_1.throwTypeErrorWithMessage)(`${i18nKey}.throwInvalidPathInput`);
 }
 function isModuleFolder(pathInput) {
     throwInvalidPathInput(pathInput);

package/utils/detectPort.d.ts

@@ -0,0 +1 @@
+export declare function detectPort(port?: number | null, exclude?: Array<number>): Promise<number>;

package/utils/detectPort.js

@@ -0,0 +1,102 @@
+"use strict";
+/*
+From https://github.com/node-modules/detect-port/tree/master
+
+The MIT License (MIT)
+
+Copyright (c) 2014 - present node-modules and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPort = void 0;
+const net_1 = __importDefault(require("net"));
+const address_1 = require("address");
+const standardErrors_1 = require("../errors/standardErrors");
+const ports_1 = require("../constants/ports");
+const i18nKey = 'utils.detectPort';
+function detectPort(port, exclude = []) {
+    if (port && (port < ports_1.MIN_PORT_NUMBER || port > ports_1.MAX_PORT_NUMBER)) {
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.invalidPort`, {
+            minPort: ports_1.MIN_PORT_NUMBER,
+            maxPort: ports_1.MAX_PORT_NUMBER,
+        });
+    }
+    const portToUse = port || 0;
+    const maxPort = Math.min(portToUse + 10, ports_1.MAX_PORT_NUMBER);
+    return new Promise(resolve => {
+        tryListen(portToUse, maxPort, exclude, (_, resolvedPort) => {
+            resolve(resolvedPort);
+        });
+    });
+}
+exports.detectPort = detectPort;
+function tryListen(port, maxPort, exclude, callback) {
+    const shouldGiveUp = port >= maxPort;
+    const nextPort = shouldGiveUp ? 0 : port + 1;
+    const nextMaxPort = shouldGiveUp ? 0 : maxPort;
+    listen(port, undefined, (err, realPort) => {
+        // ignore random listening
+        if (port === 0) {
+            return callback(err, realPort);
+        }
+        if (exclude.includes(port)) {
+            return tryListen(nextPort, nextMaxPort, exclude, callback);
+        }
+        if (err) {
+            return tryListen(nextPort, nextMaxPort, exclude, callback);
+        }
+        // 2. check 0.0.0.0
+        listen(port, '0.0.0.0', err => {
+            if (err) {
+                return tryListen(nextPort, nextMaxPort, exclude, callback);
+            }
+            // 3. check localhost
+            listen(port, 'localhost', err => {
+                if (err && err.code !== 'EADDRNOTAVAIL') {
+                    return tryListen(nextPort, nextMaxPort, exclude, callback);
+                }
+                // 4. check current ip
+                listen(port, (0, address_1.ip)(), (err, realPort) => {
+                    if (err) {
+                        return tryListen(nextPort, nextMaxPort, exclude, callback);
+                    }
+                    callback(null, realPort);
+                });
+            });
+        });
+    });
+}
+function listen(port, hostname, callback) {
+    const server = new net_1.default.Server();
+    server.on('error', (err) => {
+        server.close();
+        if (err.code === 'ENOTFOUND') {
+            return callback(null, port);
+        }
+        return callback(err, 0);
+    });
+    server.listen(port, hostname, () => {
+        const addressInfo = server.address();
+        server.close();
+        return callback(null, addressInfo.port);
+    });
+}

package/utils/lang.d.ts

@@ -1,11 +1,9 @@
-type LanguageObject = {
-    [key: string]: LanguageObject | string;
-};
+import { LanguageObject, LangKey } from '../types/Lang';
 type InterpolationData = {
     [identifier: string]: string | number;
 };
 export declare function interpolate(stringValue: string, interpolationData: InterpolationData): string;
-export declare function i18n(lookupDotNotation: string, options?: {
+export declare function i18n(lookupDotNotation: LangKey, options?: {
     [identifier: string]: string | number;
 }): string;
 export declare const setLangData: (newLocale: string, newLangObj: LanguageObject) => void;

package/utils/lang.js

@@ -1,32 +1,31 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setLangData = exports.i18n = exports.interpolate = void 0;
-const path_1 = require("path");
-const fs_extra_1 = require("fs-extra");
-const js_yaml_1 = require("js-yaml");
+const en_json_1 = __importDefault(require("../lang/en.json"));
+const LANGUAGES = {
+    en: en_json_1.default,
+};
 const MISSING_LANGUAGE_DATA_PREFIX = '[Missing language data]';
-let locale = '';
 let languageObj;
-function loadLanguageFromYaml() {
+function loadLanguageForLocale() {
     if (languageObj)
         return;
     try {
         const nodeLocale = Intl.DateTimeFormat()
             .resolvedOptions()
             .locale.split('-')[0];
-        const languageFilePath = (0, path_1.join)(__dirname, `../lang/${nodeLocale}.lyaml`);
-        const languageFileExists = (0, fs_extra_1.existsSync)(languageFilePath);
-        // Fall back to using the default language file
-        locale = languageFileExists ? nodeLocale : 'en';
-        languageObj = (0, js_yaml_1.load)((0, fs_extra_1.readFileSync)((0, path_1.join)(__dirname, `../lang/${locale}.lyaml`), 'utf8'));
+        languageObj = LANGUAGES[nodeLocale] || LANGUAGES.en;
     }
     catch (e) {
         throw new Error(`Error loading language data: ${e}`);
     }
 }
 function getTextValue(lookupDotNotation) {
-    const lookupProps = [locale, ...lookupDotNotation.split('.')];
-    const missingTextData = `${MISSING_LANGUAGE_DATA_PREFIX}: ${lookupProps.join('.')}`;
+    const lookupProps = lookupDotNotation.split('.');
+    const missingTextData = `${MISSING_LANGUAGE_DATA_PREFIX}: ${lookupDotNotation}`;
     let textValue = languageObj;
     let previouslyCheckedProp = lookupProps[0];
     lookupProps.forEach(prop => {
@@ -73,7 +72,7 @@ function interpolate(stringValue, interpolationData) {
 exports.interpolate = interpolate;
 function i18n(lookupDotNotation, options = {}) {
     if (!languageObj) {
-        loadLanguageFromYaml();
+        loadLanguageForLocale();
     }
     if (typeof lookupDotNotation !== 'string') {
         throw new Error(`i18n must be passed a string value for lookupDotNotation, received ${typeof lookupDotNotation}`);
@@ -84,7 +83,6 @@ function i18n(lookupDotNotation, options = {}) {
 }
 exports.i18n = i18n;
 const setLangData = (newLocale, newLangObj) => {
-    locale = newLocale;
     languageObj = newLangObj;
 };
 exports.setLangData = setLangData;

package/utils/logger.d.ts

@@ -1,10 +1,11 @@
 import { LogCallbacks } from '../types/LogCallbacks';
-export declare function log<T extends string>(key: T, callbacks?: LogCallbacks<T>, debugKey?: string, debugInterpolation?: {
+import { LangKey } from '../types/Lang';
+export declare function log<T extends string>(key: T, callbacks?: LogCallbacks<T>, debugKey?: LangKey, debugInterpolation?: {
     [key: string]: string | number;
 }): void;
-export declare function makeTypedLogger<T extends readonly string[]>(callbacks?: LogCallbacks<T[number]>, debugKey?: string): (key: T[number], debugInterpolation?: {
+export declare function makeTypedLogger<T extends readonly string[]>(callbacks?: LogCallbacks<T[number]>): (key: T[number], debugKey?: LangKey, debugInterpolation?: {
     [key: string]: string | number;
 } | undefined) => void;
-export declare function debug(identifier: string, interpolation?: {
+export declare function debug(identifier: LangKey, interpolation?: {
     [key: string]: string | number;
 }): void;

package/utils/logger.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.debug = exports.makeTypedLogger = exports.log = void 0;
 const lang_1 = require("./lang");
+const logger_1 = require("../lib/logging/logger");
 function log(key, callbacks, debugKey, debugInterpolation) {
     if (callbacks && callbacks[key]) {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -12,11 +13,11 @@ function log(key, callbacks, debugKey, debugInterpolation) {
     }
 }
 exports.log = log;
-function makeTypedLogger(callbacks, debugKey) {
-    return (key, debugInterpolation) => log(key, callbacks, `${debugKey}.${key}`, debugInterpolation);
+function makeTypedLogger(callbacks) {
+    return (key, debugKey, debugInterpolation) => log(key, callbacks, debugKey, debugInterpolation);
 }
 exports.makeTypedLogger = makeTypedLogger;
 function debug(identifier, interpolation) {
-    console.debug((0, lang_1.i18n)(`debug.${identifier}`, interpolation));
+    logger_1.logger.debug((0, lang_1.i18n)(identifier, interpolation));
 }
 exports.debug = debug;

package/utils/notify.js

@@ -8,6 +8,7 @@ const fs_1 = __importDefault(require("fs"));
 const moment_1 = __importDefault(require("moment"));
 const debounce_1 = __importDefault(require("debounce"));
 const standardErrors_1 = require("../errors/standardErrors");
+const i18nKey = 'utils.notify';
 const notifyQueue = [];
 const notifyPromises = [];
 const debouncedWaitForActionsToCompleteAndWriteQueueToFile = (0, debounce_1.default)(waitForActionsToCompleteAndWriteQueueToFile, 500);
@@ -36,7 +37,7 @@ function notifyFilePath(filePathToNotify, outputToWrite) {
             fs_1.default.appendFileSync(filePathToNotify, outputToWrite);
         }
         catch (e) {
-            (0, standardErrors_1.throwErrorWithMessage)('utils.notify.filePath', { filePath: filePathToNotify }, e);
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.filePath`, { filePath: filePathToNotify }, e);
         }
     }
 }