@hubspot/local-dev-lib 0.0.4 → 0.0.6

package/lib/hubdb.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearHubDbTableRows = exports.downloadHubDbTable = exports.updateHubDbTable = exports.createHubDbTable = exports.addRowsToHubDbTable = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const prettier_1 = __importDefault(require("prettier"));
+const hubdb_1 = require("../api/hubdb");
+const path_2 = require("./path");
+const standardErrors_1 = require("../errors/standardErrors");
+function validateJsonPath(src) {
+    if (path_1.default.extname(src) !== '.json') {
+        (0, standardErrors_1.throwErrorWithMessage)('hubdb.invalidJsonPath');
+    }
+}
+function validateJsonFile(src) {
+    let stats;
+    try {
+        stats = fs_extra_1.default.statSync(src);
+    }
+    catch (err) {
+        (0, standardErrors_1.throwErrorWithMessage)('hubdb.invalidJsonFile', { src }, err);
+    }
+    if (!stats.isFile()) {
+        (0, standardErrors_1.throwErrorWithMessage)('hubdb.invalidJsonFile', { src });
+    }
+    validateJsonPath(src);
+}
+async function addRowsToHubDbTable(accountId, tableId, rows) {
+    const rowsToUpdate = rows.map(row => {
+        const values = row.values;
+        return {
+            childTableId: '0',
+            isSoftEditable: false,
+            ...row,
+            values,
+        };
+    });
+    if (rowsToUpdate.length > 0) {
+        await (0, hubdb_1.createRows)(accountId, tableId, rowsToUpdate);
+    }
+    const { rowCount } = await (0, hubdb_1.publishTable)(accountId, tableId);
+    return {
+        tableId,
+        rowCount,
+    };
+}
+exports.addRowsToHubDbTable = addRowsToHubDbTable;
+async function createHubDbTable(accountId, src) {
+    validateJsonFile(src);
+    const table = fs_extra_1.default.readJsonSync(src);
+    const { rows, ...schema } = table;
+    const { id } = await (0, hubdb_1.createTable)(accountId, schema);
+    return addRowsToHubDbTable(accountId, id, rows);
+}
+exports.createHubDbTable = createHubDbTable;
+async function updateHubDbTable(accountId, tableId, src) {
+    validateJsonFile(src);
+    const table = fs_extra_1.default.readJsonSync(src);
+    const { ...schema } = table;
+    return (0, hubdb_1.updateTable)(accountId, tableId, schema);
+}
+exports.updateHubDbTable = updateHubDbTable;
+function convertToJSON(table, rows) {
+    const { allowChildTables, allowPublicApiAccess, columns, dynamicMetaTags, enableChildTablePages, label, name, useForPages, } = table;
+    const cleanedColumns = columns
+        .filter(column => !column.deleted || !column.archived)
+        .map(({ 
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    id, deleted, archived, foreignIdsByName, foreignIdsById, 
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+    ...cleanedColumn }) => cleanedColumn);
+    const cleanedRows = rows.map(row => {
+        return {
+            path: row.path,
+            name: row.name,
+            values: row.values,
+        };
+    });
+    return {
+        name,
+        useForPages,
+        label,
+        allowChildTables,
+        allowPublicApiAccess,
+        dynamicMetaTags,
+        enableChildTablePages,
+        columns: cleanedColumns,
+        rows: cleanedRows,
+    };
+}
+async function fetchAllRows(accountId, tableId) {
+    let rows = [];
+    let after = null;
+    do {
+        const response = await (0, hubdb_1.fetchRows)(accountId, tableId, after ? { after } : undefined);
+        const { paging, results } = response;
+        rows = rows.concat(results);
+        after = paging && paging.next ? paging.next.after : null;
+    } while (after !== null);
+    return rows;
+}
+async function downloadHubDbTable(accountId, tableId, dest) {
+    const table = await (0, hubdb_1.fetchTable)(accountId, tableId);
+    dest = path_1.default.resolve((0, path_2.getCwd)(), dest || `${table.name}.hubdb.json`);
+    if (fs_extra_1.default.pathExistsSync(dest)) {
+        validateJsonFile(dest);
+    }
+    else {
+        validateJsonPath(dest);
+    }
+    const rows = await fetchAllRows(accountId, tableId);
+    const tableToWrite = JSON.stringify(convertToJSON(table, rows));
+    const tableJson = await prettier_1.default.format(tableToWrite, {
+        parser: 'json',
+    });
+    await fs_extra_1.default.outputFile(dest, tableJson);
+    return { filePath: dest };
+}
+exports.downloadHubDbTable = downloadHubDbTable;
+async function clearHubDbTableRows(accountId, tableId) {
+    const rows = await fetchAllRows(accountId, tableId);
+    await (0, hubdb_1.deleteRows)(accountId, tableId, rows.map(row => row.id));
+    return {
+        deletedRowCount: rows.length,
+    };
+}
+exports.clearHubDbTableRows = clearHubDbTableRows;

package/lib/ignoreRules.d.ts

@@ -0,0 +1,3 @@
+export declare function shouldIgnoreFile(file: string, isInProject?: boolean): boolean;
+export declare function createIgnoreFilter(isInProject: boolean): (file: string) => boolean;
+export declare function ignoreFile(filePath: string): void;

package/lib/ignoreRules.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ignoreFile = exports.createIgnoreFilter = exports.shouldIgnoreFile = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ignore_1 = __importDefault(require("ignore"));
+const findup_sync_1 = __importDefault(require("findup-sync"));
+const ignoreList = [
+    'fields.output.json',
+    'hubspot.config.yml',
+    'hubspot.config.yaml',
+    'node_modules',
+    '.*',
+    '*.log',
+    '*.swp',
+    '.env',
+    // # macOS
+    'Icon\\r',
+    '__MACOSX',
+    // # Linux
+    '~',
+    // # Emacs
+    '*~',
+    // # Windows
+    'Thumbs.db',
+    'ehthumbs.db',
+    'Desktop.ini',
+    '@eaDir', // Synology Diskstation "hidden" folder where the server stores thumbnails
+];
+const ignoreRules = (0, ignore_1.default)().add(ignoreList);
+let searchDomain = null;
+let loaded = false;
+function loadIgnoreConfig(isInProject = false) {
+    if (loaded) {
+        return;
+    }
+    // Temporary solution to improve serverless beta: https://git.hubteam.com/HubSpot/cms-devex-super-repo/issues/2
+    // Do not do this when in a developer project b/c we want the package-lock.json file uploaded.
+    if (!isInProject) {
+        ignoreRules.add('package-lock.json');
+    }
+    const file = (0, findup_sync_1.default)('.hsignore');
+    if (file) {
+        if (fs_1.default.existsSync(file)) {
+            ignoreRules.add(fs_1.default.readFileSync(file).toString());
+            searchDomain = path_1.default.dirname(file);
+        }
+    }
+    loaded = true;
+}
+function shouldIgnoreFile(file, isInProject = false) {
+    loadIgnoreConfig(isInProject);
+    const relativeTo = searchDomain || '/';
+    const relativePath = path_1.default.relative(relativeTo, file);
+    return !!relativePath && ignoreRules.ignores(relativePath);
+}
+exports.shouldIgnoreFile = shouldIgnoreFile;
+function createIgnoreFilter(isInProject) {
+    loadIgnoreConfig(isInProject);
+    return (file) => !shouldIgnoreFile(file);
+}
+exports.createIgnoreFilter = createIgnoreFilter;
+function ignoreFile(filePath) {
+    ignoreRules.add(filePath);
+}
+exports.ignoreFile = ignoreFile;

package/lib/logging/git.d.ts

@@ -0,0 +1,2 @@
+export declare function checkAndWarnGitInclusion(configPath: string): void;
+export declare function checkAndUpdateGitignore(configPath: string): void;

package/lib/logging/git.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.checkAndUpdateGitignore = exports.checkAndWarnGitInclusion = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const git_1 = require("../../utils/git");
+const logger_1 = require("./logger");
+const lang_1 = require("../../utils/lang");
+const config_1 = require("../../constants/config");
+const GITIGNORE_FILE = '.gitignore';
+const i18nKey = 'debug.git';
+function checkAndWarnGitInclusion(configPath) {
+    try {
+        const { inGit, configIgnored } = (0, git_1.checkGitInclusion)(configPath);
+        if (!inGit || configIgnored)
+            return;
+        logger_1.logger.warn((0, lang_1.i18n)(`${i18nKey}.securityIssue`));
+        logger_1.logger.warn((0, lang_1.i18n)(`${i18nKey}.configFileTracked`));
+        logger_1.logger.warn((0, lang_1.i18n)(`${i18nKey}.fileName`, { configPath }));
+        logger_1.logger.warn((0, lang_1.i18n)(`${i18nKey}.remediate`));
+        logger_1.logger.warn((0, lang_1.i18n)(`${i18nKey}.moveConfig`, { homeDir: os_1.default.homedir() }));
+        logger_1.logger.warn((0, lang_1.i18n)(`${i18nKey}.addGitignore`, { configPath }));
+        logger_1.logger.warn((0, lang_1.i18n)(`${i18nKey}.noRemote`));
+    }
+    catch (e) {
+        // fail silently
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.checkFailed`));
+    }
+}
+exports.checkAndWarnGitInclusion = checkAndWarnGitInclusion;
+function checkAndUpdateGitignore(configPath) {
+    try {
+        const { configIgnored, gitignoreFiles } = (0, git_1.checkGitInclusion)(configPath);
+        if (configIgnored)
+            return;
+        let gitignoreFilePath = gitignoreFiles && gitignoreFiles.length ? gitignoreFiles[0] : null;
+        if (!gitignoreFilePath) {
+            gitignoreFilePath = path_1.default.resolve(configPath, GITIGNORE_FILE);
+            fs_extra_1.default.writeFileSync(gitignoreFilePath, '');
+        }
+        const gitignoreContents = fs_extra_1.default.readFileSync(gitignoreFilePath).toString();
+        const updatedContents = `${gitignoreContents.trim()}\n\n# HubSpot config file\n${config_1.DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME}\n`;
+        fs_extra_1.default.writeFileSync(gitignoreFilePath, updatedContents);
+    }
+    catch (e) {
+        // fail silently
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.checkFailed`));
+    }
+}
+exports.checkAndUpdateGitignore = checkAndUpdateGitignore;

package/lib/logging/logger.d.ts

@@ -0,0 +1,44 @@
+import chalk from 'chalk';
+export declare const LOG_LEVEL: {
+    NONE: number;
+    DEBUG: number;
+    LOG: number;
+    WARN: number;
+    ERROR: number;
+};
+/**
+ * Chalk styles for logger strings.
+ */
+export declare const Styles: {
+    debug: chalk.Chalk;
+    log: chalk.Chalk;
+    success: chalk.Chalk;
+    info: chalk.Chalk;
+    warn: chalk.Chalk;
+    error: chalk.Chalk;
+};
+export declare function stylize(label: string, style: (...text: unknown[]) => string, args: any[]): any[];
+export declare class Logger {
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    log(...args: any[]): void;
+    success(...args: any[]): void;
+    info(...args: any[]): void;
+    debug(...args: any[]): void;
+    group(...args: any[]): void;
+    groupEnd(): void;
+}
+export declare function setLogger(logger: Logger): void;
+export declare function setLogLevel(level: number): void;
+export declare function shouldLog(level: number): number;
+export declare function getLogLevel(): number;
+export declare const logger: {
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    log(...args: any[]): void;
+    success(...args: any[]): void;
+    info(...args: any[]): void;
+    debug(...args: any[]): void;
+    group(...args: any[]): void;
+    groupEnd(): void;
+};

package/lib/logging/logger.js

@@ -0,0 +1,146 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.getLogLevel = exports.shouldLog = exports.setLogLevel = exports.setLogger = exports.Logger = exports.stylize = exports.Styles = exports.LOG_LEVEL = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+exports.LOG_LEVEL = {
+    NONE: 0,
+    DEBUG: 1,
+    LOG: 2,
+    WARN: 4,
+    ERROR: 8,
+};
+/**
+ * Chalk styles for logger strings.
+ */
+exports.Styles = {
+    debug: chalk_1.default.reset.blue,
+    log: chalk_1.default.reset,
+    success: chalk_1.default.reset.green,
+    info: chalk_1.default.reset.white,
+    warn: chalk_1.default.reset.yellow,
+    error: chalk_1.default.reset.red,
+};
+function stylize(label, style, args) {
+    const styledLabel = style(label);
+    const [firstArg, ...rest] = args;
+    if (typeof firstArg === 'string') {
+        return [`${styledLabel} ${firstArg}`, ...rest];
+    }
+    return [styledLabel, ...args];
+}
+exports.stylize = stylize;
+class Logger {
+    error(...args) {
+        console.error(...stylize('[ERROR]', exports.Styles.error, args));
+    }
+    warn(...args) {
+        console.warn(...stylize('[WARNING]', exports.Styles.warn, args));
+    }
+    log(...args) {
+        console.log(...args);
+    }
+    success(...args) {
+        console.log(...stylize('[SUCCESS]', exports.Styles.success, args));
+    }
+    info(...args) {
+        console.info(...stylize('[INFO]', exports.Styles.info, args));
+    }
+    debug(...args) {
+        console.debug(...stylize('[DEBUG]', exports.Styles.log, args));
+    }
+    group(...args) {
+        console.group(...args);
+    }
+    groupEnd() {
+        console.groupEnd();
+    }
+}
+exports.Logger = Logger;
+let currentLogger = new Logger();
+let currentLogLevel = exports.LOG_LEVEL.ERROR;
+function setLogger(logger) {
+    currentLogger = logger;
+}
+exports.setLogger = setLogger;
+function setLogLevel(level) {
+    switch (level) {
+        case exports.LOG_LEVEL.DEBUG:
+            currentLogLevel =
+                exports.LOG_LEVEL.DEBUG | exports.LOG_LEVEL.LOG | exports.LOG_LEVEL.WARN | exports.LOG_LEVEL.ERROR;
+            break;
+        case exports.LOG_LEVEL.LOG:
+            currentLogLevel = exports.LOG_LEVEL.LOG | exports.LOG_LEVEL.WARN | exports.LOG_LEVEL.ERROR;
+            break;
+        case exports.LOG_LEVEL.WARN:
+            currentLogLevel = exports.LOG_LEVEL.WARN | exports.LOG_LEVEL.ERROR;
+            break;
+        case exports.LOG_LEVEL.ERROR:
+            currentLogLevel = exports.LOG_LEVEL.ERROR;
+            break;
+        case exports.LOG_LEVEL.NONE:
+        default:
+            currentLogLevel = exports.LOG_LEVEL.NONE;
+    }
+}
+exports.setLogLevel = setLogLevel;
+function shouldLog(level) {
+    return currentLogLevel & level;
+}
+exports.shouldLog = shouldLog;
+function getLogLevel() {
+    switch (currentLogLevel) {
+        case exports.LOG_LEVEL.DEBUG | exports.LOG_LEVEL.LOG | exports.LOG_LEVEL.WARN | exports.LOG_LEVEL.ERROR:
+            return exports.LOG_LEVEL.DEBUG;
+        case exports.LOG_LEVEL.LOG | exports.LOG_LEVEL.WARN | exports.LOG_LEVEL.ERROR:
+            return exports.LOG_LEVEL.LOG;
+        case exports.LOG_LEVEL.WARN | exports.LOG_LEVEL.ERROR:
+            return exports.LOG_LEVEL.WARN;
+        case exports.LOG_LEVEL.ERROR:
+            return exports.LOG_LEVEL.ERROR;
+        default:
+            return exports.LOG_LEVEL.NONE;
+    }
+}
+exports.getLogLevel = getLogLevel;
+exports.logger = {
+    error(...args) {
+        if (shouldLog(exports.LOG_LEVEL.ERROR)) {
+            currentLogger.error(...args);
+        }
+    },
+    warn(...args) {
+        if (shouldLog(exports.LOG_LEVEL.WARN)) {
+            currentLogger.warn(...args);
+        }
+    },
+    log(...args) {
+        if (shouldLog(exports.LOG_LEVEL.LOG)) {
+            currentLogger.log(...args);
+        }
+    },
+    success(...args) {
+        if (shouldLog(exports.LOG_LEVEL.LOG)) {
+            currentLogger.success(...args);
+        }
+    },
+    info(...args) {
+        if (shouldLog(exports.LOG_LEVEL.LOG)) {
+            currentLogger.info(...args);
+        }
+    },
+    debug(...args) {
+        if (shouldLog(exports.LOG_LEVEL.DEBUG)) {
+            currentLogger.debug(...args);
+        }
+    },
+    group(...args) {
+        currentLogger.group(...args);
+    },
+    groupEnd() {
+        currentLogger.groupEnd();
+    },
+};

package/lib/logging/logs.d.ts

@@ -0,0 +1,22 @@
+type Log = {
+    log: string;
+    status: 'SUCCESS' | 'ERROR' | 'UNHANDLED_ERROR' | 'HANDLED_ERROR';
+    createdAt: string;
+    executionTime: string;
+    error: {
+        type: string;
+        message: string;
+        stackTrace: Array<Array<string>>;
+    };
+};
+type Options = {
+    compact: boolean;
+    insertions: {
+        header: string;
+    };
+};
+type LogsResponse = {
+    results: Array<Log>;
+};
+export declare function outputLogs(logsResp: LogsResponse, options: Options): void;
+export {};

package/lib/logging/logs.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outputLogs = void 0;
+const moment_1 = __importDefault(require("moment"));
+const chalk_1 = __importDefault(require("chalk"));
+const logger_1 = require("./logger");
+const SEPARATOR = ' - ';
+const LOG_STATUS_COLORS = {
+    SUCCESS: logger_1.Styles.success,
+    ERROR: logger_1.Styles.error,
+    UNHANDLED_ERROR: logger_1.Styles.error,
+    HANDLED_ERROR: logger_1.Styles.error,
+};
+function errorHandler(log, options) {
+    return `${formatLogHeader(log, options)}${formatError(log, options)}`;
+}
+const logHandler = {
+    ERROR: errorHandler,
+    UNHANDLED_ERROR: errorHandler,
+    HANDLED_ERROR: errorHandler,
+    SUCCESS: (log, options) => {
+        return `${formatLogHeader(log, options)}${formatSuccess(log, options)}`;
+    },
+};
+function formatSuccess(log, options) {
+    if (!log.log || options.compact) {
+        return '';
+    }
+    return `\n${log.log}`;
+}
+function formatError(log, options) {
+    if (!log.error || options.compact) {
+        return '';
+    }
+    return `${log.error.type}: ${log.error.message}\n${formatStackTrace(log)}`;
+}
+function formatLogHeader(log, options) {
+    const color = LOG_STATUS_COLORS[log.status];
+    const headerInsertion = options && options.insertions && options.insertions.header;
+    return `${formatTimestamp(log)}${SEPARATOR}${color(log.status)}${headerInsertion ? `${SEPARATOR}${headerInsertion}` : ''}${SEPARATOR}${formatExecutionTime(log)}`;
+}
+function formatStackTrace(log) {
+    const stackTrace = (log.error.stackTrace && log.error.stackTrace[0]) || [];
+    return stackTrace
+        .map(trace => {
+        return `  at ${trace}\n`;
+    })
+        .join('');
+}
+function formatTimestamp(log) {
+    return `${chalk_1.default.whiteBright((0, moment_1.default)(log.createdAt).toISOString())}`;
+}
+function formatExecutionTime(log) {
+    return `${chalk_1.default.whiteBright('Execution Time:')} ${log.executionTime}ms`;
+}
+function processLog(log, options) {
+    try {
+        return logHandler[log.status](log, options);
+    }
+    catch (e) {
+        logger_1.logger.error(`Unable to process log ${JSON.stringify(log)}`);
+    }
+}
+function processLogs(logsResp, options) {
+    if (!logsResp || (logsResp.results && !logsResp.results.length)) {
+        return 'No logs found.';
+    }
+    else if (logsResp.results && logsResp.results.length) {
+        return logsResp.results
+            .map(log => {
+            return processLog(log, options);
+        })
+            .join('\n');
+    }
+}
+function outputLogs(logsResp, options) {
+    logger_1.logger.log(processLogs(logsResp, options));
+}
+exports.outputLogs = outputLogs;

package/lib/logging/table.d.ts

@@ -0,0 +1,3 @@
+import { TableUserConfig } from 'table';
+export declare function getTableContents(tableData?: Array<Array<any>>, tableConfig?: TableUserConfig): string;
+export declare function getTableHeader(headerItems: Array<string>): Array<string>;

package/lib/logging/table.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTableHeader = exports.getTableContents = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const table_1 = require("table");
+const objectUtils_1 = require("../../utils/objectUtils");
+const tableConfigDefaults = {
+    singleLine: true,
+    border: {
+        topBody: '',
+        topJoin: '',
+        topLeft: '',
+        topRight: '',
+        bottomBody: '',
+        bottomJoin: '',
+        bottomLeft: '',
+        bottomRight: '',
+        bodyLeft: '',
+        bodyRight: '',
+        bodyJoin: '',
+        joinBody: '',
+        joinLeft: '',
+        joinRight: '',
+        joinJoin: '',
+    },
+    columnDefault: {
+        paddingLeft: 0,
+        paddingRight: 1,
+    },
+    drawHorizontalLine: () => {
+        return false;
+    },
+};
+function getTableContents(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+tableData = [], tableConfig = {}) {
+    const mergedConfig = (0, objectUtils_1.mergeDeep)({}, tableConfigDefaults, tableConfig);
+    return (0, table_1.table)(tableData, mergedConfig);
+}
+exports.getTableContents = getTableContents;
+function getTableHeader(headerItems) {
+    return headerItems.map(headerItem => chalk_1.default.bold(headerItem));
+}
+exports.getTableHeader = getTableHeader;

package/lib/oauth.d.ts

@@ -0,0 +1,7 @@
+import OAuth2Manager from '../models/OAuth2Manager';
+import { FlatAccountFields } from '../types/Accounts';
+import { LogCallbacksArg } from '../types/LogCallbacks';
+export declare function getOauthManager(accountId: number, accountConfig: FlatAccountFields): OAuth2Manager | undefined;
+declare const addOauthToAccountConfigCallbackKeys: string[];
+export declare function addOauthToAccountConfig(oauth: OAuth2Manager, logCallbacks: LogCallbacksArg<typeof addOauthToAccountConfigCallbackKeys>): void;
+export {};

package/lib/oauth.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addOauthToAccountConfig = exports.getOauthManager = void 0;
+const OAuth2Manager_1 = __importDefault(require("../models/OAuth2Manager"));
+const auth_1 = require("../constants/auth");
+const standardErrors_1 = require("../errors/standardErrors");
+const logger_1 = require("../utils/logger");
+const logger_2 = require("../utils/logger");
+const getAccountIdentifier_1 = require("../utils/getAccountIdentifier");
+const config_1 = require("../config");
+const oauthManagers = new Map();
+function writeOauthTokenInfo(accountConfig) {
+    const accountId = (0, getAccountIdentifier_1.getAccountIdentifier)(accountConfig);
+    (0, logger_1.debug)('oauth.writeTokenInfo', { portalId: accountId || '' });
+    (0, config_1.updateAccountConfig)(accountConfig);
+    (0, config_1.writeConfig)();
+}
+function getOauthManager(accountId, accountConfig) {
+    if (!oauthManagers.has(accountId)) {
+        oauthManagers.set(accountId, OAuth2Manager_1.default.fromConfig(accountConfig, () => writeOauthTokenInfo(accountConfig)));
+    }
+    return oauthManagers.get(accountId);
+}
+exports.getOauthManager = getOauthManager;
+const addOauthToAccountConfigCallbackKeys = ['init', 'success'];
+function addOauthToAccountConfig(oauth, logCallbacks) {
+    const logger = (0, logger_2.makeTypedLogger)(logCallbacks, 'oauth.addOauthToAccountConfig');
+    logger('init');
+    try {
+        (0, config_1.updateAccountConfig)({
+            ...oauth.toObj(),
+            authType: auth_1.AUTH_METHODS.oauth.value,
+        });
+        (0, config_1.writeConfig)();
+        logger('success');
+    }
+    catch (err) {
+        (0, standardErrors_1.throwError)(err);
+    }
+}
+exports.addOauthToAccountConfig = addOauthToAccountConfig;

package/lib/path.d.ts

@@ -6,5 +6,6 @@ export declare function splitLocalPath(filepath: string, pathImplementation?: pa
 export declare function splitHubSpotPath(filepath: string): Array<string>;
 export declare function getCwd(): string;
 export declare function getExt(filepath: string): string;
-export declare function isAllowedExtension(filepath: string): boolean;
+export declare function getAllowedExtensions(allowList?: Array<string>): Set<string>;
+export declare function isAllowedExtension(filepath: string, allowList?: Array<string>): boolean;
 export declare function getAbsoluteFilePath(_path: string): string;