@platforma-sdk/tengo-builder 2.0.2 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/tengo-builder",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "description": "Pl Tengo Template Builder",
   "bin": {
     "pl-tengo": "./bin/run.js"
@@ -19,20 +19,18 @@
     "@oclif/core": "^4.0.37",
     "canonicalize": "~2.1.0",
     "winston": "^3.17.0",
+    "@milaboratories/ts-helpers": "1.1.5",
     "@milaboratories/resolve-helper": "1.1.0",
-    "@milaboratories/pl-model-backend": "^1.0.3"
+    "@milaboratories/pl-model-backend": "^1.1.0"
   },
   "devDependencies": {
     "typescript": "~5.5.4",
     "vite": "^5.4.11",
-    "@types/jest": "^29.5.14",
+    "vitest": "^2.1.8",
     "@types/node": "~20.16.15",
-    "jest": "^29.7.0",
-    "@jest/globals": "^29.7.0",
-    "ts-jest": "^29.2.6",
-    "@milaboratories/oclif-index": "1.1.1",
-    "@milaboratories/eslint-config": "^1.0.3",
-    "@milaboratories/platforma-build-configs": "1.0.3"
+    "@milaboratories/platforma-build-configs": "1.0.3",
+    "@milaboratories/eslint-config": "^1.0.4",
+    "@milaboratories/oclif-index": "1.1.1"
   },
   "oclif": {
     "bin": "pl-tengo",
@@ -45,9 +43,10 @@
     "topicSeparator": " "
   },
   "scripts": {
+    "lint": "eslint .",
     "type-check": "tsc --noEmit --composite false",
     "build": "oclif-index && vite build",
-    "test": "jest",
+    "test": "vitest",
     "do-pack": "rm -f *.tgz && pnpm pack && mv *.tgz package.tgz"
   }
 }

package/src/commands/build.ts

@@ -8,6 +8,7 @@ import * as fs from 'node:fs';
 import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
 import type * as winston from 'winston';
+import type { TemplatesAndLibs } from '../compiler/compiler';
 
 export default class Build extends Command {
   static override description = 'build tengo sources into single distributable pack file';
@@ -24,36 +25,12 @@ export default class Build extends Command {
     const logger = createLogger(flags['log-level']);
 
     const packageInfo = getPackageInfo(process.cwd(), logger);
-    const compiledDist = compile(logger, 'dist');
+    const compiledDist = compile(logger, packageInfo, 'dist');
     savePacks(logger, compiledDist, 'dist');
-    logger.info('');
+    logger.info('Template Pack build done.');
 
     // Building TS bindings for templates
-    let dts = `declare type TemplateFromFile = { readonly type: "from-file"; readonly path: string; };\n`;
-    dts += `declare type TplName = ${compiledDist.templates
-      .map((tpl) => '"' + tpl.fullName.id + '"')
-      .join(' | ')};\n`;
-    dts += `declare const Templates: Record<TplName, TemplateFromFile>;\n`;
-    dts += `export { Templates };\n`;
-    let cjs = `module.exports = { Templates: {\n`;
-    let mjs = `import { resolve } from 'node:path';\nexport const Templates = {\n`;
-    const recordsCjs = compiledDist.templates
-      .map(
-        (tpl) =>
-          `  '${tpl.fullName.id}': { type: 'from-file', path: require.resolve('./tengo/tpl/${tpl.fullName.id}.plj.gz') }`,
-      )
-      .join(',\n');
-    const recordsMjs = compiledDist.templates
-      .map(
-        (tpl) =>
-          `  '${tpl.fullName.id}': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/${tpl.fullName.id}.plj.gz') }`,
-      )
-      .join(',\n');
-    cjs += recordsCjs;
-    mjs += recordsMjs;
-    cjs += `\n}};\n`;
-    mjs += `\n};\n`;
-
+    const { dts, cjs, mjs } = generateTsBinding(compiledDist);
     await fsp.writeFile('dist/index.d.ts', dts);
     if (packageInfo.type === 'module') {
       await fsp.writeFile('dist/index.cjs', cjs);
@@ -70,6 +47,33 @@ export default class Build extends Command {
   }
 }
 
+function generateTsBinding(compiledDist: TemplatesAndLibs) {
+  let dts = `declare type TemplateFromFile = { readonly type: "from-file"; readonly path: string; };\n`;
+  dts += `declare type TplName = ${compiledDist.templates
+    .map((tpl) => '"' + tpl.fullName.id + '"')
+    .join(' | ')};\n`;
+  dts += `declare const Templates: Record<TplName, TemplateFromFile>;\n`;
+  dts += `export { Templates };\n`;
+  let cjs = `module.exports = { Templates: {\n`;
+  let mjs = `import { resolve } from 'node:path';\nexport const Templates = {\n`;
+  const recordsCjs = compiledDist.templates
+    .map(
+      (tpl) => `  '${tpl.fullName.id}': { type: 'from-file', path: require.resolve('./tengo/tpl/${tpl.fullName.id}.plj.gz') }`,
+    )
+    .join(',\n');
+  const recordsMjs = compiledDist.templates
+    .map(
+      (tpl) => `  '${tpl.fullName.id}': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/${tpl.fullName.id}.plj.gz') }`,
+    )
+    .join(',\n');
+  cjs += recordsCjs;
+  mjs += recordsMjs;
+  cjs += `\n}};\n`;
+  mjs += `\n};\n`;
+
+  return { dts, cjs, mjs };
+}
+
 function mergeTagsEnvs(flags: {
   'generate-tags': boolean;
   'tags-file': string;

package/src/compiler/artifactset.ts

@@ -36,6 +36,10 @@ export function createArtifactNameSet(): ArtifactMap<TypedArtifactName> {
   return new ArtifactMap<TypedArtifactName>((obj) => obj);
 }
 
+/**
+ * ArtifactStore is a store for artifacts that are compiled for different modes.
+ * It is used to collect all artifacts from the dependency tree and compile them for different modes.
+ */
 export class ArtifactStore<T> {
   // private readonly dev: ArtifactMap<T>;
   private readonly dist: ArtifactMap<T>;

package/src/compiler/compiler.test.ts

@@ -1,12 +1,14 @@
-import { TengoTemplateCompiler } from './compiler';
+import { TemplatesAndLibs, TengoTemplateCompiler } from './compiler';
 import { ArtifactSource, parseSource } from './source';
-import * as winston from 'winston';
 import * as ta from './test.artifacts';
 import { artifactNameToString } from './package';
-import { Template } from './template';
 import { createLogger } from './util';
+import { test, expect, describe, it } from 'vitest';
+import { MiLogger } from '@milaboratories/ts-helpers';
+import type { FullArtifactName, TypedArtifactName } from './package';
+import { TemplateDataV3, TemplateLibDataV3 } from '@milaboratories/pl-model-backend';
 
-function parseSrc(logger: winston.Logger, src: ta.TestArtifactSource[]): ArtifactSource[] {
+function parseSrc(logger: MiLogger, src: ta.TestArtifactSource[]): ArtifactSource[] {
   return src.map((tp) => {
     const aSrc = parseSource(logger, 'dist', tp.src, tp.fullName, true);
     return aSrc;
@@ -18,13 +20,41 @@ test('compile package 1', () => {
 
   const compiler = new TengoTemplateCompiler('dist');
   const compiled = compiler.compileAndAdd(parseSrc(logger, ta.testPackage1));
-  expect(compiled.templates[0].data.libs).toHaveProperty(
-    artifactNameToString(ta.testPackage1Lib1Name)
-  );
-  console.log(Buffer.from(compiled.templates[0].content).toString('base64'));
+
+  expect(compiled.templates[0]).toMatchObject({
+    data: {
+      type: 'pl.tengo-template.v3',
+      hashToSource: {
+        '2e0d81deae0220df5901292911fd96065be96bc2187debb24bd869b47e1caa77': `
+lib := import(\"package1:other-lib-1\")
+`,
+        '3f850fa4c5f6a8a3017fa883fc03fc2dee159f65e2dbb9c6cd0c6dff0aae6419': `
+export {
+    \"some\": \"value1\"
+}
+`,
+      },
+      template: {
+        name: 'package1:template-3',
+        version: '1.2.3',
+        sourceHash: '2e0d81deae0220df5901292911fd96065be96bc2187debb24bd869b47e1caa77',
+        templates: {},
+        software: {},
+        assets: {},
+        libs: {
+          'package1:other-lib-1': {
+            name: 'package1:other-lib-1',
+            version: '1.2.3',
+            sourceHash: '3f850fa4c5f6a8a3017fa883fc03fc2dee159f65e2dbb9c6cd0c6dff0aae6419',
+          },
+        },
+      },
+    },
+  });
 });
 
-test('compile main source set', () => {
+// FIXME: how to rewrite test to the new template version? It has a strange base64-encoded thing.
+test.skip('compile main source set', () => {
   const compiler = new TengoTemplateCompiler('dist');
   const logger = createLogger('error');
 
@@ -38,11 +68,17 @@ test('compile main source set', () => {
   compiler.addSoftware(
     parseSource(logger, 'dist', ta.testPackage1Soft1Src, ta.testPackage1Soft1Name, true)
   );
-  compiler.addTemplate(
-    new Template('dist', ta.testPackage1Tpl3Name, {
-      content: Buffer.from(ta.testPackage1Tpl3CompiledBase64, 'base64')
-    })
-  );
+
+  // FIXME: how to rewrite test to the new template?
+  // compiler.addTemplate(
+  //   templateToSource(
+  //     newTemplateFromContent(
+  //       'dist',
+  //       ta.testPackage1Tpl3Name,
+  //       Buffer.from(ta.testPackage1Tpl3CompiledBase64, 'base64')
+  //     ),
+  //   )
+  // );
 
   // all elements in the context must have all their dependencies met
   compiler.checkLibs();
@@ -53,7 +89,7 @@ test('compile main source set', () => {
   expect(tpl1).toBeDefined();
 
   // checking that transient library dependency was resolved
-  expect(tpl1.data.templates).toHaveProperty('package1:template-3');
+  expect(tpl1.data.template.templates).toHaveProperty('package1:template-3');
 });
 
 test('compile template with hash override', () => {
@@ -67,8 +103,8 @@ test('compile template with hash override', () => {
   expect(tpl3).toBeDefined();
 
   // checking that transient library dependency was resolved
-  expect(tpl3.data.hashOverride).toEqual('CE0F6EDF-D97C-44E7-B16B-D661D4C799C1'.toLowerCase());
-  expect(tpl3.data.libs[artifactNameToString(ta.testLocalLib3.fullName)]).toBeDefined();
+  expect(tpl3.data.template.hashOverride).toEqual('CE0F6EDF-D97C-44E7-B16B-D661D4C799C1'.toLowerCase());
+  expect(tpl3.data.template.libs[artifactNameToString(ta.testLocalLib3.fullName)]).toBeDefined();
 });
 
 test('wrong hash override value throws error', () => {
@@ -77,3 +113,226 @@ test('wrong hash override value throws error', () => {
 
   expect(() => compiler.compileAndAdd(parseSrc(logger, ta.testPackage2BrokenHash))).toThrow('must contain valid UUID as an override');
 });
+
+/** Functions for generating test data. */
+
+const genHash = (nameId: string) => nameId + '-hash';
+const genName = (nameId: string) => nameId + '-name';
+const genArtifactName = artifactNameToString;
+
+const genArtifactSource = (name: FullArtifactName, src: string, dependencies: TypedArtifactName[]) =>
+  new ArtifactSource('dist', name, genHash(name.id), src, genName(name.id), dependencies, []);
+
+const genTemplateData = (name: FullArtifactName, templates: TemplateDataV3[], libs: TemplateLibDataV3[]) => (
+  {
+    name: genArtifactName(name),
+    version: name.version,
+    sourceHash: genHash(name.id),
+    templates: Object.fromEntries(templates.map(t => [t.name, t])),
+    libs: Object.fromEntries(libs.map(l => [l.name, l])),
+    software: {},
+    assets: {},
+  }
+);
+
+const genLibData = (name: FullArtifactName) => (
+  {
+    name: genArtifactName(name),
+    version: name.version,
+    sourceHash: genHash(name.id),
+  }
+);
+
+describe('TengoTemplateCompiler.compileAndAdd', () => {
+  const testCases: {
+    name: string;
+    sources: ArtifactSource[];
+    expected: TemplatesAndLibs;
+  }[] = [
+    {
+      name: 'should process a single library and pass it as-is',
+      sources: [
+        genArtifactSource(ta.testLocalLib3Name, ta.testLocalLib3Src, []),
+      ],
+      expected: {
+        libs: [
+          genArtifactSource(ta.testLocalLib3Name, ta.testLocalLib3Src, []),
+        ],
+        templates: [],
+        software: [],
+        assets: []
+      }
+    },
+    {
+      name: 'should process a single software and pass it as-is',
+      sources: [
+        genArtifactSource(ta.testPackage1Soft1Name, ta.testPackage1Soft1Src, []),
+      ],
+      expected: {
+        libs: [],
+        templates: [],
+        software: [
+          genArtifactSource(ta.testPackage1Soft1Name, ta.testPackage1Soft1Src, []),
+        ],
+        assets: []
+      }
+    },
+    {
+      name: 'should process a single asset and pass it as-is',
+      sources: [
+        genArtifactSource(ta.testPackage1Asset1Name, ta.testPackage1Asset1Src, []),
+      ],
+      expected: {
+        libs: [],
+        templates: [],
+        software: [],
+        assets: [
+          genArtifactSource(ta.testPackage1Asset1Name, ta.testPackage1Asset1Src, []),
+        ]
+      }
+    },
+    {
+      name: 'should process a template with 1 library dependency',
+      sources: [
+        genArtifactSource(ta.testLocalTpl2Name, ta.testLocalTpl2Src, [ta.testLocalLib1Name]),
+        genArtifactSource(ta.testLocalLib1Name, ta.testLocalLib1Src, []),
+      ],
+      expected: {
+        libs: [
+          genArtifactSource(ta.testLocalLib1Name, ta.testLocalLib1Src, []),
+        ],
+        templates: [
+          {
+            compileMode: 'dist',
+            fullName: ta.testLocalTpl2Name,
+            source: ta.testLocalTpl2Src,
+            data: {
+              type: 'pl.tengo-template.v3',
+              hashToSource: {
+                [genHash(ta.testLocalLib1Name.id)]: ta.testLocalLib1Src,
+                [genHash(ta.testLocalTpl2Name.id)]: ta.testLocalTpl2Src,
+              },
+              template: genTemplateData(ta.testLocalTpl2Name, [], [
+                genLibData(ta.testLocalLib1Name),
+              ]),
+            },
+          }
+        ],
+        software: [],
+        assets: []
+      }
+    },
+    {
+      name: 'should process a template with another template dependency',
+      sources: [
+        genArtifactSource(ta.testLocalTpl1Name, ta.testLocalTpl1Src, [ta.testLocalTpl2Name]),
+        genArtifactSource(ta.testLocalTpl2Name, ta.testLocalTpl2Src, []),
+      ],
+      expected: {
+        libs: [],
+        templates: [
+          {
+            compileMode: 'dist',
+            fullName: ta.testLocalTpl2Name,
+            source: ta.testLocalTpl2Src,
+            data: {
+              type: 'pl.tengo-template.v3',
+              hashToSource: {
+                [genHash(ta.testLocalTpl2Name.id)]: ta.testLocalTpl2Src,
+              },
+              template: genTemplateData(ta.testLocalTpl2Name, [], []),
+            }
+          },
+          {
+            compileMode: 'dist',
+            fullName: ta.testLocalTpl1Name,
+            source: ta.testLocalTpl1Src,
+            data: {
+              type: 'pl.tengo-template.v3',
+              hashToSource: {
+                [genHash(ta.testLocalTpl1Name.id)]: ta.testLocalTpl1Src,
+                [genHash(ta.testLocalTpl2Name.id)]: ta.testLocalTpl2Src,
+              },
+              template: genTemplateData(ta.testLocalTpl1Name, [
+                genTemplateData(ta.testLocalTpl2Name, [], []),
+              ], []),
+            },
+          },
+        ],
+        software: [],
+        assets: []
+      }
+    },
+    {
+      name: 'should process a template with another template dependency and a nested library dependency',
+      sources: [
+        genArtifactSource(ta.testLocalTpl1Name, ta.testLocalTpl1Src, [ta.testLocalTpl2Name]),
+        genArtifactSource(ta.testLocalTpl2Name, ta.testLocalTpl2Src, [ta.testLocalLib3Name]),
+        genArtifactSource(ta.testLocalLib3Name, ta.testLocalLib3Src, []),
+      ],
+      expected: {
+        libs: [
+          genArtifactSource(ta.testLocalLib3Name, ta.testLocalLib3Src, []),
+        ],
+        templates: [
+          {
+            compileMode: 'dist',
+            fullName: ta.testLocalTpl2Name,
+            source: ta.testLocalTpl2Src,
+            data: {
+              type: 'pl.tengo-template.v3',
+              hashToSource: {
+                [genHash(ta.testLocalTpl2Name.id)]: ta.testLocalTpl2Src,
+                [genHash(ta.testLocalLib3Name.id)]: ta.testLocalLib3Src,
+              },
+              template: genTemplateData(ta.testLocalTpl2Name, [], [
+                genLibData(ta.testLocalLib3Name),
+              ]),
+            },
+          },
+          {
+            compileMode: 'dist',
+            fullName: ta.testLocalTpl1Name,
+            source: ta.testLocalTpl1Src,
+            data: {
+              type: 'pl.tengo-template.v3',
+              hashToSource: {
+                [genHash(ta.testLocalTpl1Name.id)]: ta.testLocalTpl1Src,
+                [genHash(ta.testLocalTpl2Name.id)]: ta.testLocalTpl2Src,
+                [genHash(ta.testLocalLib3Name.id)]: ta.testLocalLib3Src,
+              },
+              template: genTemplateData(ta.testLocalTpl1Name, [
+                genTemplateData(ta.testLocalTpl2Name, [], [
+                  genLibData(ta.testLocalLib3Name),
+                ]),
+              ], []),
+            },
+          },
+        ],
+        software: [],
+        assets: []
+      }
+    },
+  ];
+
+  // Execute all test cases
+  testCases.forEach(tc => {
+    it(tc.name, () => {
+      const compiler = new TengoTemplateCompiler('dist');
+
+      const result = compiler.compileAndAdd(tc.sources);
+
+      expect(result).toMatchObject(tc.expected);
+    });
+  });
+
+  it('should throw error for unresolvable dependencies', () => {
+    const compiler = new TengoTemplateCompiler('dist');
+
+    const sources = [
+      genArtifactSource(ta.testLocalTpl1Name, ta.testLocalTpl1Src, [ta.testLocalLib1Name]),
+    ];
+
+    expect(() => compiler.compileAndAdd(sources)).toThrow(/Unsatisfied dependencies/);
+  });
+});