@accordproject/template-engine 1.0.0 → 1.0.3

package/src/TemplateMarkToTypeScriptCompiler.ts

@@ -1,276 +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 { copySync } from 'fs-extra';
-
-import { TemplateMarkModel, CiceroMarkModel, CommonMarkModel, ConcertoMetaModel } from '@accordproject/markdown-common';
-
-import { ClassDeclaration, ModelManager, ModelUtil, Property, Resource } from '@accordproject/concerto-core';
-import { CodeGen } from '@accordproject/concerto-tools';
-import { FileWriter } from '@accordproject/concerto-util';
-import { getCompiler } from './compilers/NodeCompilers';
-import { RUNTIME_DIR, writeEpilog, writeImports, writeProlog } from './compilers/Common';
-import { getTemplateClassDeclaration } from './Common';
-import dayjs from 'dayjs';
-
-export type ProcessingFunction = (fw:FileWriter, level:number, resource:any) => void;
-
-export type CompilationOptions = {
-    skipGenerator?: boolean;
-    skipCopyRuntime?: boolean;
-}
-
-/**
- * Converts TemplateMark DOM to a Typescript function, that, when run with JSON data
- * that conforms to the template model will produce AgreementMark JSON output.
- */
-export class TemplateMarkToTypeScriptCompiler {
-    modelManager: ModelManager;
-    templateClass: ClassDeclaration;
-
-    constructor(modelManager: ModelManager) {
-        this.modelManager = modelManager;
-        this.templateClass = getTemplateClassDeclaration(this.modelManager);
-    }
-
-    writeFunctionToString(functionName: string, returnType:string, code: string) : string {
-        let result = '';
-        result += '/// ---cut---\n';
-        result += `export function ${functionName}(data:TemplateModel.I${this.templateClass.getName()}, library:any, now:dayjs.Dayjs) : ${returnType} {\n`;
-        this.templateClass.getProperties().forEach((p: Property) => {
-            result += `   const ${p.getName()} = data.${p.getName()};\n`;
-        });
-        result += '   ' + code.trim() + '\n';
-        result += '}\n';
-        result += '\n';
-
-        return result;
-    }
-
-    writeFunction(fw: FileWriter, functionName: string, returnType:string, code: string) {
-        fw.writeLine(0, this.writeFunctionToString(functionName, returnType, code));
-    }
-
-    /**
-     * Get a model manager with templatemark model
-     * @param {string} outputDir the output directory
-     * @returns {ModelManager} the model manager
-     */
-    getTemplateMarkModelManager(): ModelManager {
-        const modelManager = new ModelManager({ strict: true });
-        modelManager.addCTOModel(ConcertoMetaModel.MODEL, 'concertometamodel.cto');
-        modelManager.addCTOModel(CommonMarkModel.MODEL, 'commonmark.cto');
-        modelManager.addCTOModel(TemplateMarkModel.MODEL, 'templatemark.cto');
-        return modelManager;
-    }
-
-    /**
-     * Get a model manager with templatemark model
-     * @param {string} outputDir the output directory
-     * @returns {ModelManager} the model manager
-     */
-    getCiceroMarkModelManager(): ModelManager {
-        const modelManager = new ModelManager({ strict: true });
-        modelManager.addCTOModel(ConcertoMetaModel.MODEL, 'concertometamodel.cto');
-        modelManager.addCTOModel(CommonMarkModel.MODEL, 'commonmark.cto');
-        modelManager.addCTOModel(CiceroMarkModel.MODEL, 'ciceromark.cto');
-        return modelManager;
-    }
-
-    generateTypeScript(modelManager: ModelManager, outputDir: string) {
-        // generate the TS code for the template model
-        const tsVisitor = new CodeGen.TypescriptVisitor();
-        const parameters = {
-            fileWriter: new FileWriter(outputDir)
-        };
-        modelManager.accept(tsVisitor, parameters);
-    }
-
-    /**
-     * The main iteration function over templatemark. This function
-     * looks up an INodeCompiler that can handle each templatemark node
-     * and delegates to it for code generation.
-     * Note that the result of code generation (a CiceroMark node) is left in
-     * the $result global varianble.
-     * @param {FileWriter} fw  the file writer to use
-     * @param {number} level the indentation level
-     * @param {object} templateMark the templatemark node to iterate over
-     */
-    static doIt(fw:FileWriter, level:number, templateMark: any) {
-        fw.writeLine(level, `// start processing ${ModelUtil.getShortName(templateMark.$class)}`);
-        traverse(templateMark).forEach(function (context: any) {
-            if (typeof context === 'object' && context.$class && typeof context.$class === 'string') {
-                const nodeClass = context.$class as string;
-
-                const compiler = getCompiler(nodeClass);
-                const sourceLevel = level+1;
-
-                this.before( () => {
-                    compiler.enter(fw, sourceLevel, context);
-                    compiler.generate(fw, sourceLevel, context, TemplateMarkToTypeScriptCompiler.doIt);
-                });
-
-                this.after( () => {
-                    compiler.exit(fw, sourceLevel, context);
-                });
-            }
-        });
-        fw.writeLine(level, `// end processing ${ModelUtil.getShortName(templateMark.$class)}`);
-    }
-    /**
-     * Converts a TemplateMark document to typescript code that is parameterised
-     * by the 'data' argument.
-     *
-     * The strategy is to traverse the template mark json, converting each node into
-     * typescript statements that add an equivalent ciceromark node. Variables will
-     * pull values from 'data'.
-     *
-     * Conditionals and formulae will call the functions produced by
-     * compileUserCode.
-     *
-     * Note that code generation process is itself recursive, for example, when
-     * a list definition node is encountered the list must be iterated over
-     * based on a variable value coming from data, and code must be
-     * generated to produce each list item.
-     *
-     * All internal variables are prefixed with '$' to ensure (?)
-     * that they cannot collide with end user variable names.
-     *
-     * @param {IDocument} templateMark the TemplateMark Concerto resource
-     * @param {string} outputDir the output directory for code
-     */
-    compileGenerator(templateMark: Resource, outputDir: string) : void {
-        const fw = new FileWriter(outputDir);
-
-        fw.openFile('generator.ts');
-        fw.writeLine(0, '// generated code, do not modify');
-        fw.writeLine(0, '');
-
-        fw.writeLine(0, '// IMPORTS');
-        writeImports(fw, 0, this.templateClass);
-        fw.writeLine(0, '');
-
-        fw.writeLine(0, '// GENERATOR');
-        writeProlog(fw, 0, this.templateClass);
-
-        TemplateMarkToTypeScriptCompiler.doIt(fw, 1, templateMark);
-
-        writeEpilog(fw,0);
-        fw.closeFile();
-    }
-
-    copyRuntime(outputDir: string) {
-        copySync('./src/drafting', `${outputDir}/${RUNTIME_DIR}/drafting`);
-        copySync('./src/TypeScriptRuntime.ts', `${outputDir}/${RUNTIME_DIR}/TypeScriptRuntime.ts`);
-    }
-
-    compile(templateMark: Resource, outputDir: string, options?:CompilationOptions) {
-        // generate the model
-        this.generateTypeScript(this.modelManager, `${outputDir}`);
-        this.generateTypeScript(this.getTemplateMarkModelManager(), `${outputDir}`);
-        this.generateTypeScript(this.getCiceroMarkModelManager(), `${outputDir}`);
-
-        // generate names for all the nodes containing user code
-        const namedTemplateMark = TemplateMarkToTypeScriptCompiler.nameUserCode(templateMark.toJSON());
-
-        // compile the user code
-        this.compileUserCode(namedTemplateMark, outputDir);
-
-        // compile the generator
-        if(!options?.skipCopyRuntime) {
-            this.copyRuntime(outputDir);
-        }
-
-        // compile the generator
-        if(!options?.skipGenerator) {
-            this.compileGenerator(namedTemplateMark, outputDir);
-        }
-    }
-
-    static nameUserCode(templateMarkDom: any) {
-        return traverse(templateMarkDom).map(function (x) {
-            if (x && ((x.$class === `${TemplateMarkModel.NAMESPACE}.ConditionalDefinition` && x.condition) ||
-                (`${TemplateMarkModel.NAMESPACE}.ClauseDefinition` && x.condition))) {
-                x.functionName = `condition_${this.path.join('_')}`;
-            }
-            this.update(x);
-        });
-    }
-
-    compileUserCode(templateMark: Resource, outputDir: string) {
-        const fw = new FileWriter(outputDir);
-
-        fw.openFile('usercode.ts');
-        fw.writeLine(0, '// generated code, do not modify');
-        fw.writeLine(0, '');
-
-        fw.writeLine(0, '// IMPORTS');
-        fw.writeLine(0, `import * as TemplateModel from './${this.templateClass.getNamespace()}';`);
-        fw.writeLine(0, 'import dayjs from \'dayjs\';');
-        fw.writeLine(0, 'import jp from \'jsonpath\';');
-        fw.writeLine(0, '');
-
-        const templateMarkDom = templateMark;
-
-        const functionNodes: [] = traverse(templateMarkDom).reduce(function (acc, x) {
-            if (x && x.$class === `${TemplateMarkModel.NAMESPACE}.FormulaDefinition`) {
-                acc.push({
-                    name: x.name,
-                    code: x.code,
-                });
-            }
-            return acc;
-        }, []);
-
-        const conditionalNodes: [] = traverse(templateMarkDom).reduce(function (acc, x) {
-            if (x && x.$class === `${TemplateMarkModel.NAMESPACE}.ConditionalDefinition` && x.condition) {
-                acc.push({
-                    name: x.functionName,
-                    code: x.condition,
-                });
-            }
-            return acc;
-        }, []);
-
-        const clauseNodes: [] = traverse(templateMarkDom).reduce(function (acc, x) {
-            if (x && x.$class === `${TemplateMarkModel.NAMESPACE}.ClauseDefinition` && x.condition) {
-                acc.push({
-                    name: x.functionName,
-                    code: x.condition,
-                });
-            }
-            return acc;
-        }, []);
-
-        fw.writeLine(0, '// FORMULAE');
-        functionNodes.forEach((fun: any) => {
-            this.writeFunction(fw, `${fun.name}`, 'any', fun.code.contents);
-        });
-        fw.writeLine(0, '');
-
-        fw.writeLine(0, '// CONDITIONALS');
-        conditionalNodes.forEach((fun: any) => {
-            this.writeFunction(fw, `${fun.name}`, 'boolean', fun.code.contents);
-        });
-        fw.writeLine(0, '');
-
-        fw.writeLine(0, '// CLAUSES');
-        clauseNodes.forEach((fun: any) => {
-            this.writeFunction(fw, `${fun.name}`, 'boolean', fun.code.contents);
-        });
-        fw.writeLine(0, '');
-
-        fw.closeFile();
-    }
-}

package/src/TypeScriptCompilationContext.ts

@@ -1,73 +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, ModelManager } from '@accordproject/concerto-core';
-import { CodeGen } from '@accordproject/concerto-tools';
-import { InMemoryWriter } from '@accordproject/concerto-util';
-import { getTemplateClassDeclaration } from './Common';
-
-/**
- * This class creates the typescript types
- * required to compile Typescript expressions (used in
- * formulae, conditions and clauses) to JavaScript. It uses
- * these to create a compilation context for '@typescript/twoslash'
- * which is used to compile the typescript code.
- */
-export class TypeScriptCompilationContext {
-
-    modelManager:ModelManager;
-    templateClass:ClassDeclaration;
-
-    constructor(modelManager:ModelManager) {
-        this.modelManager = modelManager;
-        this.templateClass = getTemplateClassDeclaration(this.modelManager);
-    }
-
-    getTypeScriptFiles() : Record<string,string> {
-        const result:Record<string,string> = {};
-
-        const visitor = new CodeGen.TypescriptVisitor();
-        const writer = new InMemoryWriter();
-
-        const params = {
-            fileWriter: writer
-        };
-        this.modelManager.accept(visitor, params);
-        writer.getFilesInMemory().forEach( (value, key) => {
-            result[key] = value;
-        });
-        return result;
-    }
-
-    getCompilationContext() : string {
-        const files = this.getTypeScriptFiles();
-
-        let result = '';
-
-        Object.keys(files).forEach( key => {
-            const content = files[key];
-            result += `
-// @filename: ${key}
-${content}
-`;
-        });
-
-        result += `
-// @filename: code.ts
-import * as TemplateModel from './${this.templateClass.getNamespace()}';
-import dayjs from 'dayjs';
-import jp from 'jsonpath';
-`;
-        return result;
-    }
-}

package/src/TypeScriptRuntime.ts

@@ -1,64 +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.
- */
-const DEBUG = false;
-
-/**
- * These utility functions are used by the typescript code that
- * is generated from TemplateMark. They manage a stack to improve
- * debuggability.
- */
-
-function dump(op:string, $data:any[]) {
-    if(DEBUG) {
-        console.log(`${op}: ${JSON.stringify($data)}`);
-    }
-}
-
-export function peek($data:any[]) : any {
-    if($data.length <= 0) {
-        throw new Error('Empty array');
-    }
-    const result = $data[$data.length-1];
-    dump('peek', $data);
-    return result;
-}
-
-export function peekProperty($data:any[], propertyName:string, allowUndefined=false) : any {
-    const head = peek($data);
-    const result = head[propertyName];
-    if(!allowUndefined && result === undefined) {
-        throw new Error(`Undefined property ${propertyName}. Current stack is ${JSON.stringify($data)}`);
-    }
-    return result;
-}
-
-export function push($data:any[], item:any) : number {
-    const result = $data.push(item);
-    dump('push', $data);
-    return result;
-}
-
-export function addChild($data:any[], item:any) {
-    const node = peek($data);
-    node.nodes ? node.nodes.push(item) : node.nodes = [item];
-}
-
-export function pop($data:any[]) : any {
-    if($data.length <= 0) {
-        throw new Error('Empty array');
-    }
-    const result = $data.pop();
-    dump('pop', $data);
-    return result;
-}

package/src/TypeScriptToJavaScriptCompiler.ts

@@ -1,59 +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 ts from 'typescript';
-import { createDefaultMapFromNodeModules } from '@typescript/vfs';
-import { twoslasher, TwoSlashOptions, TwoSlashReturn } from '@typescript/twoslash';
-import { readFileSync } from 'fs-extra';
-import { ModelManager } from '@accordproject/concerto-core';
-import { TypeScriptCompilationContext } from './TypeScriptCompilationContext';
-
-/**
- * Compiles user Typescript code to JavaScript, This uses the '@typescript/twoslash'
- * project which is maintained by the Typescript team and powers their web playground.
- * It uses the TypeScriptCompilationContext class to construct a payload for twoslash
- * that is composed of multiple TS files to compile, along with their 3rd-party module
- * dependencies.
- */
-export class TypeScriptToJavaScriptCompiler {
-    context: string;
-
-    constructor(modelManager: ModelManager) {
-        this.context = new TypeScriptCompilationContext(modelManager).getCompilationContext();
-    }
-
-    compile(typescript: string): TwoSlashReturn {
-        const fsMap = createDefaultMapFromNodeModules({
-            target: ts.ScriptTarget.ES2020,
-        });
-
-        fsMap.set('/node_modules/@types/dayjs/index.d.ts', readFileSync('./node_modules/dayjs/index.d.ts', 'utf-8'));
-        fsMap.set('/node_modules/@types/jsonpath/index.d.ts', readFileSync('./node_modules/@types/jsonpath/index.d.ts', 'utf-8'));
-
-        const twoSlashCode =`
-${this.context}
-${typescript}
-`;
-
-        const options: TwoSlashOptions = {
-            fsMap,
-            defaultOptions: {
-                showEmit: true,
-                noErrorValidation: true,
-                showEmittedFile: 'code.js'
-            }
-        };
-        const result = twoslasher(twoSlashCode, 'ts', options);
-        return result;
-    }
-}

package/src/compilers/Clause.ts

@@ -1,63 +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 { FileWriter } from '@accordproject/concerto-util';
-import { TemplateMarkModel,CommonMarkModel } from '@accordproject/markdown-common';
-import { IClause } from '../model-gen/org.accordproject.ciceromark@0.6.0';
-import { IParagraph } from '../model-gen/org.accordproject.commonmark@0.5.0';
-import { IClauseDefinition, IWithDefinition } from '../model-gen/org.accordproject.templatemark@0.4.0';
-import { AbstractComplexCompiler, getTypeScriptType, makeCiceroMark, writeCloseDataScope, writeCloseGenerateScope, writeCloseNodeScope, writeDebug, writeOpenDataScope, writeOpenGenerateScope, writeOpenNodeScope } from './Common';
-
-interface INamedClauseDefinition extends IClauseDefinition {
-    readonly functionName: string;
-}
-
-export class Clause extends AbstractComplexCompiler {
-    static TYPE = `${TemplateMarkModel.NAMESPACE}.ClauseDefinition`;
-    constructor() {
-        super(false);
-    }
-
-    enter(fw:FileWriter, level:number,templateMarkNode:IWithDefinition) {
-        writeDebug(fw, level, templateMarkNode);
-        writeOpenNodeScope(fw,level);
-        writeOpenDataScope(fw,level,templateMarkNode.name);
-    }
-
-    generate(fw:FileWriter, level:number, templateMarkNode:INamedClauseDefinition) {
-        const clone = makeCiceroMark(templateMarkNode) as IClause;
-        delete (clone as any).condition;
-        delete (clone as any).functionName;
-        const para = {$class: `${CommonMarkModel.NAMESPACE}.Paragraph`} as IParagraph;
-        writeOpenGenerateScope(fw, level);
-        if(templateMarkNode.condition) {
-            fw.writeLine(level, `const isTrue:boolean = UserCode.${templateMarkNode.functionName}(data,library,now)`);
-        }
-        else {
-            fw.writeLine(level, 'const isTrue:boolean = true;');
-        }
-        fw.writeLine(level, 'if(isTrue) {');
-        fw.writeLine(level, `return ${JSON.stringify(clone)} as ${getTypeScriptType(clone.$class)};`);
-        fw.writeLine(level, '}');
-        fw.writeLine(level, 'else {');
-        fw.writeLine(level, `return ${JSON.stringify(para)} as ${getTypeScriptType(para.$class)};`);
-        fw.writeLine(level, '}');
-        writeCloseGenerateScope(fw, level);
-        delete templateMarkNode.condition;
-    }
-
-    exit(fw:FileWriter, level:number) {
-        writeCloseDataScope(fw,level);
-        writeCloseNodeScope(fw,level);
-    }
-}