@platforma-sdk/workflow-tengo 2.9.2 → 2.9.4

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

@@ -15,17 +15,28 @@ rDescriptor: desc.runEnvScheme,
 R: validation.reference
 }
 
-runRBuilder := func(wd, rPackage, rDescriptor) {
+runRBuilder := func(operationMode, wd, rPackage, rDescriptor) {
 t := desc.canBackendUseExpressions() ? constants.ARG_TYPE_EXPRESSION : constants.ARG_TYPE_VAR
 rule := desc.canBackendUseExpressions() ? "R" : "{R}"
 
-return runcmd.builder(wd).
+builder := runcmd.builder(wd).
 ref("r-run-environment", rPackage).
 substitutionRule(rule, "r-run-environment").
 addToPath(t, path.join("{R}", rDescriptor.binDir)).
-envTyped("R_HOME_DIR", t, "{R}").
 envTyped("RHOME", t, "{R}").
-envTyped("RENV_PATHS_ROOT", t, path.join("{R}", "renv-root"))
+envTyped("R_HOME_DIR", t, "{R}").
+envTyped("RENV_PATHS_ROOT", t, path.join("{R}", "renv-root")).
+envTyped("RENV_PATHS_BINARY", t, path.join("{R}", "renv-root", "binaries")).
+envTyped("RENV_PATHS_SOURCE", t, path.join("{R}", "renv-root", "sources")).
+envTyped("RENV_PATHS_CACHE", t, path.join("{R}", "renv-root", "cache"))
+
+if (operationMode != "dev-local") {
+
+
+builder.envTyped("RENV_CONFIG_REPOS_OVERRIDE", t, path.join("{R}", "renv-root", "packages"))
+}
+
+return builder
 }
 
 export ll.toStrict({

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) {
@@ -164,20 +162,31 @@ rRefVar := _newRefVar(_ARG_VAR_R, rRefKey, rPackage)
 rEnvRefKey := softName + "/R-virtual-env"
 rEnvRefVar := _newRefVar(_ARG_VAR_R_VENV, rEnvRefKey, rEnv)
 
+renvRootArg := path.join(_expr(_ARG_VAR_R), "renv-root")
+
+envs := {
+"RHOME": _newArg(false, _expr(_ARG_VAR_R)), // for Rscript (it uses RHOME instead of R_HOME)
+"R_HOME_DIR": _newArg(false, _expr(_ARG_VAR_R)), // for R startup script. It configures all the rest required for R to start.
+"RENV_PATHS_ROOT": _newArg(false, renvRootArg),
+"RENV_PATHS_BINARY": _newArg(false, path.join(renvRootArg, "binaries")),
+"RENV_PATHS_SOURCE": _newArg(false, path.join(renvRootArg, "sources")),
+"RENV_PATHS_CACHE": _newArg(false, path.join(renvRootArg, "cache")),
+"RENV_PATHS_RENV": _newArg(false, path.join(_expr(_ARG_VAR_R_VENV), "renv")),
+"RENV_PATHS_LOCKFILE": _newArg(false, path.join(_expr(_ARG_VAR_PKG), descriptor.dependencies.lockFile))
+}
+
+if (operationMode != "dev-local") {
+
+
+envs["RENV_CONFIG_REPOS_OVERRIDE"] = _newArg(false, path.join(renvRootArg, "packages"))
+}
+
 return ll.toStrict({
 runEnvType: "R",
 
 variables: [ rRefVar, rEnvRefVar ],
 customPaths: [ _newArg(false, rBinDir) ],
-envs: {
-"R_HOME_DIR": _newArg(false, _expr(_ARG_VAR_R)),
-"RHOME": _newArg(false, _expr(_ARG_VAR_R)),
-"RENV_PATHS_ROOT": _newArg(false, path.join(_expr(_ARG_VAR_R), "renv-root")),
-"RENV_PATHS_RENV": _newArg(false, path.join(_expr(_ARG_VAR_R_VENV), "renv")),
-"RENV_PATHS_LOCKFILE": _newArg(false, path.join(_expr(_ARG_VAR_PKG), descriptor.dependencies.lockFile)),
-"RENV_CONFIG_AUTO_SNAPSHOT": _newArg(true, "FALSE"),
-"RENV_CONFIG_SYNCHRONIZED_CHECK": _newArg(true, "FALSE")
-}
+envs: envs
 })
 }
 
@@ -308,13 +317,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 +330,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.4",
   "description": "Tengo SDK library",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -16,7 +16,7 @@
     "./dist/**/*"
   ],
   "dependencies": {
-    "@milaboratories/software-pframes-conv": "2.1.3",
+    "@milaboratories/software-pframes-conv": "2.1.4",
     "@platforma-open/milaboratories.software-small-binaries": "^1.15.6"
   },
   "devDependencies": {