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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/project-parsing-lib",
-    "version": "0.0.5-experimental.0",
+    "version": "0.0.6-beta.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,5 +1,3 @@
-import { IntermediateRepresentation, IntermediateRepresentationNode, IntermediateRepresentationLocalDev, TranslationContext, TranslationOptions, IntermediateRepresentationNodeLocalDev } from './lib/types';
+import { IntermediateRepresentation, TranslationContext, TranslationOptions } 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,16 +1,12 @@
 "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");
 const copy_1 = require("./lang/copy");
-const path_1 = __importDefault(require("path"));
 const defaultOptions = {
     skipValidation: false,
 };
@@ -22,29 +18,13 @@ async function translate(translationContext, translationOptions = defaultOptions
     }
     const transformation = (0, transform_1.transform)(metafileContents);
     const intermediateRepresentation = (0, transform_1.getIntermediateRepresentation)(transformation);
-    // Remove once extensions and serverless functions are supported
     if (!skipValidation) {
-        await (0, validation_1.validateIntermediateRepresentation)(intermediateRepresentation, transformation, translationContext);
+        const { valid, errors } = await (0, validation_1.validateIntermediateRepresentation)(intermediateRepresentation, transformation, translationContext);
+        if (!valid) {
+            throw new errors_1.TranslationError(copy_1.errorMessages.project.failedToTranslateProject, errors);
+        }
     }
     return intermediateRepresentation;
 }
-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; } });
+var errors_2 = require("./lib/errors");
+Object.defineProperty(exports, "isTranslationError", { enumerable: true, get: function () { return errors_2.isTranslationError; } });

package/src/lang/copy.d.ts

@@ -1,4 +1,3 @@
-import { ComponentMetadata } from '../lib/constants';
 export declare const errorMessages: {
     api: {
         failedToFetchSchemas: string;
@@ -8,16 +7,14 @@ export declare const errorMessages: {
         failedToTranslateProject: string;
         duplicateUid: (uid: string, files: string[]) => string;
     };
-    validation: {
-        errorWithFileHeader: (file: string, errors: string[]) => string;
+    file: {
+        errorWithFileHeader: (file: 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,22 +6,18 @@ exports.errorMessages = {
         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- ')}`,
+        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(', ')}`,
     },
-    validation: {
-        errorWithFileHeader: (file, errors) => `\n\nEncountered the following errors for ${file}:\n\t- ${errors.join('\n\t- ')}`,
+    file: {
+        errorWithFileHeader: (file) => `Encountered the following errors for ${file}:`,
         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

@@ -1,5 +1,7 @@
 export declare const AppKey = "app";
 export declare const ThemeKey = "theme";
+export declare const AppObjectKey = "app-object";
+export declare const AppObjectAssociationKey = "app-object-association";
 export declare const CallingKey = "calling";
 export declare const CardsKey = "card";
 export declare const FunctionsKey = "function";
@@ -9,17 +11,13 @@ export declare const TimelineEventsKey = "timeline-event";
 export declare const VideoConferencingKey = "video-conferencing";
 export declare const WebhooksKey = "webhooks";
 export declare const WorkflowActionsKey = "workflow-action";
-export interface ComponentMetadata {
+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 userFacingToInternalType: Record<string, string>;
-export declare const internalTypeToUserFacing: Record<string, string>;
+export declare const externalTypeToInternalType: Record<string, string>;
 export declare const metafileExtension = "-hsmeta.json";
 export declare const allowedAppSubComponentsDirs: string[];
 export declare const allowedThemeSubComponentsDirs: string[];
@@ -29,3 +27,4 @@ export declare const ProjectStructure: {
 };
 export declare const allowedComponentDirectories: string[];
 export declare const allowedSubComponentDirectories: string[];
+export {};

package/src/lib/constants.js

@@ -33,13 +33,15 @@ 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.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;
+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;
 // Top Level Component types
 const path = __importStar(require("path"));
 // Component types
 exports.AppKey = 'app';
 exports.ThemeKey = 'theme';
 // Sub-Component types
+exports.AppObjectKey = 'app-object';
+exports.AppObjectAssociationKey = 'app-object-association';
 exports.CallingKey = 'calling';
 exports.CardsKey = 'card';
 exports.FunctionsKey = 'function';
@@ -49,87 +51,63 @@ 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,
-        userFriendlyName: 'App',
-        ...TopLevelComponentFields,
+        isToplevel: true,
+    },
+    [exports.AppObjectKey]: {
+        dir: 'app-objects',
+        parentComponent: exports.AppKey,
+    },
+    [exports.AppObjectAssociationKey]: {
+        dir: 'app-object-associations',
+        parentComponent: exports.AppKey,
     },
     [exports.ThemeKey]: {
         dir: exports.ThemeKey,
-        userFriendlyName: 'Theme',
-        ...TopLevelComponentFields,
+        isToplevel: true,
     },
     [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,
     },
 };
-const internalAppKey = 'APPLICATION';
-exports.userFacingToInternalType = {
-    [exports.AppKey]: internalAppKey,
+exports.externalTypeToInternalType = {
+    [exports.AppKey]: 'application',
 };
-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,10 +1,8 @@
-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;
+import { CompiledError, Transformation } from './types';
 export declare class TranslationError extends Error {
     private errors;
-    private translationContext;
-    constructor(message: string, transformations: Transformation[], errors: (ErrorObject[] | null | undefined)[], translationContext: TranslationContext);
+    constructor(message: string, errors: CompiledError[]);
     toString(): string;
 }
+export declare function isTranslationError(error: unknown): error is TranslationError;
+export declare function compileError(validatedTransformation: Transformation): CompiledError;

package/src/lib/errors.js

@@ -1,152 +1,29 @@
 "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 = [];
-    translationContext;
-    constructor(message, transformations, errors, translationContext) {
+    errors;
+    constructor(message, errors) {
         super(message);
         this.name = 'TranslationError';
-        this.translationContext = translationContext;
-        this.errors = transformations.map((transformation, index) => compileTranslationErrors(transformation, errors[index]));
+        this.errors = errors;
     }
-    // Returns a formatted string for all the errors in all the files
     toString() {
-        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}`;
+        return `${this.message}: ${this.errors.map(({ message, errors }) => `\n\n${message} \n\t- ${errors.join('\n\t- ')}`)}`;
     }
 }
 exports.TranslationError = 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 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 isTranslationError(error) {
+    return error instanceof TranslationError;
 }
-function mergeEnumErrors(cur, next) {
+function compileError(validatedTransformation) {
+    const { fileParseResult } = validatedTransformation;
+    const { errors, file: filePath } = fileParseResult;
     return {
-        ...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,
-            ],
-        },
+        message: copy_1.errorMessages.file.errorWithFileHeader(filePath),
+        errors,
     };
 }
-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.validation.invalidJson);
+        fileLoadResult.errors?.push(copy_1.errorMessages.file.invalidJson);
     }
     return { ...fileLoadResult, content: parsedFileContents };
 }

package/src/lib/schemas.d.ts

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

package/src/lib/transform.d.ts

@@ -1,5 +1,3 @@
 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,37 +1,44 @@
 "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,
-        // If the file has a parent, add it as a dependency
-        ...(fileValidationResult.parentDirectory
-            ? {
-                app: parentComponents[fileValidationResult.parentDirectory],
-            }
-            : {}),
-    };
+function calculateComponentDeps(fileValidationResult, parentComponents, appObjects) {
+    let dependencies = {};
+    // If there are dependencies in the config file, pass them through
+    if (!fileValidationResult.content?.dependencies) {
+        dependencies = { ...fileValidationResult.content?.dependencies };
+    }
+    const { type } = fileValidationResult.content;
+    // If the component is a child of the App component, add the app and appObjects as dependencies
+    if (constants_1.Components[type]?.parentComponent === constants_1.AppKey) {
+        const parentUid = parentComponents[fileValidationResult.parentDirectory];
+        if (parentUid) {
+            dependencies.app = parentUid;
+        }
+        if (type !== constants_1.AppObjectKey) {
+            dependencies.allAppObjects = appObjects;
+        }
+    }
+    return dependencies;
 }
 function mapToInternalType(type) {
-    return (constants_1.userFacingToInternalType[type] || type || '').toUpperCase();
-}
-function mapToUserFacingType(type) {
-    return (constants_1.internalTypeToUserFacing[type] || type || '').toLowerCase();
+    return (constants_1.externalTypeToInternalType[type] || type || '').toUpperCase();
 }
 function transform(fileParseResults) {
     const parentTypes = Object.keys(constants_1.ProjectStructure);
+    const parentComponents = {};
+    const appObjects = [];
     // Compute the parent components, so we can add them as dependencies to the child components
-    const parentComponents = fileParseResults.reduce((acc, file) => {
+    fileParseResults.forEach(file => {
         if (file.content?.type && parentTypes.includes(file.content.type)) {
-            acc[file.content.type] = file.content.uid;
+            parentComponents[file.content.type] = file.content.uid;
         }
-        return acc;
-    }, {});
+        if (file.content?.type === constants_1.AppObjectKey) {
+            appObjects.push(file.content.uid);
+        }
+    });
     return fileParseResults.map((currentFile) => {
         if (!currentFile.content) {
             currentFile.errors?.push(`File content is missing for ${currentFile.file}`);
@@ -43,7 +50,7 @@ function transform(fileParseResults) {
                 uid,
                 config,
                 componentType: mapToInternalType(type),
-                componentDeps: calculateComponentDeps(currentFile, parentComponents),
+                componentDeps: calculateComponentDeps(currentFile, parentComponents, appObjects),
                 metaFilePath: currentFile.file,
                 files: {},
             },

package/src/lib/types.d.ts

@@ -1,9 +1,9 @@
-import { ErrorObject } from 'ajv-draft-04';
+export type Dependencies = Record<string, string | string[]>;
 export interface Components {
     uid: string;
     type: string;
     config: unknown;
-    dependencies?: Record<string, unknown>;
+    dependencies?: Dependencies;
 }
 export interface FileActionResult {
     file: string;
@@ -18,7 +18,7 @@ export interface FileParseResult extends FileActionResult {
 }
 export interface IntermediateRepresentationNode {
     componentType: string;
-    componentDeps: Record<string, string>;
+    componentDeps: Dependencies;
     metaFilePath: string;
     uid: string;
     config: unknown;
@@ -29,23 +29,12 @@ 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 {

package/src/lib/validation.d.ts

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

package/src/lib/validation.js

@@ -8,77 +8,41 @@ 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");
-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);
+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);
         }
-        else {
-            transformation[index].fileParseResult.errors.push(copy_1.errorMessages.validation.unsupportedType(irNode.componentType));
+        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]),
+            };
         }
-        // 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 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 (shouldSkipValidation) {
+        const transformationWithUpdatedErrors = hydrateValidationErrorsIntoTransformation(transformation[index], validate.errors);
         return {
             valid: false,
-            errors: (0, errors_1.compileError)(transformation[index]),
+            errors: (0, errors_1.compileError)(transformationWithUpdatedErrors),
         };
-    }
-    const validate = ajv.compile(schema[irNode.componentType]);
-    const valid = validate(irNode.config);
-    if (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]),
-            };
-    }
-    return {
-        valid: false,
-        schemaValidationErrors: validate.errors,
-    };
-}
-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);
     });
     const valid = results.every(result => result.valid);
     if (valid) {
@@ -86,6 +50,48 @@ async function validateIntermediateRepresentation(intermediateRepresentation, tr
             valid,
         };
     }
-    const schemaValidationErrors = results.map(result => result.schemaValidationErrors);
-    throw new errors_1.TranslationError(copy_1.errorMessages.project.failedToTranslateProject, transformation, schemaValidationErrors, translationContext);
+    const errors = results
+        .filter(item => item.errors !== undefined)
+        .map(result => result.errors);
+    return {
+        valid,
+        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 };
+    });
+    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- ')}`
+            : ''}`;
+    }
+    return errorMessage;
 }