@platforma-sdk/tengo-builder 2.4.13 → 2.4.15

package/src/compiler/test.artifacts.ts

@@ -1,4 +1,4 @@
-import type { FullArtifactName } from './package';
+import type { FullArtifactName } from "./package";
 
 export interface TestArtifactSource {
   fullName: FullArtifactName;
@@ -32,10 +32,10 @@ export interface TestArtifactSource {
  */
 
 export const testLocalLib1Name: FullArtifactName = {
-  type: 'library',
-  pkg: 'current-package',
-  id: 'local-library-1',
-  version: '1.2.3',
+  type: "library",
+  pkg: "current-package",
+  id: "local-library-1",
+  version: "1.2.3",
 };
 export const testLocalLib1Src = `
 otherLib := import("package1:other-lib-2" )
@@ -73,10 +73,10 @@ export {
 `;
 
 export const testLocalLib2Name: FullArtifactName = {
-  type: 'library',
-  pkg: 'current-package',
-  id: 'local-library-2',
-  version: '2.3.4',
+  type: "library",
+  pkg: "current-package",
+  id: "local-library-2",
+  version: "2.3.4",
 };
 export const testLocalLib2Src = `
 otherLib := import("package1:someid")
@@ -116,10 +116,10 @@ export {
 `;
 
 export const testLocalLib3Name: FullArtifactName = {
-  type: 'library',
-  pkg: 'current-package',
-  id: 'local-library-3',
-  version: '6.6.6',
+  type: "library",
+  pkg: "current-package",
+  id: "local-library-3",
+  version: "6.6.6",
 };
 export const testLocalLib3Src = `
 export {
@@ -128,10 +128,10 @@ export {
 `;
 
 export const testLocalTpl1Name: FullArtifactName = {
-  type: 'template',
-  pkg: 'current-package',
-  id: 'local-template-1',
-  version: '1.2.3',
+  type: "template",
+  pkg: "current-package",
+  id: "local-template-1",
+  version: "1.2.3",
 };
 export const testLocalTpl1Src = `
 lib1 := import( ":local-library-1")
@@ -142,10 +142,10 @@ tpl2 := plapi.getTemplateId("current-package:local-template-1" )
 `;
 
 export const testLocalTpl2Name: FullArtifactName = {
-  type: 'template',
-  pkg: 'current-package',
-  id: 'local-template-2',
-  version: '1.2.3',
+  type: "template",
+  pkg: "current-package",
+  id: "local-template-2",
+  version: "1.2.3",
 };
 export const testLocalTpl2Src = `
 lib := import("package1:other-lib-1")
@@ -155,10 +155,10 @@ lib := import("package1:other-lib-1")
 `;
 
 export const testLocalTpl3Name: FullArtifactName = {
-  type: 'template',
-  pkg: 'current-package',
-  id: 'local-template-3',
-  version: '1.2.3',
+  type: "template",
+  pkg: "current-package",
+  id: "local-template-3",
+  version: "1.2.3",
 };
 
 export const testLocalTpl3Src = `
@@ -203,10 +203,10 @@ export const testLocalTpl3: TestArtifactSource = {
 export const testLocalPackage = [testLocalTpl1, testLocalLib1, testLocalTpl2];
 
 export const testPackage1Lib1Name: FullArtifactName = {
-  type: 'library',
-  pkg: 'package1',
-  id: 'other-lib-1',
-  version: '1.2.3',
+  type: "library",
+  pkg: "package1",
+  id: "other-lib-1",
+  version: "1.2.3",
 };
 export const testPackage1Lib1Src = `
 export {
@@ -215,30 +215,30 @@ export {
 `;
 
 export const testPackage1Soft1Name: FullArtifactName = {
-  type: 'software',
-  pkg: 'current-package',
-  id: 'software-1',
-  version: '1.2.3',
+  type: "software",
+  pkg: "current-package",
+  id: "software-1",
+  version: "1.2.3",
 };
 export const testPackage1Soft1Src = `
 some software contents. Template builder should pass it 'as-is'
 `;
 
 export const testPackage1Asset1Name: FullArtifactName = {
-  type: 'asset',
-  pkg: 'current-package',
-  id: 'asset-1',
-  version: '1.2.3',
+  type: "asset",
+  pkg: "current-package",
+  id: "asset-1",
+  version: "1.2.3",
 };
 export const testPackage1Asset1Src = `
 some asset contents. Template builder should pass it 'as-is'
 `;
 
 export const testPackage1Lib2Name: FullArtifactName = {
-  type: 'library',
-  pkg: 'package1',
-  id: 'other-lib-2',
-  version: '1.2.3',
+  type: "library",
+  pkg: "package1",
+  id: "other-lib-2",
+  version: "1.2.3",
 };
 export const testPackage1Lib2Src = `
 lib := import("package1:other-lib-1")
@@ -249,17 +249,17 @@ export {
 `;
 
 export const testPackage1Tpl3Name: FullArtifactName = {
-  type: 'template',
-  pkg: 'package1',
-  id: 'template-3',
-  version: '1.2.3',
+  type: "template",
+  pkg: "package1",
+  id: "template-3",
+  version: "1.2.3",
 };
 export const testPackage1Tpl3Src = `
 lib := import("package1:other-lib-1")
 `;
 
-export const testPackage1Tpl3CompiledBase64
-  = 'H4sIAAAAAAAAE22PQQqDMBREr/KZVQsxELsL9CZ/E+VjQ2MiJpUWyd2LglCo2xlm3syK4LsMu2Jy/dMNYmwqD5mb4LvGbHp0o8Ce2wp57mHBUd5TmgutHImIGDmNwrDEWFx4iWFwrByhsMicfYqwMLrVN9Sq/hhFxim4Is3tBxF8R3fy4wa68OkgxnVnHPntWFUon2mvD7pIHFJz2HppzwZ9AanB7OAUAQAA';
+export const testPackage1Tpl3CompiledBase64 =
+  "H4sIAAAAAAAAE22PQQqDMBREr/KZVQsxELsL9CZ/E+VjQ2MiJpUWyd2LglCo2xlm3syK4LsMu2Jy/dMNYmwqD5mb4LvGbHp0o8Ce2wp57mHBUd5TmgutHImIGDmNwrDEWFx4iWFwrByhsMicfYqwMLrVN9Sq/hhFxim4Is3tBxF8R3fy4wa68OkgxnVnHPntWFUon2mvD7pIHFJz2HppzwZ9AanB7OAUAQAA";
 
 export const testPackage1Lib1: TestArtifactSource = {
   fullName: testPackage1Lib1Name,

package/src/compiler/util.ts

@@ -1,25 +1,25 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as winston from 'winston';
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as winston from "winston";
 
 export function assertNever(x: never): never {
   // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
-  throw new Error('Unexpected object: ' + x);
+  throw new Error("Unexpected object: " + x);
 }
 
-export function createLogger(level: string = 'debug'): winston.Logger {
+export function createLogger(level: string = "debug"): winston.Logger {
   return winston.createLogger({
     level: level,
     format: winston.format.combine(
       winston.format.errors({ stack: true }),
       winston.format.printf(({ level, message, stack }) => {
-        const baseMessage = `${level.padStart(6, ' ')}: ${message as string}`;
+        const baseMessage = `${level.padStart(6, " ")}: ${message as string}`;
         return stack ? `${baseMessage}\n${stack as string}` : baseMessage;
       }),
     ),
     transports: [
       new winston.transports.Console({
-        stderrLevels: ['error', 'warn', 'info', 'debug'],
+        stderrLevels: ["error", "warn", "info", "debug"],
         handleExceptions: true,
       }),
     ],
@@ -30,32 +30,32 @@ export function findNodeModules(): string {
   let currentDir = process.cwd();
 
   while (currentDir) {
-    const possibleNodeModulesPath = path.join(currentDir, 'node_modules');
+    const possibleNodeModulesPath = path.join(currentDir, "node_modules");
 
     if (fs.existsSync(possibleNodeModulesPath)) return possibleNodeModulesPath;
 
-    const parentDir = path.resolve(currentDir, '..');
+    const parentDir = path.resolve(currentDir, "..");
     if (parentDir === currentDir) break; // reached the root directory
 
     currentDir = parentDir;
   }
 
-  throw new Error('Unable to find node_modules directory.');
+  throw new Error("Unable to find node_modules directory.");
 }
 
-export type PathType = 'absent' | 'file' | 'dir' | 'link' | 'unknown';
+export type PathType = "absent" | "file" | "dir" | "link" | "unknown";
 
 export function pathType(path: string): PathType {
   try {
     const s = fs.statSync(path);
-    if (s.isDirectory()) return 'dir';
-    if (s.isFile()) return 'file';
-    if (s.isSymbolicLink()) return 'link';
-    return 'unknown';
+    if (s.isDirectory()) return "dir";
+    if (s.isFile()) return "file";
+    if (s.isSymbolicLink()) return "link";
+    return "unknown";
   } catch (error: unknown) {
     const err = error as NodeJS.ErrnoException;
-    if (err.code == 'ENOENT') return 'absent';
-    if (err.code == 'ENOTDIR') return 'absent';
+    if (err.code == "ENOENT") return "absent";
+    if (err.code == "ENOTDIR") return "absent";
     else throw err;
   }
 }

package/src/index.ts

@@ -1,15 +1,15 @@
 // DO NOT EDIT. This file was generated by oclif-index utility.
 
-import Cmd0 from './commands/build';
-import Cmd1 from './commands/check';
-import Cmd2 from './commands/test';
-import Cmd3 from './commands/dump/artifacts';
-import Cmd4 from './commands/dump/software';
+import Cmd0 from "./commands/build";
+import Cmd1 from "./commands/check";
+import Cmd2 from "./commands/test";
+import Cmd3 from "./commands/dump/artifacts";
+import Cmd4 from "./commands/dump/software";
 
 export const COMMANDS = {
-  'build': Cmd0,
-  'check': Cmd1,
-  'test': Cmd2,
-  'dump:artifacts': Cmd3,
-  'dump:software': Cmd4,
+  build: Cmd0,
+  check: Cmd1,
+  test: Cmd2,
+  "dump:artifacts": Cmd3,
+  "dump:software": Cmd4,
 };

package/src/shared/basecmd.ts

@@ -1,37 +1,37 @@
-import { Flags } from '@oclif/core';
+import { Flags } from "@oclif/core";
 
 export const GlobalFlags = {
-  'log-level': Flags.string({
-    description: 'logging level',
-    default: 'info',
-    options: ['error', 'warn', 'info', 'debug'],
+  "log-level": Flags.string({
+    description: "logging level",
+    default: "info",
+    options: ["error", "warn", "info", "debug"],
   }),
 };
 
 export const CtagsFlags = {
-  'generate-tags': Flags.boolean({
-    description: 'generate tags, default false',
+  "generate-tags": Flags.boolean({
+    description: "generate tags, default false",
     default: false,
   }),
 
-  'tags-file': Flags.file({
+  "tags-file": Flags.file({
     description: 'where to put ".tags" file, it should be a root of VS Code project',
-    default: '../../.tags', // usually a user opens a directory with all blocks
+    default: "../../.tags", // usually a user opens a directory with all blocks
   }),
 
-  'tags-additional-args': Flags.string({
-    description: 'additional flags for universal-ctags command: e.g. -e for emacs',
+  "tags-additional-args": Flags.string({
+    description: "additional flags for universal-ctags command: e.g. -e for emacs",
     default: [],
     multiple: true,
-    delimiter: ',',
+    delimiter: ",",
   }),
 };
 
 export const ArtifactTypeFlag = {
   type: Flags.string({
-    aliases: ['t'],
-    description: 'artifact type',
-    options: ['all', 'library', 'template', 'test', 'software', 'asset'],
-    default: 'all',
+    aliases: ["t"],
+    description: "artifact type",
+    options: ["all", "library", "template", "test", "software", "asset"],
+    default: "all",
   }),
 };

package/src/shared/dump.ts

@@ -1,8 +1,8 @@
-import type winston from 'winston';
-import { getPackageInfo, newCompiler, compile, parseSources } from '../compiler/main';
-import type { ArtifactType } from '../compiler/package';
-import { typedArtifactNameToString } from '../compiler/package';
-import type { TemplateDataV3 } from '@milaboratories/pl-model-backend';
+import type winston from "winston";
+import { getPackageInfo, newCompiler, compile, parseSources } from "../compiler/main";
+import type { ArtifactType } from "../compiler/package";
+import { typedArtifactNameToString } from "../compiler/package";
+import type { TemplateDataV3 } from "@milaboratories/pl-model-backend";
 
 export function dumpArtifacts(
   logger: winston.Logger,
@@ -11,9 +11,9 @@ export function dumpArtifacts(
 ): void {
   const packageInfo = getPackageInfo(process.cwd(), logger);
 
-  const sources = parseSources(logger, packageInfo, 'dist', 'src', '');
+  const sources = parseSources(logger, packageInfo, "dist", "src", "");
 
-  const compiler = newCompiler(logger, packageInfo, 'dist');
+  const compiler = newCompiler(logger, packageInfo, "dist");
 
   // group output by type:
   //  - all libs
@@ -24,97 +24,79 @@ export function dumpArtifacts(
 
   // Libs
 
-  if (!aType || aType === 'library') {
+  if (!aType || aType === "library") {
     for (const lib of compiler.allLibs()) {
-      logger.debug(
-        `Dumping to pl-tester: ${typedArtifactNameToString(lib.fullName)}`,
-      );
-      stream.write(JSON.stringify(lib) + '\n');
+      logger.debug(`Dumping to pl-tester: ${typedArtifactNameToString(lib.fullName)}`);
+      stream.write(JSON.stringify(lib) + "\n");
     }
 
     for (const src of sources) {
-      if (src.fullName.type === 'library') {
-        logger.debug(
-          `Dumping to pl-tester: ${typedArtifactNameToString(src.fullName)}`,
-        );
-        stream.write(JSON.stringify(src) + '\n');
+      if (src.fullName.type === "library") {
+        logger.debug(`Dumping to pl-tester: ${typedArtifactNameToString(src.fullName)}`);
+        stream.write(JSON.stringify(src) + "\n");
       }
     }
   }
 
   // Templates
 
-  if (!aType || aType === 'template') {
+  if (!aType || aType === "template") {
     for (const tpl of compiler.allTemplates()) {
-      logger.debug(
-        `Dumping to pl-tester: ${typedArtifactNameToString(tpl.fullName)}`,
-      );
-      stream.write(JSON.stringify(tpl) + '\n');
+      logger.debug(`Dumping to pl-tester: ${typedArtifactNameToString(tpl.fullName)}`);
+      stream.write(JSON.stringify(tpl) + "\n");
     }
 
     for (const src of sources) {
-      if (src.fullName.type === 'template') {
+      if (src.fullName.type === "template") {
         logger.debug(
-          `Dumping to pl-tester: ${typedArtifactNameToString(src.fullName)} ${
-            src.srcName
-          }`,
+          `Dumping to pl-tester: ${typedArtifactNameToString(src.fullName)} ${src.srcName}`,
         );
-        stream.write(JSON.stringify(src) + '\n');
+        stream.write(JSON.stringify(src) + "\n");
       }
     }
   }
 
   // Software
 
-  if (!aType || aType === 'software') {
+  if (!aType || aType === "software") {
     for (const sw of compiler.allSoftware()) {
-      logger.debug(
-        `Dumping to pl-tester: ${typedArtifactNameToString(sw.fullName)}`,
-      );
-      stream.write(JSON.stringify(sw) + '\n');
+      logger.debug(`Dumping to pl-tester: ${typedArtifactNameToString(sw.fullName)}`);
+      stream.write(JSON.stringify(sw) + "\n");
     }
 
     for (const src of sources) {
-      if (src.fullName.type === 'software') {
-        logger.debug(
-          `Dumping to pl-tester: ${typedArtifactNameToString(src.fullName)}`,
-        );
-        stream.write(JSON.stringify(src) + '\n');
+      if (src.fullName.type === "software") {
+        logger.debug(`Dumping to pl-tester: ${typedArtifactNameToString(src.fullName)}`);
+        stream.write(JSON.stringify(src) + "\n");
       }
     }
   }
 
   // Assets
 
-  if (!aType || aType === 'asset') {
+  if (!aType || aType === "asset") {
     for (const asset of compiler.allAssets()) {
-      logger.debug(
-        `Dumping to pl-tester: ${typedArtifactNameToString(asset.fullName)}`,
-      );
-      stream.write(JSON.stringify(asset) + '\n');
+      logger.debug(`Dumping to pl-tester: ${typedArtifactNameToString(asset.fullName)}`);
+      stream.write(JSON.stringify(asset) + "\n");
     }
 
     for (const src of sources) {
-      if (src.fullName.type === 'asset') {
-        logger.debug(
-          `Dumping to pl-tester: ${typedArtifactNameToString(src.fullName)}`,
-        );
-        stream.write(JSON.stringify(src) + '\n');
+      if (src.fullName.type === "asset") {
+        logger.debug(`Dumping to pl-tester: ${typedArtifactNameToString(src.fullName)}`);
+        stream.write(JSON.stringify(src) + "\n");
       }
     }
   }
 
   // Tests
 
-  if (!aType || aType === 'test') {
+  if (!aType || aType === "test") {
     for (const src of sources) {
-      if (src.fullName.type === 'test') {
+      if (src.fullName.type === "test") {
         logger.debug(
-          `Dumping to pl-tester: ${typedArtifactNameToString(src.fullName)} ${
-            src.srcName
-          }`,
+          `Dumping to pl-tester: ${typedArtifactNameToString(src.fullName)} ${src.srcName}`,
         );
-        stream.write(JSON.stringify(src) + '\n');
+        stream.write(JSON.stringify(src) + "\n");
       }
     }
   }
@@ -127,54 +109,51 @@ export function dumpLibs(
 ): void {
   const packageInfo = getPackageInfo(process.cwd(), logger);
 
-  const sources = parseSources(logger, packageInfo, 'dist', 'src', '');
+  const sources = parseSources(logger, packageInfo, "dist", "src", "");
 
   if (!recursive) {
     for (const src of sources) {
-      if (src.fullName.type === 'library') {
-        stream.write(JSON.stringify(src) + '\n');
+      if (src.fullName.type === "library") {
+        stream.write(JSON.stringify(src) + "\n");
       }
     }
 
     return;
   }
 
-  const compiler = newCompiler(logger, packageInfo, 'dist');
+  const compiler = newCompiler(logger, packageInfo, "dist");
   for (const src of sources) {
-    if (src.fullName.type === 'library') {
+    if (src.fullName.type === "library") {
       compiler.addLib(src);
     }
   }
 
   for (const lib of compiler.allLibs()) {
-    stream.write(JSON.stringify(lib) + '\n');
+    stream.write(JSON.stringify(lib) + "\n");
   }
 }
 
-export function dumpSoftware(
-  logger: winston.Logger,
-  stream: NodeJS.WritableStream,
-): void {
+export function dumpSoftware(logger: winston.Logger, stream: NodeJS.WritableStream): void {
   const packageInfo = getPackageInfo(process.cwd(), logger);
-  const compiled = compile(logger, packageInfo, 'dist');
+  const compiled = compile(logger, packageInfo, "dist");
 
   const hashes = new Set<string>();
   const sourceMap = new Map<string, string>();
   for (const tpl of compiled.templates) {
     Object.entries(tpl.data.hashToSource).forEach(([hash, src]) => sourceMap.set(hash, src));
-    getTemplateSoftware(stream, tpl.data.template).forEach((hash) => hashes.add(hash));
+    getTemplateSoftware(tpl.data.template).forEach((hash) => hashes.add(hash));
   }
 
   for (const hash of hashes) {
     const src = sourceMap.get(hash);
     if (src) {
-      if (Object.hasOwn(JSON.parse(src) as object, 'asset')) {
+      if (Object.hasOwn(JSON.parse(src) as object, "asset")) {
         // Skip assets. They are kept in templates software because of backward compatibility with backend.
         continue;
       }
       stream.write(src);
-      if (!src.endsWith('\n')) {
-        stream.write('\n');
+      if (!src.endsWith("\n")) {
+        stream.write("\n");
       }
     } else {
       throw new Error(`Source not found for hash: ${hash}`);
@@ -182,13 +161,13 @@ export function dumpSoftware(
   }
 }
 
-function getTemplateSoftware(stream: NodeJS.WritableStream, tpl: TemplateDataV3): Set<string> {
+function getTemplateSoftware(tpl: TemplateDataV3): Set<string> {
   const hashes = new Set<string>();
   for (const sw of Object.values(tpl.software)) {
     hashes.add(sw.sourceHash);
   }
   for (const subTpl of Object.values(tpl.templates)) {
-    getTemplateSoftware(stream, subTpl).forEach((hash) => hashes.add(hash));
+    getTemplateSoftware(subTpl).forEach((hash) => hashes.add(hash));
   }
 
   return new Set(hashes);

package/src/shared/proc.ts

@@ -1,16 +1,16 @@
-import type { ChildProcess, ChildProcessByStdio } from 'node:child_process';
-import { spawn } from 'node:child_process';
-import type { Writable } from 'node:stream';
+import type { ChildProcess, ChildProcessByStdio } from "node:child_process";
+import { spawn } from "node:child_process";
+import type { Writable } from "node:stream";
 
 export function spawnEmbed(
   cmd: string,
   ...args: string[]
 ): ChildProcessByStdio<Writable, null, null> {
-  const p = spawn(cmd, args, { stdio: ['pipe', 'inherit', 'inherit'] });
+  const p = spawn(cmd, args, { stdio: ["pipe", "inherit", "inherit"] });
 
-  p.stdin.on('error', (err: Error) => {
+  p.stdin.on("error", (err: Error) => {
     const systemError = err as NodeJS.ErrnoException;
-    if (systemError.code === 'EPIPE') {
+    if (systemError.code === "EPIPE") {
       // ignore EPIPE error as it stands for broken command run.
       // The command will write normal problem description by itself.
     }
@@ -21,10 +21,10 @@ export function spawnEmbed(
 
 export function waitFor(p: ChildProcess): Promise<number> {
   return new Promise((resolve, reject) => {
-    p.on('close', (code: number) => {
+    p.on("close", (code: number) => {
       resolve(code);
     });
-    p.on('error', (err) => {
+    p.on("error", (err) => {
       reject(err);
     });
   });