@platforma-sdk/workflow-tengo 5.8.2 → 5.9.0

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

@@ -3,7 +3,8 @@ ll := import("@platforma-sdk/workflow-tengo:ll")
 ARG_TYPE_STRING := "string"
 ARG_TYPE_EXPRESSION := "expressionRef"
 ARG_TYPE_VAR        := "variableRef" // TODO: deprecated, remove after 15 Mar 2025
-ARG_TYPES := [ARG_TYPE_STRING, ARG_TYPE_EXPRESSION, ARG_TYPE_VAR]
+ARG_TYPE_SECRET     := "secret"
+ARG_TYPES := [ARG_TYPE_STRING, ARG_TYPE_EXPRESSION, ARG_TYPE_VAR, ARG_TYPE_SECRET]
 
 BATCH_QUEUE    := "batch" // special queue in storage controller with no limits
 HEAVY_QUEUE    := "heavy"
@@ -19,6 +20,7 @@ export ll.toStrict({
 	ARG_TYPE_STRING: ARG_TYPE_STRING,
 	ARG_TYPE_EXPRESSION: ARG_TYPE_EXPRESSION,
 	ARG_TYPE_VAR: ARG_TYPE_VAR,
+	ARG_TYPE_SECRET: ARG_TYPE_SECRET,
 	ARG_TYPES: ARG_TYPES,
 
 	BATCH_QUEUE: BATCH_QUEUE,

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

@@ -18,6 +18,7 @@ oop := import("@platforma-sdk/workflow-tengo:oop")
 constants := import("@platforma-sdk/workflow-tengo:constants")
 monetization := import("@platforma-sdk/workflow-tengo:exec.monetization_internal")
 execConstants := import("@platforma-sdk/workflow-tengo:exec.constants")
+units := import("@platforma-sdk/workflow-tengo:units")
 
 
 
@@ -153,10 +154,6 @@ builder := func() {
 
 
 
-
-
-
-
 
 
 
@@ -212,10 +209,6 @@ builder := func() {
 
 
 
-
-
-
-
 
 
 
@@ -258,9 +251,56 @@ builder := func() {
 
 
 
-		secret: func(secretName, envName) {
-			validation.assertType([secretName, envName], ["string"])
-			secrets[envName] = "{secrets."+secretName+"}"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+		secret: func(secretName, ...opts) {
+			validation.assertType(secretName, "string")
+			validation.assert(secretName != "", "exec.secret(): secret name cannot be empty")
+
+			envName := secretName
+			if len(opts) > 0 {
+				envName = opts[0]
+				validation.assertType(envName, "string")
+				validation.assert(envName != "", "exec.secret(): environment name for secret cannot be empty")
+			}
+
+			secrets[envName] = secretName
 			return self
 		},
 
@@ -377,7 +417,7 @@ builder := func() {
 
 		mem: func(amount) {
 			validation.assertType(amount, ["or", "number", "string"], "exec.builder.mem: RAM amount should be a number or string")
-			ll.assert(is_string(amount) || amount > 0, "exec.builder.mem: amount in bytes should be greater than 0")
+			ll.assert(is_string(amount) || amount >= 16 * units.MiB, "exec.builder.mem: amount in bytes should be at least 16MiB")
 			ramRequest = amount
 
 			return self

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

@@ -26,7 +26,7 @@ _RTYPE_RUN_COMMAND_REFS := { Name: "RunCommandRefs", Version: "1" }
 
 ARG_SCHEMA := {
 	"__options__,closed": true,
-	"type": "string,regex=string|expressionRef|variableRef",
+	"type": "string,regex=string|expressionRef|variableRef|secret",
 	"value": "string"
 }
 
@@ -119,7 +119,6 @@ variableArg := func(argTpl) {
 
 
 
-
 expressionArg := func(argTpl) {
 	return {
 		type: constants.ARG_TYPE_EXPRESSION,
@@ -127,6 +126,17 @@ expressionArg := func(argTpl) {
 	}
 }
 
+
+
+
+
+secretArg := func(secretName) {
+	return {
+		type: constants.ARG_TYPE_SECRET,
+		value: secretName
+	}
+}
+
 _createAbstractRunCommandPlan := func(state, returnSelfFn) {
 	self := undefined
 
@@ -176,6 +186,8 @@ _createAbstractRunCommandPlan := func(state, returnSelfFn) {
 		cmdTyped: func(type, value) {
 			ll.assert(slices.hasElement(constants.ARG_TYPES, type),
 				"runcmd.plan.cmdTyped: unknown type %s, expect: %v", type, constants.ARG_TYPES)
+			ll.assert(type != constants.ARG_TYPE_SECRET,
+				"runcmd.plan.cmdTyped: 'secret' type is only valid for environment variables")
 
 			if type == constants.ARG_TYPE_STRING {
 				return self.cmd(value)
@@ -231,6 +243,8 @@ _createAbstractRunCommandPlan := func(state, returnSelfFn) {
 		argTyped: func(type, value) {
 			ll.assert(slices.hasElement(constants.ARG_TYPES, type),
 				"runcmd.plan.argTyped: unknown type %s, expect: %v", type, constants.ARG_TYPES)
+			ll.assert(type != constants.ARG_TYPE_SECRET,
+				"runcmd.plan.argTyped: 'secret' type is only valid for environment variables")
 
 			if type == constants.ARG_TYPE_STRING {
 				return self.arg(value)
@@ -327,6 +341,17 @@ _createAbstractRunCommandPlan := func(state, returnSelfFn) {
 			return returnSelfFn()
 		},
 
+
+
+
+
+
+
+		envSecret: func(name, secretName) {
+			state.options.envs[name] = secretArg(secretName)
+			return returnSelfFn()
+		},
+
 		envTyped: func(name, type, value) {
 			ll.assert(slices.hasElement(constants.ARG_TYPES, type),
 				"runcmd.plan.envTyped: unknown type %s, expect: %v", type, constants.ARG_TYPES)
@@ -337,6 +362,8 @@ _createAbstractRunCommandPlan := func(state, returnSelfFn) {
 				return self.envExpression(name, value)
 			} else if type == constants.ARG_TYPE_VAR {
 				return self.envVar(name, value)
+			} else if type == constants.ARG_TYPE_SECRET {
+				return self.envSecret(name, value)
 			}
 
 			ll.panic("runcmd.plan.envTyped: unknown type %s, expect: %v", type, constants.ARG_TYPES)
@@ -381,6 +408,8 @@ _createAbstractRunCommandPlan := func(state, returnSelfFn) {
 		addPathTyped: func(type, value) {
 			ll.assert(slices.hasElement(constants.ARG_TYPES, type),
 				"runcmd.plan.addPathTyped: unknown type %s, expect: %v", type, constants.ARG_TYPES)
+			ll.assert(type != constants.ARG_TYPE_SECRET,
+				"runcmd.plan.addPathTyped: 'secret' type is only valid for environment variables")
 
 			if type == constants.ARG_TYPE_STRING {
 				return self.addPath(value)
@@ -629,6 +658,7 @@ builder := func(workdir, ...initialState) {
 
 			hasPatternArgs := false
 			hasExpressionArgs := false
+			hasSecretArgs := false
 
 			check := func(arg) {
 				if !ll.isMap(arg) {
@@ -640,6 +670,9 @@ builder := func(workdir, ...initialState) {
 				if arg.type == constants.ARG_TYPE_EXPRESSION {
 					hasExpressionArgs = true
 				}
+				if arg.type == constants.ARG_TYPE_SECRET {
+					hasSecretArgs = true
+				}
 			}
 
 			check(options.cmd)
@@ -680,6 +713,8 @@ builder := func(workdir, ...initialState) {
 			ll.assert(!hasExpressionArgs || feats.commandExpressions,
 				"runcmd.builder().build: expression arguments must be enabled only if platforma backend supports expressions, found: %v",
 				hasExpressionArgs)
+			ll.assert(!hasSecretArgs || feats.secretEnvSupport,
+				"runcmd.builder().build: secret arguments must be enabled only if platforma backend supports secret env type")
 
 			if !is_undefined(allocation) {
 				runRes.getField(_FIELD_ALLOCATION).set(allocation)
@@ -751,5 +786,6 @@ export ll.toStrict({
 	simpleArg: simpleArg,
 	variableArg: variableArg,
 	expressionArg: expressionArg,
+	secretArg: secretArg,
 	createRunCommandPlan: createRunCommandPlan
 })

package/dist/tengo/lib/feats.lib.tengo

@@ -65,5 +65,8 @@ export ll.toStrict({
 	hasBlobSize:            ll.methodExists(plapi, "getBlobSize"),
 
 
-	isDockerAvailable:        _isEnabled("dockerSupport")
+	isDockerAvailable:        _isEnabled("dockerSupport"),
+
+
+	secretEnvSupport:         _isEnabled("secretEnvSupport")
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "5.8.2",
+  "version": "5.9.0",
   "description": "Tengo SDK library",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -18,11 +18,11 @@
   "dependencies": {
     "@milaboratories/software-pframes-conv": "2.2.9",
     "@platforma-open/milaboratories.software-small-binaries": "^2.0.1",
-    "@platforma-open/milaboratories.software-ptexter": "1.2.1",
-    "@platforma-open/milaboratories.software-ptabler": "1.14.1"
+    "@platforma-open/milaboratories.software-ptabler": "1.14.1",
+    "@platforma-open/milaboratories.software-ptexter": "1.2.1"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "2.4.16"
+    "@platforma-sdk/tengo-builder": "2.4.24"
   },
   "scripts": {
     "type-check": "pl-tengo check",