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

package/lib/customObjects.js

@@ -1,29 +1,21 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.downloadSchema = exports.downloadSchemas = exports.writeSchemaToDisk = exports.getResolvedPath = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const prettier_1 = __importDefault(require("prettier"));
-const path_2 = require("../lib/path");
-const customObjects_1 = require("../api/customObjects");
-function getResolvedPath(dest, name) {
+import fs from 'fs-extra';
+import path from 'path';
+import { getCwd } from '../lib/path.js';
+import { fetchObjectSchemas, fetchObjectSchema } from '../api/customObjects.js';
+import { format } from 'prettier';
+export function getResolvedPath(dest, name) {
     if (name)
-        return path_1.default.resolve((0, path_2.getCwd)(), dest || '', `${name}.json`);
-    return path_1.default.resolve((0, path_2.getCwd)(), dest || '');
+        return path.resolve(getCwd(), dest || '', `${name}.json`);
+    return path.resolve(getCwd(), dest || '');
 }
-exports.getResolvedPath = getResolvedPath;
-async function writeSchemaToDisk(schema, dest) {
-    const formattedSchema = await prettier_1.default.format(JSON.stringify(schema), {
+export async function writeSchemaToDisk(schema, dest) {
+    const formattedSchema = await format(JSON.stringify(schema), {
         parser: 'json',
     });
-    fs_extra_1.default.outputFileSync(getResolvedPath(dest, schema.name), formattedSchema);
+    fs.outputFileSync(getResolvedPath(dest, schema.name), formattedSchema);
 }
-exports.writeSchemaToDisk = writeSchemaToDisk;
-async function downloadSchemas(accountId, dest) {
-    const axiosResponse = await (0, customObjects_1.fetchObjectSchemas)(accountId);
+export async function downloadSchemas(accountId, dest) {
+    const axiosResponse = await fetchObjectSchemas(accountId);
     const response = axiosResponse.data;
     if (response.results.length) {
         for (const schema of response.results) {
@@ -32,11 +24,9 @@ async function downloadSchemas(accountId, dest) {
     }
     return response.results;
 }
-exports.downloadSchemas = downloadSchemas;
-async function downloadSchema(accountId, schemaObjectType, dest) {
-    const axiosResponse = await (0, customObjects_1.fetchObjectSchema)(accountId, schemaObjectType);
+export async function downloadSchema(accountId, schemaObjectType, dest) {
+    const axiosResponse = await fetchObjectSchema(accountId, schemaObjectType);
     const response = axiosResponse.data;
     await writeSchemaToDisk(response, dest);
     return response;
 }
-exports.downloadSchema = downloadSchema;

package/lib/environment.d.ts

@@ -1,2 +1,2 @@
-import { Environment } from '../types/Config';
+import { Environment } from '../types/Accounts.js';
 export declare function getValidEnv(env?: string | null, maskedProductionValue?: Environment): Environment;

package/lib/environment.js

@@ -1,16 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getValidEnv = void 0;
-const environments_1 = require("../constants/environments");
-function getValidEnv(env, maskedProductionValue) {
+import { ENVIRONMENTS } from '../constants/environments.js';
+export function getValidEnv(env, maskedProductionValue) {
     const prodValue = typeof maskedProductionValue === 'string'
         ? maskedProductionValue
-        : environments_1.ENVIRONMENTS.PROD;
-    const returnVal = typeof env &&
-        typeof env === 'string' &&
-        env.toLowerCase() === environments_1.ENVIRONMENTS.QA
-        ? environments_1.ENVIRONMENTS.QA
+        : ENVIRONMENTS.PROD;
+    const returnVal = env && typeof env === 'string' && env.toLowerCase() === ENVIRONMENTS.QA
+        ? ENVIRONMENTS.QA
         : prodValue;
     return returnVal;
 }
-exports.getValidEnv = getValidEnv;

package/lib/escapeRegExp.js

@@ -1,7 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.escapeRegExp = void 0;
-function escapeRegExp(string) {
+export function escapeRegExp(string) {
     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
 }
-exports.escapeRegExp = escapeRegExp;

package/lib/fileManager.js

@@ -1,74 +1,67 @@
-"use strict";
 // FILE MANAGER - not to be confused with fileMapper.ts
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.downloadFileOrFolder = exports.uploadFolder = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const fileManager_1 = require("../api/fileManager");
-const fs_1 = require("./fs");
-const logger_1 = require("./logger");
-const ignoreRules_1 = require("./ignoreRules");
-const http_1 = require("../http");
-const escapeRegExp_1 = require("./escapeRegExp");
-const path_2 = require("./path");
-const lang_1 = require("../utils/lang");
-const errors_1 = require("../errors");
-const FileSystemError_1 = require("../models/FileSystemError");
+import fs from 'fs-extra';
+import path from 'path';
+import { uploadFile, fetchStat, fetchFiles, fetchFolders, } from '../api/fileManager.js';
+import { walk } from './fs.js';
+import { logger } from './logger.js';
+import { createIgnoreFilter } from './ignoreRules.js';
+import { http } from '../http/index.js';
+import { escapeRegExp } from './escapeRegExp.js';
+import { getCwd, convertToUnixPath, convertToLocalFileSystemPath, } from './path.js';
+import { i18n } from '../utils/lang.js';
+import { isAuthError, isHubSpotHttpError } from '../errors/index.js';
+import { FileSystemError } from '../models/FileSystemError.js';
 const i18nKey = 'lib.fileManager';
-async function uploadFolder(accountId, src, dest) {
-    const regex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(src)}`);
-    const files = await (0, fs_1.walk)(src);
-    const filesToUpload = files.filter((0, ignoreRules_1.createIgnoreFilter)(false));
+export async function uploadFolder(accountId, src, dest) {
+    const regex = new RegExp(`^${escapeRegExp(src)}`);
+    const files = await walk(src);
+    const filesToUpload = files.filter(createIgnoreFilter(false));
     const len = filesToUpload.length;
     for (let index = 0; index < len; index++) {
         const file = filesToUpload[index];
         const relativePath = file.replace(regex, '');
-        const destPath = (0, path_2.convertToUnixPath)(path_1.default.join(dest, relativePath));
-        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.uploadStarted`, {
+        const destPath = convertToUnixPath(path.join(dest, relativePath));
+        logger.debug(i18n(`${i18nKey}.uploadStarted`, {
             file,
             destPath,
             accountId,
         }));
         try {
-            await (0, fileManager_1.uploadFile)(accountId, file, destPath);
-            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.uploadSuccess`, { file, destPath }));
+            await uploadFile(accountId, file, destPath);
+            logger.log(i18n(`${i18nKey}.uploadSuccess`, { file, destPath }));
         }
         catch (err) {
-            if ((0, errors_1.isHubSpotHttpError)(err)) {
+            if (isHubSpotHttpError(err)) {
                 err.updateContext({
                     filepath: file,
                     dest: destPath,
                 });
                 throw err;
             }
-            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.uploadFailed`, {
+            throw new Error(i18n(`${i18nKey}.errors.uploadFailed`, {
                 file,
                 destPath,
             }));
         }
     }
 }
-exports.uploadFolder = uploadFolder;
 async function skipExisting(overwrite, filepath) {
     if (overwrite) {
         return false;
     }
-    if (await fs_extra_1.default.pathExists(filepath)) {
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.skippedExisting`, { filepath }));
+    if (await fs.pathExists(filepath)) {
+        logger.log(i18n(`${i18nKey}.skippedExisting`, { filepath }));
         return true;
     }
     return false;
 }
 async function downloadFile(accountId, file, dest, overwrite) {
     const fileName = `${file.name}.${file.extension}`;
-    const destPath = (0, path_2.convertToLocalFileSystemPath)(path_1.default.join(dest, fileName));
+    const destPath = convertToLocalFileSystemPath(path.join(dest, fileName));
     if (await skipExisting(overwrite || false, destPath)) {
         return;
     }
-    await http_1.http.getOctetStream(accountId, {
+    await http.getOctetStream(accountId, {
         baseURL: file.url,
         url: '',
     }, destPath);
@@ -79,7 +72,7 @@ async function fetchAllPagedFiles(accountId, folderId, includeArchived) {
     let count = 0;
     let offset = 0;
     while (totalFiles === null || count < totalFiles) {
-        const { data: response } = await (0, fileManager_1.fetchFiles)(accountId, folderId, offset, includeArchived);
+        const { data: response } = await fetchFiles(accountId, folderId, offset, includeArchived);
         if (totalFiles === null) {
             totalFiles = response.total_count;
         }
@@ -91,26 +84,26 @@ async function fetchAllPagedFiles(accountId, folderId, includeArchived) {
 }
 async function fetchFolderContents(accountId, folder, dest, overwrite, includeArchived) {
     try {
-        await fs_extra_1.default.ensureDir(dest);
+        await fs.ensureDir(dest);
     }
     catch (err) {
-        throw new FileSystemError_1.FileSystemError({ cause: err }, {
+        throw new FileSystemError({ cause: err }, {
             dest,
             accountId,
             operation: 'write',
         });
     }
     const files = await fetchAllPagedFiles(accountId, folder.id, includeArchived);
-    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.fetchingFiles`, {
+    logger.debug(i18n(`${i18nKey}.fetchingFiles`, {
         fileCount: files.length,
         folderName: folder.name || '',
     }));
     for (const file of files) {
         await downloadFile(accountId, file, dest, overwrite);
     }
-    const { data: { objects: folders }, } = await (0, fileManager_1.fetchFolders)(accountId, folder.id);
+    const { data: { objects: folders }, } = await fetchFolders(accountId, folder.id);
     for (const folder of folders) {
-        const nestedFolder = path_1.default.join(dest, folder.name);
+        const nestedFolder = path.join(dest, folder.name);
         await fetchFolderContents(accountId, folder, nestedFolder, overwrite, includeArchived);
     }
 }
@@ -118,18 +111,18 @@ async function fetchFolderContents(accountId, folder, dest, overwrite, includeAr
 async function downloadFolder(accountId, src, dest, folder, overwrite, includeArchived) {
     let absolutePath;
     if (folder.name) {
-        absolutePath = (0, path_2.convertToLocalFileSystemPath)(path_1.default.resolve((0, path_2.getCwd)(), dest, folder.name));
+        absolutePath = convertToLocalFileSystemPath(path.resolve(getCwd(), dest, folder.name));
     }
     else {
-        absolutePath = (0, path_2.convertToLocalFileSystemPath)(path_1.default.resolve((0, path_2.getCwd)(), dest));
+        absolutePath = convertToLocalFileSystemPath(path.resolve(getCwd(), dest));
     }
-    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.fetchFolderStarted`, {
+    logger.log(i18n(`${i18nKey}.fetchFolderStarted`, {
         src,
         path: absolutePath,
         accountId,
     }));
     await fetchFolderContents(accountId, folder, absolutePath, overwrite, includeArchived);
-    logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.fetchFolderSuccess`, {
+    logger.success(i18n(`${i18nKey}.fetchFolderSuccess`, {
         src,
         dest,
     }));
@@ -137,24 +130,24 @@ async function downloadFolder(accountId, src, dest, folder, overwrite, includeAr
 // Download a single file and write to local file system.
 async function downloadSingleFile(accountId, src, dest, file, overwrite, includeArchived) {
     if (!includeArchived && file.archived) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.archivedFile`, { src }));
+        throw new Error(i18n(`${i18nKey}.errors.archivedFile`, { src }));
     }
     if (file.hidden) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.hiddenFile`, { src }));
+        throw new Error(i18n(`${i18nKey}.errors.hiddenFile`, { src }));
     }
-    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.fetchFileStarted`, {
+    logger.log(i18n(`${i18nKey}.fetchFileStarted`, {
         src,
         dest,
         accountId,
     }));
     await downloadFile(accountId, file, dest, overwrite);
-    logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.fetchFileSuccess`, {
+    logger.success(i18n(`${i18nKey}.fetchFileSuccess`, {
         src,
         dest,
     }));
 }
 // Lookup path in file manager and initiate download
-async function downloadFileOrFolder(accountId, src, dest, overwrite, includeArchived) {
+export async function downloadFileOrFolder(accountId, src, dest, overwrite, includeArchived) {
     try {
         if (src == '/') {
             // Filemanager API treats 'None' as the root
@@ -162,7 +155,7 @@ async function downloadFileOrFolder(accountId, src, dest, overwrite, includeArch
             await downloadFolder(accountId, src, dest, rootFolder, overwrite, includeArchived);
         }
         else {
-            const { data: { file, folder }, } = await (0, fileManager_1.fetchStat)(accountId, src);
+            const { data: { file, folder }, } = await fetchStat(accountId, src);
             if (file) {
                 await downloadSingleFile(accountId, src, dest, file, overwrite, includeArchived);
             }
@@ -172,7 +165,7 @@ async function downloadFileOrFolder(accountId, src, dest, overwrite, includeArch
         }
     }
     catch (err) {
-        if ((0, errors_1.isAuthError)(err)) {
+        if (isAuthError(err)) {
             err.updateContext({
                 request: src,
                 accountId,
@@ -181,4 +174,3 @@ async function downloadFileOrFolder(accountId, src, dest, overwrite, includeArch
         throw err;
     }
 }
-exports.downloadFileOrFolder = downloadFileOrFolder;

package/lib/fileMapper.d.ts

@@ -1,4 +1,4 @@
-import { FileMapperNode, CmsPublishMode, FileMapperOptions, FileMapperInputOptions, PathTypeData, RecursiveFileMapperCallback } from '../types/Files';
+import { FileMapperNode, CmsPublishMode, FileMapperOptions, FileMapperInputOptions, PathTypeData, RecursiveFileMapperCallback } from '../types/Files.js';
 export declare function isPathToFile(filepath: string): boolean;
 export declare function isPathToModule(filepath: string): boolean;
 export declare function isPathToRoot(filepath: string): boolean;