@hubspot/local-dev-lib 0.0.4 → 0.0.6

package/types/HublValidation.d.ts

@@ -0,0 +1,59 @@
+export type HublValidationOptions = {
+    is_available_for_new_content?: boolean;
+    template_type?: string;
+    template_path?: string;
+    module_path?: string;
+};
+export type HubLValidationError = {
+    reason: string;
+    message: string;
+    lineno: number;
+    startPosition: number;
+    categoryErrors: {
+        fullName?: string;
+        path?: string;
+    };
+    category: string;
+    severity?: string;
+};
+export type LintResult = {
+    file: string;
+    validation: Validation | null;
+};
+export type Validation = {
+    meta: {
+        all_widgets: Array<string>;
+        widgets_in_rich_text: Array<string>;
+        editable_flex_areas: Array<string>;
+        editable_layout_sections: {
+            key: string;
+        } | null;
+        email_style_settings: {
+            key: string;
+        } | null;
+        sms_flex_area: Array<string>;
+        google_font_variations: {
+            key: string;
+        } | null;
+        custom_font_variations: Array<string>;
+        has_style_tag: boolean;
+        has_header_tag: boolean;
+        output_html: string;
+        has_menu_tag: boolean;
+        has_theme_setting_function: boolean;
+        template_source: string;
+        attribute_defaults?: {
+            key: string;
+        } | null;
+        template_errors: Array<HubLValidationError>;
+        path_dependencies: Array<string>;
+        theme_field_dependencies: Array<string>;
+        template_type_ids?: {
+            key: string;
+        } | null;
+        exact_path_references: Array<string>;
+        required_scopes_to_render: Array<string>;
+    };
+    renderingErrors: Array<HubLValidationError>;
+    html: string;
+};

package/types/HublValidation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/Lighthouse.d.ts

@@ -0,0 +1,25 @@
+export type RequestLighthouseScoreResponse = {
+    desktopId: number;
+    mobileId: number;
+};
+export type GetLighthouseScoreResponse = {
+    portalId: number;
+    themePath: string;
+    status: string;
+    scores: [
+        {
+            accessibilityScore: number;
+            bestPracticesScore: number;
+            performanceScore: number;
+            pwaScore: number;
+            seoScore: number;
+            runWarnings: Array<string>;
+            auditDetails: null;
+            emulatedFormFactor: string;
+            templatePath: string | null;
+            link: string | null;
+        }
+    ];
+    failedTemplatePaths: Array<string>;
+    error: Error | null;
+};

package/types/Lighthouse.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/MarketplaceValidation.d.ts

@@ -0,0 +1,28 @@
+type Check = {
+    check: string;
+    status: string;
+    title: string;
+    documentationLink: string;
+    message: string | null;
+    description: string;
+    line: number | null;
+    file: string;
+};
+export type GetValidationResultsResponse = {
+    validationRequestId: number;
+    assetPath: string;
+    assetType: string;
+    results: {
+        REQUIRED: {
+            status: string;
+            results: Array<Check>;
+        };
+        RECOMMENDED: {
+            status: string;
+            results: Array<Check>;
+        };
+    };
+    errors: Array<Error>;
+    requestedAt: string;
+};
+export {};

package/types/MarketplaceValidation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/Project.d.ts

@@ -0,0 +1,38 @@
+import { Build } from './Build';
+import { GithubSourceData } from './Github';
+export type Project = {
+    createdAt: number;
+    deletedAt: number;
+    deployedBuild?: Build;
+    deployedBuildId?: number;
+    id: number;
+    isLocked: boolean;
+    latestBuild?: Build;
+    name: string;
+    portalId: number;
+    sourceIntegration?: GithubSourceData;
+    updatedAt: number;
+};
+export type FetchProjectResponse = {
+    results: Array<Project>;
+};
+export type UploadProjectResponse = {
+    buildId: number;
+    projectTree: {
+        path: string;
+        name: string;
+        parentPath: string;
+        updatedAt: number;
+        children: Array<UploadProjectResponse>;
+        folder: boolean;
+    };
+    buildStatusTaskLocator: {
+        id: string;
+        links: {
+            status: string;
+        };
+    };
+};
+export type ProjectSettings = {
+    isAutoDeployEnabled: boolean;
+};

package/types/Project.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/Sandbox.d.ts

@@ -0,0 +1,165 @@
+export type SandboxHubData = {
+    type?: string | null;
+    parentHubId?: number;
+};
+type User = {
+    userId: number;
+    firstName: string;
+    lastName: string;
+    gdprDeleted: boolean;
+    removed: boolean;
+    deactivated: boolean;
+};
+type TaskError = {
+    message: string;
+    in: string;
+    code: string;
+    subCategory: string;
+    context: {
+        missingScopes: Array<string>;
+    };
+};
+type MutationError = {
+    message: string;
+    portableKey: string;
+    subResource: {
+        type: string;
+        key: string;
+    };
+    standardError: {
+        status: string;
+        id: string;
+        category: string;
+        subCategory: {
+            [key: string]: string;
+        };
+        message: string;
+        errors: Array<TaskError>;
+        context: {
+            additionalProp1: Array<string>;
+            additionalProp2: Array<string>;
+            additionalProp3: Array<string>;
+        };
+        links: {
+            additionalProp1: string;
+            additionalProp2: string;
+            additionalProp3: string;
+        };
+    };
+};
+type TaskStatus = {
+    numRequests: number;
+    numSuccesses: number;
+    errors: Array<TaskError>;
+    mutationErrors: Array<MutationError>;
+};
+export type Task = {
+    id: string;
+    parentHubId: number;
+    sandboxHubId: number;
+    fromHubId: number;
+    toHubId: number;
+    command: string;
+    type: string;
+    status: string;
+    result: string;
+    sandboxType: string;
+    requestedAt: string;
+    requestedByUserId: number;
+    requestedByUser: User;
+    startedAt: string;
+    completedAt: string;
+    error: MutationError;
+    creates: TaskStatus;
+    updates: TaskStatus;
+    deletes: TaskStatus;
+    diffSummary: string;
+    portableKeys: Array<string>;
+};
+export type Sandbox = {
+    sandboxHubId: number;
+    parentHubId: number;
+    createdAt: string;
+    updatedAt: string | null;
+    archivedAt: string | null;
+    type: string;
+    archived: boolean;
+    name: string;
+    domain: string;
+    createdByUser: User;
+    updatedByUser: User | null;
+    lastSync: {
+        id: string;
+        parentHubId: number;
+        sandboxHubId: number;
+        fromHubId: number;
+        toHubId: number;
+        command: string;
+        status: string;
+        result: string;
+        sandboxType: string;
+        requestedAt: string;
+        requestedByUserId: number;
+        requestedByUser: User;
+        startedAt: string;
+        completedAt: string;
+        tasks: Array<Task>;
+    };
+    currentUserHasAccess: boolean | null;
+    currentUserHasSuperAdminAccess: boolean | null;
+    requestAccessFrom: User | null;
+    superAdminsInSandbox: number | null;
+};
+export type SandboxResponse = {
+    sandbox: Sandbox;
+    personalAccessKey: string;
+};
+export type Usage = {
+    STANDARD: {
+        used: number;
+        available: number;
+        limit: number;
+    };
+    DEVELOPER: {
+        used: number;
+        available: number;
+        limit: number;
+    };
+};
+export type SandboxUsageLimitsResponse = {
+    usage: Usage;
+};
+export type SyncTask = {
+    type: string;
+};
+export type InitiateSyncResponse = {
+    links: {
+        status: string;
+    };
+    sync: {
+        id: string;
+        parentHubId: number;
+        sandboxHubId: number;
+        fromHubId: number;
+        toHubId: number;
+        command: string;
+        status: string;
+        sandboxType: string;
+        requestedAt: string;
+        requestedByUserId: number;
+        tasks: Array<Task>;
+    };
+    id: string;
+};
+export type SandboxType = {
+    name: string;
+    dependsOn: Array<string>;
+    pushToParentEnabled: boolean;
+    isBeta: boolean;
+    diffEnabled: boolean;
+    groupType: string;
+};
+export type FetchTypesResponse = {
+    results: Array<SandboxType>;
+};
+export {};

package/types/Sandbox.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/Schemas.d.ts

@@ -0,0 +1,42 @@
+export type Schema = {
+    id: string;
+    createdAt: string;
+    updatedAt: string | null;
+    properties?: [
+        {
+            updatedAt: string | null;
+            createdAt: string;
+            name: string;
+            label: string;
+            type: string;
+            fieldType: string;
+            groupName: string;
+            displayOrder: number;
+            calculated: boolean;
+            externalOptions: boolean;
+            archived: boolean;
+            hasUniqueValue: boolean;
+        }
+    ];
+    associations?: [
+        {
+            id: string;
+            fromObjectTypeId: string;
+            toObjectTypeId: string;
+            name: string;
+        }
+    ];
+    labels: {
+        singular: string;
+        plural: string;
+    };
+    requiredProperties: Array<string>;
+    searchableProperties: Array<string>;
+    primaryDisplayProperty: Array<string>;
+    metaType: string;
+    fullyQualifiedName: string;
+    name: string;
+};
+export type FetchSchemasResponse = {
+    results: Array<Schema>;
+};

package/types/Schemas.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/utils/{modules.d.ts → cms/modules.d.ts}

@@ -1,4 +1,4 @@
-import { PathInput } from '../types/Modules';
+import { PathInput } from '../../types/Modules';
 export declare function isPathInput(pathInput?: PathInput): boolean;
 export declare function isModuleFolder(pathInput: PathInput): boolean;
 export declare function isModuleFolderChild(pathInput: PathInput, ignoreLocales?: boolean): boolean;

package/utils/{modules.js → cms/modules.js}

@@ -5,9 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isModuleFolderChild = exports.isModuleFolder = exports.isPathInput = void 0;
 const path_1 = __importDefault(require("path"));
-const path_2 = require("../lib/path");
-const extensions_1 = require("../constants/extensions");
-const standardErrors_1 = require("../errors/standardErrors");
+const path_2 = require("../../lib/path");
+const extensions_1 = require("../../constants/extensions");
+const standardErrors_1 = require("../../errors/standardErrors");
 const isBool = (x) => !!x === x;
 function isPathInput(pathInput) {
     return !!(pathInput &&

package/utils/getAccountIdentifier.d.ts

@@ -0,0 +1,10 @@
+import { CLIAccount } from '../types/Accounts';
+import { CLIConfig } from '../types/Config';
+type Account = {
+    portalId?: number;
+    accountId?: number;
+};
+export declare function getAccountIdentifier(account?: Account | null): number | undefined;
+export declare function getAccounts(config?: CLIConfig | null): Array<CLIAccount>;
+export declare function getDefaultAccount(config?: CLIConfig | null): string | number | undefined;
+export {};

package/utils/getAccountIdentifier.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultAccount = exports.getAccounts = exports.getAccountIdentifier = void 0;
+function getAccountIdentifier(account) {
+    if (!account) {
+        return undefined;
+    }
+    else if (Object.hasOwn(account, 'portalId')) {
+        return account.portalId;
+    }
+    else if (Object.hasOwn(account, 'accountId')) {
+        return account.accountId;
+    }
+}
+exports.getAccountIdentifier = getAccountIdentifier;
+function getAccounts(config) {
+    if (!config) {
+        return [];
+    }
+    else if (Object.hasOwn(config, 'portals')) {
+        return config.portals;
+    }
+    else if (Object.hasOwn(config, 'accounts')) {
+        return config.accounts;
+    }
+    return [];
+}
+exports.getAccounts = getAccounts;
+function getDefaultAccount(config) {
+    if (!config) {
+        return undefined;
+    }
+    else if (Object.hasOwn(config, 'defaultPortal')) {
+        return config.defaultPortal;
+    }
+    else if (Object.hasOwn(config, 'defaultAccount')) {
+        return config.defaultAccount;
+    }
+}
+exports.getDefaultAccount = getDefaultAccount;

package/utils/git.d.ts

@@ -1,4 +1,9 @@
-export declare function makeComparisonDir(filepath: string | null): string | null;
-export declare const getGitComparisonDir: () => string | null;
 export declare function isConfigPathInGitRepo(configPath: string): boolean;
 export declare function configFilenameIsIgnoredByGitignore(ignoreFiles: Array<string>, configPath: string): boolean;
+type GitInclusionResult = {
+    inGit: boolean;
+    configIgnored: boolean;
+    gitignoreFiles: Array<string>;
+};
+export declare function checkGitInclusion(configPath: string): GitInclusionResult;
+export {};

package/utils/git.js

@@ -3,22 +3,52 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configFilenameIsIgnoredByGitignore = exports.isConfigPathInGitRepo = exports.getGitComparisonDir = exports.makeComparisonDir = void 0;
-const fs_extra_1 = require("fs-extra");
+exports.checkGitInclusion = exports.configFilenameIsIgnoredByGitignore = exports.isConfigPathInGitRepo = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const ignore_1 = __importDefault(require("ignore"));
 const findup_sync_1 = __importDefault(require("findup-sync"));
+const GITIGNORE_FILE = '.gitignore';
 function makeComparisonDir(filepath) {
     if (typeof filepath !== 'string')
         return null;
     // Append sep to make comparisons easier e.g. 'foos'.startsWith('foo')
     return path_1.default.dirname(path_1.default.resolve(filepath)).toLowerCase() + path_1.default.sep;
 }
-exports.makeComparisonDir = makeComparisonDir;
-const getGitComparisonDir = () => makeComparisonDir((0, findup_sync_1.default)('.git'));
-exports.getGitComparisonDir = getGitComparisonDir;
+function getGitComparisonDir() {
+    return makeComparisonDir((0, findup_sync_1.default)('.git'));
+}
+// Get all .gitignore files since they can cascade down directory structures
+function getGitignoreFiles(configPath) {
+    const gitDir = getGitComparisonDir();
+    const files = [];
+    if (!gitDir) {
+        // Not in git
+        return files;
+    }
+    // Start findup from config dir
+    let cwd = configPath && path_1.default.dirname(configPath);
+    while (cwd) {
+        const ignorePath = (0, findup_sync_1.default)(GITIGNORE_FILE, { cwd });
+        const cmpIgnorePath = makeComparisonDir(ignorePath);
+        const cmpGitDir = makeComparisonDir(gitDir);
+        if (ignorePath &&
+            cmpIgnorePath &&
+            cmpGitDir &&
+            // Stop findup after .git dir is reached
+            cmpIgnorePath.startsWith(cmpGitDir)) {
+            const file = path_1.default.resolve(ignorePath);
+            files.push(file);
+            cwd = path_1.default.resolve(path_1.default.dirname(file) + '..');
+        }
+        else {
+            cwd = null;
+        }
+    }
+    return files;
+}
 function isConfigPathInGitRepo(configPath) {
-    const gitDir = (0, exports.getGitComparisonDir)();
+    const gitDir = getGitComparisonDir();
     if (!gitDir)
         return false;
     const configDir = makeComparisonDir(configPath);
@@ -29,7 +59,7 @@ function isConfigPathInGitRepo(configPath) {
 exports.isConfigPathInGitRepo = isConfigPathInGitRepo;
 function configFilenameIsIgnoredByGitignore(ignoreFiles, configPath) {
     return ignoreFiles.some(gitignore => {
-        const gitignoreContents = (0, fs_extra_1.readFileSync)(gitignore).toString();
+        const gitignoreContents = fs_extra_1.default.readFileSync(gitignore).toString();
         const gitignoreConfig = (0, ignore_1.default)().add(gitignoreContents);
         if (gitignoreConfig.ignores(path_1.default.relative(path_1.default.dirname(gitignore), configPath))) {
             return true;
@@ -38,3 +68,20 @@ function configFilenameIsIgnoredByGitignore(ignoreFiles, configPath) {
     });
 }
 exports.configFilenameIsIgnoredByGitignore = configFilenameIsIgnoredByGitignore;
+function checkGitInclusion(configPath) {
+    const result = {
+        inGit: false,
+        configIgnored: false,
+        gitignoreFiles: [],
+    };
+    if (isConfigPathInGitRepo(configPath)) {
+        result.inGit = true;
+        result.gitignoreFiles = getGitignoreFiles(configPath);
+        if (configFilenameIsIgnoredByGitignore(result.gitignoreFiles, configPath)) {
+            // Found ignore statement in .gitignore that matches config filename
+            result.configIgnored = true;
+        }
+    }
+    return result;
+}
+exports.checkGitInclusion = checkGitInclusion;

package/utils/lang.d.ts

@@ -1,3 +1,6 @@
+type LanguageObject = {
+    [key: string]: LanguageObject | string;
+};
 type InterpolationData = {
     [identifier: string]: string | number;
 };
@@ -5,4 +8,5 @@ export declare function interpolate(stringValue: string, interpolationData: Inte
 export declare function i18n(lookupDotNotation: string, options?: {
     [identifier: string]: string | number;
 }): string;
+export declare const setLangData: (newLocale: string, newLangObj: LanguageObject) => void;
 export {};

package/utils/lang.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.i18n = exports.interpolate = void 0;
+exports.setLangData = exports.i18n = exports.interpolate = void 0;
 const path_1 = require("path");
 const fs_extra_1 = require("fs-extra");
 const js_yaml_1 = require("js-yaml");
@@ -72,6 +72,9 @@ function interpolate(stringValue, interpolationData) {
 }
 exports.interpolate = interpolate;
 function i18n(lookupDotNotation, options = {}) {
+    if (!languageObj) {
+        loadLanguageFromYaml();
+    }
     if (typeof lookupDotNotation !== 'string') {
         throw new Error(`i18n must be passed a string value for lookupDotNotation, received ${typeof lookupDotNotation}`);
     }
@@ -80,4 +83,8 @@ function i18n(lookupDotNotation, options = {}) {
     return shouldInterpolate ? interpolate(textValue, options) : textValue;
 }
 exports.i18n = i18n;
-loadLanguageFromYaml();
+const setLangData = (newLocale, newLangObj) => {
+    locale = newLocale;
+    languageObj = newLangObj;
+};
+exports.setLangData = setLangData;

package/utils/notify.d.ts

@@ -0,0 +1 @@
+export declare function triggerNotify(filePathToNotify: string | undefined, actionType: string, filePath: string, actionPromise: Promise<void>): void;

package/utils/notify.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.triggerNotify = void 0;
+const fs_1 = __importDefault(require("fs"));
+const moment_1 = __importDefault(require("moment"));
+const debounce_1 = __importDefault(require("debounce"));
+const standardErrors_1 = require("../errors/standardErrors");
+const notifyQueue = [];
+const notifyPromises = [];
+const debouncedWaitForActionsToCompleteAndWriteQueueToFile = (0, debounce_1.default)(waitForActionsToCompleteAndWriteQueueToFile, 500);
+// Collects actions that have been taken on files and the corresponding Promise
+// for the remote action that is in-process
+function triggerNotify(filePathToNotify, actionType, filePath, actionPromise) {
+    if (filePathToNotify) {
+        notifyQueue.push(`${(0, moment_1.default)().toISOString()} ${actionType}: ${filePath}\n`);
+        notifyPromises.push(actionPromise);
+        debouncedWaitForActionsToCompleteAndWriteQueueToFile(filePathToNotify);
+    }
+}
+exports.triggerNotify = triggerNotify;
+// Clears both the notifyQueue and notifyPromises array, generates the output
+// string that will be eventually logged, and waits for all promises currently
+// in the notifyPromises array to resolve before logging the output
+function waitForActionsToCompleteAndWriteQueueToFile(filePathToNotify) {
+    const actionOutput = notifyQueue.splice(0, notifyQueue.length).join('');
+    const allNotifyPromisesResolution = Promise.all(notifyPromises.splice(0, notifyPromises.length));
+    allNotifyPromisesResolution.then(() => notifyFilePath(filePathToNotify, actionOutput));
+}
+// Logs output to the "notify" file
+function notifyFilePath(filePathToNotify, outputToWrite) {
+    if (filePathToNotify) {
+        try {
+            fs_1.default.appendFileSync(filePathToNotify, outputToWrite);
+        }
+        catch (e) {
+            (0, standardErrors_1.throwErrorWithMessage)('utils.notify.filePath', { filePath: filePathToNotify }, e);
+        }
+    }
+}

package/utils/objectUtils.d.ts

@@ -0,0 +1,8 @@
+export declare function isObject(value: object): boolean;
+export declare function mergeDeep(target: {
+    [key: string]: any;
+}, ...sources: Array<{
+    [key: string]: any;
+}>): {
+    [key: string]: any;
+};