@hubspot/local-dev-lib 0.0.1-experimental.0

package/utils/PortManagerServer.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { Express, Request, Response } from 'express';
+import { Server } from 'http';
+import { RequestPortsData, ServerPortMap } from '../types/PortManager';
+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;
+}
+export declare const PortManagerServer: _PortManagerServer;
+export {};

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 });
+exports.PortManagerServer = void 0;
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const detectPort_1 = require("./detectPort");
+const ports_1 = require("../constants/ports");
+const errors_1 = require("../errors");
+const logger_1 = require("../lib/logger");
+const lang_1 = require("./lang");
+const i18nKey = 'utils.PortManagerServer';
+class _PortManagerServer {
+    app;
+    server;
+    serverPortMap;
+    constructor() {
+        this.serverPortMap = {};
+    }
+    async init() {
+        if (this.app) {
+            throw new Error((0, lang_1.i18n)(`${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) {
+            if ((0, errors_1.isSystemError)(e) && e.code === 'EADDRINUSE') {
+                throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.portInUse`, {
+                    port: ports_1.PORT_MANAGER_SERVER_PORT,
+                }), { cause: e });
+            }
+            throw e;
+        }
+    }
+    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, () => {
+                logger_1.logger.debug((0, lang_1.i18n)(`${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) {
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.setPort`, { instanceId, port }));
+        this.serverPortMap[instanceId] = port;
+    }
+    deletePort(instanceId) {
+        logger_1.logger.debug((0, lang_1.i18n)(`${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.sendStatus(200);
+        }
+        else {
+            this.send404(res, instanceId);
+        }
+    };
+    closeServer = (req, res) => {
+        if (this.server) {
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.close`));
+            res.sendStatus(200);
+            this.server.close();
+            this.reset();
+        }
+    };
+}
+exports.PortManagerServer = new _PortManagerServer();

package/utils/accounts.d.ts

@@ -0,0 +1,4 @@
+import { CLIAccount } from '../types/Accounts';
+import { CLIConfig } from '../types/Config';
+export declare function getAccounts(config?: CLIConfig | null): Array<CLIAccount>;
+export declare function getDefaultAccount(config?: CLIConfig | null): string | number | undefined;

package/utils/accounts.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultAccount = exports.getAccounts = void 0;
+function getAccounts(config) {
+    if (!config) {
+        return [];
+    }
+    else if (Object.hasOwn(config, 'portals')) {
+        return config.portals;
+    }
+    else if (Object.hasOwn(config, 'accounts')) {
+        return config.accounts;
+    }
+    return [];
+}
+exports.getAccounts = getAccounts;
+function getDefaultAccount(config) {
+    if (!config) {
+        return undefined;
+    }
+    else if (Object.hasOwn(config, 'defaultPortal')) {
+        return config.defaultPortal;
+    }
+    else if (Object.hasOwn(config, 'defaultAccount')) {
+        return config.defaultAccount;
+    }
+}
+exports.getDefaultAccount = getDefaultAccount;

package/utils/cms/fieldsJS.d.ts

@@ -0,0 +1,2 @@
+import { FieldsArray } from '../../types/FieldsJS';
+export declare function fieldsArrayToJson<T>(fields: FieldsArray<T>): string;

package/utils/cms/fieldsJS.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldsArrayToJson = void 0;
+/*
+ * Polyfill for `Array.flat(Infinity)` since the `flat` is only available for Node v11+
+ * https://stackoverflow.com/a/15030117
+ */
+function flattenArray(arr) {
+    return arr.reduce((flat, toFlatten) => {
+        return flat.concat(Array.isArray(toFlatten) ? flattenArray(toFlatten) : toFlatten);
+    }, []);
+}
+//Transform fields array to JSON
+function fieldsArrayToJson(fields) {
+    const flattened = flattenArray(fields);
+    return JSON.stringify(flattened, null, 2);
+}
+exports.fieldsArrayToJson = fieldsArrayToJson;

package/utils/cms/modules.d.ts

@@ -0,0 +1,4 @@
+import { PathInput } from '../../types/Modules';
+export declare function isPathInput(pathInput?: PathInput): boolean;
+export declare function isModuleFolder(pathInput: PathInput): boolean;
+export declare function isModuleFolderChild(pathInput: PathInput, ignoreLocales?: boolean): boolean;

package/utils/cms/modules.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isModuleFolderChild = exports.isModuleFolder = exports.isPathInput = void 0;
+const path_1 = __importDefault(require("path"));
+const path_2 = require("../../lib/path");
+const extensions_1 = require("../../constants/extensions");
+const lang_1 = require("../lang");
+const i18nKey = 'utils.cms.modules';
+const isBool = (x) => !!x === x;
+function isPathInput(pathInput) {
+    return !!(pathInput &&
+        typeof pathInput.path === 'string' &&
+        (isBool(pathInput.isLocal) || isBool(pathInput.isHubSpot)));
+}
+exports.isPathInput = isPathInput;
+function throwInvalidPathInput(pathInput) {
+    if (isPathInput(pathInput))
+        return;
+    throw new Error((0, lang_1.i18n)(`${i18nKey}.throwInvalidPathInput`));
+}
+function isModuleFolder(pathInput) {
+    throwInvalidPathInput(pathInput);
+    const _path = pathInput.isHubSpot
+        ? path_1.default.posix.normalize(pathInput.path)
+        : path_1.default.normalize(pathInput.path);
+    return (0, path_2.getExt)(_path) === extensions_1.MODULE_EXTENSION;
+}
+exports.isModuleFolder = isModuleFolder;
+function isModuleFolderChild(pathInput, ignoreLocales = false) {
+    throwInvalidPathInput(pathInput);
+    let pathParts = [];
+    if (pathInput.isLocal) {
+        pathParts = (0, path_2.splitLocalPath)(pathInput.path);
+    }
+    else if (pathInput.isHubSpot) {
+        pathParts = (0, path_2.splitHubSpotPath)(pathInput.path);
+    }
+    const { length } = pathParts;
+    // Not a child path?
+    if (length <= 1)
+        return false;
+    // Check if we should ignore this file
+    if (ignoreLocales && pathParts.find(part => part === '_locales')) {
+        return false;
+    }
+    // Check if any parent folders are module folders.
+    return pathParts
+        .slice(0, length - 1)
+        .some(part => isModuleFolder({ ...pathInput, path: part }));
+}
+exports.isModuleFolderChild = isModuleFolderChild;

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 ports_1 = require("../constants/ports");
+const lang_1 = require("./lang");
+const i18nKey = 'utils.detectPort';
+function detectPort(port, exclude = []) {
+    if (port && (port < ports_1.MIN_PORT_NUMBER || port > ports_1.MAX_PORT_NUMBER)) {
+        throw new Error((0, lang_1.i18n)(`${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/git.d.ts

@@ -0,0 +1,3 @@
+export declare function getGitignoreFiles(configPath: string): Array<string>;
+export declare function isConfigPathInGitRepo(configPath: string): boolean;
+export declare function configFilenameIsIgnoredByGitignore(ignoreFiles: Array<string>, configPath: string): boolean;

package/utils/git.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configFilenameIsIgnoredByGitignore = exports.isConfigPathInGitRepo = exports.getGitignoreFiles = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const ignore_1 = __importDefault(require("ignore"));
+const findup_sync_1 = __importDefault(require("findup-sync"));
+const GITIGNORE_FILE = '.gitignore';
+function makeComparisonDir(filepath) {
+    if (typeof filepath !== 'string')
+        return null;
+    // Append sep to make comparisons easier e.g. 'foos'.startsWith('foo')
+    return path_1.default.dirname(path_1.default.resolve(filepath)).toLowerCase() + path_1.default.sep;
+}
+function getGitComparisonDir() {
+    return makeComparisonDir((0, findup_sync_1.default)('.git'));
+}
+// Get all .gitignore files since they can cascade down directory structures
+function getGitignoreFiles(configPath) {
+    const gitDir = getGitComparisonDir();
+    const files = [];
+    if (!gitDir) {
+        // Not in git
+        return files;
+    }
+    // Start findup from config dir
+    let cwd = configPath && path_1.default.dirname(configPath);
+    while (cwd) {
+        const ignorePath = (0, findup_sync_1.default)(GITIGNORE_FILE, { cwd });
+        const cmpIgnorePath = makeComparisonDir(ignorePath);
+        const cmpGitDir = makeComparisonDir(gitDir);
+        if (ignorePath &&
+            cmpIgnorePath &&
+            cmpGitDir &&
+            // Stop findup after .git dir is reached
+            cmpIgnorePath.startsWith(cmpGitDir)) {
+            const file = path_1.default.resolve(ignorePath);
+            files.push(file);
+            cwd = path_1.default.resolve(path_1.default.dirname(file) + '..');
+        }
+        else {
+            cwd = null;
+        }
+    }
+    return files;
+}
+exports.getGitignoreFiles = getGitignoreFiles;
+function isConfigPathInGitRepo(configPath) {
+    const gitDir = getGitComparisonDir();
+    if (!gitDir)
+        return false;
+    const configDir = makeComparisonDir(configPath);
+    if (!configDir)
+        return false;
+    return configDir.startsWith(gitDir);
+}
+exports.isConfigPathInGitRepo = isConfigPathInGitRepo;
+function configFilenameIsIgnoredByGitignore(ignoreFiles, configPath) {
+    return ignoreFiles.some(gitignore => {
+        const gitignoreContents = fs_extra_1.default.readFileSync(gitignore).toString();
+        const gitignoreConfig = (0, ignore_1.default)().add(gitignoreContents);
+        if (gitignoreConfig.ignores(path_1.default.relative(path_1.default.dirname(gitignore), configPath))) {
+            return true;
+        }
+        return false;
+    });
+}
+exports.configFilenameIsIgnoredByGitignore = configFilenameIsIgnoredByGitignore;

package/utils/lang.d.ts

@@ -0,0 +1,6 @@
+import { LanguageObject, LangKey, InterpolationData } from '../types/Lang';
+export declare function interpolate(stringValue: string, interpolationData: InterpolationData): string;
+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

@@ -0,0 +1,88 @@
+"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 en_json_1 = __importDefault(require("../lang/en.json"));
+const LANGUAGES = {
+    en: en_json_1.default,
+};
+const MISSING_LANGUAGE_DATA_PREFIX = '[Missing language data]';
+let languageObj;
+function loadLanguageForLocale() {
+    if (languageObj)
+        return;
+    try {
+        const nodeLocale = Intl.DateTimeFormat()
+            .resolvedOptions()
+            .locale.split('-')[0];
+        languageObj = LANGUAGES[nodeLocale] || LANGUAGES.en;
+    }
+    catch (e) {
+        throw new Error(`Error loading language data: ${e}`);
+    }
+}
+function getTextValue(lookupDotNotation) {
+    const lookupProps = lookupDotNotation.split('.');
+    const missingTextData = `${MISSING_LANGUAGE_DATA_PREFIX}: ${lookupDotNotation}`;
+    let textValue = languageObj;
+    let previouslyCheckedProp = lookupProps[0];
+    lookupProps.forEach(prop => {
+        previouslyCheckedProp = prop;
+        if (typeof textValue === 'object') {
+            textValue = textValue[prop];
+        }
+        else {
+            console.debug(`Unable to access language property: ${lookupProps.join('.')}. Failed to access prop "${previouslyCheckedProp}".`);
+        }
+    });
+    if (typeof textValue !== 'string') {
+        return missingTextData;
+    }
+    return textValue;
+}
+const delimiters = {
+    interpolation: {
+        start: '{{',
+        end: '}}',
+    },
+};
+function generateReplaceFn(matchedText, startIndex, replacementString) {
+    return function (currentStringValue) {
+        return `${currentStringValue.slice(0, startIndex)}${replacementString || ''}${currentStringValue.slice(startIndex + matchedText.length)}`;
+    };
+}
+function interpolate(stringValue, interpolationData) {
+    const interpolationIdentifierRegEx = new RegExp(`${delimiters.interpolation.start}(.*?)${delimiters.interpolation.end}`, 'g');
+    const replaceQueue = [];
+    let match;
+    // while & reduce necessary because RegExp.exec is stateful and only runs
+    // from beginning to end of string
+    while ((match = interpolationIdentifierRegEx.exec(stringValue)) != null) {
+        const { 0: matchedText, 1: rawIdentifier, index } = match;
+        const identifier = rawIdentifier.trim();
+        if (identifier) {
+            replaceQueue.unshift(generateReplaceFn(matchedText, index, interpolationData[identifier]));
+        }
+    }
+    const compiledString = replaceQueue.reduce((currentValue, replaceFn) => replaceFn(currentValue), stringValue);
+    return compiledString;
+}
+exports.interpolate = interpolate;
+function i18n(lookupDotNotation, options = {}) {
+    if (!languageObj) {
+        loadLanguageForLocale();
+    }
+    if (typeof lookupDotNotation !== 'string') {
+        throw new Error(`i18n must be passed a string value for lookupDotNotation, received ${typeof lookupDotNotation}`);
+    }
+    const textValue = getTextValue(lookupDotNotation);
+    const shouldInterpolate = !textValue.startsWith(MISSING_LANGUAGE_DATA_PREFIX);
+    return shouldInterpolate ? interpolate(textValue, options) : textValue;
+}
+exports.i18n = i18n;
+const setLangData = (newLocale, newLangObj) => {
+    languageObj = newLangObj;
+};
+exports.setLangData = setLangData;