@hubspot/local-dev-lib 0.0.2 → 0.0.3

package/src/utils/modules.js

@@ -0,0 +1,53 @@
+"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 standardErrors_1 = require("../errors/standardErrors");
+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;
+    (0, standardErrors_1.throwTypeErrorWithMessage)('modules.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/src/utils/text.d.ts

@@ -0,0 +1 @@
+export declare function commaSeparatedValues(arr: Array<string>, conjunction?: string, ifempty?: string): string;

package/src/utils/text.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commaSeparatedValues = void 0;
+function commaSeparatedValues(arr, conjunction = 'and', ifempty = '') {
+    const l = arr.length;
+    if (!l)
+        return ifempty;
+    if (l < 2)
+        return arr[0];
+    if (l < 3)
+        return arr.join(` ${conjunction} `);
+    arr = arr.slice();
+    arr[l - 1] = `${conjunction} ${arr[l - 1]}`;
+    return arr.join(', ');
+}
+exports.commaSeparatedValues = commaSeparatedValues;

package/src/utils/urls.d.ts

@@ -0,0 +1,2 @@
+export declare const getHubSpotWebsiteOrigin: (env: string) => string;
+export declare function getHubSpotApiOrigin(env?: string, useLocalHost?: boolean): string;

package/src/utils/urls.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHubSpotApiOrigin = exports.getHubSpotWebsiteOrigin = void 0;
+const environments_1 = require("../constants/environments");
+function getEnvUrlString(env) {
+    if (typeof env !== 'string') {
+        return '';
+    }
+    return env.toLowerCase() === environments_1.ENVIRONMENTS.QA ? environments_1.ENVIRONMENTS.QA : '';
+}
+const getHubSpotWebsiteOrigin = (env) => `https://app.hubspot${getEnvUrlString(env)}.com`;
+exports.getHubSpotWebsiteOrigin = getHubSpotWebsiteOrigin;
+function getHubSpotApiOrigin(env, useLocalHost) {
+    let domain = process.env.HUBAPI_DOMAIN_OVERRIDE;
+    if (!domain || typeof domain !== 'string') {
+        domain = `${useLocalHost ? 'local' : 'api'}.hubapi${getEnvUrlString(env)}`;
+    }
+    return `https://${domain}.com`;
+}
+exports.getHubSpotApiOrigin = getHubSpotApiOrigin;

package/types/Accounts.d.ts

@@ -0,0 +1,50 @@
+import { DEFAULT_MODES } from '../constants/config';
+import { ValueOf } from './Utils';
+export type AuthType = 'personalaccesskey' | 'apikey' | 'oauth2';
+export interface CLIAccount {
+    name?: string;
+    accountId: number;
+    defaultMode?: ValueOf<typeof DEFAULT_MODES>;
+    env?: string;
+    authType?: AuthType;
+    auth?: object;
+    sandboxAccountType?: string | null;
+    parentAccountId?: number | null;
+    apiKey?: string;
+    personalAccessKey?: string;
+}
+export type PersonalAccessKeyTokenInfo = {
+    accessToken: string;
+    expiresAt: string;
+};
+export type OauthTokenInfo = {
+    refreshToken?: string;
+};
+export interface PersonalAccessKeyAccount extends CLIAccount {
+    authType: 'personalaccesskey';
+    auth?: {
+        tokenInfo: PersonalAccessKeyTokenInfo;
+    };
+    personalAccessKey: string;
+}
+export interface OAuthAccount extends CLIAccount {
+    authType: 'oauth2';
+    auth?: {
+        clientId?: string;
+        clientSecret?: string;
+        scopes?: Array<string>;
+        tokenInfo?: OauthTokenInfo;
+    };
+}
+export interface APIKeyAccount extends CLIAccount {
+    authType: 'apikey';
+    apiKey: string;
+}
+export interface FlatAccountFields<T extends OauthTokenInfo | PersonalAccessKeyTokenInfo> extends CLIAccount {
+    tokenInfo?: T;
+    clientId?: string;
+    clientSecret?: string;
+    scopes?: Array<string>;
+    apiKey?: string;
+    personalAccessKey?: string;
+}

package/types/Accounts.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/CLIOptions.d.ts

@@ -0,0 +1,3 @@
+export interface CLIOptions {
+    useEnv?: boolean;
+}

package/types/CLIOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/Config.d.ts

@@ -0,0 +1,10 @@
+import { CLIAccount } from './Accounts';
+export interface CLIConfig {
+    accounts: Array<CLIAccount>;
+    allowUsageTracking?: boolean;
+    defaultAccount?: string | number;
+    defaultMode?: string;
+    httpTimeout?: number;
+    env?: string;
+    test: number;
+}

package/types/Config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/Error.d.ts

@@ -0,0 +1,38 @@
+export interface BaseError extends Error {
+    name: string;
+    message: string;
+    errno?: number | null;
+    code?: string | null;
+    syscall?: string | null;
+    reason?: string;
+}
+export interface SystemError extends BaseError {
+    errno: number;
+    code: string;
+    syscall: string;
+}
+export interface StatusCodeError extends SystemError {
+    name: 'StatusCodeError';
+    statusCode: number;
+    message: string;
+    response: {
+        request: {
+            href: string;
+            method: string;
+        };
+        body: {
+            [key: string]: string;
+        };
+        headers: {
+            [key: string]: string;
+        };
+    };
+}
+export type ErrorContext = {
+    accountId?: number;
+};
+export interface FileSystemErrorContext extends ErrorContext {
+    filepath?: string;
+    read?: boolean;
+    write?: boolean;
+}

package/types/Error.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/LogCallbacks.d.ts

@@ -0,0 +1,6 @@
+export type LogCallbacks<T extends string> = {
+    [key in T]?: () => void;
+};
+export type LogCallbacksArg<T extends readonly string[]> = {
+    [key in T[number]]?: () => void;
+};

package/types/LogCallbacks.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/Utils.d.ts

@@ -0,0 +1 @@
+export type ValueOf<T> = T[keyof T];

package/types/Utils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/utils/encoding.d.ts

@@ -0,0 +1 @@
+export declare function base64EncodeString(valueToEncode: string): string;

package/utils/encoding.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64EncodeString = void 0;
+function base64EncodeString(valueToEncode) {
+    if (typeof valueToEncode !== 'string') {
+        return valueToEncode;
+    }
+    const stringBuffer = Buffer.from(valueToEncode);
+    return encodeURIComponent(stringBuffer.toString('base64'));
+}
+exports.base64EncodeString = base64EncodeString;

package/utils/environment.d.ts

@@ -0,0 +1 @@
+export declare function getValidEnv(env: string, maskedProductionValue?: string): string;

package/utils/environment.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValidEnv = void 0;
+const environments_1 = require("../constants/environments");
+function getValidEnv(env, maskedProductionValue) {
+    const prodValue = maskedProductionValue
+        ? maskedProductionValue
+        : environments_1.ENVIRONMENTS.PROD;
+    const returnVal = typeof env &&
+        typeof env === 'string' &&
+        env.toLowerCase() === environments_1.ENVIRONMENTS.QA
+        ? environments_1.ENVIRONMENTS.QA
+        : prodValue;
+    return returnVal;
+}
+exports.getValidEnv = getValidEnv;

package/utils/escapeRegExp.d.ts

@@ -0,0 +1 @@
+export declare function escapeRegExp(string: string): string;

package/utils/escapeRegExp.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeRegExp = void 0;
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
+}
+exports.escapeRegExp = escapeRegExp;

package/utils/git.d.ts

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

package/utils/git.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAndAddConfigToGitignore = exports.configFilenameIsIgnoredByGitignore = exports.isConfigPathInGitRepo = void 0;
+const fs_extra_1 = require("fs-extra");
+const path_1 = __importDefault(require("path"));
+const ignore_1 = __importDefault(require("ignore"));
+const findup_sync_1 = __importDefault(require("findup-sync"));
+const config_1 = require("../constants/config");
+const standardErrors_1 = require("../errors/standardErrors");
+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;
+}
+const getGitComparisonDir = () => 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 ignorePathComparisonDir = makeComparisonDir(ignorePath);
+        const gitComparisonDir = makeComparisonDir(gitDir);
+        if (ignorePath &&
+            ignorePathComparisonDir &&
+            gitComparisonDir &&
+            ignorePathComparisonDir.startsWith(gitComparisonDir)) {
+            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;
+}
+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 = (0, fs_extra_1.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;
+function checkGitInclusion(configPath) {
+    const result = {
+        inGit: false,
+        configIgnored: false,
+        gitignoreFiles: [],
+    };
+    if (isConfigPathInGitRepo(configPath)) {
+        result.inGit = true;
+        result.gitignoreFiles = getGitignoreFiles(configPath);
+        if (configFilenameIsIgnoredByGitignore(result.gitignoreFiles, configPath)) {
+            // Found ignore statement in .gitignore that matches config filename
+            result.configIgnored = true;
+        }
+    }
+    return result;
+}
+function checkAndAddConfigToGitignore(configPath) {
+    try {
+        const { configIgnored, gitignoreFiles } = checkGitInclusion(configPath);
+        if (configIgnored)
+            return;
+        let gitignoreFilePath = gitignoreFiles && gitignoreFiles.length ? gitignoreFiles[0] : null;
+        if (!gitignoreFilePath) {
+            gitignoreFilePath = path_1.default.resolve(configPath, GITIGNORE_FILE);
+            (0, fs_extra_1.writeFileSync)(gitignoreFilePath, '');
+        }
+        const gitignoreContents = (0, fs_extra_1.readFileSync)(gitignoreFilePath).toString();
+        const updatedContents = `${gitignoreContents.trim()}\n\n# HubSpot config file\n${config_1.DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME}\n`;
+        (0, fs_extra_1.writeFileSync)(gitignoreFilePath, updatedContents);
+    }
+    catch (e) {
+        throw (0, standardErrors_1.throwErrorWithMessage)('utils.git.configIgnore');
+    }
+}
+exports.checkAndAddConfigToGitignore = checkAndAddConfigToGitignore;

package/utils/interpolation.d.ts

@@ -0,0 +1,5 @@
+type InterpolationData = {
+    [identifier: string]: string | number;
+};
+export declare function interpolate(stringValue: string, interpolationData: InterpolationData): string;
+export {};

package/utils/interpolation.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpolate = void 0;
+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;

package/utils/lang.d.ts

@@ -0,0 +1,3 @@
+export declare function i18n(lookupDotNotation: string, options?: {
+    [identifier: string]: string | number;
+}): string;

package/utils/lang.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i18n = void 0;
+const util_1 = require("util");
+const path_1 = require("path");
+const fs_extra_1 = require("fs-extra");
+const js_yaml_1 = require("js-yaml");
+const interpolation_1 = require("./interpolation");
+const MISSING_LANGUAGE_DATA_PREFIX = '[Missing language data]';
+let locale = '';
+let languageObj;
+function loadLanguageFromYaml() {
+    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'));
+        console.debug('Loaded language data: ', (0, util_1.inspect)(languageObj, true, 999, true));
+    }
+    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('.')}`;
+    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;
+}
+function i18n(lookupDotNotation, options = {}) {
+    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 ? (0, interpolation_1.interpolate)(textValue, options) : textValue;
+}
+exports.i18n = i18n;
+loadLanguageFromYaml();

package/utils/logger.d.ts

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

package/utils/logger.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debug = exports.makeTypedLogger = exports.log = void 0;
+const lang_1 = require("./lang");
+function log(key, callbacks, debugKey, debugInterpolation) {
+    if (callbacks && callbacks[key]) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        callbacks[key]();
+    }
+    else if (debugKey) {
+        debug(debugKey, debugInterpolation);
+    }
+}
+exports.log = log;
+function makeTypedLogger(callbacks, debugKey) {
+    return (key, debugInterpolation) => log(key, callbacks, `${debugKey}.${key}`, debugInterpolation);
+}
+exports.makeTypedLogger = makeTypedLogger;
+function debug(identifier, interpolation) {
+    console.debug((0, lang_1.i18n)(`debug.${identifier}`, interpolation));
+}
+exports.debug = debug;

package/utils/text.d.ts

@@ -0,0 +1 @@
+export declare function commaSeparatedValues(arr: Array<string>, conjunction?: string, ifempty?: string): string;

package/utils/text.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commaSeparatedValues = void 0;
+function commaSeparatedValues(arr, conjunction = 'and', ifempty = '') {
+    const l = arr.length;
+    if (!l)
+        return ifempty;
+    if (l < 2)
+        return arr[0];
+    if (l < 3)
+        return arr.join(` ${conjunction} `);
+    arr = arr.slice();
+    arr[l - 1] = `${conjunction} ${arr[l - 1]}`;
+    return arr.join(', ');
+}
+exports.commaSeparatedValues = commaSeparatedValues;