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

package/lib/archive.d.ts

@@ -1,9 +1,3 @@
 /// <reference types="node" />
-import { LogCallbacksArg } from '../types/LogCallbacks';
-declare const archiveCallbackKeys: readonly ["init", "copy"];
-type CopySourceToDestOptions = {
-    sourceDir?: string;
-    includesRootDir?: boolean;
-};
-export declare function extractZipArchive(zip: Buffer, name: string, dest: string, { sourceDir, includesRootDir }?: CopySourceToDestOptions, logCallbacks?: LogCallbacksArg<typeof archiveCallbackKeys>): Promise<boolean>;
-export {};
+import { CopySourceToDestOptions } from '../types/Archive';
+export declare function extractZipArchive(zip: Buffer, name: string, dest: string, { sourceDir, includesRootDir, hideLogs }?: CopySourceToDestOptions): Promise<boolean>;

package/lib/archive.js

@@ -8,16 +8,16 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = require("path");
 const os_1 = require("os");
 const extract_zip_1 = __importDefault(require("extract-zip"));
-const fileSystemErrors_1 = require("../errors/fileSystemErrors");
-const standardErrors_1 = require("../errors/standardErrors");
-const logger_1 = require("../utils/logger");
+const logger_1 = require("./logger");
+const lang_1 = require("../utils/lang");
+const FileSystemError_1 = require("../models/FileSystemError");
 const i18nKey = 'lib.archive';
-const archiveCallbackKeys = ['init', 'copy'];
-async function extractZip(name, zip, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
+async function extractZip(name, zip, hideLogs = false) {
     const result = { extractDir: '', tmpDir: '' };
     const TMP_FOLDER_PREFIX = `hubspot-temp-${name}-`;
-    logger('init', `${i18nKey}.extractZip.init`);
+    if (!hideLogs) {
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.extractZip.init`));
+    }
     // Write zip to disk
     let tmpZipPath = '';
     try {
@@ -30,15 +30,16 @@ async function extractZip(name, zip, logCallbacks) {
     }
     catch (err) {
         if (tmpZipPath || result.tmpDir) {
-            (0, fileSystemErrors_1.throwFileSystemError)(err, {
+            throw new FileSystemError_1.FileSystemError({ cause: err }, {
                 filepath: tmpZipPath || result.tmpDir,
-                write: true,
+                operation: 'write',
             });
         }
         else {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.extractZip.errors.write`, {}, err);
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.extractZip.errors.write`), {
+                cause: err,
+            });
         }
-        return result;
     }
     // Extract zip
     try {
@@ -47,23 +48,26 @@ async function extractZip(name, zip, logCallbacks) {
         result.extractDir = tmpExtractPath;
     }
     catch (err) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.extractZip.errors.extract`, {}, err);
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.extractZip.errors.extract`), {
+            cause: err,
+        });
     }
-    (0, logger_1.debug)(`${i18nKey}.extractZip.success`);
+    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.extractZip.success`));
     return result;
 }
-async function copySourceToDest(src, dest, { sourceDir, includesRootDir = true } = {}, logCallbacks) {
+async function copySourceToDest(src, dest, { sourceDir, includesRootDir = true, hideLogs = false, } = {}) {
     try {
-        const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
-        logger('copy', `${i18nKey}.copySourceToDest.init`);
+        if (!hideLogs) {
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.copySourceToDest.init`));
+        }
         const srcDirPath = [src];
         if (includesRootDir) {
             const files = await fs_extra_1.default.readdir(src);
             const rootDir = files[0];
             if (!rootDir) {
-                (0, logger_1.debug)(`${i18nKey}.copySourceToDest.sourceEmpty`);
+                logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.copySourceToDest.sourceEmpty`));
                 // Create the dest path if it doesn't already exist
-                fs_extra_1.default.ensureDir(dest);
+                await fs_extra_1.default.ensureDir(dest);
                 // No root found so nothing to copy
                 return true;
             }
@@ -74,39 +78,39 @@ async function copySourceToDest(src, dest, { sourceDir, includesRootDir = true }
         }
         const projectSrcDir = (0, path_1.join)(...srcDirPath);
         await fs_extra_1.default.copy(projectSrcDir, dest);
-        (0, logger_1.debug)(`${i18nKey}.copySourceToDest.success`);
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.copySourceToDest.success`));
         return true;
     }
     catch (err) {
-        (0, logger_1.debug)(`${i18nKey}.copySourceToDest.error`, { dest });
-        (0, fileSystemErrors_1.throwFileSystemError)(err, {
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.copySourceToDest.error`, { dest }));
+        throw new FileSystemError_1.FileSystemError({ cause: err }, {
             filepath: dest,
-            write: true,
+            operation: 'write',
         });
     }
-    return false;
 }
-function cleanupTempDir(tmpDir) {
+async function cleanupTempDir(tmpDir) {
     if (!tmpDir)
         return;
     try {
-        fs_extra_1.default.remove(tmpDir);
+        await fs_extra_1.default.remove(tmpDir);
     }
     catch (e) {
-        (0, logger_1.debug)(`${i18nKey}.cleanupTempDir.error`, { tmpDir });
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.cleanupTempDir.error`, { tmpDir }));
     }
 }
-async function extractZipArchive(zip, name, dest, { sourceDir, includesRootDir } = {}, logCallbacks) {
+async function extractZipArchive(zip, name, dest, { sourceDir, includesRootDir, hideLogs } = {}) {
     let success = false;
     if (zip) {
-        const { extractDir, tmpDir } = await extractZip(name, zip, logCallbacks);
+        const { extractDir, tmpDir } = await extractZip(name, zip, hideLogs);
         if (extractDir !== null) {
             success = await copySourceToDest(extractDir, dest, {
                 sourceDir,
                 includesRootDir,
-            }, logCallbacks);
+                hideLogs,
+            });
         }
-        cleanupTempDir(tmpDir);
+        await cleanupTempDir(tmpDir);
     }
     return success;
 }

package/lib/cms/functions.d.ts

@@ -1,13 +1,8 @@
-import { LogCallbacksArg } from '../../types/LogCallbacks';
-declare const createFunctionCallbackKeys: readonly ["destPathAlreadyExists", "createdDest", "createdFunctionFile", "createdConfigFile", "success"];
-type FunctionInfo = {
-    functionsFolder: string;
-    filename: string;
-    endpointPath: string;
-    endpointMethod: string;
+import { FunctionConfig, FunctionConfigInfo, FunctionInfo, FunctionOptions } from '../../types/Functions';
+export declare function isObjectOrFunction(value: object): boolean;
+export declare function createEndpoint(endpointMethod: string, filename: string): {
+    method: string;
+    file: string;
 };
-type FunctionOptions = {
-    allowExistingFile?: boolean;
-};
-export declare function createFunction(functionInfo: FunctionInfo, dest: string, options?: FunctionOptions, logCallbacks?: LogCallbacksArg<typeof createFunctionCallbackKeys>): Promise<void>;
-export {};
+export declare function createConfig({ endpointPath, endpointMethod, functionFile, }: FunctionConfigInfo): FunctionConfig;
+export declare function createFunction(functionInfo: FunctionInfo, dest: string, options?: FunctionOptions): Promise<void>;

package/lib/cms/functions.js

@@ -3,33 +3,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFunction = void 0;
+exports.createFunction = exports.createConfig = exports.createEndpoint = exports.isObjectOrFunction = void 0;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const findup_sync_1 = __importDefault(require("findup-sync"));
 const path_2 = require("../path");
 const github_1 = require("../github");
-const logger_1 = require("../../utils/logger");
-const standardErrors_1 = require("../../errors/standardErrors");
-const fileSystemErrors_1 = require("../../errors/fileSystemErrors");
+const logger_1 = require("../logger");
+const lang_1 = require("../../utils/lang");
+const FileSystemError_1 = require("../../models/FileSystemError");
 const i18nKey = 'lib.cms.functions';
-const createFunctionCallbackKeys = [
-    'destPathAlreadyExists',
-    'createdDest',
-    'createdFunctionFile',
-    'createdConfigFile',
-    'success',
-];
 function isObjectOrFunction(value) {
     const type = typeof value;
     return value != null && (type === 'object' || type === 'function');
 }
+exports.isObjectOrFunction = isObjectOrFunction;
 function createEndpoint(endpointMethod, filename) {
     return {
         method: endpointMethod || 'GET',
         file: filename,
     };
 }
+exports.createEndpoint = createEndpoint;
 function createConfig({ endpointPath, endpointMethod, functionFile, }) {
     return {
         runtime: 'nodejs18.x',
@@ -41,6 +36,7 @@ function createConfig({ endpointPath, endpointMethod, functionFile, }) {
         },
     };
 }
+exports.createConfig = createConfig;
 function writeConfig(configFilePath, config) {
     const configJson = JSON.stringify(config, null, '  ');
     fs_extra_1.default.writeFileSync(configFilePath, configJson);
@@ -51,12 +47,12 @@ function updateExistingConfig(configFilePath, { endpointPath, endpointMethod, fu
         configString = fs_extra_1.default.readFileSync(configFilePath).toString();
     }
     catch (err) {
-        (0, logger_1.debug)(`${i18nKey}.updateExistingConfig.unableToReadFile`, {
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.updateExistingConfig.unableToReadFile`, {
             configFilePath,
-        });
-        (0, fileSystemErrors_1.throwFileSystemError)(err, {
+        }));
+        throw new FileSystemError_1.FileSystemError({ cause: err }, {
             filepath: configFilePath,
-            read: true,
+            operation: 'read',
         });
     }
     let config;
@@ -64,23 +60,25 @@ function updateExistingConfig(configFilePath, { endpointPath, endpointMethod, fu
         config = JSON.parse(configString);
     }
     catch (err) {
-        (0, logger_1.debug)(`${i18nKey}.updateExistingConfig.invalidJSON`, {
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.updateExistingConfig.invalidJSON`, {
             configFilePath,
-        });
-        (0, fileSystemErrors_1.throwFileSystemError)(err, {
+        }));
+        throw new FileSystemError_1.FileSystemError({ cause: err }, {
             filepath: configFilePath,
-            read: true,
+            operation: 'read',
         });
     }
     if (!isObjectOrFunction(config)) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.updateExistingConfig.errors.configIsNotObjectError`, { configFilePath });
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.updateExistingConfig.errors.configIsNotObjectError`, {
+            configFilePath,
+        }));
     }
     if (config.endpoints) {
         if (config.endpoints[endpointPath]) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.updateExistingConfig.errors.endpointAreadyExistsError`, {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.updateExistingConfig.errors.endpointAreadyExistsError`, {
                 configFilePath,
                 endpointPath,
-            });
+            }));
         }
         else {
             config.endpoints[endpointPath] = createEndpoint(endpointMethod, functionFile);
@@ -95,17 +93,16 @@ function updateExistingConfig(configFilePath, { endpointPath, endpointMethod, fu
         writeConfig(configFilePath, config);
     }
     catch (err) {
-        (0, logger_1.debug)(`${i18nKey}.updateExistingConfig.couldNotUpdateFile`, {
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.updateExistingConfig.couldNotUpdateFile`, {
             configFilePath,
-        });
-        (0, fileSystemErrors_1.throwFileSystemError)(err, {
+        }));
+        throw new FileSystemError_1.FileSystemError({ cause: err }, {
             filepath: configFilePath,
-            write: true,
+            operation: 'read',
         });
     }
 }
-async function createFunction(functionInfo, dest, options = {}, logCallbacks) {
-    const logger = (0, logger_1.makeTypedLogger)(logCallbacks);
+async function createFunction(functionInfo, dest, options = {}) {
     const { functionsFolder, filename, endpointPath, endpointMethod } = functionInfo;
     const allowExistingFile = options.allowExistingFile || false;
     const ancestorFunctionsConfig = (0, findup_sync_1.default)('serverless.json', {
@@ -113,9 +110,9 @@ async function createFunction(functionInfo, dest, options = {}, logCallbacks) {
         nocase: true,
     });
     if (ancestorFunctionsConfig) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.createFunction.errors.nestedConfigError`, {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.createFunction.errors.nestedConfigError`, {
             ancestorConfigPath: path_1.default.dirname(ancestorFunctionsConfig),
-        });
+        }));
     }
     const folderName = functionsFolder.endsWith('.functions')
         ? functionsFolder
@@ -123,40 +120,41 @@ async function createFunction(functionInfo, dest, options = {}, logCallbacks) {
     const functionFile = filename.endsWith('.js') ? filename : `${filename}.js`;
     const destPath = path_1.default.join(dest, folderName);
     if (fs_extra_1.default.existsSync(destPath)) {
-        logger('destPathAlreadyExists', `${i18nKey}.createFunction.destPathAlreadyExists`, {
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createFunction.destPathAlreadyExists`, {
             path: destPath,
-        });
+        }));
     }
     else {
         fs_extra_1.default.mkdirp(destPath);
-        logger('createdDest', `${i18nKey}.createFunction.createdDest`, {
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createFunction.createdDest`, {
             path: destPath,
-        });
+        }));
     }
     const functionFilePath = path_1.default.join(destPath, functionFile);
     const configFilePath = path_1.default.join(destPath, 'serverless.json');
     if (!allowExistingFile && fs_extra_1.default.existsSync(functionFilePath)) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.createFunction.errors.jsFileConflictError`, {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.createFunction.errors.jsFileConflictError`, {
             functionFilePath,
-        });
+        }));
     }
-    await (0, github_1.downloadGithubRepoContents)('HubSpot/cms-sample-assets', 'functions/sample-function.js', functionFilePath);
-    logger('createdFunctionFile', `${i18nKey}.createFunction.createdFunctionFile`, {
+    const result = await (0, github_1.fetchFileFromRepository)('HubSpot/cms-sample-assets', 'functions/sample-function.js', 'main');
+    fs_extra_1.default.writeFileSync(functionFilePath, result);
+    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createFunction.createdFunctionFile`, {
         path: functionFilePath,
-    });
+    }));
     if (fs_extra_1.default.existsSync(configFilePath)) {
         updateExistingConfig(configFilePath, {
             endpointPath,
             endpointMethod,
             functionFile,
         });
-        logger('createdFunctionFile', `${i18nKey}.createFunction.createdFunctionFile`, {
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createFunction.createdFunctionFile`, {
             path: functionFilePath,
-        });
-        logger('success', `${i18nKey}.createFunction.success`, {
+        }));
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createFunction.success`, {
             endpointPath: endpointPath,
             folderName,
-        });
+        }));
     }
     else {
         const config = createConfig({ endpointPath, endpointMethod, functionFile });
@@ -164,21 +162,21 @@ async function createFunction(functionInfo, dest, options = {}, logCallbacks) {
             writeConfig(configFilePath, config);
         }
         catch (err) {
-            (0, logger_1.debug)(`${i18nKey}.createFunction.failedToCreateFile`, {
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.createFunction.failedToCreateFile`, {
                 configFilePath,
-            });
-            (0, fileSystemErrors_1.throwFileSystemError)(err, {
+            }));
+            throw new FileSystemError_1.FileSystemError({ cause: err }, {
                 filepath: configFilePath,
-                write: true,
+                operation: 'write',
             });
         }
-        logger('createdConfigFile', `${i18nKey}.createFunction.createdConfigFile`, {
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createFunction.createdConfigFile`, {
             path: configFilePath,
-        });
-        logger('success', `${i18nKey}.createFunction.success`, {
+        }));
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createFunction.success`, {
             endpointPath: endpointPath,
             folderName,
-        });
+        }));
     }
 }
 exports.createFunction = createFunction;

package/lib/cms/handleFieldsJS.js

@@ -8,10 +8,10 @@ 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 escapeRegExp_1 = require("../escapeRegExp");
 const modules_1 = require("../../utils/cms/modules");
-const logger_1 = require("../../utils/logger");
-const standardErrors_1 = require("../../errors/standardErrors");
+const logger_1 = require("../logger");
+const lang_1 = require("../../utils/lang");
 const i18nKey = 'lib.cms.handleFieldsJs';
 class FieldsJs {
     projectDir;
@@ -51,9 +51,9 @@ class FieldsJs {
                     writeDir,
                 },
             });
-            (0, logger_1.debug)(`${i18nKey}.convertFieldsJs.creating`, {
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.convertFieldsJs.creating`, {
                 pid: convertFieldsProcess.pid || '',
-            });
+            }));
             convertFieldsProcess.on('message', function (message) {
                 if (message.action === 'ERROR') {
                     reject(message.message);
@@ -63,12 +63,12 @@ class FieldsJs {
                 }
             });
             convertFieldsProcess.on('close', () => {
-                (0, logger_1.debug)(`${i18nKey}.convertFieldsJs.terminating`, {
+                logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.convertFieldsJs.terminating`, {
                     pid: convertFieldsProcess.pid || '',
-                });
+                }));
             });
         }).catch((e) => {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.convertFieldsJs.errors.errorConverting`, { filePath }, e);
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.convertFieldsJs.errors.errorConverting`, { filePath }), { cause: e });
         });
     }
     /**
@@ -78,9 +78,9 @@ class FieldsJs {
      */
     saveOutput() {
         if (!this.outputPath || !fs_extra_1.default.existsSync(this.outputPath)) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.saveOutput.errors.saveFailed`, {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.saveOutput.errors.saveFailed`, {
                 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');
@@ -88,7 +88,7 @@ class FieldsJs {
             fs_extra_1.default.copyFileSync(this.outputPath, savePath);
         }
         catch (err) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.saveOutput.errors.saveFailed`, { path: savePath }, err);
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.saveOutput.errors.saveFailed`, { path: savePath }), { cause: err });
         }
     }
     /**
@@ -120,7 +120,7 @@ function isConvertableFieldJs(rootDir, filePath, convertFields = false) {
     const inModuleFolder = (0, modules_1.isModuleFolderChild)({ path: filePath, isLocal: true });
     return !!(convertFields &&
         allowedFieldsNames.includes(baseName) &&
-        (inModuleFolder || relativePath == '/'));
+        (inModuleFolder || relativePath == path_1.default.sep));
 }
 exports.isConvertableFieldJs = isConvertableFieldJs;
 // Try creating tempdir
@@ -130,7 +130,9 @@ function createTmpDirSync(prefix) {
         tmpDir = fs_extra_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), prefix));
     }
     catch (err) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.createTmpDirSync.errors.writeFailed`, {}, err);
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.createTmpDirSync.errors.writeFailed`), {
+            cause: err,
+        });
     }
     return tmpDir;
 }
@@ -139,7 +141,7 @@ exports.createTmpDirSync = createTmpDirSync;
 function cleanupTmpDirSync(tmpDir) {
     fs_extra_1.default.rm(tmpDir, { recursive: true }, err => {
         if (err) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.cleanupTmpDirSync.errors.deleteFailed`, {}, err);
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.cleanupTmpDirSync.errors.deleteFailed`), { cause: err });
         }
     });
 }

package/lib/cms/modules.d.ts

@@ -1,6 +1,4 @@
-import { LogCallbacksArg } from '../../types/LogCallbacks';
-import { PathInput } from '../../types/Modules';
-declare const createModuleCallbackKeys: readonly ["creatingPath", "creatingModule"];
+import { PathInput, ValidationResult, ModuleDefinition } from '../../types/Modules';
 export declare const ValidationIds: {
     SRC_REQUIRED: string;
     DEST_REQUIRED: string;
@@ -8,18 +6,9 @@ export declare const ValidationIds: {
     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;
-    reactType: boolean;
-    global: boolean;
-};
 export declare function createModule(moduleDefinition: ModuleDefinition, name: string, dest: string, getInternalVersion: boolean, options?: {
     allowExistingDir: boolean;
-}, logCallbacks?: LogCallbacksArg<typeof createModuleCallbackKeys>): Promise<void>;
-export {};
+}): Promise<void>;
+export declare function retrieveDefaultModule(name: string | undefined, dest: string): Promise<import("../../types/Github").GithubRepoFile[] | undefined>;
+export declare const isModuleHTMLFile: (filePath: string) => boolean;