@hubspot/project-parsing-lib 0.0.4 → 0.0.5-experimental.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/project-parsing-lib",
-    "version": "0.0.4",
+    "version": "0.0.5-experimental.0",
     "description": "Parsing library for converting projects directory structures to their intermediate representation",
     "license": "Apache-2.0",
     "main": "src/index.js",

package/src/index.d.ts

@@ -1,3 +1,5 @@
-import { IntermediateRepresentation, TranslationContext } from './lib/types';
-export declare function translate(translationContext: TranslationContext): Promise<IntermediateRepresentation>;
+import { IntermediateRepresentation, IntermediateRepresentationNode, IntermediateRepresentationLocalDev, TranslationContext, TranslationOptions, IntermediateRepresentationNodeLocalDev } from './lib/types';
+export declare function translate(translationContext: TranslationContext, translationOptions?: TranslationOptions): Promise<IntermediateRepresentation>;
+export declare function translateForLocalDev(translationContext: TranslationContext): Promise<IntermediateRepresentationLocalDev>;
 export { isTranslationError } from './lib/errors';
+export { IntermediateRepresentation, IntermediateRepresentationNode, IntermediateRepresentationLocalDev, IntermediateRepresentationNodeLocalDev, TranslationContext, };

package/src/index.js

@@ -1,23 +1,50 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTranslationError = void 0;
 exports.translate = translate;
+exports.translateForLocalDev = translateForLocalDev;
 const files_1 = require("./lib/files");
 const validation_1 = require("./lib/validation");
 const transform_1 = require("./lib/transform");
-const errors_1 = require("./lib/errors");
-async function translate(translationContext) {
+const copy_1 = require("./lang/copy");
+const path_1 = __importDefault(require("path"));
+const defaultOptions = {
+    skipValidation: false,
+};
+async function translate(translationContext, translationOptions = defaultOptions) {
+    const { skipValidation } = translationOptions;
     const metafileContents = await (0, files_1.loadHsMetaFiles)(translationContext);
     if (metafileContents.length === 0) {
-        throw new Error('No *-hsmeta.json files found, make sure you are inside a project');
+        throw new Error(copy_1.errorMessages.project.noHsMetaFiles);
     }
     const transformation = (0, transform_1.transform)(metafileContents);
     const intermediateRepresentation = (0, transform_1.getIntermediateRepresentation)(transformation);
-    const { valid, errors } = await (0, validation_1.validateIntermediateRepresentation)(intermediateRepresentation, transformation, translationContext);
-    if (!valid) {
-        throw new errors_1.TranslationError('Failed to translate project', errors);
+    // Remove once extensions and serverless functions are supported
+    if (!skipValidation) {
+        await (0, validation_1.validateIntermediateRepresentation)(intermediateRepresentation, transformation, translationContext);
     }
     return intermediateRepresentation;
 }
-var errors_2 = require("./lib/errors");
-Object.defineProperty(exports, "isTranslationError", { enumerable: true, get: function () { return errors_2.isTranslationError; } });
+async function translateForLocalDev(translationContext) {
+    const IR = await translate(translationContext, { skipValidation: true });
+    const localDevIr = {
+        intermediateNodesIndexedByUid: {},
+    };
+    Object.entries(IR.intermediateNodesIndexedByUid).forEach(([uid, node]) => {
+        const component = IR.intermediateNodesIndexedByUid[uid];
+        const componentConfigPath = path_1.default.join(translationContext.projectSourceDir, component.metaFilePath);
+        localDevIr.intermediateNodesIndexedByUid[uid] = {
+            ...node,
+            localDev: {
+                componentRoot: path_1.default.dirname(componentConfigPath),
+                componentConfigPath,
+            },
+        };
+    });
+    return localDevIr;
+}
+var errors_1 = require("./lib/errors");
+Object.defineProperty(exports, "isTranslationError", { enumerable: true, get: function () { return errors_1.isTranslationError; } });

package/src/lang/copy.d.ts

@@ -0,0 +1,27 @@
+import { ComponentMetadata } from '../lib/constants';
+export declare const errorMessages: {
+    api: {
+        failedToFetchSchemas: string;
+    };
+    project: {
+        noHsMetaFiles: string;
+        failedToTranslateProject: string;
+        duplicateUid: (uid: string, files: string[]) => string;
+    };
+    validation: {
+        errorWithFileHeader: (file: string, errors: string[]) => string;
+        missingRequiredField: (field: string) => string;
+        missingUid: string;
+        missingType: string;
+        missingConfig: string;
+        unsupportedType: (type: string) => string;
+        errorWithField: (field: string, error: string | undefined) => string;
+        invalidJson: string;
+        wrongDirectoryForComponent: (directory: string, componentType: string, componentMetadata: ComponentMetadata, correctDir: string) => string;
+    };
+};
+export declare const logMessages: {
+    files: {
+        skippingPath: (path: string) => string;
+    };
+};

package/src/lang/copy.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logMessages = exports.errorMessages = void 0;
+exports.errorMessages = {
+    api: {
+        failedToFetchSchemas: 'Failed to fetch schemas',
+    },
+    project: {
+        noHsMetaFiles: 'No *-hsmeta.json files found in the current directory. Please make sure you are inside the correct project directory.',
+        failedToTranslateProject: 'Project validation failed',
+        duplicateUid: (uid, files) => `Duplicate uid '${uid}' found in:\n- ${files.join('\n- ')}`,
+    },
+    validation: {
+        errorWithFileHeader: (file, errors) => `\n\nEncountered the following errors for ${file}:\n\t- ${errors.join('\n\t- ')}`,
+        missingRequiredField: (field) => `Missing required field: '${field}'`,
+        missingUid: `Missing required field: 'uid'`,
+        missingType: `Missing required field: 'type'`,
+        missingConfig: `Missing required field: 'config'`,
+        unsupportedType: (type) => `Unsupported type: ${type.toLowerCase()}`,
+        errorWithField: (field, error) => `Error with ${field}: ${error || 'Unknown error'}`,
+        invalidJson: 'Invalid JSON',
+        wrongDirectoryForComponent: (directory, componentType, componentMetadata, correctDir) => 
+        // Double check this string with Jono
+        `The directory '${directory}' is incorrect for type '${componentType}'. ${componentMetadata.userFriendlyName} ${componentMetadata.userFriendlyTypePlural} should only be placed in the '${correctDir}' directory`,
+    },
+};
+exports.logMessages = {
+    files: {
+        skippingPath: (path) => `Skipping ${path} as it is not in a valid directory`,
+    },
+};

package/src/lib/constants.d.ts

@@ -9,13 +9,17 @@ export declare const TimelineEventsKey = "timeline-event";
 export declare const VideoConferencingKey = "video-conferencing";
 export declare const WebhooksKey = "webhooks";
 export declare const WorkflowActionsKey = "workflow-action";
-interface ComponentMetadata {
+export interface ComponentMetadata {
     dir: string;
-    isToplevel?: boolean;
+    isToplevel: boolean;
     parentComponent?: string;
+    userFriendlyName: string;
+    userFriendlyType: string;
+    userFriendlyTypePlural: string;
 }
 export declare const Components: Record<string, ComponentMetadata>;
-export declare const externalTypeToInternalType: Record<string, string>;
+export declare const userFacingToInternalType: Record<string, string>;
+export declare const internalTypeToUserFacing: Record<string, string>;
 export declare const metafileExtension = "-hsmeta.json";
 export declare const allowedAppSubComponentsDirs: string[];
 export declare const allowedThemeSubComponentsDirs: string[];
@@ -25,4 +29,3 @@ export declare const ProjectStructure: {
 };
 export declare const allowedComponentDirectories: string[];
 export declare const allowedSubComponentDirectories: string[];
-export {};

package/src/lib/constants.js

@@ -15,15 +15,25 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.allowedSubComponentDirectories = exports.allowedComponentDirectories = exports.ProjectStructure = exports.allowedThemeSubComponentsDirs = exports.allowedAppSubComponentsDirs = exports.metafileExtension = exports.externalTypeToInternalType = exports.Components = exports.WorkflowActionsKey = exports.WebhooksKey = exports.VideoConferencingKey = exports.TimelineEventsKey = exports.MediaBridgeKey = exports.MarketingEventsKey = exports.FunctionsKey = exports.CardsKey = exports.CallingKey = exports.ThemeKey = exports.AppKey = void 0;
+exports.allowedSubComponentDirectories = exports.allowedComponentDirectories = exports.ProjectStructure = exports.allowedThemeSubComponentsDirs = exports.allowedAppSubComponentsDirs = exports.metafileExtension = exports.internalTypeToUserFacing = exports.userFacingToInternalType = exports.Components = exports.WorkflowActionsKey = exports.WebhooksKey = exports.VideoConferencingKey = exports.TimelineEventsKey = exports.MediaBridgeKey = exports.MarketingEventsKey = exports.FunctionsKey = exports.CardsKey = exports.CallingKey = exports.ThemeKey = exports.AppKey = void 0;
 // Top Level Component types
 const path = __importStar(require("path"));
 // Component types
@@ -39,55 +49,87 @@ exports.TimelineEventsKey = 'timeline-event';
 exports.VideoConferencingKey = 'video-conferencing';
 exports.WebhooksKey = 'webhooks';
 exports.WorkflowActionsKey = 'workflow-action';
+const TopLevelComponentFields = {
+    isToplevel: true,
+    userFriendlyType: 'component',
+    userFriendlyTypePlural: 'components',
+};
+const SubComponentFields = {
+    isToplevel: false,
+    userFriendlyType: 'feature',
+    userFriendlyTypePlural: 'features',
+};
 exports.Components = {
     [exports.AppKey]: {
         dir: exports.AppKey,
-        isToplevel: true,
+        userFriendlyName: 'App',
+        ...TopLevelComponentFields,
     },
     [exports.ThemeKey]: {
         dir: exports.ThemeKey,
-        isToplevel: true,
+        userFriendlyName: 'Theme',
+        ...TopLevelComponentFields,
     },
     [exports.CallingKey]: {
         dir: exports.CallingKey,
         parentComponent: exports.AppKey,
+        userFriendlyName: 'Calling',
+        ...SubComponentFields,
     },
     [exports.CardsKey]: {
         dir: 'cards',
         parentComponent: exports.AppKey,
+        userFriendlyName: 'Card',
+        ...SubComponentFields,
     },
     [exports.FunctionsKey]: {
         dir: 'functions',
         parentComponent: exports.AppKey,
+        userFriendlyName: 'Function',
+        ...SubComponentFields,
     },
     [exports.MarketingEventsKey]: {
         dir: 'marketing-events',
         parentComponent: exports.AppKey,
+        userFriendlyName: 'Marketing Event',
+        ...SubComponentFields,
     },
     MediaBridgeKey: {
         dir: exports.MediaBridgeKey,
         parentComponent: exports.AppKey,
+        userFriendlyName: 'Media Bridge',
+        ...SubComponentFields,
     },
     [exports.TimelineEventsKey]: {
         dir: 'timeline-events',
         parentComponent: exports.AppKey,
+        userFriendlyName: 'Timeline Event',
+        ...SubComponentFields,
     },
     [exports.VideoConferencingKey]: {
         dir: exports.VideoConferencingKey,
         parentComponent: exports.AppKey,
+        userFriendlyName: 'Video Conferencing',
+        ...SubComponentFields,
     },
     [exports.WebhooksKey]: {
         dir: exports.WebhooksKey,
         parentComponent: exports.AppKey,
+        userFriendlyName: 'Webhooks',
+        ...SubComponentFields,
     },
     [exports.WorkflowActionsKey]: {
         dir: 'workflow-actions',
         parentComponent: exports.AppKey,
+        userFriendlyName: 'Workflow Action',
+        ...SubComponentFields,
     },
 };
-exports.externalTypeToInternalType = {
-    [exports.AppKey]: 'application',
+const internalAppKey = 'APPLICATION';
+exports.userFacingToInternalType = {
+    [exports.AppKey]: internalAppKey,
 };
+exports.internalTypeToUserFacing = Object.fromEntries(Object.entries(exports.userFacingToInternalType).map(([key, value]) => [value, key]));
 exports.metafileExtension = '-hsmeta.json';
 function getSubComponentDirsForParentType(parentComponent) {
     return Object.values(exports.Components).reduce((acc, item) => {

package/src/lib/errors.d.ts

@@ -1,8 +1,10 @@
-import { CompiledError, Transformation } from './types';
+import { CompiledError, Transformation, TranslationContext } from './types';
+import { ErrorObject } from 'ajv-draft-04';
+export declare function isTranslationError(error: unknown): error is TranslationError;
+export declare function compileError(validatedTransformation: Transformation): CompiledError;
 export declare class TranslationError extends Error {
     private errors;
-    constructor(message: string, errors: CompiledError[]);
+    private translationContext;
+    constructor(message: string, transformations: Transformation[], errors: (ErrorObject[] | null | undefined)[], translationContext: TranslationContext);
     toString(): string;
 }
-export declare function isTranslationError(error: unknown): error is TranslationError;
-export declare function compileError(validatedTransformation: Transformation): CompiledError;

package/src/lib/errors.js

@@ -1,28 +1,152 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TranslationError = void 0;
 exports.isTranslationError = isTranslationError;
 exports.compileError = compileError;
+const copy_1 = require("../lang/copy");
+const path_1 = __importDefault(require("path"));
+function isTranslationError(error) {
+    return error instanceof TranslationError;
+}
+function compileError(validatedTransformation) {
+    const { fileParseResult } = validatedTransformation;
+    const { errors } = fileParseResult;
+    return {
+        errors,
+    };
+}
 class TranslationError extends Error {
-    errors;
-    constructor(message, errors) {
+    errors = [];
+    translationContext;
+    constructor(message, transformations, errors, translationContext) {
         super(message);
         this.name = 'TranslationError';
-        this.errors = errors;
+        this.translationContext = translationContext;
+        this.errors = transformations.map((transformation, index) => compileTranslationErrors(transformation, errors[index]));
     }
+    // Returns a formatted string for all the errors in all the files
     toString() {
-        return `${this.message}: ${this.errors.map(({ message, errors }) => `\n\n${message} \n\t- ${errors.join('\n\t- ')}`)}`;
+        const listOfErrors = this.errors.map(({ file, errors }) => {
+            if (errors.length === 0) {
+                return '';
+            }
+            return copy_1.errorMessages.validation.errorWithFileHeader(path_1.default.join(this.translationContext.projectSourceDir, file), errors);
+        });
+        return `${this.message}: ${listOfErrors}`;
     }
 }
 exports.TranslationError = TranslationError;
-function isTranslationError(error) {
-    return error instanceof TranslationError;
+function generateDotNotationPath(error) {
+    const { instancePath } = error;
+    const errorPath = instancePath
+        .replace(/\/nodes\//, '')
+        .split('/')
+        .filter(subPath => subPath !== '')
+        .join('.');
+    if (errorPath === '') {
+        // This is a top level error
+        return `config`;
+    }
+    return `config.${errorPath}`;
 }
-function compileError(validatedTransformation) {
-    const { fileParseResult } = validatedTransformation;
-    const { errors, file: filePath } = fileParseResult;
+function compileTranslationErrors(transformation, schemaErrors) {
+    const hasOneOfErrors = schemaErrors?.some(error => isOneOfError(error));
+    const { errors: existingErrors, file } = transformation.fileParseResult;
+    const errors = [...existingErrors];
+    // If there is a one of error, we need to preprocess the errors to group them by instancePath and keyword
+    // This allows us to group data from the errors that correspond to the same field
+    if (hasOneOfErrors) {
+        errors.push(...preprocessSpecialErrors(schemaErrors));
+    }
+    else {
+        schemaErrors?.forEach(error => {
+            errors.push(generateErrorMessage(error));
+        });
+    }
+    return { file, errors };
+}
+function preprocessSpecialErrors(schemaErrors) {
+    const errors = [];
+    const preprocessedErrors = {};
+    schemaErrors?.forEach(error => {
+        // Filter out the oneOf errors, they are a secondary error caused by other errors
+        // and don't add any additional actionable context to the user
+        if (isOneOfError(error)) {
+            return;
+        }
+        const errorKey = `${error.instancePath}::${error.keyword}`;
+        if (preprocessedErrors[errorKey]) {
+            preprocessedErrors[errorKey].push(error);
+        }
+        else {
+            preprocessedErrors[errorKey] = [error];
+        }
+    });
+    Object.values(preprocessedErrors)?.forEach(value => {
+        const newValue = value.reduce((cur, next) => {
+            if (isEnumError(cur)) {
+                return mergeEnumErrors(cur, next);
+            }
+            return cur;
+        });
+        errors.push(generateErrorMessage(newValue));
+    });
+    return errors;
+}
+function generateErrorMessage(error) {
+    const errorPath = generateDotNotationPath(error);
+    const errorMessage = copy_1.errorMessages.validation.errorWithField(errorPath, error.message);
+    const params = Object.entries(error.params);
+    if (params.length === 0) {
+        return errorMessage;
+    }
+    const additionalContext = params
+        .filter(([_, value]) => value)
+        .map(([key, value]) => `${key}: ${Array.isArray(value) ? value.join(', ') : value}`);
+    if (isRequiredError(error)) {
+        return copy_1.errorMessages.validation.missingRequiredField(`${errorPath}.${error.params.missingProperty}`);
+    }
+    else if (isTypeError(error)) {
+        return copy_1.errorMessages.validation.errorWithField(generateDotNotationPath(error), error.message);
+    }
+    // Default case, it is not an error we know how to deal with
+    return `${errorMessage} ${additionalContext.length > 0
+        ? `\n\t\t-  ${additionalContext.join('\n\t\t- ')}`
+        : ''}`;
+}
+function mergeEnumErrors(cur, next) {
     return {
-        message: `Encountered the following errors for ${filePath}:`,
-        errors,
+        ...cur,
+        // Overwrite the schema path so we know it's been modified
+        schemaPath: 'CUSTOM',
+        params: {
+            ...cur.params,
+            // Merge the allowed values from the enum errors
+            allowedValues: [
+                ...cur.params.allowedValues,
+                ...next.params.allowedValues,
+            ],
+        },
     };
 }
+const JSON_SCHEMA_VALIDATION_KEYWORDS = {
+    required: 'required',
+    type: 'type',
+    oneOf: 'oneOf',
+    enum: 'enum',
+};
+function isOneOfError(error) {
+    return error.keyword === JSON_SCHEMA_VALIDATION_KEYWORDS.oneOf;
+}
+function isRequiredError(error) {
+    return error.keyword === JSON_SCHEMA_VALIDATION_KEYWORDS.required;
+}
+function isEnumError(error) {
+    return error.keyword === JSON_SCHEMA_VALIDATION_KEYWORDS.enum;
+}
+function isTypeError(error) {
+    return error.keyword === JSON_SCHEMA_VALIDATION_KEYWORDS.type;
+}

package/src/lib/files.js

@@ -8,6 +8,8 @@ const fs_1 = require("@hubspot/local-dev-lib/fs");
 const path_1 = __importDefault(require("path"));
 const constants_1 = require("./constants");
 const fs_2 = __importDefault(require("fs"));
+const copy_1 = require("../lang/copy");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
 async function loadHsMetaFiles(translationContext) {
     const metaFiles = await locateHsMetaFiles(translationContext);
     return parseHsMetaFiles(metaFiles, translationContext);
@@ -28,7 +30,7 @@ async function locateHsMetaFiles(translationContext) {
             metaFiles.push({ file, parentDirectory });
         }
         else {
-            console.warn(`Skipping ${pathRelativeToProjectSrcDir} as it is not in a valid directory`);
+            logger_1.logger.warn(copy_1.logMessages.files.skippingPath(pathRelativeToProjectSrcDir));
         }
         return metaFiles;
     }, []);
@@ -69,7 +71,7 @@ function parseFile(fileLoadResult) {
         parsedFileContents = JSON.parse(fileLoadResult.content);
     }
     catch (_e) {
-        fileLoadResult.errors?.push('Invalid JSON');
+        fileLoadResult.errors?.push(copy_1.errorMessages.validation.invalidJson);
     }
     return { ...fileLoadResult, content: parsedFileContents };
 }

package/src/lib/schemas.d.ts

@@ -1,3 +1,3 @@
-import { AnySchema } from 'ajv';
+import { AnySchema } from 'ajv-draft-04';
 import { TranslationContext } from './types';
 export declare function getIntermediateRepresentationSchema(translationContext: TranslationContext): Promise<Record<string, AnySchema>>;

package/src/lib/schemas.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getIntermediateRepresentationSchema = getIntermediateRepresentationSchema;
 const http_1 = require("@hubspot/local-dev-lib/http");
 const index_1 = require("@hubspot/local-dev-lib/errors/index");
+const copy_1 = require("../lang/copy");
 async function getIntermediateRepresentationSchema(translationContext) {
     try {
-        const { accountId } = translationContext;
+        const { accountId, platformVersion } = translationContext;
         const { data } = await http_1.http.get(accountId, {
-            // TODO: update this to use the real platform version
-            url: `project-components-external/project-schemas/v3?platformVersion=testing`,
+            url: `project-components-external/project-schemas/v3/${platformVersion}`,
         });
         return data;
     }
@@ -16,6 +16,6 @@ async function getIntermediateRepresentationSchema(translationContext) {
         if ((0, index_1.isHubSpotHttpError)(e)) {
             throw e;
         }
-        throw new Error('Failed to fetch schemas', { cause: e });
+        throw new Error(copy_1.errorMessages.api.failedToFetchSchemas, { cause: e });
     }
 }

package/src/lib/transform.d.ts

@@ -1,3 +1,5 @@
 import { FileParseResult, IntermediateRepresentation, Transformation } from './types';
+export declare function mapToInternalType(type: string): string;
+export declare function mapToUserFacingType(type: string): string;
 export declare function transform(fileParseResults: FileParseResult[]): Transformation[];
 export declare function getIntermediateRepresentation(transformations: Transformation[]): IntermediateRepresentation;

package/src/lib/transform.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapToInternalType = mapToInternalType;
+exports.mapToUserFacingType = mapToUserFacingType;
 exports.transform = transform;
 exports.getIntermediateRepresentation = getIntermediateRepresentation;
 const constants_1 = require("./constants");
+const copy_1 = require("../lang/copy");
 function calculateComponentDeps(fileValidationResult, parentComponents) {
     return {
         ...fileValidationResult.content?.dependencies,
@@ -15,7 +18,10 @@ function calculateComponentDeps(fileValidationResult, parentComponents) {
     };
 }
 function mapToInternalType(type) {
-    return (constants_1.externalTypeToInternalType[type] || type || '').toUpperCase();
+    return (constants_1.userFacingToInternalType[type] || type || '').toUpperCase();
+}
+function mapToUserFacingType(type) {
+    return (constants_1.internalTypeToUserFacing[type] || type || '').toLowerCase();
 }
 function transform(fileParseResults) {
     const parentTypes = Object.keys(constants_1.ProjectStructure);
@@ -38,6 +44,7 @@ function transform(fileParseResults) {
                 config,
                 componentType: mapToInternalType(type),
                 componentDeps: calculateComponentDeps(currentFile, parentComponents),
+                metaFilePath: currentFile.file,
                 files: {},
             },
             fileParseResult: currentFile,
@@ -51,7 +58,7 @@ function getIntermediateRepresentation(transformations) {
             const duplicates = transformations
                 .filter(t => t.intermediateRepresentation?.uid === uid)
                 .map(t => t.fileParseResult.file);
-            throw new Error(`Duplicate uid '${uid}' found in ${duplicates.join(', ')}`);
+            throw new Error(copy_1.errorMessages.project.duplicateUid(uid, duplicates));
         }
         return {
             ...acc,

package/src/lib/types.d.ts

@@ -1,3 +1,4 @@
+import { ErrorObject } from 'ajv-draft-04';
 export interface Components {
     uid: string;
     type: string;
@@ -18,6 +19,7 @@ export interface FileParseResult extends FileActionResult {
 export interface IntermediateRepresentationNode {
     componentType: string;
     componentDeps: Record<string, string>;
+    metaFilePath: string;
     uid: string;
     config: unknown;
     files: unknown;
@@ -27,12 +29,23 @@ export interface IntermediateRepresentation {
         [key: string]: IntermediateRepresentationNode;
     };
 }
+export interface IntermediateRepresentationNodeLocalDev extends IntermediateRepresentationNode {
+    localDev: {
+        componentRoot: string;
+        componentConfigPath: string;
+    };
+}
+export interface IntermediateRepresentationLocalDev {
+    intermediateNodesIndexedByUid: {
+        [key: string]: IntermediateRepresentationNodeLocalDev;
+    };
+}
 export type Transformation = {
     intermediateRepresentation?: IntermediateRepresentationNode | null;
     fileParseResult: FileParseResult;
+    schemaValidationErrors?: ErrorObject[] | null;
 };
 export type CompiledError = {
-    message: string;
     errors: string[];
 };
 export interface TranslationContext {
@@ -40,3 +53,6 @@ export interface TranslationContext {
     platformVersion: string;
     accountId: number;
 }
+export interface TranslationOptions {
+    skipValidation?: boolean;
+}

package/src/lib/validation.d.ts

@@ -1,9 +1,13 @@
 import { CompiledError, IntermediateRepresentation, Transformation, TranslationContext } from './types';
-export type ValidationResults = {
-    valid: false;
-    errors: CompiledError[];
-} | {
+import { ValidateFunction } from 'ajv-draft-04';
+export type ValidResult = {
     valid: true;
     errors?: null;
+    schemaValidationErrors?: null;
 };
-export declare function validateIntermediateRepresentation(intermediateRepresentation: IntermediateRepresentation, transformation: Transformation[], translationContext: TranslationContext): Promise<ValidationResults>;
+export type ValidationResults = {
+    valid: false;
+    errors?: CompiledError;
+    schemaValidationErrors?: ValidateFunction['errors'];
+} | ValidResult;
+export declare function validateIntermediateRepresentation(intermediateRepresentation: IntermediateRepresentation, transformation: Transformation[], translationContext: TranslationContext): Promise<ValidResult>;

package/src/lib/validation.js

@@ -7,87 +7,85 @@ exports.validateIntermediateRepresentation = validateIntermediateRepresentation;
 const schemas_1 = require("./schemas");
 const ajv_draft_04_1 = __importDefault(require("ajv-draft-04"));
 const errors_1 = require("./errors");
-async function validateIntermediateRepresentation(intermediateRepresentation, transformation, translationContext) {
-    const schema = await (0, schemas_1.getIntermediateRepresentationSchema)(translationContext);
-    const results = Object.values(intermediateRepresentation.intermediateNodesIndexedByUid).map((irNode, index) => {
-        const ajv = new ajv_draft_04_1.default({ allErrors: true });
-        if (!irNode.uid) {
-            transformation[index].fileParseResult.errors.push(`Missing required field: 'uid'`);
+const copy_1 = require("../lang/copy");
+const constants_1 = require("./constants");
+const path_1 = __importDefault(require("path"));
+const transform_1 = require("./transform");
+function validateIntermediateRepresentationNode(schema, transformation, irNode, index, translationContext) {
+    if (transformation[index].fileParseResult.errors.length > 0) {
+        return {
+            valid: false,
+            errors: (0, errors_1.compileError)(transformation[index]),
+        };
+    }
+    const ajv = new ajv_draft_04_1.default({ allErrors: true });
+    let shouldSkipValidation = false;
+    if (!irNode.uid) {
+        transformation[index].fileParseResult.errors.push(copy_1.errorMessages.validation.missingUid);
+    }
+    if (!irNode.config) {
+        transformation[index].fileParseResult.errors.push(copy_1.errorMessages.validation.missingConfig);
+        // If there is no config block, there is nothing to validation
+        shouldSkipValidation = true;
+    }
+    if (!schema[irNode.componentType]) {
+        if (!irNode.componentType) {
+            transformation[index].fileParseResult.errors.push(copy_1.errorMessages.validation.missingType);
         }
-        if (!schema[irNode.componentType]) {
-            transformation[index].fileParseResult.errors.push(`Unsupported 'type': '${irNode.componentType.toLowerCase()}'`);
-            return {
-                valid: false,
-                errors: (0, errors_1.compileError)(transformation[index]),
-            };
+        else {
+            transformation[index].fileParseResult.errors.push(copy_1.errorMessages.validation.unsupportedType(irNode.componentType));
         }
-        const validate = ajv.compile(schema[irNode.componentType]);
-        const valid = validate(irNode.config);
-        if (valid) {
-            const { errors } = transformation[index].fileParseResult;
-            return errors.length === 0
-                ? {
-                    valid: true,
-                }
-                : {
-                    valid: false,
-                    errors: (0, errors_1.compileError)(transformation[index]),
-                };
+        // If there is no schema for the component type, there is no way to validate
+        shouldSkipValidation = true;
+    }
+    const userFacingType = (0, transform_1.mapToUserFacingType)(irNode.componentType);
+    const component = constants_1.Components[userFacingType];
+    if (userFacingType && component) {
+        const expectedParentDir = component.parentComponent
+            ? constants_1.Components[component.parentComponent].dir
+            : '';
+        const expectedLocation = path_1.default.join(expectedParentDir, component.dir);
+        const actualLocation = path_1.default.dirname(transformation[index].fileParseResult.file);
+        if (expectedLocation !== actualLocation) {
+            transformation[index].fileParseResult.errors.push(copy_1.errorMessages.validation.wrongDirectoryForComponent(actualLocation, userFacingType, component, path_1.default.join(translationContext.projectSourceDir, expectedLocation)));
         }
-        const transformationWithUpdatedErrors = hydrateValidationErrorsIntoTransformation(transformation[index], validate.errors);
+    }
+    if (shouldSkipValidation) {
         return {
             valid: false,
-            errors: (0, errors_1.compileError)(transformationWithUpdatedErrors),
+            errors: (0, errors_1.compileError)(transformation[index]),
         };
-    });
-    const valid = results.every(result => result.valid);
+    }
+    const validate = ajv.compile(schema[irNode.componentType]);
+    const valid = validate(irNode.config);
     if (valid) {
-        return {
-            valid,
-        };
+        const { errors } = transformation[index].fileParseResult;
+        // Even through it passed the schema validation, it may have had other errors along the way
+        return errors.length === 0
+            ? {
+                valid: true,
+            }
+            : {
+                valid: false,
+                errors: (0, errors_1.compileError)(transformation[index]),
+            };
     }
-    const errors = results
-        .filter(item => item.errors !== undefined)
-        .map(result => result.errors);
     return {
-        valid,
-        errors,
+        valid: false,
+        schemaValidationErrors: validate.errors,
     };
 }
-function hydrateValidationErrorsIntoTransformation(transformation, errors) {
-    if (!errors) {
-        return transformation;
-    }
-    errors.forEach(error => {
-        const { intermediateRepresentation, fileParseResult } = transformation;
-        fileParseResult.errors.push(generateErrorMessage(transformInstancePath(error.instancePath), error));
-        transformation = { intermediateRepresentation, fileParseResult };
+async function validateIntermediateRepresentation(intermediateRepresentation, transformation, translationContext) {
+    const schema = await (0, schemas_1.getIntermediateRepresentationSchema)(translationContext);
+    const results = Object.values(intermediateRepresentation.intermediateNodesIndexedByUid).map((irNode, index) => {
+        return validateIntermediateRepresentationNode(schema, transformation, irNode, index, translationContext);
     });
-    return transformation;
-}
-function transformInstancePath(instancePath) {
-    return instancePath.replace(/\/nodes\//, '').split('/');
-}
-const missingRequiredFieldRegex = /must have required property '(.+)'/;
-// TODO: This needs cleanup and better error messaging
-function generateErrorMessage(path, error) {
-    let errorMessage = '';
-    const dotNotationPath = path.length === 0 || path[0] === '' ? 'Root Level' : path.join('.');
-    errorMessage = `Error with ${dotNotationPath}: ${error.message}`;
-    const params = Object.entries(error.params);
-    if (params.length > 0) {
-        const additionalContext = params
-            .filter(([_, value]) => value)
-            .map(([key, value]) => `${key}: ${value}`);
-        if (error.message &&
-            missingRequiredFieldRegex.test(error.message) &&
-            error.params) {
-            // TODO: This error message doesn't work well for nested objects, it makes it seem like the field is missing from the root object
-            return `Missing required field: '${error.params.missingProperty}'`;
-        }
-        errorMessage += `${additionalContext.length > 0
-            ? `\n\t\t-  ${additionalContext.join('\n\t\t- ')}`
-            : ''}`;
+    const valid = results.every(result => result.valid);
+    if (valid) {
+        return {
+            valid,
+        };
     }
-    return errorMessage;
+    const schemaValidationErrors = results.map(result => result.schemaValidationErrors);
+    throw new errors_1.TranslationError(copy_1.errorMessages.project.failedToTranslateProject, transformation, schemaValidationErrors, translationContext);
 }