@hubspot/local-dev-lib 0.6.1-experimental.0 → 0.6.3-experimental.0

package/lib/fileMapper.js

@@ -1,53 +1,43 @@
-"use strict";
 // FILE MAPPER - not to be confused with fileManager.ts
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.downloadFileOrFolder = exports.fetchFolderFromApi = exports.writeUtimes = exports.recurseFolder = exports.getTypeDataFromPath = exports.getFileMapperQueryValues = exports.isPathToHubspot = exports.isPathToRoot = exports.isPathToModule = exports.isPathToFile = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const p_queue_1 = __importDefault(require("p-queue"));
-const path_2 = require("./path");
-const logger_1 = require("./logger");
-const fileMapper_1 = require("../api/fileMapper");
-const extensions_1 = require("../constants/extensions");
-const files_1 = require("../constants/files");
-const errors_1 = require("../errors");
-const lang_1 = require("../utils/lang");
-const FileSystemError_1 = require("../models/FileSystemError");
+import fs from 'fs-extra';
+import path from 'path';
+import PQueue from 'p-queue';
+import { getCwd, getExt, convertToLocalFileSystemPath, isAllowedExtension, } from './path.js';
+import { logger } from './logger.js';
+import { fetchFileStream, download, downloadDefault, } from '../api/fileMapper.js';
+import { MODULE_EXTENSION, FUNCTIONS_EXTENSION, JSR_ALLOWED_EXTENSIONS, } from '../constants/extensions.js';
+import { CMS_PUBLISH_MODE } from '../constants/files.js';
+import { isTimeoutError } from '../errors/index.js';
+import { i18n } from '../utils/lang.js';
+import { FileSystemError } from '../models/FileSystemError.js';
 const i18nKey = 'lib.fileMapper';
-const queue = new p_queue_1.default({
+const queue = new PQueue({
     concurrency: 10,
 });
-function isPathToFile(filepath) {
-    const ext = (0, path_2.getExt)(filepath);
-    return !!ext && ext !== extensions_1.MODULE_EXTENSION && ext !== extensions_1.FUNCTIONS_EXTENSION;
+export function isPathToFile(filepath) {
+    const ext = getExt(filepath);
+    return !!ext && ext !== MODULE_EXTENSION && ext !== FUNCTIONS_EXTENSION;
 }
-exports.isPathToFile = isPathToFile;
-function isPathToModule(filepath) {
-    const ext = (0, path_2.getExt)(filepath);
-    return ext === extensions_1.MODULE_EXTENSION;
+export function isPathToModule(filepath) {
+    const ext = getExt(filepath);
+    return ext === MODULE_EXTENSION;
 }
-exports.isPathToModule = isPathToModule;
-function isPathToRoot(filepath) {
+export function isPathToRoot(filepath) {
     if (typeof filepath !== 'string')
         return false;
     // Root pattern matches empty strings and: / \
     return /^(\/|\\)?$/.test(filepath.trim());
 }
-exports.isPathToRoot = isPathToRoot;
-function isPathToHubspot(filepath) {
+export function isPathToHubspot(filepath) {
     if (typeof filepath !== 'string')
         return false;
     return /^(\/|\\)?@hubspot/i.test(filepath.trim());
 }
-exports.isPathToHubspot = isPathToHubspot;
 function useApiBuffer(cmsPublishMode) {
-    return cmsPublishMode === files_1.CMS_PUBLISH_MODE.draft;
+    return cmsPublishMode === CMS_PUBLISH_MODE.draft;
 }
 // Determines API param based on publish mode and options
-function getFileMapperQueryValues(cmsPublishMode, { staging, assetVersion } = {}) {
+export function getFileMapperQueryValues(cmsPublishMode, { staging, assetVersion } = {}) {
     return {
         params: {
             buffer: useApiBuffer(cmsPublishMode),
@@ -56,7 +46,6 @@ function getFileMapperQueryValues(cmsPublishMode, { staging, assetVersion } = {}
         },
     };
 }
-exports.getFileMapperQueryValues = getFileMapperQueryValues;
 // Determines version number to log based on input.options
 function getAssetVersionIdentifier(assetVersion, src) {
     if (typeof assetVersion !== 'undefined' &&
@@ -76,11 +65,11 @@ function validateFileMapperNode(node) {
     catch (err) {
         json = node;
     }
-    throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidNode`, {
+    throw new Error(i18n(`${i18nKey}.errors.invalidNode`, {
         json: JSON.stringify(json),
     }));
 }
-function getTypeDataFromPath(src) {
+export function getTypeDataFromPath(src) {
     const isModule = isPathToModule(src);
     const isHubspot = isPathToHubspot(src);
     const isFile = !isModule && isPathToFile(src);
@@ -94,8 +83,7 @@ function getTypeDataFromPath(src) {
         isFolder,
     };
 }
-exports.getTypeDataFromPath = getTypeDataFromPath;
-function recurseFolder(node, callback, filepath = '', depth = 0) {
+export function recurseFolder(node, callback, filepath = '', depth = 0) {
     validateFileMapperNode(node);
     const isRootFolder = node.folder && depth === 0;
     if (isRootFolder) {
@@ -104,7 +92,7 @@ function recurseFolder(node, callback, filepath = '', depth = 0) {
         }
     }
     else {
-        filepath = path_1.default.join(filepath, node.name);
+        filepath = path.join(filepath, node.name);
     }
     let __break = callback(node, filepath, depth);
     if (__break === false)
@@ -115,28 +103,26 @@ function recurseFolder(node, callback, filepath = '', depth = 0) {
     });
     return depth === 0 ? false : __break;
 }
-exports.recurseFolder = recurseFolder;
-async function writeUtimes(accountId, filepath, node) {
+export async function writeUtimes(accountId, filepath, node) {
     try {
         const now = new Date();
         const atime = node.createdAt ? new Date(node.createdAt) : now;
         const mtime = node.updatedAt ? new Date(node.updatedAt) : now;
-        await fs_extra_1.default.utimes(filepath, atime, mtime);
+        await fs.utimes(filepath, atime, mtime);
     }
     catch (err) {
-        throw new FileSystemError_1.FileSystemError({ cause: err }, {
+        throw new FileSystemError({ cause: err }, {
             filepath,
             accountId,
             operation: 'write',
         });
     }
 }
-exports.writeUtimes = writeUtimes;
 async function skipExisting(filepath, overwrite = false) {
     if (overwrite) {
         return false;
     }
-    if (await fs_extra_1.default.pathExists(filepath)) {
+    if (await fs.pathExists(filepath)) {
         return true;
     }
     return false;
@@ -146,21 +132,21 @@ async function fetchAndWriteFileStream(accountId, srcPath, filepath, cmsPublishM
         return;
     }
     if (await skipExisting(filepath, options.overwrite)) {
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.skippedExisting`, { filepath }));
+        logger.log(i18n(`${i18nKey}.skippedExisting`, { filepath }));
         return;
     }
-    if (!(0, path_2.isAllowedExtension)(srcPath, Array.from(extensions_1.JSR_ALLOWED_EXTENSIONS))) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidFileType`, { srcPath }));
+    if (!isAllowedExtension(srcPath, Array.from(JSR_ALLOWED_EXTENSIONS))) {
+        throw new Error(i18n(`${i18nKey}.errors.invalidFileType`, { srcPath }));
     }
-    const node = await (0, fileMapper_1.fetchFileStream)(accountId, srcPath, filepath, getFileMapperQueryValues(cmsPublishMode, options));
+    const node = await fetchFileStream(accountId, srcPath, filepath, getFileMapperQueryValues(cmsPublishMode, options));
     await writeUtimes(accountId, filepath, node);
 }
 // Writes an individual file or folder (not recursive).  If file source is missing, the
 //file is fetched.
 async function writeFileMapperNode(accountId, filepath, node, cmsPublishMode, options = {}) {
-    const localFilepath = (0, path_2.convertToLocalFileSystemPath)(path_1.default.resolve(filepath));
+    const localFilepath = convertToLocalFileSystemPath(path.resolve(filepath));
     if (await skipExisting(localFilepath, options.overwrite)) {
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.skippedExisting`, {
+        logger.log(i18n(`${i18nKey}.skippedExisting`, {
             filepath: localFilepath,
         }));
         return true;
@@ -175,13 +161,13 @@ async function writeFileMapperNode(accountId, filepath, node, cmsPublishMode, op
         }
     }
     try {
-        await fs_extra_1.default.ensureDir(localFilepath);
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.wroteFolder`, {
+        await fs.ensureDir(localFilepath);
+        logger.log(i18n(`${i18nKey}.wroteFolder`, {
             filepath: localFilepath,
         }));
     }
     catch (err) {
-        throw new FileSystemError_1.FileSystemError({ cause: err }, {
+        throw new FileSystemError({ cause: err }, {
             filepath: localFilepath,
             accountId,
             operation: 'write',
@@ -192,31 +178,31 @@ async function writeFileMapperNode(accountId, filepath, node, cmsPublishMode, op
 async function downloadFile(accountId, src, destPath, cmsPublishMode, options = {}) {
     const { isFile, isHubspot } = getTypeDataFromPath(src);
     if (!isFile) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidRequest`, { src }));
+        throw new Error(i18n(`${i18nKey}.errors.invalidRequest`, { src }));
     }
     try {
-        const dest = path_1.default.resolve(destPath);
-        const cwd = (0, path_2.getCwd)();
+        const dest = path.resolve(destPath);
+        const cwd = getCwd();
         let filepath;
         if (dest === cwd) {
             // Dest: CWD
-            filepath = path_1.default.resolve(cwd, path_1.default.basename(src));
+            filepath = path.resolve(cwd, path.basename(src));
         }
         else if (isPathToFile(dest)) {
             // Dest: file path
-            filepath = path_1.default.isAbsolute(dest) ? dest : path_1.default.resolve(cwd, dest);
+            filepath = path.isAbsolute(dest) ? dest : path.resolve(cwd, dest);
         }
         else {
             // Dest: folder path
-            const name = path_1.default.basename(src);
-            filepath = path_1.default.isAbsolute(dest)
-                ? path_1.default.resolve(dest, name)
-                : path_1.default.resolve(cwd, dest, name);
+            const name = path.basename(src);
+            filepath = path.isAbsolute(dest)
+                ? path.resolve(dest, name)
+                : path.resolve(cwd, dest, name);
         }
-        const localFsPath = (0, path_2.convertToLocalFileSystemPath)(filepath);
+        const localFsPath = convertToLocalFileSystemPath(filepath);
         await fetchAndWriteFileStream(accountId, src, localFsPath, cmsPublishMode, options);
         await queue.onIdle();
-        logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.completedFetch`, {
+        logger.success(i18n(`${i18nKey}.completedFetch`, {
             src,
             version: getAssetVersionIdentifier(options.assetVersion, src),
             dest,
@@ -224,39 +210,38 @@ async function downloadFile(accountId, src, destPath, cmsPublishMode, options =
     }
     catch (err) {
         const error = err;
-        if (isHubspot && (0, errors_1.isTimeoutError)(error)) {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.assetTimeout`), { cause: error });
+        if (isHubspot && isTimeoutError(error)) {
+            throw new Error(i18n(`${i18nKey}.errors.assetTimeout`), { cause: error });
         }
         else {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.failedToFetchFile`, { src, dest: destPath }), { cause: error });
+            throw new Error(i18n(`${i18nKey}.errors.failedToFetchFile`, { src, dest: destPath }), { cause: error });
         }
     }
 }
-async function fetchFolderFromApi(accountId, src, cmsPublishMode, options = {}) {
+export async function fetchFolderFromApi(accountId, src, cmsPublishMode, options = {}) {
     const { isRoot, isFolder, isHubspot } = getTypeDataFromPath(src);
     if (!isFolder) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidFetchFolderRequest`, {
+        throw new Error(i18n(`${i18nKey}.errors.invalidFetchFolderRequest`, {
             src,
         }));
     }
     const srcPath = isRoot ? '@root' : src;
     const queryValues = getFileMapperQueryValues(cmsPublishMode, options);
     const { data: node } = isHubspot
-        ? await (0, fileMapper_1.downloadDefault)(accountId, srcPath, queryValues)
-        : await (0, fileMapper_1.download)(accountId, srcPath, queryValues);
-    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.folderFetch`, { src, accountId }));
+        ? await downloadDefault(accountId, srcPath, queryValues)
+        : await download(accountId, srcPath, queryValues);
+    logger.log(i18n(`${i18nKey}.folderFetch`, { src, accountId }));
     return node;
 }
-exports.fetchFolderFromApi = fetchFolderFromApi;
 async function downloadFolder(accountId, src, destPath, cmsPublishMode, options = {}) {
     try {
         const node = await fetchFolderFromApi(accountId, src, cmsPublishMode, options);
         if (!node) {
             return;
         }
-        const dest = path_1.default.resolve(destPath);
-        const rootPath = dest === (0, path_2.getCwd)()
-            ? (0, path_2.convertToLocalFileSystemPath)(path_1.default.resolve(dest, node.name))
+        const dest = path.resolve(destPath);
+        const rootPath = dest === getCwd()
+            ? convertToLocalFileSystemPath(path.resolve(dest, node.name))
             : dest;
         let success = true;
         recurseFolder(node, (childNode, filepath) => {
@@ -264,7 +249,7 @@ async function downloadFolder(accountId, src, destPath, cmsPublishMode, options
                 const succeeded = await writeFileMapperNode(accountId, filepath || '', childNode, cmsPublishMode, options);
                 if (succeeded === false) {
                     success = false;
-                    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.errors.failedToFetchFile`, {
+                    logger.debug(i18n(`${i18nKey}.errors.failedToFetchFile`, {
                         src: childNode.path,
                         dest: filepath || '',
                     }));
@@ -274,7 +259,7 @@ async function downloadFolder(accountId, src, destPath, cmsPublishMode, options
         }, rootPath);
         await queue.onIdle();
         if (success) {
-            logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.completedFolderFetch`, {
+            logger.success(i18n(`${i18nKey}.completedFolderFetch`, {
                 src,
                 version: getAssetVersionIdentifier(options.assetVersion, src),
                 dest,
@@ -282,16 +267,16 @@ async function downloadFolder(accountId, src, destPath, cmsPublishMode, options
         }
         else {
             // TODO: Fix this exception. It is triggering the catch block so this error is being rewritten
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.incompleteFetch`, { src }));
+            throw new Error(i18n(`${i18nKey}.errors.incompleteFetch`, { src }));
         }
     }
     catch (err) {
         const error = err;
-        if ((0, errors_1.isTimeoutError)(error)) {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.assetTimeout`), { cause: error });
+        if (isTimeoutError(error)) {
+            throw new Error(i18n(`${i18nKey}.errors.assetTimeout`), { cause: error });
         }
         else {
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.failedToFetchFolder`, { src, dest: destPath }), { cause: err });
+            throw new Error(i18n(`${i18nKey}.errors.failedToFetchFolder`, { src, dest: destPath }), { cause: err });
         }
     }
 }
@@ -302,7 +287,7 @@ async function downloadFolder(accountId, src, destPath, cmsPublishMode, options
  * @param {FileMapperInputArguments} input
  * @returns {Promise}
  */
-async function downloadFileOrFolder(accountId, src, dest, cmsPublishMode, options = {}) {
+export async function downloadFileOrFolder(accountId, src, dest, cmsPublishMode, options = {}) {
     if (!src) {
         return;
     }
@@ -314,4 +299,3 @@ async function downloadFileOrFolder(accountId, src, dest, cmsPublishMode, option
         await downloadFolder(accountId, src, dest, cmsPublishMode, options);
     }
 }
-exports.downloadFileOrFolder = downloadFileOrFolder;

package/lib/fs.d.ts

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

package/lib/fs.js

@@ -1,51 +1,43 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.walk = exports.flattenAndRemoveSymlinks = exports.getFileInfoAsync = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const files_1 = require("../constants/files");
-const FileSystemError_1 = require("../models/FileSystemError");
-function getFileInfoAsync(dir, file) {
+import fs from 'fs';
+import path from 'path';
+import { STAT_TYPES } from '../constants/files.js';
+import { FileSystemError } from '../models/FileSystemError.js';
+export function getFileInfoAsync(dir, file) {
     return new Promise((resolve, reject) => {
-        const filepath = path_1.default.join(dir, file);
-        fs_1.default.lstat(filepath, (error, stats) => {
+        const filepath = path.join(dir, file);
+        fs.lstat(filepath, (error, stats) => {
             if (error) {
                 reject(error);
             }
-            let type = files_1.STAT_TYPES.FILE;
+            let type = STAT_TYPES.FILE;
             if (stats.isSymbolicLink()) {
-                type = files_1.STAT_TYPES.SYMBOLIC_LINK;
+                type = STAT_TYPES.SYMBOLIC_LINK;
             }
             else if (stats.isDirectory()) {
-                type = files_1.STAT_TYPES.DIRECTORY;
+                type = STAT_TYPES.DIRECTORY;
             }
             resolve({ filepath, type });
         });
     });
 }
-exports.getFileInfoAsync = getFileInfoAsync;
-function flattenAndRemoveSymlinks(filesData) {
+export function flattenAndRemoveSymlinks(filesData) {
     return filesData.reduce((acc, fileData) => {
         switch (fileData.type) {
-            case files_1.STAT_TYPES.FILE:
+            case STAT_TYPES.FILE:
                 return acc.concat(fileData.filepath);
-            case files_1.STAT_TYPES.DIRECTORY:
+            case STAT_TYPES.DIRECTORY:
                 return acc.concat(fileData.files || []);
-            case files_1.STAT_TYPES.SYMBOLIC_LINK:
+            case STAT_TYPES.SYMBOLIC_LINK:
                 return acc;
             default:
                 return acc;
         }
     }, []);
 }
-exports.flattenAndRemoveSymlinks = flattenAndRemoveSymlinks;
 const generateRecursiveFilePromise = async (dir, file, ignoreDirs) => {
     return getFileInfoAsync(dir, file).then(fileData => {
         return new Promise(resolve => {
-            if (fileData.type === files_1.STAT_TYPES.DIRECTORY) {
+            if (fileData.type === STAT_TYPES.DIRECTORY) {
                 walk(fileData.filepath, ignoreDirs).then(files => {
                     resolve({ ...fileData, files });
                 });
@@ -56,7 +48,7 @@ const generateRecursiveFilePromise = async (dir, file, ignoreDirs) => {
         });
     });
 };
-async function walk(dir, ignoreDirs) {
+export async function walk(dir, ignoreDirs) {
     function processFiles(files) {
         // If the directory is in the ignore list, return an empty array to skip the directory contents
         if (ignoreDirs?.some(ignored => dir.includes(ignored))) {
@@ -64,12 +56,11 @@ async function walk(dir, ignoreDirs) {
         }
         return Promise.all(files.map(file => generateRecursiveFilePromise(dir, file, ignoreDirs)));
     }
-    return fs_1.default.promises
+    return fs.promises
         .readdir(dir)
         .then(processFiles)
         .then(flattenAndRemoveSymlinks)
         .catch(err => {
-        throw new FileSystemError_1.FileSystemError({ cause: err });
+        throw new FileSystemError({ cause: err });
     });
 }
-exports.walk = walk;

package/lib/github.d.ts

@@ -1,6 +1,4 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { GithubReleaseData, GithubRepoFile, RepoPath, CloneGithubRepoOptions } from '../types/Github';
+import { GithubReleaseData, GithubRepoFile, RepoPath, CloneGithubRepoOptions } from '../types/Github.js';
 /**
  * @deprecated Use `fetchRepoFile` instead - this util is a thin wrapper around it
  */