@hubspot/local-dev-lib 0.0.4 → 0.0.6

package/lib/cms/templates.js

@@ -0,0 +1,62 @@
+"use strict";
+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;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const github_1 = require("../../lib/github");
+const standardErrors_1 = require("../../errors/standardErrors");
+const logger_1 = require("../../utils/logger");
+// 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
+const ANNOTATION_VALUE_REGEX = ':\\s?([\\S|\\s]*?)(\n|$)';
+exports.ANNOTATION_KEYS = {
+    isAvailableForNewContent: 'isAvailableForNewContent',
+    templateType: 'templateType',
+    label: 'label',
+    screenshotPath: 'screenshotPath',
+    // 'description' is specific to Sections
+    description: 'description',
+};
+function getAnnotationValue(annotations, key) {
+    const valueRegex = new RegExp(`${key}${ANNOTATION_VALUE_REGEX}`);
+    const match = annotations.match(valueRegex);
+    return match ? match[1].trim() : null;
+}
+exports.getAnnotationValue = getAnnotationValue;
+/*
+ * Returns true if:
+ * .html extension (ignoring module.html)
+ */
+function isCodedFile(filePath) {
+    return TEMPLATE_EXTENSION_REGEX.test(filePath);
+}
+exports.isCodedFile = isCodedFile;
+const ASSET_PATHS = {
+    'page-template': 'templates/page-template.html',
+    partial: 'templates/partial.html',
+    'global-partial': 'templates/global-partial.html',
+    'email-template': 'templates/email-template.html',
+    'blog-listing-template': 'templates/blog-listing-template.html',
+    'blog-post-template': 'templates/blog-post-template.html',
+    'search-template': 'templates/search-template.html',
+    section: 'templates/section.html',
+};
+const templatesCallbackKeys = ['creatingFile'];
+async function createTemplate(name, dest, type = 'page-template', options = { allowExisting: false }, logCallbacks) {
+    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)('templates.pathExists', { path: filePath });
+    }
+    (0, logger_1.debug)('templates.debug.creatingPath', { path: dest });
+    fs_extra_1.default.mkdirp(dest);
+    const logger = (0, logger_1.makeTypedLogger)(logCallbacks, 'templates.logging');
+    logger('creatingFile', { path: filePath });
+    await (0, github_1.downloadGithubRepoContents)('HubSpot/cms-sample-assets', assetPath, filePath);
+}
+exports.createTemplate = createTemplate;

package/lib/cms/themes.js

@@ -7,7 +7,7 @@ exports.getThemePreviewUrl = exports.getThemeJSONPath = void 0;
 const findup_sync_1 = __importDefault(require("findup-sync"));
 const urls_1 = require("../urls");
 const environments_1 = require("../../constants/environments");
-const CLIConfiguration_1 = __importDefault(require("../../config/CLIConfiguration"));
+const config_1 = require("../../config");
 function getThemeJSONPath(path) {
     return (0, findup_sync_1.default)('theme.json', {
         cwd: path,
@@ -28,7 +28,7 @@ function getThemePreviewUrl(filePath, accountId) {
     const themeName = getThemeNameFromPath(filePath);
     if (!themeName)
         return;
-    const baseUrl = (0, urls_1.getHubSpotWebsiteOrigin)(CLIConfiguration_1.default.getEnv() === 'qa' ? environments_1.ENVIRONMENTS.QA : environments_1.ENVIRONMENTS.PROD);
+    const baseUrl = (0, urls_1.getHubSpotWebsiteOrigin)((0, config_1.getEnv)(accountId) === 'qa' ? environments_1.ENVIRONMENTS.QA : environments_1.ENVIRONMENTS.PROD);
     return `${baseUrl}/theme-previewer/${accountId}/edit/${encodeURIComponent(themeName)}`;
 }
 exports.getThemePreviewUrl = getThemePreviewUrl;

package/lib/cms/uploadFolder.d.ts

@@ -0,0 +1,18 @@
+import { FieldsJs } from './handleFieldsJS';
+import { FileMapperInputOptions } from '../../types/Files';
+import { LogCallbacksArg } from '../../types/LogCallbacks';
+import { UploadFolderResults } from '../../types/Files';
+import { Mode } from '../../types/Files';
+type CommandOptions = {
+    convertFields?: boolean;
+    fieldOptions?: string;
+    saveOutput?: boolean;
+};
+type FilePathsByType = {
+    [key: string]: Array<string>;
+};
+export declare function getFilesByType(filePaths: Array<string>, projectDir: string, rootWriteDir: string | null, commandOptions: CommandOptions): Promise<[FilePathsByType, Array<FieldsJs>]>;
+declare const uploadFolderCallbackKeys: string[];
+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 hasUploadErrors(results: Array<UploadFolderResults>): boolean;
+export {};

package/lib/cms/uploadFolder.js

@@ -0,0 +1,182 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasUploadErrors = exports.uploadFolder = exports.getFilesByType = void 0;
+const path_1 = __importDefault(require("path"));
+const p_queue_1 = __importDefault(require("p-queue"));
+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 path_2 = require("../path");
+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 queue = new p_queue_1.default({
+    concurrency: 10,
+});
+function getFileType(filePath) {
+    const extension = (0, path_2.getExt)(filePath);
+    const moduleFolder = (0, modules_1.isModuleFolderChild)({ path: filePath, isLocal: true });
+    if (moduleFolder)
+        return files_1.FILE_TYPES.module;
+    switch (extension) {
+        case 'js':
+        case 'css':
+            return files_1.FILE_TYPES.cssAndJs;
+        case 'html':
+            return files_1.FILE_TYPES.template;
+        case 'json':
+            return files_1.FILE_TYPES.json;
+        default:
+            return files_1.FILE_TYPES.other;
+    }
+}
+async function getFilesByType(filePaths, projectDir, rootWriteDir, commandOptions) {
+    const { convertFields, fieldOptions } = commandOptions;
+    const projectDirRegex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(projectDir)}`);
+    const fieldsJsObjects = [];
+    // Create object with key-value pairs of form { FileType.type: [] }
+    const filePathsByType = Object.values(files_1.FILE_TYPES).reduce((acc, fileType) => {
+        return {
+            ...acc,
+            [fileType]: [],
+        };
+    }, {});
+    for (const filePath of filePaths) {
+        const fileType = getFileType(filePath);
+        const relPath = filePath.replace(projectDirRegex, '');
+        if (!convertFields) {
+            filePathsByType[fileType].push(filePath);
+            continue;
+        }
+        const convertableFields = (0, handleFieldsJS_1.isConvertableFieldJs)(projectDir, filePath, convertFields);
+        if (convertableFields) {
+            const rootOrModule = path_1.default.dirname(relPath) === '/' ? files_1.FILE_TYPES.json : files_1.FILE_TYPES.module;
+            const fieldsJs = await new handleFieldsJS_1.FieldsJs(projectDir, filePath, rootWriteDir, fieldOptions).init();
+            /*
+             * A fields.js will be rejected if the promise is rejected or if the some other error occurs.
+             * We handle this gracefully by not adding the failed fields.js to the object list.
+             */
+            if (fieldsJs.rejected)
+                continue;
+            fieldsJsObjects.push(fieldsJs);
+            filePathsByType[rootOrModule].push(fieldsJs.outputPath || '');
+        }
+        else {
+            filePathsByType[fileType].push(filePath);
+        }
+    }
+    return [filePathsByType, fieldsJsObjects];
+}
+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 { saveOutput, convertFields } = commandOptions;
+    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 failures = [];
+    let fieldsJsPaths = [];
+    let tmpDirRegex;
+    const [filesByType, fieldsJsObjects] = await getFilesByType(filePaths, src, tmpDir, commandOptions);
+    const fileList = Object.values(filesByType);
+    if (fieldsJsObjects.length) {
+        fieldsJsPaths = fieldsJsObjects.map(fieldsJs => {
+            return { outputPath: fieldsJs.outputPath, filePath: fieldsJs.filePath };
+        });
+        tmpDirRegex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(tmpDir || '')}`);
+    }
+    function uploadFile(file) {
+        const fieldsJsFileInfo = fieldsJsPaths.find(f => f.outputPath === file);
+        const originalFilePath = fieldsJsFileInfo
+            ? fieldsJsFileInfo.filePath
+            : file;
+        // files in fieldsJsPaths always belong to the tmp directory.
+        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', {
+                file: originalFilePath || '',
+                destPath,
+            });
+            try {
+                await (0, fileMapper_2.upload)(accountId, file, destPath, apiOptions);
+                logger('success', {
+                    file: originalFilePath || '',
+                    destPath,
+                });
+            }
+            catch (err) {
+                const error = err;
+                if ((0, standardErrors_1.isFatalError)(error)) {
+                    throw error;
+                }
+                (0, logger_1.debug)('cms.uploadFolder.failed', { file, destPath });
+                if (error.response && error.response.body) {
+                    console.debug(error.response.body);
+                }
+                else {
+                    console.debug(error.message);
+                }
+                failures.push({
+                    file,
+                    destPath,
+                });
+            }
+        };
+    }
+    for (let i = 0; i < fileList.length; i++) {
+        const filesToUpload = fileList[i];
+        await queue.addAll(filesToUpload.map(uploadFile));
+    }
+    const results = await queue
+        .addAll(failures.map(({ file, destPath }) => {
+        return async () => {
+            (0, logger_1.debug)('cms.uploadFolder.retry', { file, destPath });
+            try {
+                await (0, fileMapper_2.upload)(accountId, file, destPath, apiOptions);
+                logger('success', { file, destPath });
+                return {
+                    resultType: files_1.FILE_UPLOAD_RESULT_TYPES.SUCCESS,
+                    error: null,
+                    file,
+                };
+            }
+            catch (err) {
+                (0, logger_1.debug)('cms.uploadFolder.retryFailed', { file, destPath });
+                const error = err;
+                if ((0, standardErrors_1.isFatalError)(error)) {
+                    throw error;
+                }
+                (0, apiErrors_1.throwApiUploadError)(error, {
+                    accountId,
+                    request: destPath,
+                    payload: file,
+                });
+            }
+        };
+    }))
+        .finally(() => {
+        if (!convertFields)
+            return;
+        if (saveOutput) {
+            fieldsJsObjects.forEach(fieldsJs => fieldsJs.saveOutput());
+        }
+        (0, handleFieldsJS_1.cleanupTmpDirSync)(tmpDir || '');
+    });
+    return results;
+}
+exports.uploadFolder = uploadFolder;
+function hasUploadErrors(results) {
+    return results.some(result => result.resultType === files_1.FILE_UPLOAD_RESULT_TYPES.FAILURE);
+}
+exports.hasUploadErrors = hasUploadErrors;

package/lib/cms/watch.d.ts

@@ -0,0 +1,20 @@
+import chokidar from 'chokidar';
+import { LogCallbacksArg } from '../../types/LogCallbacks';
+import { Mode } from '../../types/Files';
+import { UploadFolderResults } from '../../types/Files';
+import { StatusCodeError } from '../../types/Error';
+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: StatusCodeError) => 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 {};

package/lib/cms/watch.js

@@ -0,0 +1,194 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watch = void 0;
+const path_1 = __importDefault(require("path"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const p_queue_1 = __importDefault(require("p-queue"));
+const debounce_1 = require("debounce");
+const apiErrors_1 = require("../../errors/apiErrors");
+const handleFieldsJS_1 = require("./handleFieldsJS");
+const uploadFolder_1 = require("./uploadFolder");
+const ignoreRules_1 = require("../ignoreRules");
+const fileMapper_1 = require("../fileMapper");
+const fileMapper_2 = require("../../api/fileMapper");
+const escapeRegExp_1 = require("../../utils/escapeRegExp");
+const path_2 = require("../path");
+const notify_1 = require("../../utils/notify");
+const themes_1 = require("./themes");
+const logger_1 = require("../../utils/logger");
+const logger_2 = require("../../utils/logger");
+const watchCallbackKeys = [
+    'notifyOfThemePreview',
+    'uploadSuccess',
+    'deleteSuccess',
+    'folderUploadSuccess',
+    'ready',
+    'deleteSuccessWithType',
+];
+const makeLogger = (logger_1.makeTypedLogger);
+const queue = new p_queue_1.default({
+    concurrency: 10,
+});
+function _notifyOfThemePreview(filePath, accountId, logCallbacks) {
+    const logger = makeLogger(logCallbacks, 'watch');
+    if (queue.size > 0)
+        return;
+    const previewUrl = (0, themes_1.getThemePreviewUrl)(filePath, accountId);
+    if (!previewUrl)
+        return;
+    logger('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 src = options.src;
+    const absoluteSrcPath = path_1.default.resolve((0, path_2.getCwd)(), file);
+    const themeJsonPath = (0, themes_1.getThemeJSONPath)(absoluteSrcPath);
+    const projectRoot = themeJsonPath
+        ? path_1.default.dirname(themeJsonPath)
+        : 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 });
+        return;
+    }
+    if ((0, ignoreRules_1.shouldIgnoreFile)(file)) {
+        (0, logger_2.debug)('watch.skipIgnoreRule', { file });
+        return;
+    }
+    let fieldsJs = undefined;
+    if (convertFields) {
+        fieldsJs = await new handleFieldsJS_1.FieldsJs(projectRoot, absoluteSrcPath, undefined, options.fieldOptions).init();
+        if (fieldsJs.rejected)
+            return;
+        // Ensures that the dest path is a .json. The user might pass '.js' accidentally - this ensures it just works.
+        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 });
+    const apiOptions = (0, fileMapper_1.getFileMapperQueryValues)(mode, options);
+    queue.add(() => {
+        return (0, fileMapper_2.upload)(accountId, fileToUpload, dest, apiOptions)
+            .then(() => {
+            logger('uploadSuccess', { file, dest });
+            notifyOfThemePreview(file, accountId, logCallbacks);
+        })
+            .catch(() => {
+            (0, logger_2.debug)('watch.uploadFailed', { file, dest });
+            (0, logger_2.debug)('watch.uploadRetry', { file, dest });
+            return (0, fileMapper_2.upload)(accountId, file, dest, apiOptions).catch((error) => {
+                (0, logger_2.debug)('watch.uploadFailed', { file, dest });
+                (0, apiErrors_1.throwApiUploadError)(error, {
+                    accountId,
+                    request: dest,
+                    payload: file,
+                });
+            });
+        });
+    });
+}
+async function deleteRemoteFile(accountId, filePath, remoteFilePath, logCallbacks) {
+    const logger = makeLogger(logCallbacks, 'watch');
+    if ((0, ignoreRules_1.shouldIgnoreFile)(filePath)) {
+        (0, logger_2.debug)('watch.skipIgnoreRule', { file: filePath });
+        return;
+    }
+    (0, logger_2.debug)('watch.deleteAttempt', { remoteFilePath });
+    return queue.add(() => {
+        return (0, fileMapper_2.deleteFile)(accountId, remoteFilePath)
+            .then(() => {
+            logger('deleteSuccess', { remoteFilePath });
+            notifyOfThemePreview(filePath, accountId, logCallbacks);
+        })
+            .catch((error) => {
+            (0, logger_2.debug)('watch.deleteFailed', { remoteFilePath });
+            (0, apiErrors_1.throwApiError)(error, {
+                accountId,
+                request: remoteFilePath,
+            });
+        });
+    });
+}
+function watch(accountId, src, dest, { mode, remove, disableInitial, notify, commandOptions, filePaths, }, postInitialUploadCallback = null, onUploadFolderError, onQueueAddError, logCallbacks) {
+    const logger = makeLogger(logCallbacks, 'watch');
+    const regex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(src)}`);
+    if (notify) {
+        (0, ignoreRules_1.ignoreFile)(notify);
+    }
+    const watcher = chokidar_1.default.watch(src, {
+        ignoreInitial: true,
+        ignored: (file) => (0, ignoreRules_1.shouldIgnoreFile)(file),
+    });
+    function getDesignManagerPath(file) {
+        const relativePath = file.replace(regex, '');
+        return (0, path_2.convertToUnixPath)(path_1.default.join(dest, relativePath));
+    }
+    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 });
+            if (postInitialUploadCallback) {
+                postInitialUploadCallback(result);
+            }
+        });
+        if (onUploadFolderError) {
+            uploadFolderPromise.catch(onUploadFolderError);
+        }
+    }
+    watcher.on('ready', () => {
+        logger('ready', { src });
+    });
+    watcher.on('add', async (filePath) => {
+        const destPath = getDesignManagerPath(filePath);
+        const uploadPromise = uploadFile(accountId, filePath, destPath, {
+            src,
+            commandOptions,
+        }, mode, logCallbacks);
+        (0, notify_1.triggerNotify)(notify, 'Added', filePath, uploadPromise);
+    });
+    if (remove) {
+        const deleteFileOrFolder = (type) => (filePath) => {
+            // If it's a fields.js file that is in a module folder or the root, then ignore because it will not exist on the server.
+            if ((0, handleFieldsJS_1.isConvertableFieldJs)(src, filePath, commandOptions.convertFields)) {
+                return;
+            }
+            const remotePath = getDesignManagerPath(filePath);
+            if ((0, ignoreRules_1.shouldIgnoreFile)(filePath)) {
+                (0, logger_2.debug)('watch.skipIgnoreRule', { file: filePath });
+                return;
+            }
+            (0, logger_2.debug)('watch.deleteAttemptWithType', {
+                type,
+                remoteFilePath: remotePath,
+            });
+            const queueAddPromise = queue.add(() => {
+                const deletePromise = deleteRemoteFile(accountId, filePath, remotePath, logCallbacks).then(() => {
+                    logger('deleteSuccessWithType', {
+                        type,
+                        remoteFilePath: remotePath,
+                    });
+                });
+                if (onQueueAddError) {
+                    queueAddPromise.catch(onQueueAddError);
+                }
+                (0, notify_1.triggerNotify)(notify, 'Removed', filePath, deletePromise);
+                return deletePromise;
+            });
+        };
+        watcher.on('unlink', deleteFileOrFolder('file'));
+        watcher.on('unlinkDir', deleteFileOrFolder('folder'));
+    }
+    watcher.on('change', async (filePath) => {
+        const destPath = getDesignManagerPath(filePath);
+        const uploadPromise = uploadFile(accountId, filePath, destPath, {
+            src,
+            commandOptions,
+        }, mode, logCallbacks);
+        (0, notify_1.triggerNotify)(notify, 'Changed', filePath, uploadPromise);
+    });
+    return watcher;
+}
+exports.watch = watch;

package/lib/customObjects.d.ts

@@ -0,0 +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>;

package/lib/customObjects.js

@@ -0,0 +1,36 @@
+"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) {
+    if (name)
+        return path_1.default.resolve((0, path_2.getCwd)(), dest || '', `${name}.json`);
+    return path_1.default.resolve((0, path_2.getCwd)(), dest || '');
+}
+exports.getResolvedPath = getResolvedPath;
+async function writeSchemaToDisk(schema, dest) {
+    const formattedSchema = await prettier_1.default.format(JSON.stringify(schema), {
+        parser: 'json',
+    });
+    fs_extra_1.default.outputFileSync(getResolvedPath(dest, schema.name), formattedSchema);
+}
+exports.writeSchemaToDisk = writeSchemaToDisk;
+async function downloadSchemas(accountId, dest) {
+    const response = await (0, customObjects_1.fetchObjectSchemas)(accountId);
+    if (response.results.length) {
+        response.results.forEach((r) => writeSchemaToDisk(r, dest));
+    }
+}
+exports.downloadSchemas = downloadSchemas;
+async function downloadSchema(accountId, schemaObjectType, dest) {
+    const response = await (0, customObjects_1.fetchObjectSchema)(accountId, schemaObjectType);
+    writeSchemaToDisk(response, dest);
+}
+exports.downloadSchema = downloadSchema;

package/lib/environment.d.ts

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

package/lib/fileMapper.d.ts

@@ -0,0 +1,13 @@
+import { Mode, FileMapperOptions, FileMapperInputOptions } from '../types/Files';
+import { LogCallbacksArg } from '../types/LogCallbacks';
+export declare function getFileMapperQueryValues(mode: Mode | null, { staging, assetVersion }: FileMapperInputOptions): FileMapperOptions;
+declare const filemapperCallbackKeys: string[];
+/**
+ * Fetch a file/folder and write to local file system.
+ *
+ * @async
+ * @param {FileMapperInputArguments} input
+ * @returns {Promise}
+ */
+export declare function downloadFileOrFolder(accountId: number, src: string, dest: string, mode: Mode, options: FileMapperInputOptions | undefined, logCallbacks: LogCallbacksArg<typeof filemapperCallbackKeys>): Promise<void>;
+export {};