@hubspot/local-dev-lib 0.2.2 → 0.2.3-experimental.0

package/lib/cms/modules.js

@@ -3,17 +3,16 @@ 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;
+exports.isModuleHTMLFile = exports.retrieveDefaultModule = 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 logger_1 = require("../logger");
 const modules_1 = require("../../utils/cms/modules");
+const lang_1 = require("../../utils/lang");
 const i18nKey = 'lib.cms.modules';
-const createModuleCallbackKeys = ['creatingPath', 'creatingModule'];
 // Ids for testing
 exports.ValidationIds = {
     SRC_REQUIRED: 'SRC_REQUIRED',
@@ -75,110 +74,81 @@ exports.validateSrcAndDestPaths = validateSrcAndDestPaths;
 const MODULE_STRING_TRANSFORMATIONS = [
     {
         regex: /\/\* import global styles \*\//g,
-        string: 'import "./global-samplejsr.css";',
+        string: 'import "./global-sample-react-module.css";',
         fallback: '',
     },
     {
         regex: /\/\* Default config \*\//g,
-        string: 'export const defaultModuleConfig = { \n  moduleName: "sample_jsr", \n  version: 0, \n};',
+        string: 'export const defaultModuleConfig = { \n  moduleName: "sample_react-module", \n  version: 0, \n};',
         fallback: '',
     },
 ];
-const transformFileContents = (file, metaData, getInternalVersion) => {
-    fs_extra_1.default.readFile(file, 'utf8', (err, data) => {
-        if (err) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.createModule.errors.fileReadFailure`, {
-                path: file,
-            });
-        }
-        let results = data;
+const updateFileContents = async (file, metaData, getInternalVersion) => {
+    try {
+        let fileContents = await fs_extra_1.default.readFile(file, 'utf8'); // returns Promise
         MODULE_STRING_TRANSFORMATIONS.forEach(entry => {
             const replacementString = getInternalVersion
                 ? entry.string
                 : entry.fallback;
-            results = results.replace(entry.regex, replacementString);
-        });
-        fs_extra_1.default.writeFile(file, results, 'utf8', err => {
-            if (err) {
-                (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.createModule.errors.failedToWrite`, {
-                    path: file,
-                });
-            }
+            fileContents = fileContents.replace(entry.regex, replacementString);
         });
-        fs_extra_1.default.appendFile(file, 'export const meta = ' + JSON.stringify(metaData, null, ' '), err => {
-            if (err) {
-                (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.createModule.errors.failedToWrite`, {
-                    path: file,
-                });
-            }
-        });
-    });
+        await fs_extra_1.default.writeFile(file, fileContents, 'utf8');
+        await fs_extra_1.default.appendFile(file, 'export const meta = ' + JSON.stringify(metaData, null, ' '));
+    }
+    catch (error) {
+        const { message } = error;
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.createModule.errors.fileUpdateFailure`, {
+            path: file,
+            errorMessage: message,
+        }));
+    }
 };
 async function createModule(moduleDefinition, name, dest, getInternalVersion, options = {
     allowExistingDir: false,
-}, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
-    const { reactType: isReactModule } = moduleDefinition;
+}) {
+    const { moduleLabel, contentTypes, global, reactType: isReactModule, availableForNewContent, } = moduleDefinition;
+    const moduleMetaData = {
+        label: moduleLabel,
+        css_assets: [],
+        external_js: [],
+        global: global,
+        help_text: '',
+        content_types: contentTypes,
+        js_assets: [],
+        other_assets: [],
+        smart_type: 'NOT_SMART',
+        tags: [],
+        is_available_for_new_content: availableForNewContent,
+    };
     const folderName = name.endsWith('.module') ? name : `${name}.module`;
     const destPath = !isReactModule
         ? path_1.default.join(dest, folderName)
         : path_1.default.join(dest, `${name}`);
     if (!options.allowExistingDir && fs_extra_1.default.existsSync(destPath)) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.createModule.errors.pathExists`, {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.createModule.errors.pathExists`, {
             path: destPath,
-        });
+        }));
     }
     else {
-        logger('creatingPath', `${i18nKey}.createModule.creatingPath`, {
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createModule.creatingPath`, {
             path: destPath,
-        });
+        }));
         fs_extra_1.default.ensureDirSync(destPath);
     }
-    logger('creatingModule', `${i18nKey}.createModule.creatingModule`, {
+    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createModule.creatingModule`, {
         path: destPath,
-    });
-    // Write module meta
-    const writeModuleMeta = ({ moduleLabel, contentTypes, global, reactType }, 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,
-        };
-        if (!reactType) {
-            fs_extra_1.default.writeJSONSync(dest, metaData, { spaces: 2 });
-        }
-        else {
-            transformFileContents(`${dest}/index.tsx`, metaData, getInternalVersion);
-        }
-    };
-    // Filter out ceratin fetched files from the response
-    const moduleFileFilter = (src, dest) => {
+    }));
+    // Filter out certain fetched files from the response
+    const moduleFileFilter = (src) => {
         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;
-            case 'global-samplejsr.css':
-            case 'stories':
-            case 'tests':
-                if (getInternalVersion) {
-                    return true;
-                }
-                return false;
+                return !emailEnabled;
+            case 'global-sample-react-module.css':
+                return getInternalVersion;
             default:
                 return true;
         }
@@ -187,10 +157,43 @@ async function createModule(moduleDefinition, name, dest, getInternalVersion, op
     const sampleAssetPath = !isReactModule
         ? 'Sample.module'
         : 'SampleReactModule';
-    await (0, github_1.downloadGithubRepoContents)('HubSpot/cms-sample-assets', `modules/${sampleAssetPath}`, destPath, '', moduleFileFilter);
-    // Mutating React module files after fetch
+    const sourceDir = `modules/${sampleAssetPath}`;
+    await (0, github_1.cloneGithubRepo)('HubSpot/cms-sample-assets', destPath, {
+        sourceDir,
+    });
+    const files = await (0, fs_1.walk)(destPath);
+    files
+        .filter(filePath => !moduleFileFilter(filePath))
+        .forEach(filePath => {
+        fs_extra_1.default.unlinkSync(filePath);
+    });
+    if (!getInternalVersion) {
+        fs_extra_1.default.removeSync(path_1.default.join(destPath, 'stories'));
+        fs_extra_1.default.removeSync(path_1.default.join(destPath, 'tests'));
+    }
+    // Get and write the metafiles
+    const metaFiles = files.filter(filePath => path_1.default.basename(filePath) === 'meta.json');
+    metaFiles.forEach(metaFile => {
+        fs_extra_1.default.writeJSONSync(metaFile, moduleMetaData, {
+            spaces: 2,
+        });
+    });
+    // Updating React module files after fetch
     if (isReactModule) {
-        writeModuleMeta(moduleDefinition, destPath);
+        await updateFileContents(`${destPath}/index.tsx`, moduleMetaData, getInternalVersion);
     }
 }
 exports.createModule = createModule;
+async function retrieveDefaultModule(name, dest) {
+    if (!name) {
+        const defaultReactModules = await (0, github_1.listGithubRepoContents)('HubSpot/cms-react', 'default-react-modules/src/components/modules/', 'dir');
+        return defaultReactModules;
+    }
+    await (0, github_1.cloneGithubRepo)('HubSpot/cms-react', dest, {
+        sourceDir: `default-react-modules/src/components/modules/${name}`,
+    });
+}
+exports.retrieveDefaultModule = retrieveDefaultModule;
+const MODULE_HTML_EXTENSION_REGEX = new RegExp(/\.module(?:\/|\\)module\.html$/);
+const isModuleHTMLFile = (filePath) => MODULE_HTML_EXTENSION_REGEX.test(filePath);
+exports.isModuleHTMLFile = isModuleHTMLFile;

package/lib/cms/processFieldsJs.js

@@ -1,28 +1,5 @@
 "use strict";
 /* eslint-disable @typescript-eslint/no-explicit-any */
-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 };
 };
@@ -32,7 +9,6 @@ const fs_1 = __importDefault(require("fs"));
 const semver_1 = __importDefault(require("semver"));
 const url_1 = require("url");
 const path_2 = require("../path");
-const standardErrors_1 = require("../../errors/standardErrors");
 const lang_1 = require("../../utils/lang");
 const i18nKey = 'lib.cms.processFieldsJs';
 const { dirName, fieldOptions, filePath, writeDir } = process.env;
@@ -48,21 +24,23 @@ console.info((0, lang_1.i18n)(`${i18nKey}.converting`, {
  * This function has optional return type of Promise<Array> | Array. In order to have uniform handling,
  * we wrap the return value of the function in a Promise.resolve(), and then process.
  */
-const fieldsPromise = dynamicImport(filePath).catch(e => (0, standardErrors_1.throwError)(e));
+const fieldsPromise = dynamicImport(filePath).catch(e => {
+    throw e;
+});
 fieldsPromise.then(fieldsFunc => {
     const fieldsFuncType = typeof fieldsFunc;
     if (fieldsFuncType !== 'function') {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.notFunction`, {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.notFunction`, {
             path: filePath,
             returned: fieldsFuncType,
-        });
+        }));
     }
     return Promise.resolve(fieldsFunc(fieldOptions)).then(fields => {
         if (!Array.isArray(fields)) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.notArray`, {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.notArray`, {
                 path: filePath,
                 returned: typeof fields,
-            });
+            }));
         }
         const finalPath = path_1.default.join(writeDir, '/fields.json');
         return fieldsArrayToJson(fields).then(json => {
@@ -106,14 +84,13 @@ async function fieldsArrayToJson(fields) {
  * @returns {Promise | undefined} - Returns _default_ exported content if ESM, or exported module content if CJS, or undefined if node version < 13.2 and file is .mjs.
  */
 async function dynamicImport(filePath) {
-    var _a;
     if (semver_1.default.gte(process.version, '13.2.0')) {
-        const exported = await (_a = (0, url_1.pathToFileURL)(filePath).toString(), Promise.resolve().then(() => __importStar(require(_a)))).then(content => content.default);
-        return exported;
+        const exported = await new Function(`return import("${(0, url_1.pathToFileURL)(filePath)}")`)();
+        return exported.default;
     }
     else {
         if ((0, path_2.getExt)(filePath) == 'mjs') {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.invalidMjsFile`);
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidMjsFile`));
         }
         return require(filePath);
     }

package/lib/cms/templates.d.ts

@@ -1,5 +1,3 @@
-import { LogCallbacksArg } from '../../types/LogCallbacks';
-declare const templatesCallbackKeys: readonly ["creatingFile"];
 export declare const ANNOTATION_KEYS: {
     isAvailableForNewContent: string;
     templateType: string;
@@ -21,5 +19,47 @@ declare const ASSET_PATHS: {
 };
 export declare function createTemplate(name: string, dest: string, type?: keyof typeof ASSET_PATHS, options?: {
     allowExisting: boolean;
-}, logCallbacks?: LogCallbacksArg<typeof templatesCallbackKeys>): Promise<void>;
+}): Promise<void>;
+export declare const TEMPLATE_TYPES: {
+    unmapped: number;
+    email_base_template: number;
+    email: number;
+    landing_page_base_template: number;
+    landing_page: number;
+    blog_base: number;
+    blog: number;
+    blog_listing: number;
+    site_page: number;
+    blog_listing_context: number;
+    blog_post_context: number;
+    error_page: number;
+    subscription_preferences: number;
+    unsubscribe_confirmation: number;
+    unsubscribe_simple: number;
+    optin_email: number;
+    optin_followup_email: number;
+    optin_confirmation_page: number;
+    global_group: number;
+    password_prompt_page: number;
+    resubscribe_email: number;
+    unsubscribe_confirmation_email: number;
+    resubscribe_confirmation_email: number;
+    custom_module: number;
+    css: number;
+    js: number;
+    search_results: number;
+    membership_login: number;
+    membership_register: number;
+    membership_reset: number;
+    membership_reset_request: number;
+    drag_drop_email: number;
+    knowledge_article: number;
+    membership_email: number;
+    section: number;
+    global_content_partial: number;
+    simple_landing_page_template: number;
+    proposal: number;
+    blog_post: number;
+    quote: number;
+};
 export {};

package/lib/cms/templates.js

@@ -3,14 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTemplate = exports.isCodedFile = exports.getAnnotationValue = exports.ANNOTATION_KEYS = void 0;
+exports.TEMPLATE_TYPES = exports.createTemplate = exports.isCodedFile = exports.getAnnotationValue = exports.ANNOTATION_KEYS = void 0;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const github_1 = require("../github");
-const standardErrors_1 = require("../../errors/standardErrors");
-const logger_1 = require("../../utils/logger");
+const logger_1 = require("../logger");
+const lang_1 = require("../../utils/lang");
 const i18nKey = 'lib.cms.templates';
-const templatesCallbackKeys = ['creatingFile'];
 // Matches the .html file extension, excluding module.html
 const TEMPLATE_EXTENSION_REGEX = new RegExp(/(?<!module)\.html$/);
 // Matches an annotation value, ending at space, newline, or end of string
@@ -47,21 +46,64 @@ const ASSET_PATHS = {
     'search-template': 'templates/search-template.html',
     section: 'templates/section.html',
 };
-async function createTemplate(name, dest, type = 'page-template', options = { allowExisting: false }, logCallbacks) {
+async function createTemplate(name, dest, type = 'page-template', options = { allowExisting: false }) {
     const assetPath = ASSET_PATHS[type];
     const filename = name.endsWith('.html') ? name : `${name}.html`;
     const filePath = path_1.default.join(dest, filename);
     if (!options.allowExisting && fs_extra_1.default.existsSync(filePath)) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.createTemplate.errors.pathExists`, {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.createTemplate.errors.pathExists`, {
             path: filePath,
-        });
+        }));
     }
-    (0, logger_1.debug)(`${i18nKey}.createTemplate.creatingPath`, { path: dest });
+    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.createTemplate.creatingPath`, { path: dest }));
     fs_extra_1.default.mkdirp(dest);
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
-    logger('creatingFile', `${i18nKey}.createTemplate.creatingFile`, {
+    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createTemplate.creatingFile`, {
         path: filePath,
+    }));
+    await (0, github_1.cloneGithubRepo)('HubSpot/cms-sample-assets', filePath, {
+        sourceDir: assetPath,
     });
-    await (0, github_1.downloadGithubRepoContents)('HubSpot/cms-sample-assets', assetPath, filePath);
 }
 exports.createTemplate = createTemplate;
+exports.TEMPLATE_TYPES = {
+    unmapped: 0,
+    email_base_template: 1,
+    email: 2,
+    landing_page_base_template: 3,
+    landing_page: 4,
+    blog_base: 5,
+    blog: 6,
+    blog_listing: 42,
+    site_page: 8,
+    blog_listing_context: 9,
+    blog_post_context: 10,
+    error_page: 11,
+    subscription_preferences: 12,
+    unsubscribe_confirmation: 13,
+    unsubscribe_simple: 14,
+    optin_email: 15,
+    optin_followup_email: 16,
+    optin_confirmation_page: 17,
+    global_group: 18,
+    password_prompt_page: 19,
+    resubscribe_email: 20,
+    unsubscribe_confirmation_email: 21,
+    resubscribe_confirmation_email: 22,
+    custom_module: 23,
+    css: 24,
+    js: 25,
+    search_results: 27,
+    membership_login: 29,
+    membership_register: 30,
+    membership_reset: 31,
+    membership_reset_request: 32,
+    drag_drop_email: 34,
+    knowledge_article: 35,
+    membership_email: 36,
+    section: 37,
+    global_content_partial: 38,
+    simple_landing_page_template: 39,
+    proposal: 40,
+    blog_post: 41,
+    quote: 43,
+};

package/lib/cms/uploadFolder.d.ts

@@ -1,18 +1,7 @@
 import { FieldsJs } from './handleFieldsJS';
 import { FileMapperInputOptions } from '../../types/Files';
-import { LogCallbacksArg } from '../../types/LogCallbacks';
-import { UploadFolderResults } from '../../types/Files';
-import { Mode } from '../../types/Files';
-declare const uploadFolderCallbackKeys: readonly ["success"];
-type CommandOptions = {
-    convertFields?: boolean;
-    fieldOptions?: string;
-    saveOutput?: boolean;
-};
-type FilePathsByType = {
-    [key: string]: Array<string>;
-};
+import { UploadFolderResults, CommandOptions, FilePathsByType } from '../../types/Files';
+import { CmsPublishMode } from '../../types/Files';
 export declare function getFilesByType(filePaths: Array<string>, projectDir: string, rootWriteDir: string | null, commandOptions: CommandOptions): Promise<[FilePathsByType, Array<FieldsJs>]>;
-export declare function uploadFolder(accountId: number, src: string, dest: string, fileMapperOptions: FileMapperInputOptions, commandOptions?: CommandOptions, filePaths?: Array<string>, mode?: Mode | null, logCallbacks?: LogCallbacksArg<typeof uploadFolderCallbackKeys>): Promise<Array<UploadFolderResults>>;
+export declare function uploadFolder(accountId: number, src: string, dest: string, fileMapperOptions: FileMapperInputOptions, commandOptions?: CommandOptions, filePaths?: Array<string>, cmsPublishMode?: CmsPublishMode | null): Promise<Array<UploadFolderResults>>;
 export declare function hasUploadErrors(results: Array<UploadFolderResults>): boolean;
-export {};

package/lib/cms/uploadFolder.js

@@ -10,15 +10,14 @@ const handleFieldsJS_1 = require("./handleFieldsJS");
 const fileMapper_1 = require("../fileMapper");
 const fileMapper_2 = require("../../api/fileMapper");
 const modules_1 = require("../../utils/cms/modules");
-const escapeRegExp_1 = require("../../utils/escapeRegExp");
-const logger_1 = require("../../utils/logger");
+const escapeRegExp_1 = require("../escapeRegExp");
 const path_2 = require("../path");
-const standardErrors_1 = require("../../errors/standardErrors");
-const apiErrors_1 = require("../../errors/apiErrors");
-const logger_2 = require("../../utils/logger");
+const errors_1 = require("../../errors");
+const logger_1 = require("../logger");
 const files_1 = require("../../constants/files");
+const lang_1 = require("../../utils/lang");
+const HubSpotHttpError_1 = require("../../models/HubSpotHttpError");
 const i18nKey = 'lib.cms.uploadFolder';
-const uploadFolderCallbackKeys = ['success'];
 const queue = new p_queue_1.default({
     concurrency: 10,
 });
@@ -77,14 +76,48 @@ async function getFilesByType(filePaths, projectDir, rootWriteDir, commandOption
     return [filePathsByType, fieldsJsObjects];
 }
 exports.getFilesByType = getFilesByType;
-async function uploadFolder(accountId, src, dest, fileMapperOptions, commandOptions = {}, filePaths = [], mode = null, logCallbacks) {
-    const logger = (0, logger_2.makeTypedLogger)(logCallbacks);
-    const { saveOutput, convertFields } = commandOptions;
+const defaultUploadAttemptCallback = (file, destPath) => logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadFolder.attempt`, {
+    file: file || '',
+    destPath,
+}));
+const defaultUploadSuccessCallback = (file, destPath) => logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.uploadFolder.success`, {
+    file: file || '',
+    destPath,
+}));
+const defaultUploadFirstErrorCallback = (file, destPath, error) => {
+    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadFolder.failed`, { file, destPath }));
+    if ((0, errors_1.isHubSpotHttpError)(error)) {
+        logger_1.logger.debug(error.data);
+    }
+    else if (error instanceof Error) {
+        logger_1.logger.debug(error.message);
+    }
+};
+const defaultUploadRetryCallback = (file, destPath) => logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadFolder.retry`, { file, destPath }));
+const defaultUploadFinalErrorCallback = (accountId, file, destPath, error) => {
+    const retryFailed = (0, lang_1.i18n)(`${i18nKey}.uploadFolder.retryFailed`, {
+        file,
+        destPath,
+    });
+    logger_1.logger.debug(retryFailed);
+    throw new HubSpotHttpError_1.HubSpotHttpError(retryFailed, { cause: error }, {
+        accountId,
+        request: destPath,
+        payload: file,
+    });
+};
+async function uploadFolder(accountId, src, dest, fileMapperOptions, commandOptions = {}, filePaths = [], cmsPublishMode = null) {
+    const { saveOutput, convertFields, onAttemptCallback, onSuccessCallback, onFirstErrorCallback, onRetryCallback, onFinalErrorCallback, } = commandOptions;
+    const _onAttemptCallback = onAttemptCallback || defaultUploadAttemptCallback;
+    const _onSuccessCallback = onSuccessCallback || defaultUploadSuccessCallback;
+    const _onFirstErrorCallback = onFirstErrorCallback || defaultUploadFirstErrorCallback;
+    const _onRetryCallback = onRetryCallback || defaultUploadRetryCallback;
+    const _onFinalErrorCallback = onFinalErrorCallback || defaultUploadFinalErrorCallback;
     const tmpDir = convertFields
         ? (0, handleFieldsJS_1.createTmpDirSync)('hubspot-temp-fieldsjs-output-')
         : null;
     const regex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(src)}`);
-    const apiOptions = (0, fileMapper_1.getFileMapperQueryValues)(mode, fileMapperOptions);
+    const apiOptions = (0, fileMapper_1.getFileMapperQueryValues)(cmsPublishMode, fileMapperOptions);
     const failures = [];
     let fieldsJsPaths = [];
     let tmpDirRegex;
@@ -105,29 +138,16 @@ async function uploadFolder(accountId, src, dest, fileMapperOptions, commandOpti
         const relativePath = file.replace(fieldsJsFileInfo ? tmpDirRegex : regex, '');
         const destPath = (0, path_2.convertToUnixPath)(path_1.default.join(dest, relativePath));
         return async () => {
-            (0, logger_1.debug)(`${i18nKey}.uploadFolder.attempt`, {
-                file: originalFilePath || '',
-                destPath,
-            });
+            _onAttemptCallback(originalFilePath, destPath);
             try {
                 await (0, fileMapper_2.upload)(accountId, file, destPath, apiOptions);
-                logger('success', `${i18nKey}.uploadFolder.success`, {
-                    file: originalFilePath || '',
-                    destPath,
-                });
+                _onSuccessCallback(originalFilePath, destPath);
             }
             catch (err) {
-                const error = err;
-                if ((0, standardErrors_1.isFatalError)(error)) {
-                    throw error;
-                }
-                (0, logger_1.debug)(`${i18nKey}.uploadFolder.failed`, { file, destPath });
-                if (error.response && error.response.data) {
-                    console.debug(error.response.data);
-                }
-                else {
-                    console.debug(error.message);
+                if ((0, errors_1.isAuthError)(err)) {
+                    throw err;
                 }
+                _onFirstErrorCallback(file, destPath, err);
                 failures.push({
                     file,
                     destPath,
@@ -142,30 +162,26 @@ async function uploadFolder(accountId, src, dest, fileMapperOptions, commandOpti
     const results = await queue
         .addAll(failures.map(({ file, destPath }) => {
         return async () => {
-            (0, logger_1.debug)(`${i18nKey}.uploadFolder.retry`, { file, destPath });
+            _onRetryCallback(file, destPath);
             try {
                 await (0, fileMapper_2.upload)(accountId, file, destPath, apiOptions);
-                logger('success', `${i18nKey}.uploadFolder.success`, {
-                    file,
-                    destPath,
-                });
+                _onSuccessCallback(file, destPath);
                 return {
                     resultType: files_1.FILE_UPLOAD_RESULT_TYPES.SUCCESS,
                     error: null,
                     file,
                 };
             }
-            catch (err) {
-                (0, logger_1.debug)(`${i18nKey}.uploadFolder.retryFailed`, { file, destPath });
-                const error = err;
-                if ((0, standardErrors_1.isFatalError)(error)) {
+            catch (error) {
+                if ((0, errors_1.isAuthError)(error)) {
                     throw error;
                 }
-                (0, apiErrors_1.throwApiUploadError)(error, {
-                    accountId,
-                    request: destPath,
-                    payload: file,
-                });
+                _onFinalErrorCallback(accountId, file, destPath, error);
+                return {
+                    resultType: files_1.FILE_UPLOAD_RESULT_TYPES.FAILURE,
+                    error,
+                    file,
+                };
             }
         };
     }))

package/lib/cms/validate.js

@@ -26,7 +26,7 @@ async function lint(accountId, filepath, callback) {
             }
             return result;
         }
-        const validation = await (0, validateHubl_1.validateHubl)(accountId, source);
+        const { data: validation } = await (0, validateHubl_1.validateHubl)(accountId, source);
         const result = {
             file,
             validation,

package/lib/cms/watch.d.ts

@@ -1,20 +1,4 @@
 import chokidar from 'chokidar';
-import { AxiosError } from 'axios';
-import { LogCallbacksArg } from '../../types/LogCallbacks';
-import { Mode } from '../../types/Files';
+import { WatchOptions, WatchErrorHandler } from '../../types/Files';
 import { UploadFolderResults } from '../../types/Files';
-declare const watchCallbackKeys: readonly ["notifyOfThemePreview", "uploadSuccess", "deleteSuccess", "folderUploadSuccess", "ready", "deleteSuccessWithType"];
-type WatchLogCallbacks = LogCallbacksArg<typeof watchCallbackKeys>;
-type WatchOptions = {
-    mode?: Mode;
-    remove?: boolean;
-    disableInitial?: boolean;
-    notify?: string;
-    commandOptions: {
-        convertFields?: boolean;
-    };
-    filePaths?: Array<string>;
-};
-type ErrorHandler = (error: AxiosError) => void;
-export declare function watch(accountId: number, src: string, dest: string, { mode, remove, disableInitial, notify, commandOptions, filePaths, }: WatchOptions, postInitialUploadCallback?: ((result: Array<UploadFolderResults>) => void) | null, onUploadFolderError?: ErrorHandler, onQueueAddError?: ErrorHandler, logCallbacks?: WatchLogCallbacks): chokidar.FSWatcher;
-export {};
+export declare function watch(accountId: number, src: string, dest: string, { cmsPublishMode, remove, disableInitial, notify, commandOptions, filePaths, }: WatchOptions, postInitialUploadCallback?: ((result: Array<UploadFolderResults>) => void) | null, onUploadFolderError?: WatchErrorHandler, onQueueAddError?: WatchErrorHandler, onUploadFileError?: (file: string, dest: string, accountId: number) => WatchErrorHandler): chokidar.FSWatcher;