@hubspot/local-dev-lib 0.0.7 → 0.0.9

package/lib/cms/processFieldsJs.js

@@ -34,13 +34,9 @@ const url_1 = require("url");
 const path_2 = require("../path");
 const standardErrors_1 = require("../../errors/standardErrors");
 const lang_1 = require("../../utils/lang");
-const i18nKey = 'processFieldsJs';
+const i18nKey = 'lib.cms.processFieldsJs';
 const { dirName, fieldOptions, filePath, writeDir } = process.env;
 const baseName = path_1.default.basename(filePath);
-const FieldErrors = {
-    IsNotFunction: 'IsNotFunction',
-    DoesNotReturnArray: 'DoesNotReturnArray',
-};
 //TODO - Figure out agnostic logging
 console.info((0, lang_1.i18n)(`${i18nKey}.converting`, {
     src: dirName + `/${baseName}`,
@@ -56,14 +52,16 @@ const fieldsPromise = dynamicImport(filePath).catch(e => (0, standardErrors_1.th
 fieldsPromise.then(fieldsFunc => {
     const fieldsFuncType = typeof fieldsFunc;
     if (fieldsFuncType !== 'function') {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.${FieldErrors.IsNotFunction}`, {
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.notFunction`, {
             path: filePath,
+            returned: fieldsFuncType,
         });
     }
     return Promise.resolve(fieldsFunc(fieldOptions)).then(fields => {
         if (!Array.isArray(fields)) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.${FieldErrors.DoesNotReturnArray}`, {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.notArray`, {
                 path: filePath,
+                returned: typeof fields,
             });
         }
         const finalPath = path_1.default.join(writeDir, '/fields.json');
@@ -115,7 +113,7 @@ async function dynamicImport(filePath) {
     }
     else {
         if ((0, path_2.getExt)(filePath) == 'mjs') {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.invalidMjsFile`);
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.invalidMjsFile`);
         }
         return require(filePath);
     }

package/lib/cms/templates.js

@@ -6,9 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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("../../lib/github");
+const github_1 = require("../github");
 const standardErrors_1 = require("../../errors/standardErrors");
 const logger_1 = require("../../utils/logger");
+const i18nKey = 'lib.cms.templates';
 // 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
@@ -51,12 +52,16 @@ async function createTemplate(name, dest, type = 'page-template', options = { al
     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)('templates.pathExists', { path: filePath });
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.createTemplate.errors.pathExists`, {
+            path: filePath,
+        });
     }
-    (0, logger_1.debug)('templates.debug.creatingPath', { path: dest });
+    (0, logger_1.debug)(`${i18nKey}.createTemplate.creatingPath`, { path: dest });
     fs_extra_1.default.mkdirp(dest);
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks, 'templates.logging');
-    logger('creatingFile', { path: filePath });
+    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
+    logger('creatingFile', `${i18nKey}.createTemplate.creatingFile`, {
+        path: filePath,
+    });
     await (0, github_1.downloadGithubRepoContents)('HubSpot/cms-sample-assets', assetPath, filePath);
 }
 exports.createTemplate = createTemplate;

package/lib/cms/uploadFolder.js

@@ -17,6 +17,7 @@ const standardErrors_1 = require("../../errors/standardErrors");
 const apiErrors_1 = require("../../errors/apiErrors");
 const logger_2 = require("../../utils/logger");
 const files_1 = require("../../constants/files");
+const i18nKey = 'lib.cms.uploadFolder';
 const queue = new p_queue_1.default({
     concurrency: 10,
 });
@@ -77,7 +78,7 @@ async function getFilesByType(filePaths, projectDir, rootWriteDir, commandOption
 exports.getFilesByType = getFilesByType;
 const uploadFolderCallbackKeys = ['success'];
 async function uploadFolder(accountId, src, dest, fileMapperOptions, commandOptions = {}, filePaths = [], mode = null, logCallbacks) {
-    const logger = (0, logger_2.makeTypedLogger)(logCallbacks, 'cms.uploadFolder');
+    const logger = (0, logger_2.makeTypedLogger)(logCallbacks);
     const { saveOutput, convertFields } = commandOptions;
     const tmpDir = convertFields
         ? (0, handleFieldsJS_1.createTmpDirSync)('hubspot-temp-fieldsjs-output-')
@@ -104,13 +105,13 @@ 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)('cms.uploadFolder.attempt', {
+            (0, logger_1.debug)(`${i18nKey}.uploadFolder.attempt`, {
                 file: originalFilePath || '',
                 destPath,
             });
             try {
                 await (0, fileMapper_2.upload)(accountId, file, destPath, apiOptions);
-                logger('success', {
+                logger('success', `${i18nKey}.uploadFolder.success`, {
                     file: originalFilePath || '',
                     destPath,
                 });
@@ -120,7 +121,7 @@ async function uploadFolder(accountId, src, dest, fileMapperOptions, commandOpti
                 if ((0, standardErrors_1.isFatalError)(error)) {
                     throw error;
                 }
-                (0, logger_1.debug)('cms.uploadFolder.failed', { file, destPath });
+                (0, logger_1.debug)(`${i18nKey}.uploadFolder.failed`, { file, destPath });
                 if (error.response && error.response.body) {
                     console.debug(error.response.body);
                 }
@@ -141,10 +142,13 @@ async function uploadFolder(accountId, src, dest, fileMapperOptions, commandOpti
     const results = await queue
         .addAll(failures.map(({ file, destPath }) => {
         return async () => {
-            (0, logger_1.debug)('cms.uploadFolder.retry', { file, destPath });
+            (0, logger_1.debug)(`${i18nKey}.uploadFolder.retry`, { file, destPath });
             try {
                 await (0, fileMapper_2.upload)(accountId, file, destPath, apiOptions);
-                logger('success', { file, destPath });
+                logger('success', `${i18nKey}.uploadFolder.success`, {
+                    file,
+                    destPath,
+                });
                 return {
                     resultType: files_1.FILE_UPLOAD_RESULT_TYPES.SUCCESS,
                     error: null,
@@ -152,7 +156,7 @@ async function uploadFolder(accountId, src, dest, fileMapperOptions, commandOpti
                 };
             }
             catch (err) {
-                (0, logger_1.debug)('cms.uploadFolder.retryFailed', { file, destPath });
+                (0, logger_1.debug)(`${i18nKey}.uploadFolder.retryFailed`, { file, destPath });
                 const error = err;
                 if ((0, standardErrors_1.isFatalError)(error)) {
                     throw error;

package/lib/cms/watch.js

@@ -20,6 +20,7 @@ const notify_1 = require("../../utils/notify");
 const themes_1 = require("./themes");
 const logger_1 = require("../../utils/logger");
 const logger_2 = require("../../utils/logger");
+const i18nKey = 'lib.cms.watch';
 const watchCallbackKeys = [
     'notifyOfThemePreview',
     'uploadSuccess',
@@ -33,17 +34,19 @@ const queue = new p_queue_1.default({
     concurrency: 10,
 });
 function _notifyOfThemePreview(filePath, accountId, logCallbacks) {
-    const logger = makeLogger(logCallbacks, 'watch');
+    const logger = makeLogger(logCallbacks);
     if (queue.size > 0)
         return;
     const previewUrl = (0, themes_1.getThemePreviewUrl)(filePath, accountId);
     if (!previewUrl)
         return;
-    logger('notifyOfThemePreview', { previewUrl });
+    logger('notifyOfThemePreview', `${i18nKey}.notifyOfThemePreview`, {
+        previewUrl,
+    });
 }
 const notifyOfThemePreview = (0, debounce_1.debounce)(_notifyOfThemePreview, 1000);
 async function uploadFile(accountId, file, dest, options, mode = null, logCallbacks) {
-    const logger = makeLogger(logCallbacks, 'watch');
+    const logger = makeLogger(logCallbacks);
     const src = options.src;
     const absoluteSrcPath = path_1.default.resolve((0, path_2.getCwd)(), file);
     const themeJsonPath = (0, themes_1.getThemeJSONPath)(absoluteSrcPath);
@@ -52,11 +55,11 @@ async function uploadFile(accountId, file, dest, options, mode = null, logCallba
         : path_1.default.dirname((0, path_2.getCwd)());
     const convertFields = (0, handleFieldsJS_1.isConvertableFieldJs)(src, file, options.commandOptions.convertFields);
     if (!(0, path_2.isAllowedExtension)(file) && !convertFields) {
-        (0, logger_2.debug)('watch.skipUnsupportedExtension', { file });
+        (0, logger_2.debug)(`${i18nKey}.skipUnsupportedExtension`, { file });
         return;
     }
     if ((0, ignoreRules_1.shouldIgnoreFile)(file)) {
-        (0, logger_2.debug)('watch.skipIgnoreRule', { file });
+        (0, logger_2.debug)(`${i18nKey}.skipIgnoreRule`, { file });
         return;
     }
     let fieldsJs = undefined;
@@ -68,19 +71,22 @@ async function uploadFile(accountId, file, dest, options, mode = null, logCallba
         dest = (0, path_2.convertToUnixPath)(path_1.default.join(path_1.default.dirname(dest), 'fields.json'));
     }
     const fileToUpload = convertFields && fieldsJs?.outputPath ? fieldsJs.outputPath : file;
-    (0, logger_2.debug)('watch.uploadAttempt', { file, dest });
+    (0, logger_2.debug)(`${i18nKey}.uploadAttempt`, { file, dest });
     const apiOptions = (0, fileMapper_1.getFileMapperQueryValues)(mode, options);
     queue.add(() => {
         return (0, fileMapper_2.upload)(accountId, fileToUpload, dest, apiOptions)
             .then(() => {
-            logger('uploadSuccess', { file, dest });
+            logger('uploadSuccess', `${i18nKey}.uploadSuccess`, { file, dest });
             notifyOfThemePreview(file, accountId, logCallbacks);
         })
             .catch(() => {
-            (0, logger_2.debug)('watch.uploadFailed', { file, dest });
-            (0, logger_2.debug)('watch.uploadRetry', { file, dest });
+            (0, logger_2.debug)(`${i18nKey}.uploadFailed`, { file, dest });
+            (0, logger_2.debug)(`${i18nKey}.uploadRetry`, { file, dest });
             return (0, fileMapper_2.upload)(accountId, file, dest, apiOptions).catch((error) => {
-                (0, logger_2.debug)('watch.uploadFailed', { file, dest });
+                (0, logger_2.debug)(`${i18nKey}.uploadFailed`, {
+                    file,
+                    dest,
+                });
                 (0, apiErrors_1.throwApiUploadError)(error, {
                     accountId,
                     request: dest,
@@ -91,20 +97,22 @@ async function uploadFile(accountId, file, dest, options, mode = null, logCallba
     });
 }
 async function deleteRemoteFile(accountId, filePath, remoteFilePath, logCallbacks) {
-    const logger = makeLogger(logCallbacks, 'watch');
+    const logger = makeLogger(logCallbacks);
     if ((0, ignoreRules_1.shouldIgnoreFile)(filePath)) {
-        (0, logger_2.debug)('watch.skipIgnoreRule', { file: filePath });
+        (0, logger_2.debug)(`${i18nKey}.skipIgnoreRule`, { file: filePath });
         return;
     }
-    (0, logger_2.debug)('watch.deleteAttempt', { remoteFilePath });
+    (0, logger_2.debug)(`${i18nKey}.deleteAttempt`, { remoteFilePath });
     return queue.add(() => {
         return (0, fileMapper_2.deleteFile)(accountId, remoteFilePath)
             .then(() => {
-            logger('deleteSuccess', { remoteFilePath });
+            logger('deleteSuccess', `${i18nKey}.deleteSuccess`, { remoteFilePath });
             notifyOfThemePreview(filePath, accountId, logCallbacks);
         })
             .catch((error) => {
-            (0, logger_2.debug)('watch.deleteFailed', { remoteFilePath });
+            (0, logger_2.debug)(`${i18nKey}.deleteFailed`, {
+                remoteFilePath,
+            });
             (0, apiErrors_1.throwApiError)(error, {
                 accountId,
                 request: remoteFilePath,
@@ -113,7 +121,7 @@ async function deleteRemoteFile(accountId, filePath, remoteFilePath, logCallback
     });
 }
 function watch(accountId, src, dest, { mode, remove, disableInitial, notify, commandOptions, filePaths, }, postInitialUploadCallback = null, onUploadFolderError, onQueueAddError, logCallbacks) {
-    const logger = makeLogger(logCallbacks, 'watch');
+    const logger = makeLogger(logCallbacks);
     const regex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(src)}`);
     if (notify) {
         (0, ignoreRules_1.ignoreFile)(notify);
@@ -129,7 +137,11 @@ function watch(accountId, src, dest, { mode, remove, disableInitial, notify, com
     if (!disableInitial) {
         // Use uploadFolder so that failures of initial upload are retried
         const uploadFolderPromise = (0, uploadFolder_1.uploadFolder)(accountId, src, dest, {}, commandOptions, filePaths, mode || null).then(result => {
-            logger('folderUploadSuccess', { src, dest, accountId });
+            logger('folderUploadSuccess', `${i18nKey}.folderUploadSuccess`, {
+                src,
+                dest,
+                accountId,
+            });
             if (postInitialUploadCallback) {
                 postInitialUploadCallback(result);
             }
@@ -139,7 +151,7 @@ function watch(accountId, src, dest, { mode, remove, disableInitial, notify, com
         }
     }
     watcher.on('ready', () => {
-        logger('ready', { src });
+        logger('ready', `${i18nKey}.ready`, { src });
     });
     watcher.on('add', async (filePath) => {
         const destPath = getDesignManagerPath(filePath);
@@ -157,16 +169,16 @@ function watch(accountId, src, dest, { mode, remove, disableInitial, notify, com
             }
             const remotePath = getDesignManagerPath(filePath);
             if ((0, ignoreRules_1.shouldIgnoreFile)(filePath)) {
-                (0, logger_2.debug)('watch.skipIgnoreRule', { file: filePath });
+                (0, logger_2.debug)(`${i18nKey}.skipIgnoreRule`, { file: filePath });
                 return;
             }
-            (0, logger_2.debug)('watch.deleteAttemptWithType', {
+            (0, logger_2.debug)(`${i18nKey}.deleteAttemptWithType`, {
                 type,
                 remoteFilePath: remotePath,
             });
             const queueAddPromise = queue.add(() => {
                 const deletePromise = deleteRemoteFile(accountId, filePath, remotePath, logCallbacks).then(() => {
-                    logger('deleteSuccessWithType', {
+                    logger('deleteSuccessWithType', `${i18nKey}.deleteSuccessWithType`, {
                         type,
                         remoteFilePath: remotePath,
                     });

package/lib/customObjects.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from '../types/Schemas';
-export declare function getResolvedPath(dest: string, name: string): string;
-export declare function writeSchemaToDisk(schema: Schema, dest: string): Promise<void>;
-export declare function downloadSchemas(accountId: number, dest: string): Promise<void>;
-export declare function downloadSchema(accountId: number, schemaObjectType: string, dest: string): Promise<void>;
+export declare function getResolvedPath(dest?: string, name?: string): string;
+export declare function writeSchemaToDisk(schema: Schema, dest?: string): Promise<void>;
+export declare function downloadSchemas(accountId: number, dest?: string): Promise<Array<Schema>>;
+export declare function downloadSchema(accountId: number, schemaObjectType: string, dest?: string): Promise<Schema>;

package/lib/customObjects.js

@@ -9,6 +9,7 @@ const path_1 = __importDefault(require("path"));
 const prettier_1 = __importDefault(require("prettier"));
 const path_2 = require("../lib/path");
 const customObjects_1 = require("../api/customObjects");
+const apiErrors_1 = require("../errors/apiErrors");
 function getResolvedPath(dest, name) {
     if (name)
         return path_1.default.resolve((0, path_2.getCwd)(), dest || '', `${name}.json`);
@@ -23,14 +24,30 @@ async function writeSchemaToDisk(schema, dest) {
 }
 exports.writeSchemaToDisk = writeSchemaToDisk;
 async function downloadSchemas(accountId, dest) {
-    const response = await (0, customObjects_1.fetchObjectSchemas)(accountId);
+    let response;
+    try {
+        response = await (0, customObjects_1.fetchObjectSchemas)(accountId);
+    }
+    catch (err) {
+        (0, apiErrors_1.throwApiError)(err);
+    }
     if (response.results.length) {
-        response.results.forEach((r) => writeSchemaToDisk(r, dest));
+        for (const schema of response.results) {
+            await writeSchemaToDisk(schema, dest);
+        }
     }
+    return response.results;
 }
 exports.downloadSchemas = downloadSchemas;
 async function downloadSchema(accountId, schemaObjectType, dest) {
-    const response = await (0, customObjects_1.fetchObjectSchema)(accountId, schemaObjectType);
-    writeSchemaToDisk(response, dest);
+    let response;
+    try {
+        response = await (0, customObjects_1.fetchObjectSchema)(accountId, schemaObjectType);
+    }
+    catch (err) {
+        (0, apiErrors_1.throwApiError)(err);
+    }
+    await writeSchemaToDisk(response, dest);
+    return response;
 }
 exports.downloadSchema = downloadSchema;

package/lib/fileMapper.js

@@ -15,6 +15,7 @@ const files_1 = require("../constants/files");
 const fileSystemErrors_1 = require("../errors/fileSystemErrors");
 const apiErrors_1 = require("../errors/apiErrors");
 const logger_1 = require("../utils/logger");
+const i18nKey = 'lib.fileMapper';
 const queue = new p_queue_1.default({
     concurrency: 10,
 });
@@ -74,7 +75,7 @@ function validateFileMapperNode(node) {
     catch (err) {
         json = node;
     }
-    (0, standardErrors_1.throwTypeErrorWithMessage)('filemapper.invalidNode', {
+    (0, standardErrors_1.throwTypeErrorWithMessage)(`${i18nKey}.errors.invalidNode`, {
         json: JSON.stringify(json),
     });
 }
@@ -141,16 +142,16 @@ async function skipExisting(filepath, overwrite = false) {
 }
 const filemapperCallbackKeys = ['skippedExisting', 'wroteFolder'];
 async function fetchAndWriteFileStream(accountId, srcPath, filepath, mode, options = {}, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks, 'filemapper');
+    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
     if (typeof srcPath !== 'string' || !srcPath.trim()) {
         return;
     }
     if (await skipExisting(filepath, options.overwrite)) {
-        logger('skippedExisting', { filepath });
+        logger('skippedExisting', `${i18nKey}.skippedExisting`, { filepath });
         return;
     }
     if (!(0, path_2.isAllowedExtension)(srcPath)) {
-        (0, standardErrors_1.throwErrorWithMessage)('filemapper.invalidFileType', { srcPath });
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.invalidFileType`, { srcPath });
     }
     let node;
     try {
@@ -167,10 +168,12 @@ async function fetchAndWriteFileStream(accountId, srcPath, filepath, mode, optio
 // Writes an individual file or folder (not recursive).  If file source is missing, the
 //file is fetched.
 async function writeFileMapperNode(accountId, filepath, node, mode, options = {}, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks, 'filemapper');
+    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
     const localFilepath = (0, path_2.convertToLocalFileSystemPath)(path_1.default.resolve(filepath));
     if (await skipExisting(localFilepath, options.overwrite)) {
-        logger('skippedExisting', { filepath: localFilepath });
+        logger('skippedExisting', `${i18nKey}.skippedExisting`, {
+            filepath: localFilepath,
+        });
         return true;
     }
     if (!node.folder) {
@@ -184,7 +187,9 @@ async function writeFileMapperNode(accountId, filepath, node, mode, options = {}
     }
     try {
         await fs_extra_1.default.ensureDir(localFilepath);
-        logger('wroteFolder', { filepath: localFilepath });
+        logger('wroteFolder', `${i18nKey}.wroteFolder`, {
+            filepath: localFilepath,
+        });
     }
     catch (err) {
         (0, fileSystemErrors_1.throwFileSystemError)(err, {
@@ -197,14 +202,14 @@ async function writeFileMapperNode(accountId, filepath, node, mode, options = {}
     return true;
 }
 function isTimeout(err) {
-    return !!err && (err.statusCode === 408 || err.code === 'ESOCKETTIMEDOUT');
+    return !!err && (err.status === 408 || err.code === 'ESOCKETTIMEDOUT');
 }
 async function downloadFile(accountId, src, destPath, mode, options = {}, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks, 'filemapper');
+    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
     const { isFile, isHubspot } = getTypeDataFromPath(src);
     try {
         if (!isFile) {
-            throw new Error(`Invalid request for file: "${src}"`);
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.invalidRequest`, { src });
         }
         const dest = path_1.default.resolve(destPath);
         const cwd = (0, path_2.getCwd)();
@@ -227,7 +232,7 @@ async function downloadFile(accountId, src, destPath, mode, options = {}, logCal
         const localFsPath = (0, path_2.convertToLocalFileSystemPath)(filepath);
         await fetchAndWriteFileStream(accountId, src, localFsPath, mode, options, logCallbacks);
         await queue.onIdle();
-        logger('completedFetch', {
+        logger('completedFetch', `${i18nKey}.completedFetch`, {
             src,
             version: getAssetVersionIdentifier(options.assetVersion, src),
             dest,
@@ -236,18 +241,20 @@ async function downloadFile(accountId, src, destPath, mode, options = {}, logCal
     catch (err) {
         const error = err;
         if (isHubspot && isTimeout(err)) {
-            (0, standardErrors_1.throwErrorWithMessage)('filemapper.assetTimeout', {}, error);
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.assetTimeout`, {}, error);
         }
         else {
-            (0, standardErrors_1.throwErrorWithMessage)('filemapper.failedToFetchFile', { src, dest: destPath }, error);
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.failedToFetchFile`, { src, dest: destPath }, error);
         }
     }
 }
 async function fetchFolderFromApi(accountId, src, mode, options = {}, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks, 'filemapper');
+    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
     const { isRoot, isFolder, isHubspot } = getTypeDataFromPath(src);
     if (!isFolder) {
-        (0, standardErrors_1.throwErrorWithMessage)('filemapper.invalidFetchFolderRequest', { src });
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.invalidFetchFolderRequest`, {
+            src,
+        });
     }
     try {
         const srcPath = isRoot ? '@root' : src;
@@ -255,13 +262,13 @@ async function fetchFolderFromApi(accountId, src, mode, options = {}, logCallbac
         const node = isHubspot
             ? await (0, fileMapper_1.downloadDefault)(accountId, srcPath, queryValues)
             : await (0, fileMapper_1.download)(accountId, srcPath, queryValues);
-        logger('folderFetch', { src, accountId });
+        logger('folderFetch', `${i18nKey}.folderFetch`, { src, accountId });
         return node;
     }
     catch (err) {
         const error = err;
         if (isHubspot && isTimeout(error)) {
-            (0, standardErrors_1.throwErrorWithMessage)('filemapper.assetTimeout', {}, error);
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.assetTimeout`, {}, error);
         }
         else {
             (0, apiErrors_1.throwStatusCodeError)(error, {
@@ -273,7 +280,7 @@ async function fetchFolderFromApi(accountId, src, mode, options = {}, logCallbac
 }
 exports.fetchFolderFromApi = fetchFolderFromApi;
 async function downloadFolder(accountId, src, destPath, mode, options = {}, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks, 'filemapper');
+    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
     try {
         const node = await fetchFolderFromApi(accountId, src, mode, options, logCallbacks);
         if (!node) {
@@ -295,18 +302,18 @@ async function downloadFolder(accountId, src, destPath, mode, options = {}, logC
         }, rootPath);
         await queue.onIdle();
         if (success) {
-            logger('completedFolderFetch', {
+            logger('completedFolderFetch', `${i18nKey}.completedFolderFetch`, {
                 src,
                 version: getAssetVersionIdentifier(options.assetVersion, src),
                 dest,
             });
         }
         else {
-            (0, standardErrors_1.throwErrorWithMessage)('filemapper.incompleteFetch', { src });
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.incompleteFetch`, { src });
         }
     }
     catch (err) {
-        (0, standardErrors_1.throwErrorWithMessage)('filemapper.failedToFetchFolder', { src, dest: destPath }, err);
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.failedToFetchFolder`, { src, dest: destPath }, err);
     }
 }
 /**

package/lib/github.js

@@ -12,20 +12,21 @@ const standardErrors_1 = require("../errors/standardErrors");
 const archive_1 = require("./archive");
 const github_1 = require("../constants/github");
 const getAxiosConfig_1 = require("../http/getAxiosConfig");
+const i18nKey = 'lib.github';
 const GITHUB_AUTH_HEADERS = {
     authorization: global && global.githubToken ? `Bearer ${global.githubToken}` : null,
 };
 async function fetchJsonFromRepository(repoPath, filePath, ref) {
     try {
         const URL = `https://raw.githubusercontent.com/${repoPath}/${ref}/${filePath}`;
-        (0, logger_1.debug)('github.fetchJsonFromRepository', { url: URL });
+        (0, logger_1.debug)(`${i18nKey}.fetchJsonFromRepository.fetching`, { url: URL });
         const { data } = await axios_1.default.get(URL, {
             headers: { ...getAxiosConfig_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
         });
         return data;
     }
     catch (err) {
-        (0, standardErrors_1.throwErrorWithMessage)('github.fetchJsonFromRepository', {}, err);
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.fetchJsonFromRepository.errors.fetchFail`, {}, err);
     }
 }
 exports.fetchJsonFromRepository = fetchJsonFromRepository;
@@ -45,7 +46,7 @@ async function fetchReleaseData(repoPath, tag = '') {
     }
     catch (err) {
         const error = err;
-        (0, standardErrors_1.throwErrorWithMessage)('github.fetchReleaseData', { tag: tag || 'latest' }, error);
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.fetchReleaseData.errors.fetchFail`, { tag: tag || 'latest' }, error);
     }
 }
 exports.fetchReleaseData = fetchReleaseData;
@@ -53,35 +54,38 @@ async function downloadGithubRepoZip(repoPath, tag = '', releaseType = github_1.
     try {
         let zipUrl;
         if (releaseType === github_1.GITHUB_RELEASE_TYPES.REPOSITORY) {
-            (0, logger_1.debug)('github.downloadGithubRepoZip.fetching', { releaseType, repoPath });
+            (0, logger_1.debug)(`${i18nKey}.downloadGithubRepoZip.fetching`, {
+                releaseType,
+                repoPath,
+            });
             zipUrl = `https://api.github.com/repos/${repoPath}/zipball${ref ? `/${ref}` : ''}`;
         }
         else {
             const releaseData = await fetchReleaseData(repoPath, tag);
             zipUrl = releaseData.zipball_url;
             const { name } = releaseData;
-            (0, logger_1.debug)('github.downloadGithubRepoZip.fetchingName', { name });
+            (0, logger_1.debug)(`${i18nKey}.downloadGithubRepoZip.fetchingName`, { name });
         }
         const { data } = await axios_1.default.get(zipUrl, {
             headers: { ...getAxiosConfig_1.DEFAULT_USER_AGENT_HEADERS, ...GITHUB_AUTH_HEADERS },
         });
-        (0, logger_1.debug)('github.downloadGithubRepoZip.completed');
+        (0, logger_1.debug)(`${i18nKey}.downloadGithubRepoZip.completed`);
         return data;
     }
     catch (err) {
-        (0, standardErrors_1.throwErrorWithMessage)('github.downloadGithubRepoZip', {}, err);
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.downloadGithubRepoZip.errors.fetchFail`, {}, err);
     }
 }
 const cloneGithubRepoCallbackKeys = ['success'];
 async function cloneGithubRepo(dest, type, repoPath, sourceDir, options = {}, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks, 'github.cloneGithubRepo');
+    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
     const { themeVersion, projectVersion, releaseType, ref } = options;
     const tag = projectVersion || themeVersion;
     const zip = await downloadGithubRepoZip(repoPath, tag, releaseType, ref);
     const repoName = repoPath.split('/')[1];
     const success = await (0, archive_1.extractZipArchive)(zip, repoName, dest, { sourceDir });
     if (success) {
-        logger('success', { type, dest });
+        logger('success', `${i18nKey}.cloneGithubRepo.success`, { type, dest });
     }
     return success;
 }
@@ -111,7 +115,7 @@ async function downloadGithubRepoContents(repoPath, contentPath, dest, ref, filt
             if (filter && !filter(contentPiecePath, downloadPath)) {
                 return Promise.resolve();
             }
-            (0, logger_1.debug)('github.downloadGithubRepoContents.downloading', {
+            (0, logger_1.debug)(`${i18nKey}.downloadGithubRepoContents.downloading`, {
                 contentPiecePath,
                 downloadUrl: download_url,
                 downloadPath,
@@ -130,7 +134,7 @@ async function downloadGithubRepoContents(repoPath, contentPath, dest, ref, filt
     catch (e) {
         const error = e;
         if (error?.error?.message) {
-            (0, standardErrors_1.throwErrorWithMessage)('github.downloadGithubRepoContents', {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.downloadGithubRepoContents.errors.fetchFail`, {
                 errorMessage: error.error.message,
             }, error);
         }

package/lib/gitignore.js

@@ -9,6 +9,7 @@ const path_1 = __importDefault(require("path"));
 const git_1 = require("../utils/git");
 const config_1 = require("../constants/config");
 const standardErrors_1 = require("../errors/standardErrors");
+const i18nKey = 'lib.gitignore';
 const GITIGNORE_FILE = '.gitignore';
 function checkAndAddConfigToGitignore(configPath) {
     try {
@@ -25,7 +26,7 @@ function checkAndAddConfigToGitignore(configPath) {
         (0, fs_extra_1.writeFileSync)(gitignoreFilePath, updatedContents);
     }
     catch (e) {
-        (0, standardErrors_1.throwErrorWithMessage)('utils.git.configIgnore', {}, e);
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.configIgnore`, {}, e);
     }
 }
 exports.checkAndAddConfigToGitignore = checkAndAddConfigToGitignore;

package/lib/hubdb.d.ts

@@ -1,5 +1,5 @@
 import { Row } from '../types/Hubdb';
-export declare function addRowsToHubDbTable(accountId: number, tableId: string, rows: Array<Row>): Promise<{
+export declare function addRowsToHubDbTable(accountId: number, tableId: string, rows?: Array<Row>): Promise<{
     tableId: string;
     rowCount: number;
 }>;