@platforma-sdk/tengo-builder 1.17.5 → 1.17.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/tengo-builder",
-  "version": "1.17.5",
+  "version": "1.17.7",
   "description": "Pl Tengo Template Builder",
   "bin": {
     "pl-tengo": "./bin/run.js"
@@ -12,7 +12,7 @@
   ],
   "license": "UNLICENSED",
   "dependencies": {
-    "@milaboratories/tengo-tester": "^1.5.0",
+    "@milaboratories/tengo-tester": "^1.5.2",
     "@oclif/core": "^4.0.37",
     "canonicalize": "^2.0.0",
     "winston": "^3.17.0",
@@ -27,8 +27,8 @@
     "@jest/globals": "^29.7.0",
     "ts-jest": "^29.2.5",
     "@milaboratories/platforma-build-configs": "1.0.2",
-    "@milaboratories/eslint-config": "^1.0.1",
-    "@milaboratories/oclif-index": "1.1.1"
+    "@milaboratories/oclif-index": "1.1.1",
+    "@milaboratories/eslint-config": "^1.0.1"
   },
   "oclif": {
     "bin": "pl-tengo",

package/src/commands/build.ts

@@ -1,4 +1,5 @@
-import { SpawnSyncReturns, spawnSync } from 'child_process';
+import type { SpawnSyncReturns } from 'node:child_process';
+import { spawnSync } from 'node:child_process';
 import { Command } from '@oclif/core';
 import { compile, savePacks, getPackageInfo } from '../compiler/main';
 import { createLogger } from '../compiler/util';
@@ -6,7 +7,7 @@ import { CtagsFlags, GlobalFlags } from '../shared/basecmd';
 import * as fs from 'node:fs';
 import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
-import * as winston from 'winston';
+import type * as winston from 'winston';
 
 export default class Build extends Command {
   static override description = 'build tengo sources into single distributable pack file';
@@ -15,7 +16,7 @@ export default class Build extends Command {
 
   static override flags = {
     ...GlobalFlags,
-    ...CtagsFlags
+    ...CtagsFlags,
   };
 
   public async run(): Promise<void> {
@@ -39,13 +40,13 @@ export default class Build extends Command {
     const recordsCjs = compiledDist.templates
       .map(
         (tpl) =>
-          `  '${tpl.fullName.id}': { type: 'from-file', path: require.resolve('./tengo/tpl/${tpl.fullName.id}.plj.gz') }`
+          `  '${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') }`
+          `  '${tpl.fullName.id}': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/${tpl.fullName.id}.plj.gz') }`,
       )
       .join(',\n');
     cjs += recordsCjs;
@@ -92,7 +93,7 @@ function checkAndGenerateCtags(
   flags: {
     'tags-file': string;
     'tags-additional-args': string[];
-  }
+  },
 ) {
   const fileName = path.resolve(flags['tags-file']);
   const rootDir = path.dirname(fileName);
@@ -103,8 +104,8 @@ function checkAndGenerateCtags(
 
   logger.info(
     `Generating tags for tengo autocompletion from "${rootDir}" \
-in "${fileName}", additional arguments: "${additionalArgs}".
-Found ${tengoFiles.length} tengo files...`
+in "${fileName}", additional arguments: "${additionalArgs.join('" "')}".
+Found ${tengoFiles.length} tengo files...`,
   );
 
   // see https://docs.ctags.io/en/lates// t/man/ctags-optlib.7.html#perl-pod
@@ -121,13 +122,13 @@ Found ${tengoFiles.length} tengo files...`
       '--kinddef-tengo=c,constant,constant',
       '--regex-tengo=/^\\s*(.*) := ("|\\{).*/\\1/c/',
       '-R',
-      ...tengoFiles
+      ...tengoFiles,
     ],
     {
       env: process.env,
       stdio: 'inherit',
-      cwd: rootDir
-    }
+      cwd: rootDir,
+    },
   );
 
   if (result.error?.message.includes('ENOENT')) {

package/src/commands/check.ts

@@ -29,8 +29,8 @@ export default class Check extends Command {
       TengoTesterBinaryPath,
       'check', '--log-level', flags['log-level'],
       '--artifacts', '-',
-      ...testerArgs
-    )
+      ...testerArgs,
+    );
 
     try {
       dumpAll(logger, tester.stdin);

package/src/commands/dump/all.ts

@@ -1,17 +1,17 @@
-import { Command } from '@oclif/core'
-import { createLogger } from '../../compiler/util'
-import { dumpAll } from '../../shared/dump'
-import { stdout } from 'process'
+import { Command } from '@oclif/core';
+import { createLogger } from '../../compiler/util';
+import { dumpAll } from '../../shared/dump';
+import { stdout } from 'node:process';
 
 export default class DumpAll extends Command {
-  static override description = 'parse sources in current package and dump all found artifacts to stdout'
+  static override description = 'parse sources in current package and dump all found artifacts to stdout';
 
   static override examples = [
     '<%= config.bin %> <%= command.id %>',
-  ]
+  ];
 
   public async run(): Promise<void> {
-    const logger = createLogger()
-    dumpAll(logger, stdout)
+    const logger = createLogger();
+    dumpAll(logger, stdout);
   }
 }

package/src/commands/dump/assets.ts

@@ -1,17 +1,17 @@
-import { Command } from '@oclif/core'
-import { createLogger } from '../../compiler/util'
-import { dumpAssets } from '../../shared/dump'
-import { stdout } from 'process'
+import { Command } from '@oclif/core';
+import { createLogger } from '../../compiler/util';
+import { dumpAssets } from '../../shared/dump';
+import { stdout } from 'node:process';
 
 export default class DumpAssets extends Command {
-  static override description = 'parse sources in current package and dump all found tests to stdout'
+  static override description = 'parse sources in current package and dump all found assets to stdout';
 
   static override examples = [
     '<%= config.bin %> <%= command.id %>',
-  ]
+  ];
 
   public async run(): Promise<void> {
-    const logger = createLogger()
-    dumpAssets(logger, stdout)
+    const logger = createLogger();
+    dumpAssets(logger, stdout);
   }
 }

package/src/commands/dump/libs.ts

@@ -1,24 +1,23 @@
-import { Command, Flags } from '@oclif/core'
-import { createLogger } from '../../compiler/util'
-import { dumpLibs } from '../../shared/dump'
-import { stdout } from 'process'
+import { Command, Flags } from '@oclif/core';
+import { createLogger } from '../../compiler/util';
+import { dumpLibs } from '../../shared/dump';
+import { stdout } from 'node:process';
 
 export default class DumpLibs extends Command {
-  static override description = 'parse sources in current package and dump all found templates to stdout'
+  static override description = 'parse sources in current package and dump all found libs to stdout';
 
   static override examples = [
     '<%= config.bin %> <%= command.id %>',
-  ]
+  ];
 
   static override flags = {
-    deps: Flags.boolean({name: 'deps', description: 'add also all libraries found in node_modules'}),
-  }
+    deps: Flags.boolean({ name: 'deps', description: 'add also all libraries found in node_modules' }),
+  };
 
   public async run(): Promise<void> {
-    const {flags} = await this.parse(DumpLibs)
+    const { flags } = await this.parse(DumpLibs);
 
-    const logger = createLogger()
-    dumpLibs(logger, flags.deps, stdout)
+    const logger = createLogger();
+    dumpLibs(logger, flags.deps, stdout);
   }
 }
-

package/src/commands/dump/software.ts

@@ -1,17 +1,17 @@
-import { Command } from '@oclif/core'
-import { createLogger } from '../../compiler/util'
-import { dumpSoftware } from '../../shared/dump'
-import { stdout } from 'process'
+import { Command } from '@oclif/core';
+import { createLogger } from '../../compiler/util';
+import { dumpSoftware } from '../../shared/dump';
+import { stdout } from 'node:process';
 
 export default class DumpSoftware extends Command {
-  static override description = 'parse sources in current package and dump all found tests to stdout'
+  static override description = 'parse sources in current package and dump all found software to stdout';
 
   static override examples = [
     '<%= config.bin %> <%= command.id %>',
-  ]
+  ];
 
   public async run(): Promise<void> {
-    const logger = createLogger()
-    dumpSoftware(logger, stdout)
+    const logger = createLogger();
+    dumpSoftware(logger, stdout);
   }
 }

package/src/commands/dump/templates.ts

@@ -1,18 +1,17 @@
-import { Command } from '@oclif/core'
-import { createLogger } from '../../compiler/util'
-import { dumpTemplates } from '../../shared/dump'
-import { stdout } from 'process'
+import { Command } from '@oclif/core';
+import { createLogger } from '../../compiler/util';
+import { dumpTemplates } from '../../shared/dump';
+import { stdout } from 'node:process';
 
 export default class DumpTemplates extends Command {
-  static override description = 'parse sources in current package and dump all found templates to stdout'
+  static override description = 'parse sources in current package and dump all found templates to stdout';
 
   static override examples = [
     '<%= config.bin %> <%= command.id %>',
-  ]
+  ];
 
   public async run(): Promise<void> {
-    const logger = createLogger()
-    dumpTemplates(logger, stdout)
+    const logger = createLogger();
+    dumpTemplates(logger, stdout);
   }
 }
-

package/src/commands/dump/tests.ts

@@ -1,17 +1,17 @@
-import { Command } from '@oclif/core'
-import { createLogger } from '../../compiler/util'
-import { dumpTests } from '../../shared/dump'
-import { stdout } from 'process'
+import { Command } from '@oclif/core';
+import { createLogger } from '../../compiler/util';
+import { dumpTests } from '../../shared/dump';
+import { stdout } from 'node:process';
 
 export default class DumpTests extends Command {
-  static override description = 'parse sources in current package and dump all found tests to stdout'
+  static override description = 'parse sources in current package and dump all found tests to stdout';
 
   static override examples = [
     '<%= config.bin %> <%= command.id %>',
-  ]
+  ];
 
   public async run(): Promise<void> {
-    const logger = createLogger()
-    dumpTests(logger, stdout)
+    const logger = createLogger();
+    dumpTests(logger, stdout);
   }
 }

package/src/commands/test.ts

@@ -26,7 +26,7 @@ export default class Test extends Command {
       'run', '--log-level', flags['log-level'],
       '--artifacts', '-',
       ...testerArgs,
-    )
+    );
 
     try {
       dumpAll(logger, tester.stdin);

package/src/compiler/artifactset.ts

@@ -1,4 +1,5 @@
-import { CompileMode, TypedArtifactName, artifactKey } from './package';
+import type { CompileMode, TypedArtifactName } from './package';
+import { artifactKey } from './package';
 import { assertNever } from './util';
 
 export class ArtifactMap<T> {
@@ -22,35 +23,35 @@ export class ArtifactMap<T> {
 
   get array(): T[] {
     const ret: T[] = [];
-    this.map.forEach(obj => ret.push(obj));
+    this.map.forEach((obj) => ret.push(obj));
     return ret;
   }
 
   forEach(callback: (value: T, key: TypedArtifactName) => void) {
-    this.map.forEach(v => callback(v, this.nameExtractor(v)));
+    this.map.forEach((v) => callback(v, this.nameExtractor(v)));
   }
 }
 
 export function createArtifactNameSet(): ArtifactMap<TypedArtifactName> {
-  return new ArtifactMap<TypedArtifactName>(obj => obj);
+  return new ArtifactMap<TypedArtifactName>((obj) => obj);
 }
 
 export class ArtifactStore<T> {
-  private readonly dev: ArtifactMap<T>
-  private readonly dist: ArtifactMap<T>
+  private readonly dev: ArtifactMap<T>;
+  private readonly dist: ArtifactMap<T>;
 
   constructor(private readonly nameExtractor: (obj: T) => TypedArtifactName) {
-    this.dev = new ArtifactMap<T>(nameExtractor)
-    this.dist = new ArtifactMap<T>(nameExtractor)
+    this.dev = new ArtifactMap<T>(nameExtractor);
+    this.dist = new ArtifactMap<T>(nameExtractor);
   }
 
   add(mode: CompileMode, obj: T, replace: boolean = true): T | undefined {
     switch (mode) {
       case 'dist':
-        return this.dist.add(obj, replace)
+        return this.dist.add(obj, replace);
 
       default:
-        assertNever(mode)
+        assertNever(mode);
     }
   }
 
@@ -60,17 +61,17 @@ export class ArtifactStore<T> {
         return this.dist.get(name);
 
       default:
-        assertNever(mode)
+        assertNever(mode);
     }
   }
 
   array(mode: CompileMode): T[] {
     const ret: T[] = [];
-    this.forEach(mode, obj => ret.push(obj));
+    this.forEach(mode, (obj) => ret.push(obj));
     return ret;
   }
 
   forEach(mode: CompileMode, callback: (value: T, key: TypedArtifactName) => void) {
-    this.dist.forEach( (obj, k) => callback(this.get(mode, k) ?? obj, k) )
+    this.dist.forEach((obj, k) => callback(this.get(mode, k) ?? obj, k));
   }
 }

package/src/compiler/compiler.ts

@@ -1,56 +1,58 @@
-import { ArtifactSource } from './source';
+import type { ArtifactSource } from './source';
 import { Template } from './template';
+import type {
+  TypedArtifactName, FullArtifactName,
+  CompileMode,
+} from './package';
 import {
-  TypedArtifactName,
   fullNameToString,
   typedArtifactNameToString,
   artifactNameToString,
-  formatArtefactNameAndVersion, typedArtifactNamesEquals, FullArtifactName,
-  CompileMode
+  formatArtefactNameAndVersion, typedArtifactNamesEquals,
 } from './package';
 import { ArtifactStore } from './artifactset';
 import { assertNever } from './util';
 import { applyLibraryCompilerOptions, applyTemplateCompilerOptions } from './compileroptions';
-import { TemplateData } from '@milaboratories/pl-model-backend';
+import type { TemplateData } from '@milaboratories/pl-model-backend';
 
 export interface TemplatesAndLibs {
-  templates: Template[],
-  libs: ArtifactSource[],
-  software: ArtifactSource[]
-  assets: ArtifactSource[]
+  templates: Template[];
+  libs: ArtifactSource[];
+  software: ArtifactSource[];
+  assets: ArtifactSource[];
 }
 
 export class TengoTemplateCompiler {
   constructor(
-    private readonly compileMode: CompileMode
+    private readonly compileMode: CompileMode,
   ) { }
 
-  private readonly libs = new ArtifactStore<ArtifactSource>(src => src.fullName);
-  private readonly software = new ArtifactStore<ArtifactSource>(src => src.fullName);
-  private readonly assets = new ArtifactStore<ArtifactSource>(src => src.fullName);
-  private readonly templates = new ArtifactStore<Template>(tpl => tpl.fullName);
+  private readonly libs = new ArtifactStore<ArtifactSource>((src) => src.fullName);
+  private readonly software = new ArtifactStore<ArtifactSource>((src) => src.fullName);
+  private readonly assets = new ArtifactStore<ArtifactSource>((src) => src.fullName);
+  private readonly templates = new ArtifactStore<Template>((tpl) => tpl.fullName);
 
   private populateTemplateDataFromDependencies(fullName: FullArtifactName,
-                                               data: TemplateData,
-                                               deps: TypedArtifactName[],
-                                               trace: string[]) {
+    data: TemplateData,
+    deps: TypedArtifactName[],
+    trace: string[]) {
     for (const dep of deps) {
       switch (dep.type) {
         case 'library': {
           const lib = this.getLibOrError(dep);
 
-          const recursionStart = trace.indexOf(artifactNameToString(dep))
+          const recursionStart = trace.indexOf(artifactNameToString(dep));
           if (recursionStart >= 0) {
-            let errorMessage = `library import recursion detected: ${trace.slice(recursionStart).join(" -> ")} -> ${artifactNameToString(dep)}`
-            throw new Error(errorMessage)
+            const errorMessage = `library import recursion detected: ${trace.slice(recursionStart).join(' -> ')} -> ${artifactNameToString(dep)}`;
+            throw new Error(errorMessage);
           }
 
           const tplLib = {
             ...formatArtefactNameAndVersion(lib.fullName),
-            src: lib.src
-          }
+            src: lib.src,
+          };
 
-          applyLibraryCompilerOptions(lib.compilerOptions, tplLib)
+          applyLibraryCompilerOptions(lib.compilerOptions, tplLib);
           data.libs[artifactNameToString(dep)] = tplLib;
 
           // populate with transient library dependencies
@@ -58,25 +60,27 @@ export class TengoTemplateCompiler {
 
           break;
         }
-        case 'software':
+        case 'software': {
           const software = this.getSoftwareOrError(dep);
           data.software[artifactNameToString(dep)] = {
             ...formatArtefactNameAndVersion(software.fullName),
-            src: software.src
-          }
+            src: software.src,
+          };
 
           break;
-        case 'asset':
+        }
+        case 'asset': {
           const asset = this.getAssetOrError(dep);
           // Yes, we temporarily put assets into 'software' section of template, so controller can
           // handle it the right way without updates
           data.software[artifactNameToString(dep)] = {
             ...formatArtefactNameAndVersion(asset.fullName),
-            src: asset.src
-          }
+            src: asset.src,
+          };
 
           break;
-        case 'template':
+        }
+        case 'template': {
           if (typedArtifactNamesEquals(fullName, dep))
             // skipping self reference
             continue;
@@ -84,10 +88,11 @@ export class TengoTemplateCompiler {
           const tpl = this.getTemplateOrError(dep);
           data.templates[artifactNameToString(dep)] = tpl.data;
           break;
+        }
         case 'test':
           throw new Error(
             `dependencies tree error: tests should never be part of template: ${typedArtifactNameToString(dep)} is dependency of ${artifactNameToString(fullName)}`,
-          )
+          );
         default:
           assertNever(dep.type);
       }
@@ -107,7 +112,7 @@ export class TengoTemplateCompiler {
       libs: {},
       software: {},
       assets: {},
-      src: tplSrc.src
+      src: tplSrc.src,
     };
 
     applyTemplateCompilerOptions(tplSrc.compilerOptions, tplData);
@@ -121,15 +126,15 @@ export class TengoTemplateCompiler {
   }
 
   addLib(lib: ArtifactSource) {
-    const libFromMap = this.libs.add(lib.compileMode, lib, false)
+    const libFromMap = this.libs.add(lib.compileMode, lib, false);
     if (libFromMap)
       throw new Error(
-        `compiler already contain such library: adding = ${fullNameToString(lib.fullName)}, contains = ${fullNameToString(libFromMap.fullName)}`
+        `compiler already contain such library: adding = ${fullNameToString(lib.fullName)}, contains = ${fullNameToString(libFromMap.fullName)}`,
       );
   }
 
   allLibs(): ArtifactSource[] {
-    return this.libs.array(this.compileMode)
+    return this.libs.array(this.compileMode);
   }
 
   getLib(name: TypedArtifactName): ArtifactSource | undefined {
@@ -146,15 +151,15 @@ export class TengoTemplateCompiler {
   }
 
   addSoftware(software: ArtifactSource) {
-    const swFromMap = this.software.add(software.compileMode, software, false)
+    const swFromMap = this.software.add(software.compileMode, software, false);
     if (swFromMap)
       throw new Error(
-        `compiler already contain info for software: adding = ${fullNameToString(software.fullName)}, contains = ${fullNameToString(swFromMap.fullName)}`
+        `compiler already contain info for software: adding = ${fullNameToString(software.fullName)}, contains = ${fullNameToString(swFromMap.fullName)}`,
       );
   }
 
   allSoftware(): ArtifactSource[] {
-    return this.software.array(this.compileMode)
+    return this.software.array(this.compileMode);
   }
 
   getSoftware(name: TypedArtifactName): ArtifactSource | undefined {
@@ -172,15 +177,15 @@ export class TengoTemplateCompiler {
   }
 
   addAsset(asset: ArtifactSource) {
-    const assetFromMap = this.assets.add(asset.compileMode, asset, false)
+    const assetFromMap = this.assets.add(asset.compileMode, asset, false);
     if (assetFromMap)
       throw new Error(
-        `compiler already contain info for asset: adding = ${fullNameToString(asset.fullName)}, contains = ${fullNameToString(assetFromMap.fullName)}`
+        `compiler already contain info for asset: adding = ${fullNameToString(asset.fullName)}, contains = ${fullNameToString(assetFromMap.fullName)}`,
       );
   }
 
   allAssets(): ArtifactSource[] {
-    return this.assets.array(this.compileMode)
+    return this.assets.array(this.compileMode);
   }
 
   getAsset(name: TypedArtifactName): ArtifactSource | undefined {
@@ -201,12 +206,12 @@ export class TengoTemplateCompiler {
     const tplFromMap = this.templates.add(tpl.compileMode, tpl, false);
     if (tplFromMap)
       throw new Error(
-        `compiler already contain such template: adding = ${fullNameToString(tpl.fullName)}, contains = ${fullNameToString(tplFromMap.fullName)}`
+        `compiler already contain such template: adding = ${fullNameToString(tpl.fullName)}, contains = ${fullNameToString(tplFromMap.fullName)}`,
       );
   }
 
   allTemplates(): Template[] {
-    return this.templates.array(this.compileMode)
+    return this.templates.array(this.compileMode);
   }
 
   getTemplate(name: TypedArtifactName): Template | undefined {
@@ -242,7 +247,7 @@ export class TengoTemplateCompiler {
   }
 
   checkLibs() {
-    this.libs.forEach(this.compileMode, lib => {
+    this.libs.forEach(this.compileMode, (lib) => {
       for (const dep of lib.dependencies) {
         if (dep.type === 'test')
           throw new Error(`test should never be dependency of production code: ${typedArtifactNameToString(dep)} test is dependency of ${fullNameToString(lib.fullName)}`);
@@ -271,12 +276,12 @@ export class TengoTemplateCompiler {
         this.addAsset(src);
         ret.assets.push(src);
       } else {
-        current.push(src)
+        current.push(src);
       }
     }
 
     while (current.length > 0) {
-      const unprocessed: { src: ArtifactSource, err: Error }[] = [];
+      const unprocessed: { src: ArtifactSource; err: Error }[] = [];
 
       for (const src of current) {
         //
@@ -286,17 +291,17 @@ export class TengoTemplateCompiler {
         //
         // This is equivalent to topological sorting of input sources.
         //
-        const unsatisfied = src.dependencies.filter(dep =>
-          !this.getArtefact(dep) &&
+        const unsatisfied = src.dependencies.filter((dep) =>
+          !this.getArtefact(dep)
           // allow self reference for templates
-          !(src.fullName.type === 'template' && typedArtifactNamesEquals(src.fullName, dep))
-        )
+          && !(src.fullName.type === 'template' && typedArtifactNamesEquals(src.fullName, dep)),
+        );
         if (unsatisfied.length > 0) {
-          let errorMessage = `Unsatisfied dependencies in ${fullNameToString(src.fullName)}:\n`
+          let errorMessage = `Unsatisfied dependencies in ${fullNameToString(src.fullName)}:\n`;
           for (const dep of unsatisfied) {
             errorMessage += `  - ${typedArtifactNameToString(dep)}\n`;
           }
-          unprocessed.push({ src, err: Error(errorMessage) })
+          unprocessed.push({ src, err: Error(errorMessage) });
 
           continue;
         }
@@ -323,11 +328,12 @@ export class TengoTemplateCompiler {
             try {
               const tpl = this.compileAndAddTemplate(src);
               ret.templates.push(tpl);
-            } catch (err: any) {
-              let errorMessage = `Unsatisfied dependencies in ${fullNameToString(src.fullName)}:\n`
+            } catch (error: unknown) {
+              const err = error as Error;
+              let errorMessage = `Unsatisfied dependencies in ${fullNameToString(src.fullName)}:\n`;
               errorMessage += `  - ${err.message}\n`;
 
-              unprocessed.push({ src, err: Error(errorMessage) }) // one or more dependencies are not resolvable yet
+              unprocessed.push({ src, err: Error(errorMessage) }); // one or more dependencies are not resolvable yet
             }
             break;
           case 'test':
@@ -344,7 +350,7 @@ export class TengoTemplateCompiler {
         let errorMessage = '';
 
         for (const u of unprocessed) {
-          errorMessage += `\n${u.err.message}`
+          errorMessage += `\n${u.err.message}`;
         }
         throw new Error(errorMessage);
       }