@accordproject/template-engine 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@accordproject/template-engine",
-    "version": "1.0.0",
+    "version": "1.0.2",
     "description": "Generation of AgreementMark from TemplateMark + JSON Data",
     "homepage": "https://github.com/accordproject",
     "engines": {
@@ -8,7 +8,10 @@
         "npm": ">=6"
     },
     "main": "dist/index.js",
-    "typings": "dist/index.d.ts",
+    "types": "dist/index.d.ts",
+    "files": [
+        "/dist"
+    ],
     "scripts": {
         "clean": "rimraf dist",
         "prebuild": "npm-run-all clean",

package/.github/workflows/npm-publish.yml

@@ -1,37 +0,0 @@
-# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
-# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
-
-name: Node.js Package
-
-on:
-  release:
-    types: [created]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 16
-      - run: npm ci
-      - run: npm test
-
-  publish-npm:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 16
-          registry-url: https://registry.npmjs.org/
-      - name: build and publish
-        run: |
-          npm ci
-          npm config set //registry.npmjs.org/:_authToken ${{ secrets.NPM_TOKEN }}
-          npm version --no-git-tag-version --yes --exact ${{ steps.timestamp.outputs.stamp }}
-          npm publish --access public ${{ steps.tag.outputs.tag }} 2>&1
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/src/Common.ts

@@ -1,58 +0,0 @@
-/*
- * 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.
- */
-
-import { ClassDeclaration, Introspector, ModelManager } from '@accordproject/concerto-core';
-import { TemplateMarkModel } from '@accordproject/markdown-common';
-
-// use to create agreementmark from templatemark
-export const TEMPLATEMARK_RE = /^(org\.accordproject\.templatemark)@(.+)\.(\w+)Definition$/;
-export const FORMULA_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.FormulaDefinition$/;
-export const VARIABLE_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.VariableDefinition$/;
-export const CONDITIONAL_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.ConditionalDefinition$/;
-export const ENUM_VARIABLE_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.EnumVariableDefinition$/;
-export const FORMATTED_VARIABLE_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.FormattedVariableDefinition$/;
-export const WITH_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.WithDefinition$/;
-export const LISTBLOCK_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.ListBlockDefinition$/;
-export const JOIN_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.JoinDefinition$/;
-export const OPTIONAL_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.OptionalDefinition$/;
-export const CLAUSE_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.ClauseDefinition$/;
-export const CONTRACT_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.ContractDefinition$/;
-
-export type TemplateData = Record<string, unknown>;
-
-/**
- * TemplateMark nodes that implicity change the data access scope
- * by specifying the name of a property on the node.
- */
-export const NAVIGATION_NODES = [
-    `${TemplateMarkModel.NAMESPACE}.ListBlockDefinition`,
-    `${TemplateMarkModel.NAMESPACE}.WithDefinition`,
-    `${TemplateMarkModel.NAMESPACE}.JoinDefinition`,
-    `${TemplateMarkModel.NAMESPACE}.OptionalDefinition`,
-    `${TemplateMarkModel.NAMESPACE}.ClauseDefinition`
-];
-
-export function getTemplateClassDeclaration(modelManager: ModelManager) : ClassDeclaration {
-    const introspector = new Introspector(modelManager);
-    const templateModels = introspector.getClassDeclarations().filter((item) => {
-        return !item.isAbstract() && item.getDecorator('template');
-    });
-    if (templateModels.length > 1) {
-        throw new Error('Found multiple concepts with @template decorator. The model for the template must contain a single concept with the @template decorator.');
-    } else if (templateModels.length === 0) {
-        throw new Error('Failed to find a concept with the @template decorator. The model for the template must contain a single concept with the @template decoratpr.');
-    } else {
-        return templateModels[0];
-    }
-}

package/src/TemplateMarkInterpreter.ts

@@ -1,420 +0,0 @@
-/*
- * 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.
- */
-
-import dayjs from 'dayjs';
-import jp from 'jsonpath';
-import traverse from 'traverse';
-
-import { ClassDeclaration, Factory, Introspector, ModelManager, Serializer } from '@accordproject/concerto-core';
-import { draftingMap } from './drafting';
-import { TemplateMarkModel, CommonMarkModel, CiceroMarkModel, ConcertoMetaModel } from '@accordproject/markdown-common';
-import { ModelUtil } from '@accordproject/concerto-core';
-
-import {
-    TEMPLATEMARK_RE,
-    FORMULA_DEFINITION_RE,
-    VARIABLE_DEFINITION_RE,
-    CONDITIONAL_DEFINITION_RE,
-    ENUM_VARIABLE_DEFINITION_RE,
-    FORMATTED_VARIABLE_DEFINITION_RE,
-    WITH_DEFINITION_RE,
-    LISTBLOCK_DEFINITION_RE,
-    JOIN_DEFINITION_RE,
-    OPTIONAL_DEFINITION_RE,
-    CLAUSE_DEFINITION_RE,
-    CONTRACT_DEFINITION_RE,
-    TemplateData,
-    NAVIGATION_NODES,
-    getTemplateClassDeclaration
-} from './Common';
-import { TemplateMarkToJavaScriptCompiler } from './TemplateMarkToJavaScriptCompiler';
-
-/**
- * Evaluates a JS expression
- * @param {*} clauseLibrary the clause library
- * @param {*} data the contract data
- * @param {string} fn the JS function (including header)
- * @param {Date} now the current value for now
- * @returns {object} the result of evaluating the expression against the data
- */
-function evaluateJavaScript(clauseLibrary:object, data: TemplateData, fn: string, now?: dayjs.Dayjs): object {
-    if (!data || !fn) {
-        throw new Error(`Cannot evaluate JS ${fn} against ${data}`);
-    }
-    const runtimeNow = now ? now : dayjs();
-    const functionArgNames = new Array<string>();
-    functionArgNames.push('data');
-    functionArgNames.push('library');
-    functionArgNames.push('now');
-    functionArgNames.push('jp');
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const functionArgValues = new Array<any>();
-    functionArgValues.push(data);
-    functionArgValues.push(clauseLibrary);
-    functionArgValues.push(runtimeNow);
-    functionArgValues.push(jp);
-
-    // chop the function header and closing
-    const expression = fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}'));
-    if(expression.trim().length === 0) {
-        throw new Error('Empty expression');
-    }
-    try {
-        const fun = new Function(...functionArgNames, expression); // SECURITY!
-        const result = fun(...functionArgValues);
-        return result;
-    }
-    catch(err) {
-        throw new Error(`Caught error ${err} evaluating ${expression} with arguments ${functionArgValues}`);
-    }
-}
-
-/**
- * Calculates a JSON path to use to retrieve data, based on a TemplatemMark tree.
- * For example, if we hit a VariableDefinition {{city}} that is nested inside a
- * WithDefinition {{#with address}} then the JSON path returned should be '$.address.city'.
- * Similarly ListBlockDefinition, JoinDefinition and OptionalDefinition also include
- * property names that must apply to their child nodes.
- * @param {*} rootData the root of the JSON document, typically this is a TemplateMark JSON
- * @param {*} currentNode the current TemplateMark node we are processing
- * @param {string[]} paths the traverse path to the current node
- * @returns {string} the JSON path to use to retrieve data
- */
-function getJsonPath(rootData:any, currentNode:any, paths:string[]) : string {
-    if(!currentNode) {
-        throw new Error('Node must be supplied');
-    }
-    if(!currentNode.name) {
-        throw new Error(`Node must have a name: ${JSON.stringify(currentNode)}`);
-    }
-    if(currentNode.name.indexOf('.') >=0) {
-        // prevent JSON path injection
-        throw new Error(`Invalid name property ${currentNode.name}`);
-    }
-    if(!paths || !paths.length || paths.length <1 ) {
-        throw new Error('Paths must be supplied');
-    }
-    const withPath = [];
-    for (let n = 1; n < paths.length; n++) {
-        const sub = paths.slice(0, n);
-        const obj = traverse.get(rootData, sub);
-        // HACK
-        // if(obj===undefined) {
-        //     throw new Error(`Failed to find data with path ${sub} and data ${JSON.stringify(rootData, null, 2)}`);
-        // }
-        if (obj && obj.$class) {
-            if(NAVIGATION_NODES.indexOf(obj.$class) >= 0) {
-                withPath.push(`['${obj.name}']`);
-            }
-        }
-    }
-
-    if(currentNode.name !== 'this') {
-        withPath.push(`['${currentNode.name}']`);
-    }
-
-    return withPath.length > 0 ? `$${withPath.join('')}` : '$';
-}
-
-/**
- * Generates an AgreementMark JSON document from a template plus data.
- * @param {ModelManager} modelManager - the template model
- * @param {*} clauseLibrary - the clause library
- * @param {*} templateMark - the TemplateMark JSON document
- * @param {*} data - the template data JSON
- * @param {[dayjs.Dayjs]} now - date/time to use for the now variable
- * @returns {*} the AgreementMark JSON
- */
-function generateAgreement(modelManager:ModelManager, clauseLibrary:object, templateMark: object, data: TemplateData, now?:dayjs.Dayjs): any {
-    const introspector = new Introspector(modelManager);
-    return traverse(templateMark).map(function (context: any) {
-        let stopHere = false;
-        if (typeof context === 'object' && context.$class && typeof context.$class === 'string') {
-            const nodeClass = context.$class as string;
-
-            // rewrite node types, mapping from TemplateMark namespace to CiceroMark
-            const match = nodeClass.match(TEMPLATEMARK_RE);
-            if (match && match.length > 1) {
-                context.$class = `${CiceroMarkModel.NAMESPACE}.${match[3]}`;
-            }
-
-            // convert a contract node to a clause note HACK
-            if (CONTRACT_DEFINITION_RE.test(nodeClass)) {
-                context.$class = `${CommonMarkModel.NAMESPACE}.Paragraph`;
-                delete context.name;
-                delete context.elementType;
-            }
-
-            // convert a WithDefinition to a Paragraph in the output
-            // not 100% sure we want to do that ... we may need to process
-            // the child variable nodes and reparent them?
-            if (WITH_DEFINITION_RE.test(nodeClass)) {
-                context.$class = `${CommonMarkModel.NAMESPACE}.Paragraph`;
-                delete context.name;
-                delete context.elementType;
-            }
-
-            // add a 'value' property to FormulaDefinition
-            // with the result of evaluating the JS code
-            else if (FORMULA_DEFINITION_RE.test(nodeClass)) {
-                if (context.code) {
-                    const result = evaluateJavaScript(clauseLibrary, data, context.code.contents, now);
-                    if(result === null) {
-                        context.value = '<null>';
-                    }
-                    else if(typeof result === 'string') {
-                        context.value = result;
-                    }
-                    else {
-                        context.value = JSON.stringify(result);
-                    }
-                    delete context.code;
-                }
-                else {
-                    throw new Error('Formula node is missing code.');
-                }
-            }
-
-            // evaluate lists, recursing on each list item
-            else if (LISTBLOCK_DEFINITION_RE.test(nodeClass)) {
-                const path = getJsonPath(templateMark, context, this.path);
-                const variableValues = jp.query(data, path, 1);
-
-                if (variableValues.length === 0) {
-                    throw new Error(`No values found for path '${path}' in data ${data}.`);
-                }
-                else {
-                    const arrayData = variableValues[0];
-                    if(!Array.isArray(arrayData)) {
-                        throw new Error(`Values found for path '${path}' in data ${data} is not an array: ${arrayData}.`);
-                    }
-                    else {
-                        context.$class = `${CommonMarkModel.NAMESPACE}.List`;
-                        delete context.elementType;
-                        delete context.name;
-                        context.nodes = arrayData.map( arrayItem => {
-                            // arrayItem is now the data for the nested traversal
-                            const subResult = generateAgreement(modelManager, clauseLibrary, context.nodes[0].nodes[0], arrayItem);
-                            return {
-                                $class: `${CommonMarkModel.NAMESPACE}.Item`,
-                                nodes: subResult.nodes ? subResult.nodes : []
-                            };
-                        });
-                        stopHere = true; // do not process child nodes, we've already done it above...
-                    }
-                }
-            }
-
-            // map over an array of items, joining them into a Text node
-            else if (JOIN_DEFINITION_RE.test(nodeClass)) {
-                const path = getJsonPath(templateMark, context, this.path);
-                const variableValues = jp.query(data, path, 1);
-
-                if (variableValues.length === 0) {
-                    throw new Error(`No values found for path '${path}' in data ${data}.`);
-                }
-                else {
-                    const arrayData = variableValues[0];
-                    if(!Array.isArray(arrayData)) {
-                        throw new Error(`Values found for path '${path}' in data ${data} is not an array: ${arrayData}.`);
-                    }
-                    else {
-                        context.$class = `${CommonMarkModel.NAMESPACE}.Text`;
-                        const drafter = draftingMap.get(context.elementType);
-                        context.text = arrayData.map( arrayItem => {
-                            return drafter ? drafter(arrayItem, context.format) : arrayItem as string;
-                        }).join(context.separator);
-                        delete context.elementType;
-                        delete context.name;
-                        delete context.separator;
-                        delete context.nodes;
-                        stopHere = true; // do not process child nodes, we've already done it above...
-                    }
-                }
-            }
-
-            // add a 'value' property to VariableDefinition
-            // with the value of the variable from 'data'
-            else if (VARIABLE_DEFINITION_RE.test(nodeClass) ||
-                ENUM_VARIABLE_DEFINITION_RE.test(nodeClass) ||
-                FORMATTED_VARIABLE_DEFINITION_RE.test(nodeClass)) {
-                if(typeof data === 'object') {
-                    const path = getJsonPath(templateMark, context, this.path);
-                    const variableValues = jp.query(data, path, 1);
-                    if (variableValues.length === 0) {
-                        throw new Error(`No values found for path '${path}' in data ${data}.`);
-                    }
-                    else {
-                        // convert the value to a string, optionally using the formatter
-                        const variableValue = variableValues[0];
-                        const drafter = draftingMap.get(context.elementType);
-                        context.value = drafter ? drafter(variableValue, context.format) : JSON.stringify(variableValue) as string;
-                    }
-                }
-                else {
-                    // a list of enum values or primitives brings us here
-                    const variableValue = data;
-                    const type = (ModelUtil as any).isPrimitiveType(context.elementType) ? null : introspector.getClassDeclaration(context.elementType);
-                    // we want to draft Enums as strings, not objects
-                    const drafter = draftingMap.get(type && type.isEnum() ? 'String' : context.elementType);
-                    context.value = drafter ? drafter(variableValue, context.format) : JSON.stringify(variableValue) as string;
-                }
-            }
-
-            // add a 'isTrue' property to ConditionDefinition
-            // with the result of evaluating the JS code or a boolean property
-            else if (CONDITIONAL_DEFINITION_RE.test(nodeClass)) {
-                if (context.condition) {
-                    context.isTrue = !!evaluateJavaScript(clauseLibrary, data, context.condition.contents, now) as unknown as boolean;
-                }
-                else {
-                    const path = getJsonPath(templateMark, context, this.path);
-                    const variableValues = jp.query(data, path, 1);
-                    if (variableValues && variableValues.length) {
-                        if(variableValues.length === 1) {
-                            context.isTrue = !!variableValues[0];
-                        }
-                        else {
-                            throw new Error(`Multiple values found for path '${path}' in data ${data}.`);
-                        }
-                    }
-                    else {
-                        context.isTrue = false;
-                    }
-                }
-                context.nodes = context.isTrue ? context.whenTrue : context.whenFalse;
-                delete context.condition;
-                delete context.dependencies;
-                delete context.functionName;
-            }
-
-            // only include the children of a clause if its condition is true
-            else if (CLAUSE_DEFINITION_RE.test(nodeClass)) {
-                if (context.condition) {
-                    const result = !!evaluateJavaScript(clauseLibrary, data, context.condition.contents, now) as unknown as boolean;
-                    if(!result) {
-                        delete context.nodes;
-                        stopHere = true;
-                    }
-                }
-                delete context.condition;
-                delete context.functionName;
-            }
-
-            // add a 'hasSome' property to OptionalDefinition
-            else if (OPTIONAL_DEFINITION_RE.test(nodeClass)) {
-                const path = getJsonPath(templateMark, context, this.path);
-                const variableValues = jp.query(data, path, 1);
-                if (variableValues && variableValues.length) {
-                    if(variableValues.length === 1) {
-                        context.hasSome = true;
-                        context.whenNone = [];
-                    }
-                    else {
-                        throw new Error(`Multiple values found for path '${path}' in data ${data}.`);
-                    }
-                }
-                else {
-                    context.hasSome = false;
-                    context.whenSome = [];
-                }
-                context.nodes = context.hasSome ? context.whenSome : context.whenNone;
-            }
-        }
-        this.update(context, stopHere);
-    });
-}
-
-/**
- * A template engine: merges the markup and logic of a template with
- * JSON data to produce JSON data.
- */
-export class TemplateMarkInterpreter {
-    modelManager: ModelManager;
-    templateClass: ClassDeclaration;
-    clauseLibrary: object;
-
-    constructor(modelManager: ModelManager, clauseLibrary:object) {
-        this.modelManager = modelManager;
-        this.clauseLibrary = clauseLibrary;
-        this.templateClass = getTemplateClassDeclaration(this.modelManager);
-    }
-
-    /**
-     * Checks that a TemplateMark JSON document is valid with respect to the
-     * TemplateMark model, as well as the template model.
-     *
-     * Checks:
-     * 1. Variable names are valid properties in the template model
-     * 2. Optional properties have guards
-     * @param {*} templateMark the TemplateMark JSON object
-     * @returns {*} TemplateMark JSON that has been typed checked and has type metadata added
-     * @throws {Error} if the templateMark document is invalid
-     */
-    checkTypes(templateMark: object): object {
-        const modelManager = new ModelManager({ strict: true });
-        modelManager.addCTOModel(ConcertoMetaModel.MODEL, 'concertometamodel.cto');
-        modelManager.addCTOModel(CommonMarkModel.MODEL, 'commonmark.cto');
-        modelManager.addCTOModel(TemplateMarkModel.MODEL, 'templatemark.cto');
-        const factory = new Factory(modelManager);
-        const serializer = new Serializer(factory, modelManager);
-        try {
-            serializer.fromJSON(templateMark);
-            return templateMark;
-        }
-        catch(err) {
-            throw new Error(`Generated invalid agreement: ${err}: ${JSON.stringify(templateMark, null, 2)}`);
-        }
-    }
-
-    /**
-     * Compiles the code nodes containing TS to code nodes containing JS.
-     * @param {*} templateMark the TemplateMark JSON object
-     * @returns {*} TemplateMark JSON with JS nodes
-     * @throws {Error} if the templateMark document is invalid
-     */
-    compileTypeScriptToJavaScript(templateMark: object): object {
-        const compiler = new TemplateMarkToJavaScriptCompiler(this.modelManager);
-        return compiler.compile(templateMark);
-    }
-
-    validateCiceroMark(ciceroMark: object) {
-        const modelManager = new ModelManager({ strict: true });
-        modelManager.addCTOModel(ConcertoMetaModel.MODEL, 'concertometamodel.cto');
-        modelManager.addCTOModel(CommonMarkModel.MODEL, 'commonmark.cto');
-        modelManager.addCTOModel(CiceroMarkModel.MODEL, 'ciceromark.cto');
-        const factory = new Factory(modelManager);
-        const serializer = new Serializer(factory, modelManager);
-        try {
-            return serializer.fromJSON(ciceroMark);
-        }
-        catch(err) {
-            throw new Error(`Generated invalid agreement: ${err}: ${JSON.stringify(ciceroMark, null, 2)}`);
-        }
-    }
-
-    async generate(templateMark: object, data: TemplateData, now?:dayjs.Dayjs): Promise<any> {
-        const factory = new Factory(this.modelManager);
-        const serializer = new Serializer(factory, this.modelManager);
-        const templateData = serializer.fromJSON(data);
-        if (templateData.getFullyQualifiedType() !== this.templateClass.getFullyQualifiedName()) {
-            throw new Error(`Template data must be of type '${this.templateClass.getFullyQualifiedName()}'.`);
-        }
-        const typedTemplateMark = this.checkTypes(templateMark);
-        const jsTemplateMark = this.compileTypeScriptToJavaScript(typedTemplateMark);
-        const ciceroMark = generateAgreement(this.modelManager, this.clauseLibrary, jsTemplateMark, data, now);
-        return this.validateCiceroMark(ciceroMark);
-    }
-}

package/src/TemplateMarkToJavaScriptCompiler.ts

@@ -1,99 +0,0 @@
-/*
- * 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.
- */
-
-import traverse from 'traverse';
-import { TemplateMarkModel } from '@accordproject/markdown-common';
-import { ClassDeclaration, ModelManager } from '@accordproject/concerto-core';
-import { TypeScriptToJavaScriptCompiler } from './TypeScriptToJavaScriptCompiler';
-import { TwoSlashReturn } from '@typescript/twoslash';
-import { getTemplateClassDeclaration } from './Common';
-import { TemplateMarkToTypeScriptCompiler } from './TemplateMarkToTypeScriptCompiler';
-
-const CODE_NODES = [
-    `${TemplateMarkModel.NAMESPACE}.FormulaDefinition`,
-    `${TemplateMarkModel.NAMESPACE}.ConditionalDefinition`,
-    `${TemplateMarkModel.NAMESPACE}.ClauseDefinition`,
-];
-
-export type CompilerError = {
-    nodeId: string;
-    code: string;
-    errors:TwoSlashReturn['errors'];
-};
-
-/**
- * Compiles all the Typescript nodes in a TemplateMark JSON
- * to ES_2020 and returns a modified TemplateMark JSON.
- */
-export class TemplateMarkToJavaScriptCompiler {
-    modelManager:ModelManager;
-    compiler: TypeScriptToJavaScriptCompiler;
-    templateClass: ClassDeclaration;
-
-    constructor(modelManager: ModelManager) {
-        this.modelManager = modelManager;
-        this.compiler = new TypeScriptToJavaScriptCompiler(modelManager);
-        this.templateClass = getTemplateClassDeclaration(modelManager);
-    }
-
-    compile(templateJson: any) : any {
-        const namedTemplateMark = TemplateMarkToTypeScriptCompiler.nameUserCode(templateJson);
-        const functionCompiler = new TemplateMarkToTypeScriptCompiler(this.modelManager);
-
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const that = this;
-        const errors = Array<CompilerError>();
-        const compiled = traverse(namedTemplateMark).map(function (x) {
-            if (x && CODE_NODES.includes(x.$class)) {
-                if (x.code) {  // formula
-                    const result = that.compiler.compile(functionCompiler.writeFunctionToString(x.name, 'any', x.code.contents));
-                    if(result.errors.length === 0) {
-                        x.code.contents = result.code;
-                        x.code.type = 'ES_2020';
-                        this.update(x);
-                    }
-                    else {
-                        errors.push({
-                            nodeId: x.name,
-                            code: x.code.contents,
-                            errors: result.errors
-                        });
-                    }
-                }
-                else if (x.condition) {  // condition or clause (boolean condition)
-                    const result = that.compiler.compile(functionCompiler.writeFunctionToString(x.functionName, 'boolean', x.condition.contents));
-                    if(result.errors.length === 0) {
-                        x.condition.contents = result.code;
-                        x.condition.type = 'ES_2020';
-                        this.update(x);
-                    }
-                    else {
-                        errors.push({
-                            nodeId: x.functionName,
-                            code: x.condition.contents,
-                            errors: result.errors
-                        });
-                    }
-                }
-            }
-        });
-
-        if(errors.length === 0) {
-            return compiled;
-        }
-        else {
-            throw errors;
-        }
-    }
-}