@hubspot/local-dev-lib 0.4.0-experimental.1 → 0.4.2-experimental.0

package/errors/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFileSystemError = exports.isSystemError = exports.isHubSpotHttpError = exports.isValidationError = exports.isAuthError = exports.isTimeoutError = exports.isGatingError = exports.isMissingScopeError = exports.isSpecifiedError = void 0;
+exports.isFileSystemError = exports.isSystemError = exports.isGithubRateLimitError = exports.isHubSpotHttpError = exports.isValidationError = exports.isAuthError = exports.isTimeoutError = exports.isGatingError = exports.isMissingScopeError = exports.isSpecifiedError = void 0;
 const HubSpotHttpError_1 = require("../models/HubSpotHttpError");
 const FileSystemError_1 = require("../models/FileSystemError");
 function isSpecifiedError(err, { statusCode, category, subCategory, errorType, code, }) {
@@ -47,6 +47,15 @@ function isHubSpotHttpError(error) {
     return !!error && error instanceof HubSpotHttpError_1.HubSpotHttpError;
 }
 exports.isHubSpotHttpError = isHubSpotHttpError;
+function isGithubRateLimitError(err) {
+    if (!isHubSpotHttpError(err)) {
+        return false;
+    }
+    return (!!err.headers &&
+        err.headers['x-ratelimit-remaining'] === '0' &&
+        'x-github-request-id' in err.headers);
+}
+exports.isGithubRateLimitError = isGithubRateLimitError;
 function isSystemError(err) {
     return (err instanceof Error &&
         'errno' in err &&

package/lang/en.json

@@ -31,6 +31,7 @@
       }
     },
     "github": {
+      "rateLimitError": "Github rate limit hit. Set the GITHUB_TOKEN env variable with your github PATH. This will increase the github api's rate limit.",
       "fetchFileFromRepository": {
         "fetching": "Fetching {{ path }}...",
         "errors": {
@@ -77,6 +78,15 @@
         "invalidPersonalAccessKey": "Error while retrieving new access token: {{ errorMessage }}"
       }
     },
+    "crm": {
+      "importData": {
+        "errors": {
+          "fileNotFound": "The file {{ fileName }} does not exist",
+          "notJson": "You must provide a JSON file for the import data request schema.",
+          "noFiles": "You must provide at least one data file for the import data request schema."
+        }
+      }
+    },
     "cms": {
       "modules": {
         "createModule": {
@@ -242,13 +252,13 @@
         "empty": "The config file was empty. Initializing an empty config."
       },
       "validate": {
-        "noConfig": "Valiation failed: No config was found.",
-        "noConfigAccounts": "Valiation failed: config.accounts[] is not defined.",
-        "emptyAccountConfig": "Valiation failed: config.accounts[] has an empty entry.",
-        "noAccountId": "Valiation failed: config.accounts[] has an entry missing accountId.",
-        "duplicateAccountIds": "Valiation failed: config.accounts[] has multiple entries with {{ accountId }}.",
-        "duplicateAccountNames": "Valiation failed: config.accounts[] has multiple entries with {{ accountName }}.",
-        "nameContainsSpaces": "Valiation failed: config.name {{ accountName }} cannot contain spaces."
+        "noConfig": "Validation failed: No config was found.",
+        "noConfigAccounts": "Validation failed: config.accounts[] is not defined.",
+        "emptyAccountConfig": "Validation failed: config.accounts[] has an empty entry.",
+        "noAccountId": "Validation failed: config.accounts[] has an entry missing accountId.",
+        "duplicateAccountIds": "Validation failed: config.accounts[] has multiple entries with {{ accountId }}.",
+        "duplicateAccountNames": "Validation failed: config.accounts[] has multiple entries with {{ accountName }}.",
+        "nameContainsSpaces": "Validation failed: config.name {{ accountName }} cannot contain spaces."
       },
       "updateAccount": {
         "noConfigToUpdate": "No config to update.",
@@ -292,6 +302,11 @@
         "errors": {
           "invalidInput": "Unable to update allowUsageTracking. The value {{ isEnabled }} is invalid. The value must be a boolean."
         }
+      },
+      "updateAutoOpenBrowser": {
+        "errors": {
+          "invalidInput": "Unable to update autoOpenBrowser. The value {{ isEnabled }} is invalid. The value must be a boolean."
+        }
       }
     },
     "configFile": {

package/lib/archive.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { CopySourceToDestOptions } from '../types/Archive';
-export declare function extractZipArchive(zip: Buffer, name: string, dest: string, { sourceDir, includesRootDir, hideLogs }?: CopySourceToDestOptions): Promise<boolean>;
+export declare function extractZipArchive(zip: Buffer, name: string, dest: string, { sourceDir, includesRootDir, hideLogs, handleCollision, }?: CopySourceToDestOptions): Promise<boolean>;

package/lib/archive.js

@@ -1,16 +1,40 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractZipArchive = void 0;
 const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = require("path");
+const path_1 = __importStar(require("path"));
 const os_1 = require("os");
 const extract_zip_1 = __importDefault(require("extract-zip"));
 const logger_1 = require("./logger");
 const lang_1 = require("../utils/lang");
 const FileSystemError_1 = require("../models/FileSystemError");
+const fs_1 = require("./fs");
 const i18nKey = 'lib.archive';
 async function extractZip(name, zip, hideLogs = false) {
     const result = { extractDir: '', tmpDir: '' };
@@ -55,7 +79,7 @@ async function extractZip(name, zip, hideLogs = false) {
     logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.extractZip.success`));
     return result;
 }
-async function copySourceToDest(src, dest, { sourceDir, includesRootDir = true, hideLogs = false, } = {}) {
+async function copySourceToDest(src, dest, { sourceDir, includesRootDir = true, hideLogs = false, handleCollision, } = {}) {
     try {
         if (!hideLogs) {
             logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.copySourceToDest.init`));
@@ -73,11 +97,43 @@ async function copySourceToDest(src, dest, { sourceDir, includesRootDir = true,
             }
             srcDirPath.push(rootDir);
         }
+        const sourceDirs = [];
         if (sourceDir) {
-            srcDirPath.push(sourceDir);
+            sourceDirs.push(...(Array.isArray(sourceDir) ? new Set(sourceDir) : [sourceDir]));
+        }
+        if (sourceDirs.length === 0) {
+            const projectSrcDir = (0, path_1.join)(...srcDirPath);
+            await fs_extra_1.default.copy(projectSrcDir, dest);
+        }
+        else {
+            for (let i = 0; i < sourceDirs.length; i++) {
+                const projectSrcDir = (0, path_1.join)(...srcDirPath, sourceDirs[i]);
+                let collisions = [];
+                let filesWithoutCollisions = [];
+                if (fs_extra_1.default.existsSync(dest) &&
+                    handleCollision &&
+                    typeof handleCollision === 'function') {
+                    const existingFiles = (await (0, fs_1.walk)(dest, ['node_modules'])).map(file => path_1.default.normalize(path_1.default.relative(dest, file)));
+                    const newFiles = (await (0, fs_1.walk)(projectSrcDir, ['node_modules'])).map(file => path_1.default.relative(projectSrcDir, file));
+                    // Find files that exist in the same positions in both directories
+                    collisions = existingFiles.filter(currentFile => newFiles.includes(currentFile));
+                    filesWithoutCollisions = newFiles.filter(currentFile => !collisions.includes(currentFile));
+                }
+                if (collisions.length &&
+                    handleCollision &&
+                    typeof handleCollision === 'function') {
+                    await handleCollision({
+                        dest,
+                        src: projectSrcDir,
+                        collisions,
+                    });
+                    await Promise.all(filesWithoutCollisions.map(currentFile => fs_extra_1.default.copy(path_1.default.join(projectSrcDir, currentFile), path_1.default.join(dest, currentFile))));
+                }
+                else {
+                    await fs_extra_1.default.copy(projectSrcDir, dest);
+                }
+            }
         }
-        const projectSrcDir = (0, path_1.join)(...srcDirPath);
-        await fs_extra_1.default.copy(projectSrcDir, dest);
         logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.copySourceToDest.success`));
         return true;
     }
@@ -99,7 +155,7 @@ async function cleanupTempDir(tmpDir) {
         logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.cleanupTempDir.error`, { tmpDir }));
     }
 }
-async function extractZipArchive(zip, name, dest, { sourceDir, includesRootDir, hideLogs } = {}) {
+async function extractZipArchive(zip, name, dest, { sourceDir, includesRootDir, hideLogs, handleCollision, } = {}) {
     let success = false;
     if (zip) {
         const { extractDir, tmpDir } = await extractZip(name, zip, hideLogs);
@@ -108,6 +164,7 @@ async function extractZipArchive(zip, name, dest, { sourceDir, includesRootDir,
                 sourceDir,
                 includesRootDir,
                 hideLogs,
+                handleCollision,
             });
         }
         await cleanupTempDir(tmpDir);

package/lib/cms/uploadFolder.js

@@ -38,6 +38,16 @@ function getFileType(filePath) {
             return files_1.FILE_TYPES.other;
     }
 }
+function isMetaJsonFile(filePath) {
+    return path_1.default.basename(filePath).toLowerCase() === 'meta.json';
+}
+function resolveUploadPath(file, fieldsJsPaths, tmpDirRegex, regex, dest) {
+    const fieldsJsFileInfo = fieldsJsPaths.find(f => f.outputPath === file);
+    const relativePath = file.replace(fieldsJsFileInfo ? tmpDirRegex : regex, '');
+    const destPath = (0, path_2.convertToUnixPath)(path_1.default.join(dest, relativePath));
+    const originalFilePath = fieldsJsFileInfo ? fieldsJsFileInfo.filePath : file;
+    return { fieldsJsFileInfo, relativePath, destPath, originalFilePath };
+}
 async function getFilesByType(filePaths, projectDir, rootWriteDir, commandOptions) {
     const { convertFields, fieldOptions } = commandOptions;
     const projectDirRegex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(projectDir)}`);
@@ -106,6 +116,12 @@ const defaultUploadFinalErrorCallback = (accountId, file, destPath, error) => {
         payload: file,
     });
 };
+async function uploadMetaJsonFiles(moduleFiles, uploadFile) {
+    const moduleMetaJsonFiles = moduleFiles.filter(isMetaJsonFile);
+    if (moduleMetaJsonFiles.length > 0) {
+        await queue.addAll(moduleMetaJsonFiles.map(uploadFile));
+    }
+}
 async function uploadFolder(accountId, src, dest, fileMapperOptions, commandOptions = {}, filePaths = [], cmsPublishMode = null) {
     const { saveOutput, convertFields, onAttemptCallback, onSuccessCallback, onFirstErrorCallback, onRetryCallback, onFinalErrorCallback, } = commandOptions;
     const _onAttemptCallback = onAttemptCallback || defaultUploadAttemptCallback;
@@ -120,23 +136,15 @@ async function uploadFolder(accountId, src, dest, fileMapperOptions, commandOpti
     const apiOptions = (0, fileMapper_1.getFileMapperQueryValues)(cmsPublishMode, fileMapperOptions);
     const failures = [];
     let fieldsJsPaths = [];
-    let tmpDirRegex;
+    const tmpDirRegex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(tmpDir || '')}`);
     const [filesByType, fieldsJsObjects] = await getFilesByType(filePaths, src, tmpDir, commandOptions);
-    const fileList = Object.values(filesByType);
     if (fieldsJsObjects.length) {
         fieldsJsPaths = fieldsJsObjects.map(fieldsJs => {
             return { outputPath: fieldsJs.outputPath, filePath: fieldsJs.filePath };
         });
-        tmpDirRegex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(tmpDir || '')}`);
     }
     function uploadFile(file) {
-        const fieldsJsFileInfo = fieldsJsPaths.find(f => f.outputPath === file);
-        const originalFilePath = fieldsJsFileInfo
-            ? fieldsJsFileInfo.filePath
-            : file;
-        // files in fieldsJsPaths always belong to the tmp directory.
-        const relativePath = file.replace(fieldsJsFileInfo ? tmpDirRegex : regex, '');
-        const destPath = (0, path_2.convertToUnixPath)(path_1.default.join(dest, relativePath));
+        const { originalFilePath, destPath } = resolveUploadPath(file, fieldsJsPaths, tmpDirRegex, regex, dest);
         return async () => {
             _onAttemptCallback(originalFilePath, destPath);
             try {
@@ -155,9 +163,23 @@ async function uploadFolder(accountId, src, dest, fileMapperOptions, commandOpti
             }
         };
     }
-    for (let i = 0; i < fileList.length; i++) {
-        const filesToUpload = fileList[i];
-        await queue.addAll(filesToUpload.map(uploadFile));
+    // Upload all meta.json files first
+    await uploadMetaJsonFiles(filesByType[files_1.FILE_TYPES.module] || [], uploadFile);
+    // Collect all remaining files for upload
+    const deferredFiles = [];
+    Object.entries(filesByType).forEach(([fileType, files]) => {
+        if (fileType === files_1.FILE_TYPES.module) {
+            // Add non-meta.json module files
+            deferredFiles.push(...files.filter(f => !isMetaJsonFile(f)));
+        }
+        else {
+            // Add all non-module files
+            deferredFiles.push(...files);
+        }
+    });
+    // Upload all remaining files concurrently
+    if (deferredFiles.length > 0) {
+        await queue.addAll(deferredFiles.map(uploadFile));
     }
     const results = await queue
         .addAll(failures.map(({ file, destPath }) => {

package/lib/crm.d.ts

@@ -0,0 +1,6 @@
+import { ImportRequest } from '../types/Crm';
+export declare function getImportDataRequest(fileName: string): {
+    importRequest: ImportRequest;
+    dataFileNames: string[];
+};
+export declare function validateImportRequestFile(fileName: string): void;

package/lib/crm.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateImportRequestFile = exports.getImportDataRequest = void 0;
+const path_1 = __importDefault(require("path"));
+const path_2 = require("./path");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const lang_1 = require("../utils/lang");
+function getImportDataRequest(fileName) {
+    validateImportRequestFile(fileName);
+    const importRequest = fs_extra_1.default.readJsonSync(path_1.default.resolve((0, path_2.getCwd)(), fileName));
+    const dataFileNames = importRequest.files.map(file => file.fileName);
+    // allow relative paths in the provided import request
+    importRequest.files = importRequest.files.map(file => ({
+        ...file,
+        fileName: path_1.default.basename(file.fileName),
+    }));
+    if (dataFileNames.length === 0) {
+        throw new Error((0, lang_1.i18n)('lib.crm.importData.errors.noFiles'));
+    }
+    dataFileNames.forEach(fileName => {
+        if (!fileExists(fileName)) {
+            throw new Error((0, lang_1.i18n)('lib.crm.importData.errors.fileNotFound', { fileName }));
+        }
+    });
+    return { importRequest, dataFileNames };
+}
+exports.getImportDataRequest = getImportDataRequest;
+function validateImportRequestFile(fileName) {
+    if (!fileExists(fileName)) {
+        throw new Error((0, lang_1.i18n)('lib.crm.importData.errors.fileNotFound', { fileName }));
+    }
+    if (path_1.default.extname(fileName) !== '.json') {
+        throw new Error((0, lang_1.i18n)('lib.crm.importData.errors.notJson'));
+    }
+}
+exports.validateImportRequestFile = validateImportRequestFile;
+function fileExists(_path) {
+    try {
+        const absoluteSrcPath = path_1.default.resolve((0, path_2.getCwd)(), _path);
+        if (!absoluteSrcPath)
+            return false;
+        const stats = fs_extra_1.default.statSync(absoluteSrcPath);
+        const isFile = stats.isFile();
+        if (!isFile) {
+            return false;
+        }
+    }
+    catch (e) {
+        return false;
+    }
+    return true;
+}

package/lib/github.js

@@ -24,6 +24,7 @@ async function fetchFileFromRepository(repoPath, filePath, ref) {
         return data;
     }
     catch (err) {
+        checkGithubRateLimit(err);
         throw new Error((0, lang_1.i18n)(`${i18nKey}.fetchFileFromRepository.errors.fetchFail`), {
             cause: err,
         });
@@ -43,6 +44,7 @@ async function fetchReleaseData(repoPath, tag) {
         return data;
     }
     catch (err) {
+        checkGithubRateLimit(err);
         throw new Error((0, lang_1.i18n)(`${i18nKey}.fetchReleaseData.errors.fetchFail`, {
             tag: tag || 'latest',
         }), { cause: err });
@@ -72,13 +74,14 @@ async function downloadGithubRepoZip(repoPath, isRelease = false, options = {})
         return data;
     }
     catch (err) {
+        checkGithubRateLimit(err);
         throw new Error((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoZip.errors.fetchFail`), {
             cause: err,
         });
     }
 }
 async function cloneGithubRepo(repoPath, dest, options = {}) {
-    const { tag, isRelease, branch, sourceDir, type, hideLogs } = options;
+    const { tag, isRelease, branch, sourceDir, type, hideLogs, handleCollision } = options;
     const zip = await downloadGithubRepoZip(repoPath, isRelease, {
         tag,
         branch,
@@ -87,6 +90,7 @@ async function cloneGithubRepo(repoPath, dest, options = {}) {
     const success = await (0, archive_1.extractZipArchive)(zip, repoName, dest, {
         sourceDir,
         hideLogs,
+        handleCollision,
     });
     if (success && !hideLogs) {
         logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.cloneGithubRepo.success`, {
@@ -146,6 +150,7 @@ async function downloadGithubRepoContents(repoPath, contentPath, dest, ref, filt
         await Promise.all(contentPromises);
     }
     catch (e) {
+        checkGithubRateLimit(e);
         if ((0, errors_1.isSystemError)(e) && e?.error?.message) {
             throw new Error((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoContents.errors.fetchFail`, {
                 errorMessage: e.error.message,
@@ -165,6 +170,7 @@ async function listGithubRepoContents(repoPath, contentPath, fileFilter) {
         return filteredFiles;
     }
     catch (e) {
+        checkGithubRateLimit(e);
         if ((0, errors_1.isHubSpotHttpError)(e) && e.data.message) {
             throw new Error((0, lang_1.i18n)(`${i18nKey}.downloadGithubRepoContents.errors.fetchFail`, {
                 errorMessage: e.data.message,
@@ -174,3 +180,10 @@ async function listGithubRepoContents(repoPath, contentPath, fileFilter) {
     }
 }
 exports.listGithubRepoContents = listGithubRepoContents;
+function checkGithubRateLimit(err) {
+    if ((0, errors_1.isGithubRateLimitError)(err)) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.rateLimitError`), {
+            cause: err,
+        });
+    }
+}

package/lib/hubdb.d.ts

@@ -8,7 +8,7 @@ export declare function createHubDbTable(accountId: number, src: string): Promis
     tableId: string;
     rowCount: number;
 }>;
-export declare function updateHubDbTable(accountId: number, tableId: string, src: string): Promise<AxiosResponse<Table, any>>;
+export declare function updateHubDbTable(accountId: number, tableId: string, src: string): Promise<AxiosResponse<Table, any, {}>>;
 export declare function downloadHubDbTable(accountId: number, tableId: string, dest: string): Promise<{
     filePath: string;
 }>;

package/lib/isDeepEqual.d.ts

@@ -0,0 +1 @@
+export declare function isDeepEqual(object1: unknown, object2: unknown, ignoreKeys?: string[]): boolean;

package/lib/isDeepEqual.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDeepEqual = void 0;
+function isDeepEqual(object1, object2, ignoreKeys) {
+    if (object1 === object2) {
+        return true;
+    }
+    if (object1 === null ||
+        object2 === null ||
+        typeof object1 !== 'object' ||
+        typeof object2 !== 'object') {
+        return object1 === object2;
+    }
+    if (typeof object1 !== typeof object2) {
+        return false;
+    }
+    const isArray1 = Array.isArray(object1);
+    const isArray2 = Array.isArray(object2);
+    if (isArray1 !== isArray2) {
+        return false;
+    }
+    const objKeys1 = Object.keys(object1).filter(key => !ignoreKeys?.includes(key));
+    const objKeys2 = Object.keys(object2).filter(key => !ignoreKeys?.includes(key));
+    if (objKeys1.length !== objKeys2.length)
+        return false;
+    for (const key of objKeys1) {
+        const value1 = object1[key];
+        const value2 = object2[key];
+        if (!isDeepEqual(value1, value2, ignoreKeys)) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.isDeepEqual = isDeepEqual;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/local-dev-lib",
-    "version": "0.4.0-experimental.1",
+    "version": "0.4.2-experimental.0",
     "description": "Provides library functionality for HubSpot local development tooling, including the HubSpot CLI",
     "repository": {
         "type": "git",
@@ -20,6 +20,7 @@
     },
     "license": "Apache-2.0",
     "devDependencies": {
+        "@hubspot/npm-scripts": "0.0.4-beta.0",
         "@inquirer/prompts": "^7.0.1",
         "@types/content-disposition": "^0.5.5",
         "@types/cors": "^2.8.15",
@@ -61,7 +62,7 @@
     },
     "dependencies": {
         "address": "2.0.2",
-        "axios": "1.8.4",
+        "axios": "1.12.0",
         "chalk": "2.4.2",
         "chokidar": "3.6.0",
         "content-disposition": "0.5.4",
@@ -70,6 +71,7 @@
         "express": "4.21.2",
         "extract-zip": "2.0.1",
         "findup-sync": "5.0.0",
+        "form-data": "^4.0.4",
         "fs-extra": "11.2.0",
         "ignore": "5.3.1",
         "js-yaml": "4.1.0",

package/types/Archive.d.ts

@@ -1,9 +1,15 @@
+export interface Collision {
+    dest: string;
+    src: string;
+    collisions: string[];
+}
 export type ZipData = {
     extractDir: string;
     tmpDir: string;
 };
 export type CopySourceToDestOptions = {
-    sourceDir?: string;
+    sourceDir?: string | string[];
     includesRootDir?: boolean;
     hideLogs?: boolean;
+    handleCollision?: (collision: Collision) => void | Promise<void>;
 };

package/types/Config.d.ts

@@ -12,6 +12,8 @@ export interface CLIConfig_NEW {
     httpTimeout?: number;
     env?: Environment;
     httpUseLocalhost?: boolean;
+    autoOpenBrowser?: boolean;
+    flags?: Array<string>;
 }
 export interface CLIConfig_DEPRECATED {
     portals: Array<CLIAccount_DEPRECATED>;
@@ -23,6 +25,8 @@ export interface CLIConfig_DEPRECATED {
     httpTimeout?: number;
     env?: Environment;
     httpUseLocalhost?: boolean;
+    autoOpenBrowser?: boolean;
+    flags?: Array<string>;
 }
 export type CLIConfig = CLIConfig_NEW | CLIConfig_DEPRECATED;
 export type Environment = ValueOf<typeof ENVIRONMENTS> | '';

package/types/Crm.d.ts

@@ -0,0 +1,26 @@
+export interface ImportRequest {
+    name: string;
+    importOperations: {
+        [objectTypeId: string]: 'CREATE' | 'UPDATE' | 'UPSERT';
+    };
+    dateFormat?: string;
+    marketableContactImport?: boolean;
+    createContactListFromImport?: boolean;
+    files: Array<{
+        fileName: string;
+        fileFormat: 'CSV' | 'XLSX' | 'XLS';
+        fileImportPage: {
+            hasHeader: boolean;
+            columnMappings: Array<{
+                columnObjectTypeId: string;
+                columnName: string;
+                propertyName: string;
+                columnType?: string;
+            }>;
+        };
+    }>;
+}
+export interface ImportResponse {
+    id: string;
+    state: 'STARTED' | 'PROCESSING' | 'DONE' | 'FAILED' | 'CANCELED' | 'DEFERRED';
+}

package/types/Crm.js

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

package/types/Deploy.d.ts

@@ -35,9 +35,24 @@ export type DeployStatusTaskLocator = {
         status: string;
     }>;
 };
-export type ProjectDeployResponse = {
+export type ProjectDeployResponseQueued = {
     id: string;
+    buildResultType: 'DEPLOY_QUEUED';
     links: {
         status: string;
     };
 };
+export type SubdeployValidationIssue = {
+    uid: string;
+    componentTypeName: string;
+    errorMessages: string[];
+    blockingMessages: {
+        message: string;
+        isWarning: boolean;
+    }[];
+};
+export type ProjectDeployResponseBlocked = {
+    buildResultType: 'DEPLOY_BLOCKED';
+    issues: SubdeployValidationIssue[];
+};
+export type ProjectDeployResponse = ProjectDeployResponseQueued | ProjectDeployResponseBlocked;

package/types/Github.d.ts

@@ -1,3 +1,4 @@
+import { Collision } from './Archive';
 type GithubAuthor = {
     login: string;
     id: number;
@@ -71,7 +72,8 @@ export type CloneGithubRepoOptions = {
     type?: string;
     branch?: string;
     tag?: string;
-    sourceDir?: string;
+    sourceDir?: string | string[];
     hideLogs?: boolean;
+    handleCollision?: (collision: Collision) => void;
 };
 export {};

package/types/Sandbox.d.ts

@@ -111,6 +111,33 @@ export type Sandbox = {
     requestAccessFrom?: User | null;
     superAdminsInSandbox?: number;
 };
+export declare const SandboxVersioning: {
+    readonly V1: "V1";
+    readonly V2: "V2";
+};
+export declare const SandboxStatus: {
+    readonly PENDING: "PENDING";
+    readonly READY: "READY";
+    readonly FAILED: "FAILED";
+};
+export type SandboxVersion = keyof typeof SandboxVersioning;
+export type V2SandboxStatus = keyof typeof SandboxStatus;
+export type V2Sandbox = {
+    sandboxHubId: number;
+    parentHubId: number;
+    name: string;
+    version: SandboxVersion;
+    type: string;
+    status: V2SandboxStatus;
+    createdAt: string;
+    createdByUser: User;
+    currentUserHasAccess?: boolean;
+    currentUserHasSuperAdminAccess?: boolean;
+    superAdminsInSandbox?: number;
+    requestAccessFrom?: User | null;
+    updatedAt?: string;
+    updatedByUser?: User | null;
+};
 export type SandboxResponse = {
     sandbox: Sandbox;
     personalAccessKey: string;
@@ -152,4 +179,10 @@ export type SandboxType = {
 export type FetchTypesResponse = {
     results: Array<SandboxType>;
 };
+export type SandboxPersonalAccessKey = {
+    personalAccessKey: {
+        encodedOAuthRefreshToken: string;
+        oauthAccessToken: string;
+    };
+};
 export {};

package/types/Sandbox.js

@@ -1,2 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxStatus = exports.SandboxVersioning = void 0;
+exports.SandboxVersioning = {
+    V1: 'V1',
+    V2: 'V2',
+};
+exports.SandboxStatus = {
+    PENDING: 'PENDING',
+    READY: 'READY',
+    FAILED: 'FAILED',
+};