@hubspot/local-dev-lib 0.0.1-experimental.0

package/lib/cms/functions.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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("../logger");
+const lang_1 = require("../../utils/lang");
+const FileSystemError_1 = require("../../models/FileSystemError");
+const i18nKey = 'lib.cms.functions';
+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',
+        version: '1.0',
+        environment: {},
+        secrets: [],
+        endpoints: {
+            [endpointPath]: createEndpoint(endpointMethod, functionFile),
+        },
+    };
+}
+exports.createConfig = createConfig;
+function writeConfig(configFilePath, config) {
+    const configJson = JSON.stringify(config, null, '  ');
+    fs_extra_1.default.writeFileSync(configFilePath, configJson);
+}
+function updateExistingConfig(configFilePath, { endpointPath, endpointMethod, functionFile }) {
+    let configString;
+    try {
+        configString = fs_extra_1.default.readFileSync(configFilePath).toString();
+    }
+    catch (err) {
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.updateExistingConfig.unableToReadFile`, {
+            configFilePath,
+        }));
+        throw new FileSystemError_1.FileSystemError({ cause: err }, {
+            filepath: configFilePath,
+            operation: 'read',
+        });
+    }
+    let config;
+    try {
+        config = JSON.parse(configString);
+    }
+    catch (err) {
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.updateExistingConfig.invalidJSON`, {
+            configFilePath,
+        }));
+        throw new FileSystemError_1.FileSystemError({ cause: err }, {
+            filepath: configFilePath,
+            operation: 'read',
+        });
+    }
+    if (!isObjectOrFunction(config)) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.updateExistingConfig.errors.configIsNotObjectError`, {
+            configFilePath,
+        }));
+    }
+    if (config.endpoints) {
+        if (config.endpoints[endpointPath]) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.updateExistingConfig.errors.endpointAreadyExistsError`, {
+                configFilePath,
+                endpointPath,
+            }));
+        }
+        else {
+            config.endpoints[endpointPath] = createEndpoint(endpointMethod, functionFile);
+        }
+    }
+    else {
+        config.endpoints = {
+            [endpointPath]: createEndpoint(endpointMethod, functionFile),
+        };
+    }
+    try {
+        writeConfig(configFilePath, config);
+    }
+    catch (err) {
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.updateExistingConfig.couldNotUpdateFile`, {
+            configFilePath,
+        }));
+        throw new FileSystemError_1.FileSystemError({ cause: err }, {
+            filepath: configFilePath,
+            operation: 'read',
+        });
+    }
+}
+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', {
+        cwd: (0, path_2.getCwd)(),
+        nocase: true,
+    });
+    if (ancestorFunctionsConfig) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.createFunction.errors.nestedConfigError`, {
+            ancestorConfigPath: path_1.default.dirname(ancestorFunctionsConfig),
+        }));
+    }
+    const folderName = functionsFolder.endsWith('.functions')
+        ? functionsFolder
+        : `${functionsFolder}.functions`;
+    const functionFile = filename.endsWith('.js') ? filename : `${filename}.js`;
+    const destPath = path_1.default.join(dest, folderName);
+    if (fs_extra_1.default.existsSync(destPath)) {
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createFunction.destPathAlreadyExists`, {
+            path: destPath,
+        }));
+    }
+    else {
+        fs_extra_1.default.mkdirp(destPath);
+        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)) {
+        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_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_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createFunction.createdFunctionFile`, {
+            path: functionFilePath,
+        }));
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createFunction.success`, {
+            endpointPath: endpointPath,
+            folderName,
+        }));
+    }
+    else {
+        const config = createConfig({ endpointPath, endpointMethod, functionFile });
+        try {
+            writeConfig(configFilePath, config);
+        }
+        catch (err) {
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.createFunction.failedToCreateFile`, {
+                configFilePath,
+            }));
+            throw new FileSystemError_1.FileSystemError({ cause: err }, {
+                filepath: configFilePath,
+                operation: 'write',
+            });
+        }
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createFunction.createdConfigFile`, {
+            path: configFilePath,
+        }));
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createFunction.success`, {
+            endpointPath: endpointPath,
+            folderName,
+        }));
+    }
+}
+exports.createFunction = createFunction;

package/lib/cms/handleFieldsJS.d.ts

@@ -0,0 +1,33 @@
+export declare class FieldsJs {
+    projectDir: string;
+    filePath: string;
+    rootWriteDir: string;
+    rejected: boolean;
+    fieldOptions: string;
+    outputPath?: string;
+    toJSON?: () => JSON;
+    constructor(projectDir: string, filePath: string, rootWriteDir?: string | null, fieldOptions?: string);
+    init(): Promise<this>;
+    convertFieldsJs(writeDir: string): Promise<string | void>;
+    /**
+     * If there has been a fields.json written to the output path, then copy it from the output
+     * directory to the project directory, respecting the path within the output directory.
+     * Ex: path/to/tmp/example.module/fields.json => path/to/project/example.module/fields.output.json
+     */
+    saveOutput(): void;
+    /**
+     * Resolves the relative path to the fields.js within the project directory and returns
+     * directory name to write to in rootWriteDir directory.
+     *
+     * Ex: If rootWriteDir = 'path/to/temp', filePath = 'projectRoot/sample.module/fields.js'. Then getWriteDir() => path/to/temp/sample.module
+     */
+    getWriteDir(): string;
+    getOutputPathPromise(): Promise<string | void>;
+}
+/**
+ * Determines if file is a convertable fields.js file i.e., if it is called
+ * 'fields.js' and in a root or in a module folder, and if convertFields flag is true.
+ */
+export declare function isConvertableFieldJs(rootDir: string, filePath: string, convertFields?: boolean): boolean;
+export declare function createTmpDirSync(prefix: string): string;
+export declare function cleanupTmpDirSync(tmpDir: string): void;

package/lib/cms/handleFieldsJS.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupTmpDirSync = exports.createTmpDirSync = exports.isConvertableFieldJs = exports.FieldsJs = void 0;
+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("../escapeRegExp");
+const modules_1 = require("../../utils/cms/modules");
+const logger_1 = require("../logger");
+const lang_1 = require("../../utils/lang");
+const i18nKey = 'lib.cms.handleFieldsJs';
+class FieldsJs {
+    projectDir;
+    filePath;
+    rootWriteDir;
+    rejected;
+    fieldOptions;
+    outputPath;
+    toJSON;
+    constructor(projectDir, filePath, rootWriteDir, fieldOptions = '') {
+        this.projectDir = projectDir;
+        this.filePath = filePath;
+        this.fieldOptions = fieldOptions;
+        this.rejected = false;
+        // Create tmpDir if no writeDir is given.
+        this.rootWriteDir =
+            rootWriteDir === undefined || rootWriteDir === null
+                ? createTmpDirSync('hubspot-temp-fieldsjs-output-')
+                : rootWriteDir;
+    }
+    async init() {
+        const outputPath = await this.getOutputPathPromise();
+        this.outputPath = this.rejected ? undefined : outputPath;
+        return this;
+    }
+    // Converts a fields.js file into a fields.json file, writes, and returns of fields.json
+    convertFieldsJs(writeDir) {
+        const filePath = this.filePath;
+        const dirName = path_1.default.dirname(filePath);
+        return new Promise((resolve, reject) => {
+            const convertFieldsProcess = (0, child_process_1.fork)(path_1.default.join(__dirname, './processFieldsJs.js'), [], {
+                cwd: dirName,
+                env: {
+                    dirName,
+                    fieldOptions: this.fieldOptions,
+                    filePath,
+                    writeDir,
+                },
+            });
+            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);
+                }
+                else if (message.action === 'COMPLETE') {
+                    resolve(message.finalPath);
+                }
+            });
+            convertFieldsProcess.on('close', () => {
+                logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.convertFieldsJs.terminating`, {
+                    pid: convertFieldsProcess.pid || '',
+                }));
+            });
+        }).catch((e) => {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.convertFieldsJs.errors.errorConverting`, { filePath }), { cause: e });
+        });
+    }
+    /**
+     * If there has been a fields.json written to the output path, then copy it from the output
+     * directory to the project directory, respecting the path within the output directory.
+     * Ex: path/to/tmp/example.module/fields.json => path/to/project/example.module/fields.output.json
+     */
+    saveOutput() {
+        if (!this.outputPath || !fs_extra_1.default.existsSync(this.outputPath)) {
+            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');
+        try {
+            fs_extra_1.default.copyFileSync(this.outputPath, savePath);
+        }
+        catch (err) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.saveOutput.errors.saveFailed`, { path: savePath }), { cause: err });
+        }
+    }
+    /**
+     * Resolves the relative path to the fields.js within the project directory and returns
+     * directory name to write to in rootWriteDir directory.
+     *
+     * Ex: If rootWriteDir = 'path/to/temp', filePath = 'projectRoot/sample.module/fields.js'. Then getWriteDir() => path/to/temp/sample.module
+     */
+    getWriteDir() {
+        const projectDirRegex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(this.projectDir)}`);
+        const relativePath = this.filePath.replace(projectDirRegex, '');
+        return path_1.default.dirname(path_1.default.join(this.rootWriteDir, relativePath));
+    }
+    getOutputPathPromise() {
+        const writeDir = this.getWriteDir();
+        return this.convertFieldsJs(writeDir).then(outputPath => outputPath);
+    }
+}
+exports.FieldsJs = FieldsJs;
+/**
+ * Determines if file is a convertable fields.js file i.e., if it is called
+ * 'fields.js' and in a root or in a module folder, and if convertFields flag is true.
+ */
+function isConvertableFieldJs(rootDir, filePath, convertFields = false) {
+    const allowedFieldsNames = ['fields.js', 'fields.mjs', 'fields.cjs'];
+    const regex = new RegExp(`^${(0, escapeRegExp_1.escapeRegExp)(rootDir)}`);
+    const relativePath = path_1.default.dirname(filePath.replace(regex, ''));
+    const baseName = path_1.default.basename(filePath);
+    const inModuleFolder = (0, modules_1.isModuleFolderChild)({ path: filePath, isLocal: true });
+    return !!(convertFields &&
+        allowedFieldsNames.includes(baseName) &&
+        (inModuleFolder || relativePath == path_1.default.sep));
+}
+exports.isConvertableFieldJs = isConvertableFieldJs;
+// Try creating tempdir
+function createTmpDirSync(prefix) {
+    let tmpDir;
+    try {
+        tmpDir = fs_extra_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), prefix));
+    }
+    catch (err) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.createTmpDirSync.errors.writeFailed`), {
+            cause: err,
+        });
+    }
+    return tmpDir;
+}
+exports.createTmpDirSync = createTmpDirSync;
+// Try cleaning up resources from os's tempdir
+function cleanupTmpDirSync(tmpDir) {
+    fs_extra_1.default.rm(tmpDir, { recursive: true }, err => {
+        if (err) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.cleanupTmpDirSync.errors.deleteFailed`), { cause: err });
+        }
+    });
+}
+exports.cleanupTmpDirSync = cleanupTmpDirSync;

package/lib/cms/modules.d.ts

@@ -0,0 +1,14 @@
+import { PathInput, ValidationResult, ModuleDefinition } from '../../types/Modules';
+export declare const ValidationIds: {
+    SRC_REQUIRED: string;
+    DEST_REQUIRED: string;
+    MODULE_FOLDER_REQUIRED: string;
+    MODULE_TO_MODULE_NESTING: string;
+    MODULE_NESTING: string;
+};
+export declare function validateSrcAndDestPaths(src?: PathInput, dest?: PathInput): Promise<Array<ValidationResult>>;
+export declare function createModule(moduleDefinition: ModuleDefinition, name: string, dest: string, getInternalVersion: boolean, options?: {
+    allowExistingDir: boolean;
+}): Promise<void>;
+export declare function retrieveDefaultModule(name: string | undefined, dest: string): Promise<import("../../types/Github").GithubRepoFile[] | undefined>;
+export declare const isModuleHTMLFile: (filePath: string) => boolean;

package/lib/cms/modules.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isModuleHTMLFile = exports.retrieveDefaultModule = exports.createModule = exports.validateSrcAndDestPaths = exports.ValidationIds = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_2 = require("../path");
+const fs_1 = require("../fs");
+const github_1 = require("../github");
+const logger_1 = require("../logger");
+const modules_1 = require("../../utils/cms/modules");
+const lang_1 = require("../../utils/lang");
+const i18nKey = 'lib.cms.modules';
+// Ids for testing
+exports.ValidationIds = {
+    SRC_REQUIRED: 'SRC_REQUIRED',
+    DEST_REQUIRED: 'DEST_REQUIRED',
+    MODULE_FOLDER_REQUIRED: 'MODULE_FOLDER_REQUIRED',
+    MODULE_TO_MODULE_NESTING: 'MODULE_TO_MODULE_NESTING',
+    MODULE_NESTING: 'MODULE_NESTING',
+};
+const getValidationResult = (id, message) => ({ id, message });
+async function validateSrcAndDestPaths(src, dest) {
+    const results = [];
+    if (!(0, modules_1.isPathInput)(src)) {
+        results.push(getValidationResult(exports.ValidationIds.SRC_REQUIRED, '`src` is required.'));
+    }
+    if (!(0, modules_1.isPathInput)(dest)) {
+        results.push(getValidationResult(exports.ValidationIds.DEST_REQUIRED, '`dest` is required.'));
+    }
+    if (results.length || !src || !dest) {
+        return results;
+    }
+    const [_src, _dest] = [src, dest].map(inputPath => {
+        const result = { ...inputPath };
+        if (result.isLocal) {
+            result.path = path_1.default.resolve((0, path_2.getCwd)(), result.path);
+        }
+        else if (result.isHubSpot) {
+            result.path = path_1.default.posix.normalize(result.path);
+        }
+        return result;
+    });
+    // src is a .module folder and dest is within a module. (Nesting)
+    // e.g. `upload foo.module bar.module/zzz`
+    if ((0, modules_1.isModuleFolder)(_src) && (0, modules_1.isModuleFolderChild)(_dest)) {
+        return results.concat(getValidationResult(exports.ValidationIds.MODULE_TO_MODULE_NESTING, '`src` is a module path and `dest` is within a module.'));
+    }
+    // src is a .module folder but dest is not
+    // e.g. `upload foo.module bar`
+    if ((0, modules_1.isModuleFolder)(_src) && !(0, modules_1.isModuleFolder)(_dest)) {
+        return results.concat(getValidationResult(exports.ValidationIds.MODULE_FOLDER_REQUIRED, '`src` is a module path but `dest` is not.'));
+    }
+    // src is a folder that includes modules and dest is within a module. (Nesting)
+    if (_src.isLocal && (0, modules_1.isModuleFolderChild)(_dest)) {
+        const stat = await fs_extra_1.default.stat(_src.path);
+        if (stat.isDirectory()) {
+            const files = await (0, fs_1.walk)(_src.path);
+            const srcHasModulesChildren = files.some(file => (0, modules_1.isModuleFolderChild)({ ..._src, path: file }));
+            if (srcHasModulesChildren) {
+                return results.concat(getValidationResult(exports.ValidationIds.MODULE_NESTING, '`src` contains modules and `dest` is within a module.'));
+            }
+        }
+    }
+    return results;
+}
+exports.validateSrcAndDestPaths = validateSrcAndDestPaths;
+/* createModule() helper
+ * Takes a file and uses the constants above to transform the contents
+ */
+// Strings to replace in React module files
+const MODULE_STRING_TRANSFORMATIONS = [
+    {
+        regex: /\/\* import global styles \*\//g,
+        string: 'import "./global-sample-react-module.css";',
+        fallback: '',
+    },
+    {
+        regex: /\/\* Default config \*\//g,
+        string: 'export const defaultModuleConfig = { \n  moduleName: "sample_react-module", \n  version: 0, \n};',
+        fallback: '',
+    },
+];
+const updateFileContents = async (file, metaData, getInternalVersion) => {
+    try {
+        let fileContents = await fs_extra_1.default.readFile(file, 'utf8'); // returns Promise
+        MODULE_STRING_TRANSFORMATIONS.forEach(entry => {
+            const replacementString = getInternalVersion
+                ? entry.string
+                : entry.fallback;
+            fileContents = fileContents.replace(entry.regex, replacementString);
+        });
+        await fs_extra_1.default.writeFile(file, fileContents, 'utf8');
+        await fs_extra_1.default.appendFile(file, 'export const meta = ' + JSON.stringify(metaData, null, ' '));
+    }
+    catch (error) {
+        const { message } = error;
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.createModule.errors.fileUpdateFailure`, {
+            path: file,
+            errorMessage: message,
+        }));
+    }
+};
+async function createModule(moduleDefinition, name, dest, getInternalVersion, options = {
+    allowExistingDir: false,
+}) {
+    const { moduleLabel, contentTypes, global, reactType: isReactModule, availableForNewContent, } = moduleDefinition;
+    const moduleMetaData = {
+        label: moduleLabel,
+        css_assets: [],
+        external_js: [],
+        global: global,
+        help_text: '',
+        content_types: contentTypes,
+        js_assets: [],
+        other_assets: [],
+        smart_type: 'NOT_SMART',
+        tags: [],
+        is_available_for_new_content: availableForNewContent,
+    };
+    const folderName = name.endsWith('.module') ? name : `${name}.module`;
+    const destPath = !isReactModule
+        ? path_1.default.join(dest, folderName)
+        : path_1.default.join(dest, `${name}`);
+    if (!options.allowExistingDir && fs_extra_1.default.existsSync(destPath)) {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.createModule.errors.pathExists`, {
+            path: destPath,
+        }));
+    }
+    else {
+        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createModule.creatingPath`, {
+            path: destPath,
+        }));
+        fs_extra_1.default.ensureDirSync(destPath);
+    }
+    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.createModule.creatingModule`, {
+        path: destPath,
+    }));
+    // Filter out certain fetched files from the response
+    const moduleFileFilter = (src, dest) => {
+        const emailEnabled = moduleDefinition.contentTypes.includes('EMAIL');
+        switch (path_1.default.basename(src)) {
+            case 'meta.json':
+                fs_extra_1.default.writeJSONSync(dest, moduleMetaData, { spaces: 2 }); // writing a meta.json file to standard HubL modules
+                return false;
+            case 'module.js':
+            case 'module.css':
+                if (emailEnabled) {
+                    return false;
+                }
+                return true;
+            case 'global-sample-react-module.css':
+            case 'stories':
+            case 'tests':
+                if (getInternalVersion) {
+                    return true;
+                }
+                return false;
+            default:
+                return true;
+        }
+    };
+    // Download gitHub contents to the dest directory
+    const sampleAssetPath = !isReactModule
+        ? 'Sample.module'
+        : 'SampleReactModule';
+    await (0, github_1.downloadGithubRepoContents)('HubSpot/cms-sample-assets', `modules/${sampleAssetPath}`, destPath, '', moduleFileFilter);
+    // Updating React module files after fetch
+    if (isReactModule) {
+        await updateFileContents(`${destPath}/index.tsx`, moduleMetaData, getInternalVersion);
+    }
+}
+exports.createModule = createModule;
+async function retrieveDefaultModule(name, dest) {
+    if (!name) {
+        const defaultReactModules = await (0, github_1.listGithubRepoContents)('HubSpot/cms-react', 'default-react-modules/src/components/modules/', 'dir');
+        return defaultReactModules;
+    }
+    await (0, github_1.downloadGithubRepoContents)('HubSpot/cms-react', `default-react-modules/src/components/modules/${name}`, dest);
+}
+exports.retrieveDefaultModule = retrieveDefaultModule;
+const MODULE_HTML_EXTENSION_REGEX = new RegExp(/\.module(?:\/|\\)module\.html$/);
+const isModuleHTMLFile = (filePath) => MODULE_HTML_EXTENSION_REGEX.test(filePath);
+exports.isModuleHTMLFile = isModuleHTMLFile;

package/lib/cms/processFieldsJs.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/cms/processFieldsJs.js

@@ -0,0 +1,97 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const semver_1 = __importDefault(require("semver"));
+const url_1 = require("url");
+const path_2 = require("../path");
+const lang_1 = require("../../utils/lang");
+const i18nKey = 'lib.cms.processFieldsJs';
+const { dirName, fieldOptions, filePath, writeDir } = process.env;
+const baseName = path_1.default.basename(filePath);
+//TODO - Figure out agnostic logging
+console.info((0, lang_1.i18n)(`${i18nKey}.converting`, {
+    src: dirName + `/${baseName}`,
+    dest: dirName + '/fields.json',
+}));
+/*
+ * How this works: dynamicImport() will always return either a Promise or undefined.
+ * In the case when it's a Promise, its expected that it will resolve to a function.
+ * This function has optional return type of Promise<Array> | Array. In order to have uniform handling,
+ * we wrap the return value of the function in a Promise.resolve(), and then process.
+ */
+const fieldsPromise = dynamicImport(filePath).catch(e => {
+    throw e;
+});
+fieldsPromise.then(fieldsFunc => {
+    const fieldsFuncType = typeof fieldsFunc;
+    if (fieldsFuncType !== 'function') {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.notFunction`, {
+            path: filePath,
+            returned: fieldsFuncType,
+        }));
+    }
+    return Promise.resolve(fieldsFunc(fieldOptions)).then(fields => {
+        if (!Array.isArray(fields)) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.notArray`, {
+                path: filePath,
+                returned: typeof fields,
+            }));
+        }
+        const finalPath = path_1.default.join(writeDir, '/fields.json');
+        return fieldsArrayToJson(fields).then(json => {
+            if (!fs_1.default.existsSync(writeDir)) {
+                fs_1.default.mkdirSync(writeDir, { recursive: true });
+            }
+            fs_1.default.writeFileSync(finalPath, json);
+            //TODO - Figure out agnostic logging
+            console.log((0, lang_1.i18n)(`${i18nKey}.converted`, {
+                src: dirName + `/${baseName}`,
+                dest: dirName + '/fields.json',
+            }));
+            if (process) {
+                process.send({
+                    action: 'COMPLETE',
+                    finalPath,
+                });
+            }
+        });
+    });
+});
+/*
+ * Polyfill for `Array.flat(Infinity)` since the `flat` is only available for Node v11+
+ * https://stackoverflow.com/a/15030117
+ */
+function flattenArray(arr) {
+    return arr.reduce((flat, toFlatten) => {
+        return flat.concat(Array.isArray(toFlatten) ? flattenArray(toFlatten) : toFlatten);
+    }, []);
+}
+async function fieldsArrayToJson(fields) {
+    const allFields = await Promise.all(flattenArray(fields));
+    const jsonFields = allFields.map(field => {
+        return typeof field['toJSON'] === 'function' ? field.toJSON() : field;
+    });
+    return JSON.stringify(jsonFields, null, 2);
+}
+/**
+ * Takes in a path to a javascript file and either dynamically imports it or requires it, and returns, depending on node version.
+ * @param {string} filePath - Path to javascript file
+ * @returns {Promise | undefined} - Returns _default_ exported content if ESM, or exported module content if CJS, or undefined if node version < 13.2 and file is .mjs.
+ */
+async function dynamicImport(filePath) {
+    if (semver_1.default.gte(process.version, '13.2.0')) {
+        const exported = await new Function(`return import("${(0, url_1.pathToFileURL)(filePath)}")`)();
+        return exported.default;
+    }
+    else {
+        if ((0, path_2.getExt)(filePath) == 'mjs') {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidMjsFile`));
+        }
+        return require(filePath);
+    }
+}