@hubspot/local-dev-lib 0.0.2 → 0.0.4

package/lib/cms/handleFieldsJS.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupTmpDirSync = exports.createTmpDirSync = exports.isConvertableFieldJs = exports.FieldsJs = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const escapeRegExp_1 = require("../../utils/escapeRegExp");
+const modules_1 = require("../../utils/modules");
+const logger_1 = require("../../utils/logger");
+const standardErrors_1 = require("../../errors/standardErrors");
+const i18nKey = 'utils.handleFieldsJs';
+class FieldsJs {
+    projectDir;
+    filePath;
+    rootWriteDir;
+    rejected;
+    fieldOptions;
+    outputPath;
+    constructor(projectDir, filePath, rootWriteDir, fieldOptions = '') {
+        this.projectDir = projectDir;
+        this.filePath = filePath;
+        this.fieldOptions = fieldOptions;
+        this.rejected = false;
+        // Create tmpDir if no writeDir is given.
+        this.rootWriteDir =
+            rootWriteDir === undefined
+                ? createTmpDirSync('hubspot-temp-fieldsjs-output-')
+                : rootWriteDir;
+    }
+    async init() {
+        const outputPath = await this.getOutputPathPromise();
+        this.outputPath = this.rejected ? undefined : outputPath;
+        return this;
+    }
+    // Converts a fields.js file into a fields.json file, writes, and returns of fields.json
+    convertFieldsJs(writeDir) {
+        const filePath = this.filePath;
+        const dirName = path_1.default.dirname(filePath);
+        return new Promise((resolve, reject) => {
+            const convertFieldsProcess = (0, child_process_1.fork)(path_1.default.join(__dirname, './processFieldsJs.js'), [], {
+                cwd: dirName,
+                env: {
+                    dirName,
+                    fieldOptions: this.fieldOptions,
+                    filePath,
+                    writeDir,
+                },
+            });
+            (0, logger_1.debug)(`${i18nKey}.convertFieldsJs.creating`, {
+                pid: convertFieldsProcess.pid || '',
+            });
+            convertFieldsProcess.on('message', function (message) {
+                if (message.action === 'ERROR') {
+                    reject(message.message);
+                }
+                else if (message.action === 'COMPLETE') {
+                    resolve(message.finalPath);
+                }
+            });
+            convertFieldsProcess.on('close', () => {
+                (0, logger_1.debug)(`${i18nKey}.convertFieldsJs.terminating`, {
+                    pid: convertFieldsProcess.pid || '',
+                });
+            });
+        }).catch((e) => {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.convertFieldsJs`, { filePath }, e);
+        });
+    }
+    /**
+     * If there has been a fields.json written to the output path, then copy it from the output
+     * directory to the project directory, respecting the path within the output directory.
+     * Ex: path/to/tmp/example.module/fields.json => path/to/project/example.module/fields.output.json
+     */
+    saveOutput() {
+        if (!this.outputPath || !fs_extra_1.default.existsSync(this.outputPath)) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.saveOutput`, { path: this.filePath });
+        }
+        const relativePath = path_1.default.relative(this.rootWriteDir, path_1.default.dirname(this.outputPath));
+        const savePath = path_1.default.join(this.projectDir, relativePath, 'fields.output.json');
+        try {
+            fs_extra_1.default.copyFileSync(this.outputPath, savePath);
+        }
+        catch (err) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.saveOutput`, { path: savePath }, err);
+        }
+    }
+    /**
+     * Resolves the relative path to the fields.js within the project directory and returns
+     * directory name to write to in rootWriteDir directory.
+     *
+     * Ex: If rootWriteDir = 'path/to/temp', filePath = 'projectRoot/sample.module/fields.js'. Then getWriteDir() => path/to/temp/sample.module
+     */
+    getWriteDir() {
+        const projectDirRegex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(this.projectDir)}`);
+        const relativePath = this.filePath.replace(projectDirRegex, '');
+        return path_1.default.dirname(path_1.default.join(this.rootWriteDir, relativePath));
+    }
+    getOutputPathPromise() {
+        const writeDir = this.getWriteDir();
+        return this.convertFieldsJs(writeDir).then(outputPath => outputPath);
+    }
+}
+exports.FieldsJs = FieldsJs;
+/**
+ * Determines if file is a convertable fields.js file i.e., if it is called
+ * 'fields.js' and in a root or in a module folder, and if convertFields flag is true.
+ */
+function isConvertableFieldJs(rootDir, filePath, convertFields = false) {
+    const allowedFieldsNames = ['fields.js', 'fields.mjs', 'fields.cjs'];
+    const regex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(rootDir)}`);
+    const relativePath = path_1.default.dirname(filePath.replace(regex, ''));
+    const baseName = path_1.default.basename(filePath);
+    const inModuleFolder = (0, modules_1.isModuleFolderChild)({ path: filePath, isLocal: true });
+    return !!(convertFields &&
+        allowedFieldsNames.includes(baseName) &&
+        (inModuleFolder || relativePath == '/'));
+}
+exports.isConvertableFieldJs = isConvertableFieldJs;
+// Try creating tempdir
+function createTmpDirSync(prefix) {
+    let tmpDir;
+    try {
+        tmpDir = fs_extra_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), prefix));
+    }
+    catch (err) {
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.createTmpDirSync`, {}, err);
+    }
+    return tmpDir;
+}
+exports.createTmpDirSync = createTmpDirSync;
+// Try cleaning up resources from os's tempdir
+function cleanupTmpDirSync(tmpDir) {
+    fs_extra_1.default.rm(tmpDir, { recursive: true }, err => {
+        if (err) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.cleanupTmpDirSync`, {}, err);
+        }
+    });
+}
+exports.cleanupTmpDirSync = cleanupTmpDirSync;

package/lib/cms/index.d.ts

@@ -0,0 +1,10 @@
+import { isConvertableFieldJs as __isConvertableFieldJs, createTmpDirSync as __createTmpDirSync, cleanupTmpDirSync as __cleanupTmpDirSync } from './handleFieldsJS';
+import { validateSrcAndDestPaths as __validateSrcAndDestPaths, createModule as __createModule } from './modules';
+import { getThemeJSONPath as __getThemeJSONPath, getThemePreviewUrl as __getThemePreviewUrl } from './themes';
+export declare const isConvertableFieldJs: typeof __isConvertableFieldJs;
+export declare const createTmpDirSync: typeof __createTmpDirSync;
+export declare const cleanupTmpDirSync: typeof __cleanupTmpDirSync;
+export declare const validateSrcAndDestPaths: typeof __validateSrcAndDestPaths;
+export declare const createModule: typeof __createModule;
+export declare const getThemeJSONPath: typeof __getThemeJSONPath;
+export declare const getThemePreviewUrl: typeof __getThemePreviewUrl;

package/lib/cms/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThemePreviewUrl = exports.getThemeJSONPath = exports.createModule = exports.validateSrcAndDestPaths = exports.cleanupTmpDirSync = exports.createTmpDirSync = exports.isConvertableFieldJs = void 0;
+const handleFieldsJS_1 = require("./handleFieldsJS");
+const modules_1 = require("./modules");
+const themes_1 = require("./themes");
+exports.isConvertableFieldJs = handleFieldsJS_1.isConvertableFieldJs;
+exports.createTmpDirSync = handleFieldsJS_1.createTmpDirSync;
+exports.cleanupTmpDirSync = handleFieldsJS_1.cleanupTmpDirSync;
+exports.validateSrcAndDestPaths = modules_1.validateSrcAndDestPaths;
+exports.createModule = modules_1.createModule;
+exports.getThemeJSONPath = themes_1.getThemeJSONPath;
+exports.getThemePreviewUrl = themes_1.getThemePreviewUrl;

package/lib/cms/modules.d.ts

@@ -0,0 +1,24 @@
+import { LogCallbacksArg } from '../../types/LogCallbacks';
+import { PathInput } from '../../types/Modules';
+export declare const ValidationIds: {
+    SRC_REQUIRED: string;
+    DEST_REQUIRED: string;
+    MODULE_FOLDER_REQUIRED: string;
+    MODULE_TO_MODULE_NESTING: string;
+    MODULE_NESTING: string;
+};
+type ValidationResult = {
+    id: string;
+    message: string;
+};
+export declare function validateSrcAndDestPaths(src?: PathInput, dest?: PathInput): Promise<Array<ValidationResult>>;
+type ModuleDefinition = {
+    contentTypes: Array<string>;
+    moduleLabel: string;
+    global: boolean;
+};
+declare const createModuleCallbackKeys: readonly ["creatingPath", "creatingModule"];
+export declare function createModule(moduleDefinition: ModuleDefinition, name: string, dest: string, options?: {
+    allowExistingDir: boolean;
+}, logCallbacks?: LogCallbacksArg<typeof createModuleCallbackKeys>): Promise<void>;
+export {};

package/lib/cms/modules.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModule = exports.validateSrcAndDestPaths = exports.ValidationIds = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_2 = require("../path");
+const fs_1 = require("../fs");
+const github_1 = require("../github");
+const standardErrors_1 = require("../../errors/standardErrors");
+const logger_1 = require("../../utils/logger");
+const modules_1 = require("../../utils/modules");
+// Ids for testing
+exports.ValidationIds = {
+    SRC_REQUIRED: 'SRC_REQUIRED',
+    DEST_REQUIRED: 'DEST_REQUIRED',
+    MODULE_FOLDER_REQUIRED: 'MODULE_FOLDER_REQUIRED',
+    MODULE_TO_MODULE_NESTING: 'MODULE_TO_MODULE_NESTING',
+    MODULE_NESTING: 'MODULE_NESTING',
+};
+const getValidationResult = (id, message) => ({ id, message });
+async function validateSrcAndDestPaths(src, dest) {
+    const results = [];
+    if (!(0, modules_1.isPathInput)(src)) {
+        results.push(getValidationResult(exports.ValidationIds.SRC_REQUIRED, '`src` is required.'));
+    }
+    if (!(0, modules_1.isPathInput)(dest)) {
+        results.push(getValidationResult(exports.ValidationIds.DEST_REQUIRED, '`dest` is required.'));
+    }
+    if (results.length || !src || !dest) {
+        return results;
+    }
+    const [_src, _dest] = [src, dest].map(inputPath => {
+        const result = { ...inputPath };
+        if (result.isLocal) {
+            result.path = path_1.default.resolve((0, path_2.getCwd)(), result.path);
+        }
+        else if (result.isHubSpot) {
+            result.path = path_1.default.posix.normalize(result.path);
+        }
+        return result;
+    });
+    // src is a .module folder and dest is within a module. (Nesting)
+    // e.g. `upload foo.module bar.module/zzz`
+    if ((0, modules_1.isModuleFolder)(_src) && (0, modules_1.isModuleFolderChild)(_dest)) {
+        return results.concat(getValidationResult(exports.ValidationIds.MODULE_TO_MODULE_NESTING, '`src` is a module path and `dest` is within a module.'));
+    }
+    // src is a .module folder but dest is not
+    // e.g. `upload foo.module bar`
+    if ((0, modules_1.isModuleFolder)(_src) && !(0, modules_1.isModuleFolder)(_dest)) {
+        return results.concat(getValidationResult(exports.ValidationIds.MODULE_FOLDER_REQUIRED, '`src` is a module path but `dest` is not.'));
+    }
+    // src is a folder that includes modules and dest is within a module. (Nesting)
+    if (_src.isLocal && (0, modules_1.isModuleFolderChild)(_dest)) {
+        const stat = await fs_extra_1.default.stat(_src.path);
+        if (stat.isDirectory()) {
+            const files = await (0, fs_1.walk)(_src.path);
+            const srcHasModulesChildren = files.some(file => (0, modules_1.isModuleFolderChild)({ ..._src, path: file }));
+            if (srcHasModulesChildren) {
+                return results.concat(getValidationResult(exports.ValidationIds.MODULE_NESTING, '`src` contains modules and `dest` is within a module.'));
+            }
+        }
+    }
+    return results;
+}
+exports.validateSrcAndDestPaths = validateSrcAndDestPaths;
+const createModuleCallbackKeys = ['creatingPath', 'creatingModule'];
+async function createModule(moduleDefinition, name, dest, options = {
+    allowExistingDir: false,
+}, logCallbacks) {
+    const logger = (0, logger_1.makeTypedLogger)(logCallbacks, 'modules.createModule');
+    const writeModuleMeta = ({ contentTypes, moduleLabel, global }, dest) => {
+        const metaData = {
+            label: moduleLabel,
+            css_assets: [],
+            external_js: [],
+            global: global,
+            help_text: '',
+            host_template_types: contentTypes,
+            js_assets: [],
+            other_assets: [],
+            smart_type: 'NOT_SMART',
+            tags: [],
+            is_available_for_new_content: false,
+        };
+        fs_extra_1.default.writeJSONSync(dest, metaData, { spaces: 2 });
+    };
+    const moduleFileFilter = (src, dest) => {
+        const emailEnabled = moduleDefinition.contentTypes.includes('EMAIL');
+        switch (path_1.default.basename(src)) {
+            case 'meta.json':
+                writeModuleMeta(moduleDefinition, dest);
+                return false;
+            case 'module.js':
+            case 'module.css':
+                if (emailEnabled) {
+                    return false;
+                }
+                return true;
+            default:
+                return true;
+        }
+    };
+    const folderName = !name || name.endsWith('.module') ? name : `${name}.module`;
+    const destPath = path_1.default.join(dest, folderName);
+    if (!options.allowExistingDir && fs_extra_1.default.existsSync(destPath)) {
+        (0, standardErrors_1.throwErrorWithMessage)('modules.createModule', {
+            path: destPath,
+        });
+    }
+    else {
+        logger('creatingPath', {
+            path: destPath,
+        });
+        fs_extra_1.default.ensureDirSync(destPath);
+    }
+    logger('creatingModule', {
+        path: destPath,
+    });
+    await (0, github_1.downloadGithubRepoContents)('cms-sample-assets', 'modules/Sample.module', destPath, moduleFileFilter);
+}
+exports.createModule = createModule;

package/lib/cms/themes.d.ts

@@ -0,0 +1,2 @@
+export declare function getThemeJSONPath(path: string): string | null;
+export declare function getThemePreviewUrl(filePath: string, accountId: number): string | undefined;

package/lib/cms/themes.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThemePreviewUrl = exports.getThemeJSONPath = void 0;
+const findup_sync_1 = __importDefault(require("findup-sync"));
+const urls_1 = require("../urls");
+const environments_1 = require("../../constants/environments");
+const CLIConfiguration_1 = __importDefault(require("../../config/CLIConfiguration"));
+function getThemeJSONPath(path) {
+    return (0, findup_sync_1.default)('theme.json', {
+        cwd: path,
+        nocase: true,
+    });
+}
+exports.getThemeJSONPath = getThemeJSONPath;
+function getThemeNameFromPath(filePath) {
+    const themeJSONPath = getThemeJSONPath(filePath);
+    if (!themeJSONPath)
+        return;
+    const pathParts = themeJSONPath.split('/');
+    if (pathParts.length < 2)
+        return;
+    return pathParts[pathParts.length - 2];
+}
+function getThemePreviewUrl(filePath, accountId) {
+    const themeName = getThemeNameFromPath(filePath);
+    if (!themeName)
+        return;
+    const baseUrl = (0, urls_1.getHubSpotWebsiteOrigin)(CLIConfiguration_1.default.getEnv() === 'qa' ? environments_1.ENVIRONMENTS.QA : environments_1.ENVIRONMENTS.PROD);
+    return `${baseUrl}/theme-previewer/${accountId}/edit/${encodeURIComponent(themeName)}`;
+}
+exports.getThemePreviewUrl = getThemePreviewUrl;

package/lib/environment.d.ts

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

package/lib/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/lib/fs.d.ts

@@ -0,0 +1,4 @@
+import { FileData } from '../types/Files';
+export declare function getFileInfoAsync(dir: string, file: string): Promise<FileData>;
+export declare function flattenAndRemoveSymlinks(filesData: Array<FileData>): Array<string>;
+export declare function walk(dir: string): Promise<Array<string>>;

package/lib/fs.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.walk = exports.flattenAndRemoveSymlinks = exports.getFileInfoAsync = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const files_1 = require("../constants/files");
+const standardErrors_1 = require("../errors/standardErrors");
+function getFileInfoAsync(dir, file) {
+    return new Promise((resolve, reject) => {
+        const filepath = path_1.default.join(dir, file);
+        fs_1.default.lstat(filepath, (error, stats) => {
+            if (error) {
+                reject(error);
+            }
+            let type = files_1.STAT_TYPES.FILE;
+            if (stats.isSymbolicLink()) {
+                type = files_1.STAT_TYPES.SYMBOLIC_LINK;
+            }
+            else if (stats.isDirectory()) {
+                type = files_1.STAT_TYPES.DIRECTORY;
+            }
+            resolve({ filepath, type });
+        });
+    });
+}
+exports.getFileInfoAsync = getFileInfoAsync;
+function flattenAndRemoveSymlinks(filesData) {
+    return filesData.reduce((acc, fileData) => {
+        switch (fileData.type) {
+            case files_1.STAT_TYPES.FILE:
+                return acc.concat(fileData.filepath);
+            case files_1.STAT_TYPES.DIRECTORY:
+                return acc.concat(fileData.files || []);
+            case files_1.STAT_TYPES.SYMBOLIC_LINK:
+                return acc;
+            default:
+                return acc;
+        }
+    }, []);
+}
+exports.flattenAndRemoveSymlinks = flattenAndRemoveSymlinks;
+const generateRecursiveFilePromise = async (dir, file) => {
+    return getFileInfoAsync(dir, file).then(fileData => {
+        return new Promise(resolve => {
+            if (fileData.type === files_1.STAT_TYPES.DIRECTORY) {
+                walk(fileData.filepath).then(files => {
+                    resolve({ ...fileData, files });
+                });
+            }
+            else {
+                resolve(fileData);
+            }
+        });
+    });
+};
+async function walk(dir) {
+    function processFiles(files) {
+        return Promise.all(files.map(file => generateRecursiveFilePromise(dir, file)));
+    }
+    return fs_1.default.promises
+        .readdir(dir)
+        .then(processFiles)
+        .then(flattenAndRemoveSymlinks)
+        .catch(err => {
+        (0, standardErrors_1.throwError)(err);
+    });
+}
+exports.walk = walk;

package/lib/github.d.ts

@@ -0,0 +1,17 @@
+import { GITHUB_RELEASE_TYPES } from '../constants/github';
+import { ValueOf } from '../types/Utils';
+import { LogCallbacksArg } from '../types/LogCallbacks';
+declare global {
+    var githubToken: string;
+}
+export declare function fetchJsonFromRepository(repoName: string, filePath: string): Promise<JSON>;
+type CloneGithubRepoOptions = {
+    themeVersion?: string;
+    projectVersion?: string;
+    releaseType?: ValueOf<typeof GITHUB_RELEASE_TYPES>;
+    ref?: string;
+};
+declare const cloneGithubRepoCallbackKeys: string[];
+export declare function cloneGithubRepo(dest: string, type: string, repoName: string, sourceDir: string, options?: CloneGithubRepoOptions, logCallbacks?: LogCallbacksArg<typeof cloneGithubRepoCallbackKeys>): Promise<boolean>;
+export declare function downloadGithubRepoContents(repoName: string, contentPath: string, dest: string, filter?: (contentPiecePath: string, downloadPath: string) => boolean): Promise<void>;
+export {};

package/lib/github.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadGithubRepoContents = exports.cloneGithubRepo = exports.fetchJsonFromRepository = void 0;
+const axios_1 = __importDefault(require("axios"));
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const logger_1 = require("../utils/logger");
+const standardErrors_1 = require("../errors/standardErrors");
+const archive_1 = require("./archive");
+const github_1 = require("../constants/github");
+const requestOptions_1 = require("../http/requestOptions");
+const GITHUB_AUTH_HEADERS = {
+    authorization: global && global.githubToken ? `Bearer ${global.githubToken}` : null,
+};
+async function fetchJsonFromRepository(repoName, filePath) {
+    try {
+        const URI = `https://raw.githubusercontent.com/HubSpot/${repoName}/${filePath}`;
+        (0, logger_1.debug)('github.fetchJsonFromRepository', { uri: URI });
+        const { data } = await axios_1.default.get(URI, {
+            headers: { ...requestOptions_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
+        });
+        return data;
+    }
+    catch (err) {
+        (0, standardErrors_1.throwErrorWithMessage)('github.fetchJsonFromRepository', {}, err);
+    }
+}
+exports.fetchJsonFromRepository = fetchJsonFromRepository;
+async function fetchReleaseData(repoName, tag = '') {
+    tag = tag.trim().toLowerCase();
+    if (tag.length && tag[0] !== 'v') {
+        tag = `v${tag}`;
+    }
+    const URI = tag
+        ? `https://api.github.com/repos/HubSpot/${repoName}/releases/tags/${tag}`
+        : `https://api.github.com/repos/HubSpot/${repoName}/releases/latest`;
+    try {
+        const { data } = await axios_1.default.get(URI, {
+            headers: { ...requestOptions_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
+        });
+        return data;
+    }
+    catch (err) {
+        const error = err;
+        (0, standardErrors_1.throwErrorWithMessage)('github.fetchReleaseData', { tag: tag || 'latest' }, error);
+    }
+}
+async function downloadGithubRepoZip(repoName, tag = '', releaseType = github_1.GITHUB_RELEASE_TYPES.RELEASE, ref) {
+    try {
+        let zipUrl;
+        if (releaseType === github_1.GITHUB_RELEASE_TYPES.REPOSITORY) {
+            (0, logger_1.debug)('github.downloadGithubRepoZip.fetching', { releaseType, repoName });
+            zipUrl = `https://api.github.com/repos/HubSpot/${repoName}/zipball${ref ? `/${ref}` : ''}`;
+        }
+        else {
+            const releaseData = await fetchReleaseData(repoName, tag);
+            zipUrl = releaseData.zipball_url;
+            const { name } = releaseData;
+            (0, logger_1.debug)('github.downloadGithubRepoZip.fetchingName', { name });
+        }
+        const { data } = await axios_1.default.get(zipUrl, {
+            headers: { ...requestOptions_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
+        });
+        (0, logger_1.debug)('github.downloadGithubRepoZip.completed');
+        return data;
+    }
+    catch (err) {
+        (0, standardErrors_1.throwErrorWithMessage)('github.downloadGithubRepoZip', {}, err);
+    }
+}
+const cloneGithubRepoCallbackKeys = ['success'];
+async function cloneGithubRepo(dest, type, repoName, sourceDir, options = {}, logCallbacks) {
+    const logger = (0, logger_1.makeTypedLogger)(logCallbacks, 'github.cloneGithubRepo');
+    const { themeVersion, projectVersion, releaseType, ref } = options;
+    const tag = projectVersion || themeVersion;
+    const zip = await downloadGithubRepoZip(repoName, tag, releaseType, ref);
+    const success = await (0, archive_1.extractZipArchive)(zip, repoName, dest, { sourceDir });
+    if (success) {
+        logger('success', { type, dest });
+    }
+    return success;
+}
+exports.cloneGithubRepo = cloneGithubRepo;
+async function getGitHubRepoContentsAtPath(repoName, path) {
+    const contentsRequestUrl = `https://api.github.com/repos/HubSpot/${repoName}/contents/${path}`;
+    const response = await axios_1.default.get(contentsRequestUrl, {
+        headers: { ...requestOptions_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
+    });
+    return response.data;
+}
+async function fetchGitHubRepoContentFromDownloadUrl(dest, downloadUrl) {
+    const resp = await axios_1.default.get(downloadUrl, {
+        headers: { ...requestOptions_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
+    });
+    fs_extra_1.default.writeFileSync(dest, resp.data, 'utf8');
+}
+// Writes files from a HubSpot public repository to the destination folder
+async function downloadGithubRepoContents(repoName, contentPath, dest, filter) {
+    fs_extra_1.default.ensureDirSync(path_1.default.dirname(dest));
+    try {
+        const contentsResp = await getGitHubRepoContentsAtPath(repoName, contentPath);
+        const downloadContent = async (contentPiece) => {
+            const { path: contentPiecePath, download_url } = contentPiece;
+            const downloadPath = path_1.default.join(dest, contentPiecePath.replace(contentPath, ''));
+            if (filter && !filter(contentPiecePath, downloadPath)) {
+                return Promise.resolve();
+            }
+            (0, logger_1.debug)('github.downloadGithubRepoContents.downloading', {
+                contentPiecePath,
+                downloadUrl: download_url,
+                downloadPath,
+            });
+            return fetchGitHubRepoContentFromDownloadUrl(downloadPath, download_url);
+        };
+        const contentPromises = contentsResp.map(downloadContent);
+        Promise.all(contentPromises);
+    }
+    catch (e) {
+        const error = e;
+        if (error.error.message) {
+            (0, standardErrors_1.throwErrorWithMessage)('github.downloadGithubRepoContents', {
+                errorMessage: error.error.message,
+            }, error);
+        }
+        else {
+            (0, standardErrors_1.throwError)(error);
+        }
+    }
+}
+exports.downloadGithubRepoContents = downloadGithubRepoContents;

package/lib/gitignore.d.ts

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