@platforma-sdk/workflow-tengo 2.8.6 → 2.8.8

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 declare type TemplateFromFile = { readonly type: "from-file"; readonly path: string; };
-declare type TplName = "pframes.aggregate" | "pframes.export-single-pcolumn" | "pframes.import-dir" | "pframes.map-pframe" | "workdir.save" | "workflow.build-ctx" | "exec.R.create-renv" | "exec.python.install-deps" | "pframes.export-multiple-pcolumns" | "pframes.export-pframe" | "exec.python.create-venv" | "exec.exec" | "pframes.xsv-export-pframe" | "pframes.xsv-import-map";
+declare type TplName = "exec.monetization_to_json" | "pframes.aggregate" | "pframes.export-single-pcolumn" | "pframes.import-dir" | "pframes.map-pframe" | "workdir.save" | "workflow.build-ctx" | "exec.R.create-renv" | "exec.python.install-deps" | "pframes.export-multiple-pcolumns" | "pframes.export-pframe" | "exec.python.create-venv" | "exec.exec" | "pframes.xsv-export-pframe" | "pframes.xsv-import-map";
 declare const Templates: Record<TplName, TemplateFromFile>;
 export { Templates };

package/dist/index.js

@@ -1,4 +1,5 @@
 module.exports = { Templates: {
+  'exec.monetization_to_json': { type: 'from-file', path: require.resolve('./tengo/tpl/exec.monetization_to_json.plj.gz') },
   'pframes.aggregate': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.aggregate.plj.gz') },
   'pframes.export-single-pcolumn': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.export-single-pcolumn.plj.gz') },
   'pframes.import-dir': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.import-dir.plj.gz') },

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import { resolve } from 'node:path';
 export const Templates = {
+  'exec.monetization_to_json': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/exec.monetization_to_json.plj.gz') },
   'pframes.aggregate': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.aggregate.plj.gz') },
   'pframes.export-single-pcolumn': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.export-single-pcolumn.plj.gz') },
   'pframes.import-dir': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.import-dir.plj.gz') },

package/dist/tengo/lib/exec.internal.lib.tengo

@@ -16,6 +16,7 @@ pkg := import("@platforma-sdk/workflow-tengo:exec.package")
 runcmd := import("@platforma-sdk/workflow-tengo:exec.runcmd")
 python := import("@platforma-sdk/workflow-tengo:exec.python")
 R := import("@platforma-sdk/workflow-tengo:exec.R")
+validation := import("@platforma-sdk/workflow-tengo:validation")
 
 
 _ARG_VAR_PKG            := "{pkg}"  // abs path to software package
@@ -23,6 +24,7 @@ _ARG_VAR_JAVA           := "{java}" // abs path to 'java' run environment
 _ARG_VAR_PYTHON         := "{python}" // abs path to 'python' run environment
 _ARG_VAR_R              := "{R}" // abs path to 'R' run environment runtime
 _ARG_VAR_R_VENV         := "{rVenv}" // abs path to 'R' portable virtual environment
+_ARG_VAR_MNZ            := "{monetization}" // monetization env value
 
 
 
@@ -45,29 +47,20 @@ reference: reference
 }
 
 _installSoftware := func(registry, pkgName) {
+ll.assert(is_string(registry), "exec.internal._installSoftware(): registry is not a string, got: %v", registry, pkgName)
+ll.assert(is_string(pkgName), "exec.internal._installSoftware(): pkgName is not a string, got: %v", pkgName, registry)
+
 archive := pkg.get(registry, pkgName).archive()
 return pkg.install(archive).package()
 }
 
 _directCallOptions := func(runOptions) {
-cmd := _newArg(false, runOptions.cmd)
-args := []
-envs := {}
-
-for name, arg in runOptions.args {
-args = append(args, _newArg(false, arg))
-}
-
-for name, val in runOptions.envs {
-envs[name] = _newArg(false, val)
-}
-
-return oop.inherit(runOptions, {
+return ll.toStrict({
 variables: [],
 customPaths: [],
-cmd: cmd,
-args: args,
-envs: envs
+cmd: _newArg(false, runOptions.cmd),
+args: [],
+envs: {}
 })
 }
 
@@ -176,7 +169,7 @@ ll.panic("run environment type %q is not currently supported by workflow-sdk",	d
 
 
 
-_binPackageCallOptions := func(operationMode, runOptions, variables, descriptor, softPackage) {
+_binPackageCallOptions := func(operationMode, softwareName, variables, descriptor, softPackage) {
 customPaths := []
 envs := ll.toStrict({})
 args := []
@@ -185,7 +178,7 @@ runEnvType := "binary"
 
 
 if (maps.containsKey(descriptor, "runEnv")) {
-runEnvInfo := _loadRunEnvironment(operationMode, descriptor, runOptions.software.name, softPackage)
+runEnvInfo := _loadRunEnvironment(operationMode, descriptor, softwareName, softPackage)
 
 runEnvType = runEnvInfo.runEnvType
 if len(runEnvInfo.variables) > 0 {
@@ -208,15 +201,8 @@ cmd := _newArg(true, descriptor.cmd[0])
 for arg in splice(descriptor.cmd, 1) {
 args = append(args, _newArg(true, arg))
 }
-for arg in runOptions.args {
-args = append(args, _newArg(false, arg))
-}
-
-for name, val in runOptions.envs {
-envs[name] = _newArg(false, val)
-}
 
-return oop.inherit(runOptions, {
+return ll.toStrict({
 runEnvType: runEnvType,
 variables: variables,
 customPaths: customPaths,
@@ -226,56 +212,101 @@ envs: envs
 })
 }
 
-_devLocalPackageCallOptions := func(runOptions) {
-software := runOptions.software
-localDescriptor := software.descriptor.local
-
+_devLocalPackageCallOptions := func(softwareName, localDescriptor) {
 softPackage := pkg.use({
 hash: localDescriptor.hash,
 path: localDescriptor.path,
-descriptor: json.encode(ll.fromStrict(software.descriptor)),
+descriptor: json.encode(ll.fromStrict(localDescriptor)),
 origin: {
 registry: "dev-local",
 url: "file://" + localDescriptor.path,
-packageName: software.descriptor.name
+packageName: softwareName
 }
 }).package()
 
-variables := [ _newRefVar(_ARG_VAR_PKG, software.name, softPackage) ]
+variables := [ _newRefVar(_ARG_VAR_PKG, softwareName, softPackage) ]
 
-return _binPackageCallOptions("dev-local", runOptions, variables, localDescriptor, softPackage)
+return _binPackageCallOptions("dev-local", softwareName, variables, localDescriptor, softPackage)
 }
 
-_remotePackageCallOptions := func(runOptions) {
-software := runOptions.software
-binaryDescriptor := software.descriptor.binary
+_remotePackageCallOptions := func(softwareName, binaryDescriptor) {
 softPackage := _installSoftware(binaryDescriptor.registry, binaryDescriptor.package)
 
-variables := [ _newRefVar(_ARG_VAR_PKG, software.name, softPackage) ]
+variables := [ _newRefVar(_ARG_VAR_PKG, softwareName, softPackage) ]
 
-return _binPackageCallOptions("remote", runOptions, variables, binaryDescriptor, softPackage)
+return _binPackageCallOptions("remote", softwareName, variables, binaryDescriptor, softPackage)
 }
 
-binaryRunOptions := func(runOptions) {
-if (is_undefined(ll.fromStrict(runOptions).software)) {
 
 
 
-return _directCallOptions(runOptions)
+
+swToRunCmdOptions := func(softwareName, softwareVersion, softwareDescriptor) {
+ll.assert(is_string(softwareName),
+"exec.internal.swToRunCmdOptions: software name must be a string, got %v", softwareName)
+ll.assert(is_string(softwareVersion),
+"exec.internal.swToRunCmdOptions: software version must be a string, got %v", softwareVersion)
+validation.assertJsonSchema(softwareDescriptor, pkg.descriptorScheme,
+"exec.internal.swToRunCmdOptions: descriptor does not fit schema")
+
+result := undefined
+if maps.containsKey(softwareDescriptor, "local") {
+result = _devLocalPackageCallOptions(softwareName, softwareDescriptor.local)
+} else if maps.containsKey(softwareDescriptor, "binary") {
+result = _remotePackageCallOptions(softwareName, softwareDescriptor.binary)
+} else {
+ll.panic(
+"Unable to run software %s v%s: 'binary' execution mode is not enabled in software descriptor",
+softwareName, softwareVersion)
+}
+
+
+
+return ll.toStrict({
+runEnvType: result.runEnvType,
+variables: result.variables,
+customPaths: result.customPaths,
+cmd: result.cmd,
+args: result.args,
+envs: result.envs
+})
 }
 
+binaryRunOptions := func(runOptions, mnzEnvs) {
+validation.assertJsonSchema(mnzEnvs, {"any": validation.reference})
+
+runCmdOpts := undefined
+if (is_undefined(ll.fromStrict(runOptions).software)) {
+
+
+
+runCmdOpts = _directCallOptions(runOptions)
+} else {
 software := runOptions.software
 descriptor := software.descriptor
 
-if (maps.containsKey(descriptor, "local")) {
-return _devLocalPackageCallOptions(runOptions)
+runCmdOpts = swToRunCmdOptions(software.name, software.version, descriptor)
+}
+
+
+for arg in runOptions.args {
+runCmdOpts.args = append(runCmdOpts.args, _newArg(false, arg))
 }
+for name, val in runOptions.envs {
+runCmdOpts.envs[name] = _newArg(false, val)
+}
+
+for name, val in mnzEnvs { // can be empty
 
-if (maps.containsKey(descriptor, "binary")) {
-return _remotePackageCallOptions(runOptions)
+
+runCmdOpts.envs[name] = _newArg(true, _ARG_VAR_MNZ)
+
+runCmdOpts.variables = append(runCmdOpts.variables,
+_newRefVar(_ARG_VAR_MNZ, "monetization", val))
 }
 
-ll.panic("Unable to run software %s v%s: 'binary' execution mode is not enabled in software descriptor", software.name, software.version)
+
+return oop.inherit(runOptions, ll.fromStrict(runCmdOpts))
 }
 
 prepareCommandRun := func(wd, opts) {
@@ -328,6 +359,7 @@ return wd
 }
 
 export {
+swToRunCmdOptions           : swToRunCmdOptions,
 binaryRunOptions			: binaryRunOptions,
 
 prepareWDForRunEnvironment	: prepareWDForRunEnvironment,

package/dist/tengo/lib/exec.lib.tengo

@@ -15,6 +15,7 @@ enum := import("enum")
 oop := import("@platforma-sdk/workflow-tengo:oop")
 validation := import("@platforma-sdk/workflow-tengo:validation")
 constants := import("@platforma-sdk/workflow-tengo:constants")
+monetization := import("@platforma-sdk/workflow-tengo:exec.monetization")
 
 _HEAVY_QUEUE    := "heavy"
 _MEDIUM_QUEUE   := "medium"
@@ -71,6 +72,27 @@ assetDescriptors := {}
 assetRules := {}
 assetCache := {}
 
+mnz := monetization.init()
+
+
+_getMnzOption := func(...opts) {
+if slices.length(opts) < 1 {
+return undefined
+}
+opt := opts[0]["mnz"]
+
+
+return is_undefined(opt) ? undefined : opt
+}
+
+
+_addMnzOption := func(fileName, ...opts) {
+opt := _getMnzOption(opts...)
+if !is_undefined(opt) {
+monetization.addFileParams(mnz, fileName, opt)
+}
+}
+
 stdout := "stdout.txt"
 stderr := "stderr.txt"
 
@@ -392,15 +414,24 @@ assetCache[assetIdKey] = days * 24 * times.hour
 return self
 },
 
+enableMnz: func(productName) {
+monetization.enable(mnz, productName)
+return self
+},
+
 
 
 
 
 
 
-addFile: func(fileName, file) {
+addFile: func(fileName, file, ...opts) {
+ll.assert(is_string(fileName), "exec.builder().addFile: fileName must be a string")
+ll.assert(smart.isReference(file), "exec.builder().addFile: file must be a reference")
+
 fileName = path.canonize(fileName)
 filesToAdd[fileName] = file
+_addMnzOption(fileName, opts...)
 return self
 },
 
@@ -409,8 +440,11 @@ return self
 
 
 
-addFiles: func(filesMap) {
-enum.each(filesMap, self.addFile)
+addFiles: func(filesMap, ...opts) {
+ll.assert(ll.isMap(filesMap), "exec.builder().addFiles: filesMap must be map of file names to file resources")
+for fileName, file in filesMap {
+self.addFile(fileName, file, opts...)
+}
 return self
 },
 
@@ -421,7 +455,7 @@ return self
 
 
 
-writeFile: func(fileName, data) {
+writeFile: func(fileName, data, ...opts) {
 validation.assertJsonSchema(data, ["or",
 "string",
 "bytes",
@@ -430,6 +464,7 @@ validation.reference])
 fileName = path.canonize(fileName)
 
 filesToWrite[fileName] = data
+_addMnzOption(fileName, opts...)
 
 return self
 },
@@ -585,11 +620,7 @@ return smart.createValueResource(constants.RTYPE_BINARY_VALUE, v)
 ll.assert(entrypointSet,
 "incomplete command: cmd() or software() must be provided to exec.builder")
 
-execInputs := {
-filesToAdd: smart.createMapResource(filesToAdd),
-filesToWrite: smart.createMapResource(filesToWriteRefs),
-dirsToCreate: slices.fromSet(dirsToCreate),
-runOptions: {
+runOptions := {
 cmd: cmd,
 args: args,
 envs: envs,
@@ -598,7 +629,13 @@ queue: queue,
 stdout: stdout,
 stderr: stderr,
 nErrorLines: nErrorLines
-},
+}
+
+execInputs := {
+filesToAdd: smart.createMapResource(filesToAdd),
+filesToWrite: smart.createMapResource(filesToWriteRefs),
+dirsToCreate: slices.fromSet(dirsToCreate),
+runOptions: runOptions,
 filesToSave: slices.fromSet(filesToSave),
 filesContentToSave: slices.fromSet(filesContentToSave),
 fileSetsToSave: fileSetsToSave,
@@ -611,6 +648,13 @@ assetRules: assetRules,
 assetCache: assetCache
 }
 
+
+
+
+if monetization.shouldRun(mnz) {
+execInputs.runOptions.monetization = monetization.toJson(mnz)
+}
+
 if !is_undefined(soft) {
 execInputs.softwareInfo = soft.resource
 execInputs.runOptions.software = {

package/dist/tengo/lib/exec.monetization.lib.tengo

@@ -0,0 +1,173 @@
+
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+validation := import("@platforma-sdk/workflow-tengo:validation")
+assets := import("@platforma-sdk/workflow-tengo:assets")
+internal := import("@platforma-sdk/workflow-tengo:exec.internal")
+fmt := import("fmt")
+text := import("text")
+runcmd := import("@platforma-sdk/workflow-tengo:exec.runcmd")
+workdir := import("@platforma-sdk/workflow-tengo:workdir")
+render := import("@platforma-sdk/workflow-tengo:render")
+
+_JWT_TOKEN_RESULT_ENV := "PLATFORMA_MNZ_JWT"
+
+
+init := func() {
+return ll.toStrict({
+enabled: false,
+
+
+productName: "",
+
+
+fileParams: {}
+})
+}
+
+fileParamsSchema := {
+"arg": "string",
+"collect": [`string,regex=size|lines|sha256`]
+}
+
+schema := {
+"enabled": "bool",
+"productName": "string",
+"fileParams": {"any": fileParamsSchema}
+}
+
+_assertIsReady := func(mnz) {
+validation.assertJsonSchema(mnz, schema,
+"monetization.assertIsReady(): monetization does not fit schema")
+ll.assert(len(mnz.productName) > 0,
+"monetization.assertIsReady(): product name must be set")
+ll.assert(len(mnz.fileParams) > 0,
+"monetization.assertIsReady(): at least 1 file param must be set")
+}
+
+
+enable := func(mnz, productName) {
+ll.assert(is_string(productName),
+"monetization.enable(): product name must be a string, got %v", productName)
+
+validation.assertJsonSchema(mnz, schema,
+"monetization.enable(): mnz object does not fit schema")
+
+mnz.enabled = true
+mnz.productName = productName
+}
+
+
+shouldRun := func(mnz) {
+if mnz.enabled {
+_assertIsReady(mnz)
+return true
+}
+
+return false
+}
+
+toJson := func(mnz) {
+validation.assertJsonSchema(mnz, schema,
+"monetization.toJson(): monetization object does not fit json schema")
+
+return ll.fromStrict(mnz)
+}
+
+
+addFileParams := func(mnz, fileName, params) {
+validation.assertJsonSchema(mnz, schema,
+"monetization.addFileParams(): monetization object does not fit json schema")
+
+validation.assertJsonSchema(params, fileParamsSchema,
+"monetization.addFileParams(): file params does not fit json schema")
+
+ll.assert(mnz.enabled,
+"monetization.addFileParams(): monetization must be explicitly enabled by enableMnz(productName) function")
+
+ll.assert(is_string(fileName),
+"monetization.addFileParams(): file name must be a string.")
+
+mnz.fileParams[fileName] = params
+}
+
+
+
+
+
+
+
+
+run := func(mnz, wd, queue) {
+_assertIsReady(mnz)
+
+mnzSw := assets.importSoftware("@platforma-open/milaboratories.software-small-binaries:mnz-client")
+
+builder := runcmd.builder(wd)
+builder.envVar("MI_LICENSE", "{secrets.MI_LICENSE}")
+
+opts := internal.swToRunCmdOptions(mnzSw.name, mnzSw.version, mnzSw.descriptor)
+
+for _, varInfo in opts.variables {
+builder.ref(varInfo.refName, varInfo.reference)
+builder.substitutionRule(varInfo.varName, varInfo.refName)
+}
+
+builder.cmdVar(opts.cmd.value)
+for _, arg in opts.args {
+
+builder.argVar(arg)
+}
+builder.arg("-productName").arg(mnz.productName)
+
+
+for fileName, param in mnz.fileParams {
+
+toCollect := text.join(param.collect, ",")
+arg := fmt.sprintf("%s:file:%s:%s", param.arg, fileName, toCollect)
+builder.arg(arg)
+}
+
+builder.inQueue(queue)
+stdout := "mnz_stdout.txt"
+builder.stdout(stdout)
+run := builder.build()
+
+
+savedWd := workdir.save(run.workdir).
+saveFileContent(stdout).
+build()
+
+jwtResultAsBytes := savedWd.filesContent.getFutureInputField(stdout)
+
+
+
+
+jwtResultAsString := render.create(
+assets.importTemplate("@platforma-sdk/workflow-tengo:exec.monetization_to_json"),
+{ resource: jwtResultAsBytes }
+).output("jsonedData")
+
+return ll.toStrict({
+
+
+
+wdAfter: savedWd.workdir,
+
+
+
+
+jwtEnvName: _JWT_TOKEN_RESULT_ENV,
+jwtEnvValue: jwtResultAsString
+})
+}
+
+export ll.toStrict({
+init: init,
+schema: schema,
+enable: enable,
+shouldRun: shouldRun,
+toJson: toJson,
+addFileParams: addFileParams,
+run: run
+})

package/dist/tengo/lib/exec.package.lib.tengo

@@ -21,7 +21,7 @@ binaryDescriptorScheme := {
 registry: "string",
 package: "string",
 cmd: ["string"],
-runEnv: runEnvDescriptorScheme
+"runEnv,?": runEnvDescriptorScheme
 }
 
 assetDescriptorScheme := {

package/dist/tengo/lib/ll.lib.tengo

@@ -1,7 +1,6 @@
 
 
 plapi := import("plapi")
-json := import("json")
 fmt := import("fmt")
 log := import("log")
 text := import("text")

package/dist/tengo/lib/maps.lib.tengo

@@ -101,6 +101,49 @@ return filter(map, func(k, v) { return predicateFnK(k) && predicateFnV(v) })
 
 
 
+
+
+
+
+
+
+clone := func(obj, ...ops) {
+removeUndefs := false
+if len(ops) == 1 {
+removeUndefs = ops[0].removeUndefs
+}
+
+if is_map(obj) || ll.isStrict(obj) {
+res := {}
+strict := ll.isStrict(obj)
+if strict {
+obj = ll.fromStrict(obj)
+}
+for k, v in obj {
+if !removeUndefs || !is_undefined(v) {
+res[k] = clone(v, ops...)
+}
+}
+if strict {
+return ll.toStrict(res)
+} else {
+return res
+}
+} else if is_array(obj) {
+res := []
+for v in obj {
+res = append(res, clone(v, ops...))
+}
+return res
+}
+
+return obj
+}
+
+
+
+
+
 merge := func(...maps) {
 res := {}
 for map in maps {
@@ -140,6 +183,7 @@ export ll.toStrict({
 map : map,
 merge: merge,
 deepMerge: deepMerge,
+clone: clone,
 mapKeys : mapKeys,
 mapValues : mapValues,
 filter : filter,

package/dist/tengo/lib/smart.lib.tengo

@@ -1131,6 +1131,7 @@ ll.assert(!ll.isStrict(value), "can't encode strict map: ", value)
 
 
 encoded := json.encode(value)
+
 return createValueResource(constants.RTYPE_JSON, encoded)
 }
 

package/dist/tengo/lib/tpl.lib.tengo

@@ -28,7 +28,6 @@ ll.assert(smart.isResource(resource), "expected resource, found ", resource)
 
 self := func(resource) { return _unmarshal(resource, preprocessors) }
 
-
 for preproc in preprocessors {
 if preproc.canParse(resource) {
 return preproc.parse(resource, self)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "2.8.6",
+  "version": "2.8.8",
   "description": "Tengo SDK library",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -17,7 +17,7 @@
   ],
   "dependencies": {
     "@milaboratories/software-pframes-conv": "2.1.2",
-    "@platforma-open/milaboratories.software-small-binaries": "^1.15.4"
+    "@platforma-open/milaboratories.software-small-binaries": "^1.15.6"
   },
   "devDependencies": {
     "@platforma-sdk/tengo-builder": "^1.17.5"