@hubspot/project-parsing-lib 0.0.1

package/LICENSE

@@ -0,0 +1,12 @@
+Copyright 2019  HubSpot, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,38 @@
+# project-translation-layer
+
+## Description
+This project is a translation layer that can be used to translate a project to its immediate representation prior to being uploaded
+to the project v2 service.
+
+## Flow Chart
+
+```mermaid
+sequenceDiagram
+    autonumber
+    
+    actor dev as External Developer
+    participant cli as HS CLI
+    participant ppl as Project Parsing Library
+    participant pv3 as Projects v3
+    
+    dev ->> cli: Developer runs `hs project upload`
+    cli ->> cli: Loads project config
+    cli ->> ppl: CLI calls `translate` function with the values required from the project config
+    ppl ->> ppl: Walks the project directory looking for the hsmeta files
+    loop For each hsmeta file
+        ppl ->> ppl: Checks if file is valid JSON
+        ppl ->> ppl: Checks if the file is in a valid location
+        ppl ->> ppl: Generates the IR
+    end
+    ppl ->> pv3: Fetch the schemas used to validate the generated IR
+    loop For each hsmeta file
+        ppl ->> ppl: Validate the IR config block against the schema
+    end
+    alt Validation successful for all schemas
+        ppl ->> cli: Pass the IR back to the CLI
+        cli ->> cli: Zip the project contents
+        cli ->> pv3: Upload the project and the IR
+    else Validation failed for 1+ schema(s)
+        ppl ->> cli: Log the error and exit the upload
+end
+```

package/package.json

@@ -0,0 +1,40 @@
+{
+    "name": "@hubspot/project-parsing-lib",
+    "version": "0.0.1",
+    "description": "Parsing library for converting projects directory structures to their intermediate representation",
+    "license": "Apache-2.0",
+    "main": "src/index.js",
+    "devDependencies": {
+        "@inquirer/prompts": "^7.1.0",
+        "@types/jest": "^29.5.14",
+        "@types/semver": "^7.5.8",
+        "@typescript-eslint/eslint-plugin": "^8.11.0",
+        "@typescript-eslint/parser": "^8.11.0",
+        "eslint": "^8.56.0",
+        "eslint-plugin-import": "^2.31.0",
+        "husky": "^9.1.7",
+        "jest": "^29.5.0",
+        "lint-staged": "^10.5.4",
+        "prettier": "^1.19.1",
+        "semver": "^7.6.3",
+        "ts-jest": "^29.2.5",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.6.2"
+    },
+    "dependencies": {
+        "@hubspot/local-dev-lib": "^3.1.0",
+        "ajv": "^8.17.1",
+        "ajv-draft-04": "^1.0.0"
+    },
+    "scripts": {
+        "build": "ts-node ./scripts/build.ts",
+        "lint": "eslint --max-warnings=0 . && prettier ./src/** --check",
+        "local-dev": "yarn build && yarn link --cwd=./dist && tsc --watch --rootDir . --outdir dist",
+        "prettier:write": "prettier ./src/** --write",
+        "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ./node_modules/.bin/jest",
+        "release": "yarn ts-node ./scripts/release.ts release"
+    },
+    "engines": {
+        "node": ">=18"
+    }
+}

package/src/index.d.ts

@@ -0,0 +1,3 @@
+import { IntermediateRepresentation, TranslationContext } from './lib/types';
+export declare function translate(translationContext: TranslationContext): Promise<IntermediateRepresentation>;
+export { isTranslationError } from './lib/errors';

package/src/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTranslationError = void 0;
+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");
+async function translate(translationContext) {
+    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');
+    }
+    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);
+    }
+    return intermediateRepresentation;
+}
+var errors_2 = require("./lib/errors");
+Object.defineProperty(exports, "isTranslationError", { enumerable: true, get: function () { return errors_2.isTranslationError; } });

package/src/lib/constants.d.ts

@@ -0,0 +1,27 @@
+export declare const AppKey = "app";
+export declare const ThemeKey = "theme";
+export declare const CallingKey = "calling";
+export declare const CardsKey = "card";
+export declare const FunctionsKey = "function";
+export declare const MarketingEventsKey = "marketing-event";
+export declare const MediaBridgeKey = "media-bridge";
+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 {
+    dir: string;
+    isToplevel?: boolean;
+    parentComponent?: string;
+}
+export declare const Components: Record<string, ComponentMetadata>;
+export declare const metafileExtension = "-hsmeta.json";
+export declare const allowedAppSubComponentsDirs: string[];
+export declare const allowedThemeSubComponentsDirs: string[];
+export declare const ProjectStructure: {
+    readonly app: string[];
+    readonly theme: string[];
+};
+export declare const allowedComponentDirectories: string[];
+export declare const allowedSubComponentDirectories: string[];
+export {};

package/src/lib/constants.js

@@ -0,0 +1,106 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allowedSubComponentDirectories = exports.allowedComponentDirectories = exports.ProjectStructure = exports.allowedThemeSubComponentsDirs = exports.allowedAppSubComponentsDirs = exports.metafileExtension = 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
+exports.AppKey = 'app';
+exports.ThemeKey = 'theme';
+// Sub-Component types
+exports.CallingKey = 'calling';
+exports.CardsKey = 'card';
+exports.FunctionsKey = 'function';
+exports.MarketingEventsKey = 'marketing-event';
+exports.MediaBridgeKey = 'media-bridge';
+exports.TimelineEventsKey = 'timeline-event';
+exports.VideoConferencingKey = 'video-conferencing';
+exports.WebhooksKey = 'webhooks';
+exports.WorkflowActionsKey = 'workflow-action';
+exports.Components = {
+    [exports.AppKey]: {
+        dir: exports.AppKey,
+        isToplevel: true,
+    },
+    [exports.ThemeKey]: {
+        dir: exports.ThemeKey,
+        isToplevel: true,
+    },
+    [exports.CallingKey]: {
+        dir: exports.CallingKey,
+        parentComponent: exports.AppKey,
+    },
+    [exports.CardsKey]: {
+        dir: 'cards',
+        parentComponent: exports.AppKey,
+    },
+    [exports.FunctionsKey]: {
+        dir: 'functions',
+        parentComponent: exports.AppKey,
+    },
+    [exports.MarketingEventsKey]: {
+        dir: 'marketing-events',
+        parentComponent: exports.AppKey,
+    },
+    MediaBridgeKey: {
+        dir: exports.MediaBridgeKey,
+        parentComponent: exports.AppKey,
+    },
+    [exports.TimelineEventsKey]: {
+        dir: 'timeline-events',
+        parentComponent: exports.AppKey,
+    },
+    [exports.VideoConferencingKey]: {
+        dir: exports.VideoConferencingKey,
+        parentComponent: exports.AppKey,
+    },
+    [exports.WebhooksKey]: {
+        dir: exports.WebhooksKey,
+        parentComponent: exports.AppKey,
+    },
+    [exports.WorkflowActionsKey]: {
+        dir: 'workflow-actions',
+        parentComponent: exports.AppKey,
+    },
+};
+exports.metafileExtension = '-hsmeta.json';
+function getSubComponentDirsForParentType(parentComponent) {
+    return Object.values(exports.Components).reduce((acc, item) => {
+        if (item.parentComponent === parentComponent) {
+            acc.push(item.dir);
+        }
+        return acc;
+    }, []);
+}
+exports.allowedAppSubComponentsDirs = getSubComponentDirsForParentType(exports.AppKey);
+exports.allowedThemeSubComponentsDirs = getSubComponentDirsForParentType(exports.ThemeKey);
+exports.ProjectStructure = {
+    [exports.AppKey]: exports.allowedAppSubComponentsDirs,
+    [exports.ThemeKey]: exports.allowedThemeSubComponentsDirs,
+};
+exports.allowedComponentDirectories = Object.keys(exports.ProjectStructure);
+exports.allowedSubComponentDirectories = Object.entries(exports.ProjectStructure)
+    .map(([key, value]) => value.map((value) => path.join(key, value)))
+    .flat();

package/src/lib/errors.d.ts

@@ -0,0 +1,8 @@
+import { CompiledError, Transformation } from './types';
+export declare class TranslationError extends Error {
+    private errors;
+    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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TranslationError = void 0;
+exports.isTranslationError = isTranslationError;
+exports.compileError = compileError;
+class TranslationError extends Error {
+    errors;
+    constructor(message, errors) {
+        super(message);
+        this.name = 'TranslationError';
+        this.errors = errors;
+    }
+    toString() {
+        return `${this.message}: ${this.errors.map(({ message, errors }) => `\n\n${message} \n\t- ${errors.join('\n\t- ')}`)}`;
+    }
+}
+exports.TranslationError = TranslationError;
+function isTranslationError(error) {
+    return error instanceof TranslationError;
+}
+function compileError(validatedTransformation) {
+    const { fileParseResult } = validatedTransformation;
+    const { errors, file: filePath } = fileParseResult;
+    return {
+        message: `Encountered the following errors for ${filePath}:`,
+        errors,
+    };
+}

package/src/lib/files.d.ts

@@ -0,0 +1,2 @@
+import { FileParseResult, TranslationContext } from './types';
+export declare function loadHsMetaFiles(translationContext: TranslationContext): Promise<FileParseResult[]>;

package/src/lib/files.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadHsMetaFiles = loadHsMetaFiles;
+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"));
+async function loadHsMetaFiles(translationContext) {
+    const metaFiles = await locateHsMetaFiles(translationContext);
+    return parseHsMetaFiles(metaFiles, translationContext);
+}
+async function locateHsMetaFiles(translationContext) {
+    const { projectSourceDir } = translationContext;
+    return (await (0, fs_1.walk)(projectSourceDir, ['node_modules'])).reduce((metaFiles, file) => {
+        // Ignore the node_modules directory
+        if (file.includes('node_modules')) {
+            return metaFiles;
+        }
+        const pathRelativeToProjectSrcDir = path_1.default.relative(projectSourceDir, file);
+        if (!pathRelativeToProjectSrcDir.endsWith(constants_1.metafileExtension)) {
+            return metaFiles;
+        }
+        const { dir: metaFileDir } = path_1.default.parse(pathRelativeToProjectSrcDir);
+        const parent = metaFileDir.split(path_1.default.sep)[0];
+        if (constants_1.allowedComponentDirectories.includes(metaFileDir)) {
+            metaFiles.push({ file });
+        }
+        else if (constants_1.allowedSubComponentDirectories.includes(metaFileDir)) {
+            metaFiles.push({ file, parent });
+        }
+        else {
+            console.warn(`Skipping ${pathRelativeToProjectSrcDir} as it is not in a valid directory`);
+        }
+        return metaFiles;
+    }, []);
+}
+async function parseHsMetaFiles(metaFileLocations, translationContext) {
+    const fileLoadResults = await Promise.all(metaFileLocations.map(fileLocation => {
+        return loadFile(fileLocation, translationContext);
+    }));
+    return fileLoadResults.map(result => parseFile(result));
+}
+function loadFile(metaFileLocation, translationContext) {
+    const { projectSourceDir } = translationContext;
+    return new Promise(async (resolve) => {
+        const { file, parent } = metaFileLocation;
+        fs_2.default.readFile(file, 'utf-8', (err, content) => {
+            if (err) {
+                return resolve({
+                    file,
+                    errors: [err.message],
+                });
+            }
+            resolve({
+                file: path_1.default.relative(projectSourceDir, file),
+                content,
+                parent,
+                errors: [],
+            });
+        });
+    });
+}
+function parseFile(fileLoadResult) {
+    if (!fileLoadResult.content) {
+        // This is just to please TS, revisit this hack
+        return { ...fileLoadResult, content: undefined };
+    }
+    let parsedFileContents;
+    try {
+        parsedFileContents = JSON.parse(fileLoadResult.content);
+    }
+    catch (_e) {
+        fileLoadResult.errors?.push('Invalid JSON');
+    }
+    return { ...fileLoadResult, content: parsedFileContents };
+}

package/src/lib/schemas.d.ts

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

package/src/lib/schemas.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIntermediateRepresentationSchema = getIntermediateRepresentationSchema;
+const http_1 = require("@hubspot/local-dev-lib/http");
+async function getIntermediateRepresentationSchema(translationContext) {
+    // This is just a placeholder that resolves the hardcoded object until we
+    // implement the actual logic to load the schemas from the backend
+    try {
+        const { accountId } = 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`,
+        });
+        return data;
+    }
+    catch (e) {
+        throw new Error('Failed to fetch schemas', { cause: e });
+    }
+}

package/src/lib/transform.d.ts

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

package/src/lib/transform.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform = transform;
+exports.getIntermediateRepresentation = getIntermediateRepresentation;
+const constants_1 = require("./constants");
+function calculateComponentDeps(fileValidationResult, parentComponents) {
+    return {
+        ...fileValidationResult.content?.dependencies,
+        // If the file has a parent, add it as a dependency
+        ...(fileValidationResult.parent
+            ? { upstreamBuildArtifact: parentComponents[fileValidationResult.parent] }
+            : {}),
+    };
+}
+function transform(fileParseResults) {
+    const parentTypes = Object.keys(constants_1.ProjectStructure);
+    // Compute the parent components, so we can add them as dependencies to the child components
+    const parentComponents = fileParseResults.reduce((acc, file) => {
+        if (file.content?.type && parentTypes.includes(file.content.type)) {
+            acc[file.content.type] = file.content.uid;
+        }
+        return acc;
+    }, {});
+    return fileParseResults.map((currentFile) => {
+        if (!currentFile.content) {
+            currentFile.errors?.push(`File content is missing for ${currentFile.file}`);
+            return { intermediateRepresentation: null, fileParseResult: currentFile };
+        }
+        const { config, uid } = currentFile.content;
+        return {
+            intermediateRepresentation: {
+                uid,
+                config,
+                componentType: currentFile.content?.type.toUpperCase() || '',
+                componentDeps: calculateComponentDeps(currentFile, parentComponents),
+                files: {},
+            },
+            fileParseResult: currentFile,
+        };
+    });
+}
+function getIntermediateRepresentation(transformations) {
+    const nodes = transformations.reduce((acc, current) => {
+        return {
+            ...acc,
+            [current.intermediateRepresentation
+                .uid]: current.intermediateRepresentation,
+        };
+    }, {});
+    return {
+        intermediateNodesIndexedByUid: nodes,
+    };
+}

package/src/lib/types.d.ts

@@ -0,0 +1,42 @@
+export interface Components {
+    uid: string;
+    type: string;
+    config: unknown;
+    dependencies?: Record<string, unknown>;
+}
+export interface FileActionResult {
+    file: string;
+    parent?: string;
+    errors: string[];
+}
+export interface FileLoadResult extends FileActionResult {
+    content?: string;
+}
+export interface FileParseResult extends FileActionResult {
+    content?: Components;
+}
+export interface IntermediateRepresentationNode {
+    componentType: string;
+    componentDeps: Record<string, string>;
+    uid: string;
+    config: unknown;
+    files: unknown;
+}
+export interface IntermediateRepresentation {
+    intermediateNodesIndexedByUid: {
+        [key: string]: IntermediateRepresentationNode;
+    };
+}
+export type Transformation = {
+    intermediateRepresentation?: IntermediateRepresentationNode | null;
+    fileParseResult: FileParseResult;
+};
+export type CompiledError = {
+    message: string;
+    errors: string[];
+};
+export interface TranslationContext {
+    projectSourceDir: string;
+    platformVersion: string;
+    accountId: number;
+}

package/src/lib/types.js

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

package/src/lib/validation.d.ts

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

package/src/lib/validation.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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'`);
+        }
+        if (!schema[irNode.componentType]) {
+            transformation[index].fileParseResult.errors.push(`Unsupported 'type': '${irNode.componentType.toLowerCase()}'`);
+            return {
+                valid: false,
+                errors: (0, errors_1.compileError)(transformation[index]),
+            };
+        }
+        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]),
+                };
+        }
+        const transformationWithUpdatedErrors = hydrateValidationErrorsIntoTransformation(transformation[index], validate.errors);
+        return {
+            valid: false,
+            errors: (0, errors_1.compileError)(transformationWithUpdatedErrors),
+        };
+    });
+    const valid = results.every(result => result.valid);
+    if (valid) {
+        return {
+            valid,
+        };
+    }
+    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 = `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- ')}`
+            : ''}`;
+    }
+    return errorMessage;
+}