@hubspot/local-dev-lib 0.0.4 → 0.0.6

package/lang/en.lyaml

@@ -0,0 +1,247 @@
+en:
+  debug:
+    archive:
+      extractZip:
+        init: "Extracting project source..."
+        success: "Completed project source extraction."
+      copySourceToDest:
+        init: "Copying project source..."
+        sourceEmpty: "Project source is empty"
+        success: "Completed copying project source."
+        error: "An error occured copying project source to {{ dest }}."
+      cleanupTempDir:
+        error: "Failed to clean up temp dir: {{ tmpDir }}"
+    github:
+      fetchJsonFromRepository: "Fetching {{ url }}..."
+      downloadGithubRepoZip:
+        fetching: "Fetching {{ releaseType }} with name {{ repoName }}..."
+        fetchingName: "Fetching {{ name }}..."
+        completed: "Completed project fetch."
+      cloneGithubRepo:
+        success: "Your new {{ type }} has been created in {{ dest }}"
+      downloadGithubRepoContents:
+        downloading: "Downloading content piece: {{ contentPiecePath }} from {{ downloadUrl }} to {{ downloadPath }}"
+    git:
+      securityIssue: "Security Issue Detected"
+      configFileTracked: "The HubSpot config file can be tracked by git."
+      fileName: 'File: "{{ configPath }}"'
+      remediate: "To remediate:"
+      moveConfig: "- Move the config file to your home directory: '{{ homeDir }}'"
+      addGitignore: "- Add gitignore pattern '{{ configPath }}' to a .gitignore file in root of your repository."
+      noRemote: "- Ensure that the config file has not already been pushed to a remote repository."
+      checkFailed: "Unable to determine if config file is properly ignored by git."
+    modules:
+      createModule:
+        creatingModule: "Creating module at {{ path }}"
+        creatingPath: "Creating {{ path }}"
+    oauth:
+      writeTokenInfo: "Updating Oauth2 token info for portalId: {{ portalId }}"
+      addOauthToAccountConfig:
+        init: "Updating configuration"
+        success: "Configuration updated"
+    filemapper:
+      skippedExisting: "Skipped existing {{ filepath }}"
+      wroteFolder: "Wrote folder {{ filepath }}"
+      completedFetch: 'Completed fetch of file "{{ src }}"{{ version }} to "{{ dest }}" from the Design Manager'
+      folderFetch: 'Fetched "{{ src }}" from account {{ accountId }} from the Design Manager successfully'
+      completedFolderFetch: 'Completed fetch of folder "{{ src }}"{{ version }} to "{{ dest }}" from the Design Manager'
+    watch:
+      notifyOfThemePreview: "To preview this theme, visit: {{ previewUrl }}"
+      skipUnsupportedExtension: "Skipping {{ file }} due to unsupported extension"
+      skipIgnoreRule: "Skipping {{ file }} due to an ignore rule"
+      uploadAttempt: 'Attempting to upload file "{{ file }}" to "{{ dest }}"'
+      uploadSuccess: "Uploaded file {{ file }} to {{ dest }}"
+      uploadFailed: "Uploading file {{ file }} to {{ dest }} failed"
+      uploadRetry: 'Retrying to upload file "{{ file }}" to "{{ dest }}"'
+      deleteAttempt: "Attempting to delete file {{ remoteFilePath }}"
+      deleteAttemptWithType: "Attempting to delete {{ type }} {{ remoteFilePath }}"
+      deleteSuccess: "Deleted file {{ remoteFilePath }}"
+      deleteSuccessWithType: "Deleted {{ type }} {{ remoteFilePath }}"
+      deleteFailed: "Deleting file {{ remoteFilePath }} failed"
+      folderUploadSuccess: "Completed uploading files in {{ src }} to {{ dest }} in {{ accountId }}"
+      ready: "Watcher is ready and watching {{ src }}. Any changes detected will be automatically uploaded and overwrite the current version in the developer file system."
+    config:
+      cliConfiguration:
+        load:
+          configFromEnv: "Loaded config from environment variables for {{ accountId }}"
+          configFromFile: "Loaded config from configuration file."
+          empty: "The config file was empty. Initializing an empty config."
+        validate:
+          noConfig: "Valiation failed: No config was found."
+          noConfigAccounts: "Valiation failed: config.accounts[] is not defined."
+          emptyAccountConfig: "Valiation failed: config.accounts[] has an empty entry."
+          noAccountId: "Valiation failed: config.accounts[] has an entry missing accountId."
+          duplicateAccountIds: "Valiation failed: config.accounts[] has multiple entries with {{ accountId }}."
+          duplicateAccountNames: "Valiation failed: config.accounts[] has multiple entries with {{ accountName }}."
+          nameContainsSpaces: "Valiation failed: config.name {{ accountName }} cannot contain spaces."
+        updateAccount:
+          noConfigToUpdate: "No config to update."
+          updating: "Updating account config for {{ accountId }}"
+          addingConfigEntry: "Adding account config entry for {{ accountId }}"
+        removeAccountFromConfig: "Deleting config for {{ accountId }}"
+      configFile:
+        errorReading: "Config file could not be read: {{ configPath }}"
+        writeSuccess: "Successfully wrote updated config data to {{ configPath }}"
+        errorLoading: "A configuration file could not be found at {{ configPath }}."
+      configUtils:
+        unknownType: "Unknown auth type {{ type }}"
+    environment:
+      loadConfig:
+        missingAccountId: "Unable to load config from environment variables: Missing accountId"
+        missingEnv: "Unable to load config from environment variables: Missing env"
+        unknownAuthType: "Unable to load config from environment variables: Unknown auth type"
+    cms:
+      functions:
+        updateExistingConfig:
+          unableToReadFile: "The file {{ configFilePath }} could not be read"
+          invalidJSON: "The file {{ configFilePath }} is not valid JSON"
+          couldNotUpdateFile: "The file {{ configFilePath }} could not be updated"
+        createFunction:
+          destPathAlreadyExists: "The {{ path }} path already exists"
+          createdDest: "Created {{ path }}"
+          failedToCreateFile: "The file {{ configFilePath }} could not be created"
+          createdFunctionFile: "Created {{ path }}"
+          createdConfigFile: "Created {{ path }}"
+          success: "A function for the endpoint '/_hcms/api/{{ endpointPath }}' has been created. Upload {{ folderName }} to try it out"
+      handleFieldsJs:
+        convertFieldsJs:
+          creating: "Creating child process with pid {{ pid }}"
+          terminating: "Child process with pid {{ pid }} has been terminated"
+      uploadFolder:
+        attempt: 'Attempting to upload file "{{ file }}" to "{{ destPath }}"'
+        success: 'Uploaded file "{{ file}}" to "{{ destPath }}"'
+        failed: 'Uploading file "{{ file }}" to "{{ destPath }}" failed so scheduled retry'
+        retry: 'Retrying to upload file "{{ file }}" to "{{ destPath }}"'
+        retryFailed: 'Uploading file "{{ file }}" to "{{ destPath }}" failed'
+    models:
+      OAuth2Manager:
+        fetchingAccessToken: "Fetching access token for accountId {{ accountId }} for clientId {{ clientId }}"
+        updatingTokenInfo: "Persisting updated tokenInfo for accountId {{ accountId }} for clientId {{ clientId }}"
+        refreshingAccessToken: "Waiting for access token for accountId {{ accountId }}  for clientId {{ clientId }} to be fetched"
+    http:
+      index:
+        createGetRequestStream:
+          onWrite: "Wrote file {{ filepath }}"
+    api:
+      filemapper:
+        trackUsage:
+          invalidEvent: "Usage tracking event {{ eventName }} is not a valid event type."
+          sendingEventAuthenticated: "Sending usage event to authenticated endpoint"
+          sendingEventUnauthenticated: "Sending usage event to unauthenticated endpoint"
+    templates:
+      debug:
+        creatingPath: "Making {{ path }} if needed"
+      logging:
+        creatingFile: "Creating file at {{ path }}"
+    processFieldsJs:
+      converting: "Converting \"{{ src }}\" to \"{{ dest }}\"."
+      converted: "Finished converting \"{{ src }}\" to \"{{ dest }}\"."
+  errors:
+    hubdb:
+      invalidJsonPath: "The HubDB table file must be a '.json' file"
+      invalidJsonFile: "The '{{{ src }}' path is not a path to a file"
+    archive:
+      extractZip:
+        write: "An error occured writing temp project source."
+        extract: "An error occured extracting project source."
+    errorTypes:
+      fileSystem:
+        readAction: "reading from"
+        writeAction: "writing to"
+        otherAction: "accessing"
+        unknownFilepath: "a file or folder"
+        baseMessage: "An error occurred while {{ fileAction }} {{ filepath }}."
+        systemErrorMessage: "This is the result of a system error: {{ errorMessage }}"
+      api:
+        messageDetail: "{{ request }} in account {{ accountId }}"
+        unableToUpload: 'Unable to upload "{{ payload }}.'
+        codes:
+          400: "The {{ messageDetail }} was bad."
+          401: "The {{ messageDetail }} was unauthorized."
+          403MissingScope: "Couldn't run the project command because there are scopes missing in your production account. To update scopes, deactivate your current personal access key for {{ accountId }}, and generate a new one. Then run `hs auth` to update the CLI with the new key."
+          403Gating: "The current target account {{ accountId }} does not have access to HubSpot projects. To opt in to the CRM Development Beta and use projects, visit https://app.hubspot.com/l/whats-new/betas?productUpdateId=13860216."
+          403: "The {{ messageDetail }} was forbidden."
+          404Request: 'The {{ action }} failed because "{{ request }}" was not found in account {{ accountId }}.'
+          404: "The {{ messageDetail }} was not found."
+          429: "The {{ messageDetail }} surpassed the rate limit. Retry in one minute."
+          503: "The {{ messageDetail }} could not be handled at this time. Please try again or visit https://help.hubspot.com/ to submit a ticket or contact HubSpot Support if the issue persists."
+          500generic: "The {{ messageDetail }} failed due to a server error. Please try again or visit https://help.hubspot.com/ to submit a ticket or contact HubSpot Support if the issue persists."
+          400generic: "The {{ messageDetail }} failed due to a client error."
+          generic: "The {{ messageDetail }} failed."
+      cmsFields:
+        syntax: 'There was an error converting JS file "{{ path }}"'
+        notFunction: 'There was an error loading JS file "{{ path }}". Expected type "Function" but received type "{{ returned }}". Make sure that your default export is a function.'
+        notReturnArray: 'There was an error loading JS file "{{ path }}". Expected type "Array" but received type "{{ returned }}" . Make sure that your function returns an array'
+        invalidPath: 'The path "{{ path }}" is not a path to a file or folder'
+      generic: "A {{ name }} has occurred"
+    filemapper:
+      invalidNode: "Invalid FileMapperNode: {{ json }}"
+      invalidFileType: "Invalid file type requested: {{ srcPath }}"
+      assetTimeout: "HubSpot assets are unavailable at the moment. Please wait a few minutes and try again."
+      failedToFetchFile: 'Failed fetch of file "{{ src }}" to "{{ dest }}" from the Design Manager'
+      failedToFetchFolder: 'Failed fetch of folder "{{ src }}" to "{{ dest }}" from the Design Manager'
+      invalidFetchFolderRequest: 'Invalid request for folder: "{{ src }}"'
+      incompleteFetch: 'Not all files in folder "{{ src }}" were successfully fetched.  Re-run the last command to try again'
+    github:
+      downloadGithubRepoContents: "Failed to fetch contents: {{ errorMessage }}"
+      fetchJsonFromRepository: "An error occured fetching JSON file."
+      fetchReleaseData: "Failed fetching release data for {{ tag }} project."
+      downloadGithubRepoZip: "An error occurred fetching the project source."
+    modules:
+      throwInvalidPathInput: "Expected Path Input"
+      writeModuleMeta: "The {{ path }} path already exists"
+    personalAccessKey:
+      accountNotFound: "Account with id {{ accountId }} does not exist."
+      invalidPersonalAccessKey: "Error while retrieving new access token: {{ errorMessage }}"
+    templates:
+      fileAnnotations: "Error reading file annotations {{ file }}"
+      pathExists: "The {{ path }} path already exists"
+    utils:
+      git:
+        configIgnore: "Unable to determine if config file is properly ignored by git."
+      notify:
+        filePath: "Unable to notify file '{{ filePath }}'"
+    config:
+      cliConfiguration:
+        noConfigLoaded: "No config loaded."
+        updateAccount: "An accountId is required to update the config"
+        updateDefaultAccount: "A 'defaultAccount' with value of number or string is required to update the config."
+        renameAccount: "Cannot find account with identifier {{ currentName }}"
+        removeAccountFromConfig: "Unable to find account for {{ nameOrId }}."
+        updateDefaultMode: "The mode {{ defaultMode }} is invalid. Valid values are {{ validModes }}."
+        updateHttpTimeout: "The value {{ timeout }} is invalid. The value must be a number greater than {{ minTimeout }}."
+        updateAllowUsageTracking: "Unable to update allowUsageTracking. The value {{ isEnabled }} is invalid. The value must be a boolean."
+      configFile:
+        parsing: "Config file could not be parsed"
+    models:
+      OAuth2Manager:
+        missingRefreshToken: "The account {{ accountId }} has not been authenticated with Oauth2"
+        auth: "Error while retrieving new token: {{ token }}"
+    http:
+      index:
+        withOauth: "Oauth manager for account {{ accountId }} not found."
+        withAuth: "Account with id {{ accountId }} not found."
+    cms:
+      handleFieldsJs:
+        convertFieldsJs: "There was an error converting '{{ filePath }}'"
+        saveOutput: "There was an error saving the json output of {{ path }}"
+        createTmpDirSync: "An error occured writing temporary project source."
+        cleanupTmpDirSync: "There was an error deleting the temporary project source"
+      functions:
+        updateExistingConfig:
+          configIsNotObjectError: "The existing {{ configFilePath }} is not an object"
+          endpointAreadyExistsError: "The endpoint {{ endpointPath }} already exists in {{ configFilePath }}"
+        createFunction:
+          nestedConfigError: "Cannot create a functions directory inside '{{ ancestorConfigPath }}'"
+          jsFileConflictError: "The JavaScript file at '{{ functionFilePath }}'' already exists"
+    sandboxes:
+      createSandbox: "There was an error creating your sandbox."
+      deleteSandbox: "There was an error deleting your sandbox."
+      getSandboxUsageLimits: "There was an error fetching sandbox usage limits."
+      initiateSync: "There was an error initiating the sandbox sync."
+      fetchTaskStatus: "There was an error fetching the task status while syncing sandboxes."
+      fetchTypes: "There was an error fetching sandbox types."
+    processFieldsJs:
+      fieldsJsNotReturnArray: "There was an error loading JS file \"{{ path }}\". Expected type \"Array\". Make sure that your function returns an array"
+      fieldsJsNotFunction:  "There was an error loading JS file \"{{ path }}\". Expected type \"Function\". Make sure that your default export is a function."
+      invalidMjsFile: ".mjs files are only supported when using Node 13.2.0+"

package/lib/cms/functions.d.ts

@@ -0,0 +1,13 @@
+import { LogCallbacksArg } from '../../types/LogCallbacks';
+type FunctionInfo = {
+    functionsFolder: string;
+    filename: string;
+    endpointPath: string;
+    endpointMethod: string;
+};
+type FunctionOptions = {
+    allowExistingFile?: boolean;
+};
+declare const createFunctionCallbackKeys: string[];
+export declare function createFunction(functionInfo: FunctionInfo, dest: string, options: FunctionOptions, logCallbacks?: LogCallbacksArg<typeof createFunctionCallbackKeys>): Promise<void>;
+export {};

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 = 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 objectUtils_1 = require("../../utils/objectUtils");
+const standardErrors_1 = require("../../errors/standardErrors");
+const fileSystemErrors_1 = require("../../errors/fileSystemErrors");
+const i18nKey = 'cms.functions';
+function createEndpoint(endpointMethod, filename) {
+    return {
+        method: endpointMethod || 'GET',
+        file: filename,
+    };
+}
+function createConfig({ endpointPath, endpointMethod, functionFile, }) {
+    return {
+        runtime: 'nodejs18.x',
+        version: '1.0',
+        environment: {},
+        secrets: [],
+        endpoints: {
+            [endpointPath]: createEndpoint(endpointMethod, functionFile),
+        },
+    };
+}
+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) {
+        (0, logger_1.debug)(`${i18nKey}.updateExistingConfig.unableToReadFile`, {
+            configFilePath,
+        });
+        (0, fileSystemErrors_1.throwFileSystemError)(err, {
+            filepath: configFilePath,
+            read: true,
+        });
+    }
+    let config;
+    try {
+        config = JSON.parse(configString);
+    }
+    catch (err) {
+        (0, logger_1.debug)(`${i18nKey}.updateExistingConfig.invalidJSON`, {
+            configFilePath,
+        });
+        (0, fileSystemErrors_1.throwFileSystemError)(err, {
+            filepath: configFilePath,
+            read: true,
+        });
+    }
+    if (!(0, objectUtils_1.isObject)(config)) {
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.updateExistingConfig.configIsNotObjectError`, { configFilePath });
+    }
+    if (config.endpoints) {
+        if (config.endpoints[endpointPath]) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.updateExistingConfig.endpointAreadyExistsError`, {
+                configFilePath,
+                endpointPath,
+            });
+        }
+        else {
+            config.endpoints[endpointPath] = createEndpoint(endpointMethod, functionFile);
+        }
+    }
+    else {
+        config.endpoints = {
+            [endpointPath]: createEndpoint(endpointMethod, functionFile),
+        };
+    }
+    try {
+        writeConfig(configFilePath, config);
+    }
+    catch (err) {
+        (0, logger_1.debug)(`${i18nKey}.updateExistingConfig.couldNotUpdateFile`, {
+            configFilePath,
+        });
+        (0, fileSystemErrors_1.throwFileSystemError)(err, {
+            filepath: configFilePath,
+            write: true,
+        });
+    }
+}
+const createFunctionCallbackKeys = [
+    'destPathAlreadyExists',
+    'createdDest',
+    'createdFunctionFile',
+    'createdConfigFile',
+    'success',
+];
+async function createFunction(functionInfo, dest, options, logCallbacks) {
+    const logger = (0, logger_1.makeTypedLogger)(logCallbacks, `${i18nKey}.createFunction`);
+    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) {
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.createFunction.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('destPathAlreadyExists', {
+            path: destPath,
+        });
+    }
+    else {
+        fs_extra_1.default.mkdirp(destPath);
+        logger('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.jsFileConflictError`, {
+            functionFilePath,
+        });
+    }
+    await (0, github_1.downloadGithubRepoContents)('HubSpot/cms-sample-assets', 'functions/sample-function.js', functionFilePath);
+    logger('createdFunctionFile', {
+        path: functionFilePath,
+    });
+    if (fs_extra_1.default.existsSync(configFilePath)) {
+        updateExistingConfig(configFilePath, {
+            endpointPath,
+            endpointMethod,
+            functionFile,
+        });
+        logger('createdFunctionFile', {
+            path: functionFilePath,
+        });
+        logger('success', {
+            endpointPath: endpointPath,
+            folderName,
+        });
+    }
+    else {
+        const config = createConfig({ endpointPath, endpointMethod, functionFile });
+        try {
+            writeConfig(configFilePath, config);
+        }
+        catch (err) {
+            (0, logger_1.debug)(`${i18nKey}.createFunction.failedToCreateFile`, {
+                configFilePath,
+            });
+            (0, fileSystemErrors_1.throwFileSystemError)(err, {
+                filepath: configFilePath,
+                write: true,
+            });
+        }
+        logger('createdConfigFile', {
+            path: configFilePath,
+        });
+        logger('success', {
+            endpointPath: endpointPath,
+            folderName,
+        });
+    }
+}
+exports.createFunction = createFunction;

package/lib/cms/handleFieldsJS.d.ts

@@ -5,7 +5,8 @@ export declare class FieldsJs {
     rejected: boolean;
     fieldOptions: string;
     outputPath?: string;
-    constructor(projectDir: string, filePath: string, rootWriteDir?: string, fieldOptions?: string);
+    toJSON?: () => JSON;
+    constructor(projectDir: string, filePath: string, rootWriteDir?: string | null, fieldOptions?: string);
     init(): Promise<this>;
     convertFieldsJs(writeDir: string): Promise<string | void>;
     /**

package/lib/cms/handleFieldsJS.js

@@ -9,10 +9,10 @@ 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 modules_1 = require("../../utils/modules");
+const modules_1 = require("../../utils/cms/modules");
 const logger_1 = require("../../utils/logger");
 const standardErrors_1 = require("../../errors/standardErrors");
-const i18nKey = 'utils.handleFieldsJs';
+const i18nKey = 'cms.handleFieldsJs';
 class FieldsJs {
     projectDir;
     filePath;
@@ -20,6 +20,7 @@ class FieldsJs {
     rejected;
     fieldOptions;
     outputPath;
+    toJSON;
     constructor(projectDir, filePath, rootWriteDir, fieldOptions = '') {
         this.projectDir = projectDir;
         this.filePath = filePath;
@@ -27,7 +28,7 @@ class FieldsJs {
         this.rejected = false;
         // Create tmpDir if no writeDir is given.
         this.rootWriteDir =
-            rootWriteDir === undefined
+            rootWriteDir === undefined || rootWriteDir === null
                 ? createTmpDirSync('hubspot-temp-fieldsjs-output-')
                 : rootWriteDir;
     }

package/lib/cms/modules.js

@@ -11,7 +11,7 @@ const fs_1 = require("../fs");
 const github_1 = require("../github");
 const standardErrors_1 = require("../../errors/standardErrors");
 const logger_1 = require("../../utils/logger");
-const modules_1 = require("../../utils/modules");
+const modules_1 = require("../../utils/cms/modules");
 // Ids for testing
 exports.ValidationIds = {
     SRC_REQUIRED: 'SRC_REQUIRED',
@@ -106,7 +106,7 @@ async function createModule(moduleDefinition, name, dest, options = {
     const folderName = !name || name.endsWith('.module') ? name : `${name}.module`;
     const destPath = path_1.default.join(dest, folderName);
     if (!options.allowExistingDir && fs_extra_1.default.existsSync(destPath)) {
-        (0, standardErrors_1.throwErrorWithMessage)('modules.createModule', {
+        (0, standardErrors_1.throwErrorWithMessage)('modules.writeModuleMeta', {
             path: destPath,
         });
     }
@@ -119,6 +119,6 @@ async function createModule(moduleDefinition, name, dest, options = {
     logger('creatingModule', {
         path: destPath,
     });
-    await (0, github_1.downloadGithubRepoContents)('cms-sample-assets', 'modules/Sample.module', destPath, moduleFileFilter);
+    await (0, github_1.downloadGithubRepoContents)('HubSpot/cms-sample-assets', 'modules/Sample.module', destPath, '', moduleFileFilter);
 }
 exports.createModule = createModule;

package/lib/cms/processFieldsJs.d.ts

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

package/lib/cms/processFieldsJs.js

@@ -0,0 +1,122 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 standardErrors_1 = require("../../errors/standardErrors");
+const lang_1 = require("../../utils/lang");
+const i18nKey = 'processFieldsJs';
+const { dirName, fieldOptions, filePath, writeDir } = process.env;
+const baseName = path_1.default.basename(filePath);
+const FieldErrors = {
+    IsNotFunction: 'IsNotFunction',
+    DoesNotReturnArray: 'DoesNotReturnArray',
+};
+//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 => (0, standardErrors_1.throwError)(e));
+fieldsPromise.then(fieldsFunc => {
+    const fieldsFuncType = typeof fieldsFunc;
+    if (fieldsFuncType !== 'function') {
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.${FieldErrors.IsNotFunction}`, {
+            path: filePath,
+        });
+    }
+    return Promise.resolve(fieldsFunc(fieldOptions)).then(fields => {
+        if (!Array.isArray(fields)) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.${FieldErrors.DoesNotReturnArray}`, {
+                path: filePath,
+            });
+        }
+        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) {
+    var _a;
+    if (semver_1.default.gte(process.version, '13.2.0')) {
+        const exported = await (_a = (0, url_1.pathToFileURL)(filePath).toString(), Promise.resolve().then(() => __importStar(require(_a)))).then(content => content.default);
+        return exported;
+    }
+    else {
+        if ((0, path_2.getExt)(filePath) == 'mjs') {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.invalidMjsFile`);
+        }
+        return require(filePath);
+    }
+}

package/lib/cms/templates.d.ts

@@ -0,0 +1,25 @@
+import { LogCallbacksArg } from '../../types/LogCallbacks';
+export declare const ANNOTATION_KEYS: {
+    isAvailableForNewContent: string;
+    templateType: string;
+    label: string;
+    screenshotPath: string;
+    description: string;
+};
+export declare function getAnnotationValue(annotations: string, key: string): string | null;
+export declare function isCodedFile(filePath: string): boolean;
+declare const ASSET_PATHS: {
+    readonly 'page-template': "templates/page-template.html";
+    readonly partial: "templates/partial.html";
+    readonly 'global-partial': "templates/global-partial.html";
+    readonly 'email-template': "templates/email-template.html";
+    readonly 'blog-listing-template': "templates/blog-listing-template.html";
+    readonly 'blog-post-template': "templates/blog-post-template.html";
+    readonly 'search-template': "templates/search-template.html";
+    readonly section: "templates/section.html";
+};
+declare const templatesCallbackKeys: string[];
+export declare function createTemplate(name: string, dest: string, type?: keyof typeof ASSET_PATHS, options?: {
+    allowExisting: boolean;
+}, logCallbacks?: LogCallbacksArg<typeof templatesCallbackKeys>): Promise<void>;
+export {};