@platforma-sdk/workflow-tengo 2.9.2 → 2.9.3

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

@@ -33,6 +33,13 @@ _expr := func(varName) {
 return "{" + varName + "}"
 }
 
+_newTypedArg := func(type, value) {
+return ll.toStrict({
+type: type,
+value: value
+})
+}
+
 
 
 
@@ -42,21 +49,12 @@ return "{" + varName + "}"
 
 _newArg := func(isString, value) {
 if isString {
-return ll.toStrict({
-type: constants.ARG_TYPE_STRING,
-value: value
-})
+return _newTypedArg(constants.ARG_TYPE_STRING, value)
 }
 if desc.canBackendUseExpressions() {
-return ll.toStrict({
-type: constants.ARG_TYPE_EXPRESSION,
-value: value
-})
+return _newTypedArg(constants.ARG_TYPE_EXPRESSION, value)
 }
-return ll.toStrict({
-type: constants.ARG_TYPE_VAR,
-value: value
-})
+return _newTypedArg(constants.ARG_TYPE_VAR, value)
 }
 
 _newRefVar := func(varName, refName, reference) {
@@ -308,13 +306,11 @@ binaryRunOptions := func(runOptions, mnzEnvs) {
 validation.assertJsonSchema(mnzEnvs, {"any": validation.reference})
 
 runCmdOpts := undefined
-onlyStrings := false
 if (is_undefined(ll.fromStrict(runOptions).software)) {
 
 
 
 runCmdOpts = _directCallOptions(runOptions)
-onlyStrings = true
 } else {
 software := runOptions.software
 descriptor := software.descriptor
@@ -323,11 +319,22 @@ runCmdOpts = swToRunCmdOptions(software.name, software.version, descriptor)
 }
 
 
-for arg in runOptions.args {
-runCmdOpts.args = append(runCmdOpts.args, _newArg(true, arg))
+
+
+
+opts := ll.fromStrict(runOptions)
+shouldUseNewTyped := !is_undefined(opts.argsTyped) || !is_undefined(opts.envsTyped)
+
+args := shouldUseNewTyped ? runOptions.argsTyped : runOptions.args
+for _, arg in args {
+typedArg := shouldUseNewTyped ? _newTypedArg(arg.type, arg.value) :	_newArg(true, arg)
+runCmdOpts.args = append(runCmdOpts.args, typedArg)
 }
-for name, val in runOptions.envs {
-runCmdOpts.envs[name] = _newArg(true, val)
+
+envs := shouldUseNewTyped ? runOptions.envsTyped : runOptions.envs
+for name, v in envs {
+typedEnv := shouldUseNewTyped ? _newTypedArg(v.type, v.value) : _newArg(true, v)
+runCmdOpts.envs[name] = typedEnv
 }
 
 for name, val in mnzEnvs { // can be empty

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

@@ -17,6 +17,7 @@ validation := import("@platforma-sdk/workflow-tengo:validation")
 constants := import("@platforma-sdk/workflow-tengo:constants")
 desc := import("@platforma-sdk/workflow-tengo:exec.descriptor")
 monetization := import("@platforma-sdk/workflow-tengo:exec.monetization")
+execConstants := import("@platforma-sdk/workflow-tengo:exec.constants")
 
 _HEAVY_QUEUE    := "heavy"
 _MEDIUM_QUEUE   := "medium"
@@ -33,7 +34,14 @@ self := undefined
 
 soft := undefined
 cmd := undefined
-args := []
+args := [] // list of strings
+argsTyped := [] // list of {type: expression|string, value: string}
+typedArgSet := false
+typedEnvSet := false
+envs := {} // map of names to values-strings
+envsTyped := {} // map of names to {type: expression|string, value: string}
+secrets := {} // { "env_name": "{secrets.secret_name}", ... }
+
 entrypointSet := false
 
 assertEntrypointNotSet := func() {
@@ -41,8 +49,6 @@ ll.assert(!entrypointSet,
 "either a command with arguments or a software were already set.")
 }
 
-envs := {}
-secrets := {} // { "env_name": "{secrets.secret_name}", ... }
 queue := _HEAVY_QUEUE
 cache := 0
 nErrorLines := 200
@@ -137,10 +143,31 @@ return self
 
 
 arg: func(arg) {
-if is_undefined(arg) {
-ll.panic("exec: arg can't be undefined")
-}
+ll.assert(is_string(arg), "exec.arg(): argument must be a string, got: %v", arg)
 args = append(args, arg)
+argsTyped = append(argsTyped, {
+type: execConstants.ARG_TYPE_STRING,
+value: arg
+})
+return self
+},
+
+
+
+
+
+
+argWithVar: func(arg) {
+ll.assert(is_string(arg), "exec.argWithVar(): argument with var must be a string, got: %v", arg)
+
+
+t := desc.canBackendUseExpressions() ? execConstants.ARG_TYPE_EXPRESSION : execConstants.ARG_TYPE_VAR
+argsTyped = append(argsTyped, {
+type: t,
+value: arg
+})
+typedArgSet = true
+
 return self
 },
 
@@ -153,6 +180,30 @@ return self
 env: func(name, value) {
 validation.assertJsonSchema([name, value], ["string"])
 envs[name] = value
+envsTyped[name] = {
+type: execConstants.ARG_TYPE_STRING,
+value: value
+}
+return self
+},
+
+
+
+
+
+
+
+envWithVar: func(name, value) {
+validation.assertJsonSchema([name, value], ["string"])
+
+
+t := desc.canBackendUseExpressions() ? execConstants.ARG_TYPE_EXPRESSION : execConstants.ARG_TYPE_VAR
+envsTyped[name] = {
+type: t,
+value: value
+}
+typedEnvSet = true
+
 return self
 },
 
@@ -656,6 +707,13 @@ if monetization.shouldRun(mnz) {
 execInputs.runOptions.monetization = monetization.toJson(mnz)
 }
 
+
+
+if typedArgSet || typedEnvSet {
+execInputs.runOptions.argsTyped = argsTyped
+execInputs.runOptions.envsTyped = envsTyped
+}
+
 if !is_undefined(soft) {
 execInputs.softwareInfo = soft.resource
 execInputs.runOptions.software = {

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

@@ -355,7 +355,7 @@ return self
 build: func() {
 
 
-ll.assert(!(hasPatternArgs || hasExpressionArgs) || len(substRules) != 0,
+ll.assert(!hasPatternArgs || len(substRules) != 0,
 "found pattern argument, but no substitution rules were set: hasPatternArgs: %v, substRules: %v, cmd: %v, args: %v, envs: %v",
 hasPatternArgs, substRules, cmd, args, envs)
 ll.assert(!hasExpressionArgs || desc.canBackendUseExpressions(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "2.9.2",
+  "version": "2.9.3",
   "description": "Tengo SDK library",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",