@hubspot/project-parsing-lib 0.0.7 → 0.0.8

package/package.json

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

package/src/index.js

@@ -5,7 +5,6 @@ exports.translate = translate;
 const files_1 = require("./lib/files");
 const validation_1 = require("./lib/validation");
 const transform_1 = require("./lib/transform");
-const errors_1 = require("./lib/errors");
 const copy_1 = require("./lang/copy");
 const defaultOptions = {
     skipValidation: false,
@@ -19,12 +18,9 @@ async function translate(translationContext, translationOptions = defaultOptions
     const transformation = (0, transform_1.transform)(metafileContents);
     const intermediateRepresentation = (0, transform_1.getIntermediateRepresentation)(transformation);
     if (!skipValidation) {
-        const { valid, errors } = await (0, validation_1.validateIntermediateRepresentation)(intermediateRepresentation, transformation, translationContext);
-        if (!valid) {
-            throw new errors_1.TranslationError(copy_1.errorMessages.project.failedToTranslateProject, errors);
-        }
+        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; } });
+var errors_1 = require("./lib/errors");
+Object.defineProperty(exports, "isTranslationError", { enumerable: true, get: function () { return errors_1.isTranslationError; } });

package/src/lang/copy.d.ts

@@ -1,3 +1,4 @@
+import { ComponentMetadata } from '../lib/constants';
 export declare const errorMessages: {
     api: {
         failedToFetchSchemas: string;
@@ -7,14 +8,16 @@ export declare const errorMessages: {
         failedToTranslateProject: string;
         duplicateUid: (uid: string, files: string[]) => string;
     };
-    file: {
-        errorWithFileHeader: (file: 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: {

package/src/lang/copy.js

@@ -6,18 +6,22 @@ exports.errorMessages = {
         failedToFetchSchemas: 'Failed to fetch schemas',
     },
     project: {
-        noHsMetaFiles: 'No *-hsmeta.json files found, make sure you are inside a project',
-        failedToTranslateProject: 'Failed to translate project',
-        duplicateUid: (uid, files) => `Duplicate uid '${uid}' found in ${files.join(', ')}`,
+        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- ')}`,
     },
-    file: {
-        errorWithFileHeader: (file) => `Encountered the following errors for ${file}:`,
+    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 = {

package/src/lib/constants.d.ts

@@ -11,13 +11,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[];
@@ -27,4 +31,3 @@ export declare const ProjectStructure: {
 };
 export declare const allowedComponentDirectories: string[];
 export declare const allowedSubComponentDirectories: string[];
-export {};

package/src/lib/constants.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 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.AppObjectAssociationKey = exports.AppObjectKey = 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.AppObjectAssociationKey = exports.AppObjectKey = exports.ThemeKey = exports.AppKey = void 0;
 // Top Level Component types
 const path = __importStar(require("path"));
 // Component types
@@ -51,63 +51,99 @@ 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.AppObjectKey]: {
         dir: 'app-objects',
         parentComponent: exports.AppKey,
+        ...SubComponentFields,
+        userFriendlyName: 'App Object',
     },
     [exports.AppObjectAssociationKey]: {
         dir: 'app-object-associations',
         parentComponent: exports.AppKey,
+        ...SubComponentFields,
+        userFriendlyName: 'App Object Association',
     },
     [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,29 +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: copy_1.errorMessages.file.errorWithFileHeader(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

@@ -71,7 +71,7 @@ function parseFile(fileLoadResult) {
         parsedFileContents = JSON.parse(fileLoadResult.content);
     }
     catch (_e) {
-        fileLoadResult.errors?.push(copy_1.errorMessages.file.invalidJson);
+        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/transform.d.ts

@@ -1,3 +1,4 @@
 import { FileParseResult, IntermediateRepresentation, Transformation } from './types';
+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,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapToUserFacingType = mapToUserFacingType;
 exports.transform = transform;
 exports.getIntermediateRepresentation = getIntermediateRepresentation;
 const constants_1 = require("./constants");
@@ -24,9 +25,14 @@ function calculateComponentDeps(fileValidationResult, parentComponents, appObjec
     return dependencies;
 }
 function mapToInternalType(type) {
-    const resolvedType = constants_1.externalTypeToInternalType[type] || type || '';
+    const resolvedType = constants_1.userFacingToInternalType[type] || type || '';
     return resolvedType.toUpperCase().replace(/-/g, '_');
 }
+function mapToUserFacingType(type) {
+    return (constants_1.internalTypeToUserFacing[type] || type || '')
+        .toLowerCase()
+        .replace(/_/g, '-');
+}
 function transform(fileParseResults) {
     const parentTypes = Object.keys(constants_1.ProjectStructure);
     const parentComponents = {};
@@ -61,6 +67,9 @@ function transform(fileParseResults) {
 }
 function getIntermediateRepresentation(transformations) {
     const nodes = transformations.reduce((acc, current) => {
+        if (!current.intermediateRepresentation) {
+            return acc;
+        }
         const { uid } = current.intermediateRepresentation;
         if (acc[uid]) {
             const duplicates = transformations

package/src/lib/types.d.ts

@@ -1,4 +1,5 @@
 export type Dependencies = Record<string, string | string[]>;
+import { ErrorObject } from 'ajv-draft-04';
 export interface Components {
     uid: string;
     type: string;
@@ -32,9 +33,9 @@ export interface IntermediateRepresentation {
 export type Transformation = {
     intermediateRepresentation?: IntermediateRepresentationNode | null;
     fileParseResult: FileParseResult;
+    schemaValidationErrors?: ErrorObject[] | null;
 };
 export type CompiledError = {
-    message: string;
     errors: string[];
 };
 export interface TranslationContext {

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

@@ -8,90 +8,84 @@ const schemas_1 = require("./schemas");
 const ajv_draft_04_1 = __importDefault(require("ajv-draft-04"));
 const errors_1 = require("./errors");
 const copy_1 = require("../lang/copy");
-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(copy_1.errorMessages.file.missingUid);
+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]) {
-            if (!irNode.componentType) {
-                transformation[index].fileParseResult.errors.push(copy_1.errorMessages.file.missingType);
-            }
-            transformation[index].fileParseResult.errors.push(copy_1.errorMessages.file.unsupportedType(irNode.componentType));
-            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 = copy_1.errorMessages.file.errorWithField(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 copy_1.errorMessages.file.missingRequiredField(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);
 }