@platforma-sdk/workflow-tengo 4.9.3 → 4.11.0

package/dist/tengo/lib/pframes.xsv-builder.lib.tengo

@@ -2,6 +2,7 @@ ll := import("@platforma-sdk/workflow-tengo:ll")
 maps := import("@platforma-sdk/workflow-tengo:maps")
 strings := import("@platforma-sdk/workflow-tengo:strings")
 text := import("text")
+times := import("times")
 pSpec := import("@platforma-sdk/workflow-tengo:pframes.spec")
 pBuilder := import("@platforma-sdk/workflow-tengo:pframes.builder")
 xsv := import("@platforma-sdk/workflow-tengo:pframes.xsv")
@@ -24,6 +25,7 @@ xsvFileBuilder := func(xsvType) {
     cpu := undefined
     mem := undefined
     queue := undefined
+    inputCache := undefined
 
     getSpecDistiller := func() {
         if is_undefined(distiller) {
@@ -362,6 +364,75 @@ xsvFileBuilder := func(xsvType) {
 
 
 
+        cacheInputs: func(time) {
+            ll.assert(
+                is_int(time),
+                "cache time must be an integer. " +
+                "Did you forget to import a standard tengo library 'times'?")
+            inputCache = time
+            return self
+        },
+
+
+
+
+
+
+        cacheInputsMillis: func(millis) {
+            ll.assert(is_int(millis) && millis > 0, "cache time must be a number of milliseconds")
+            inputCache = millis * times.millisecond
+            return self
+        },
+
+
+
+
+
+
+        cacheInputsSeconds: func(seconds) {
+            ll.assert(is_int(seconds) && seconds > 0, "cache time must be a number of seconds")
+            inputCache = seconds * times.second
+            return self
+        },
+
+
+
+
+
+
+        cacheInputsMinutes: func(minutes) {
+            ll.assert(is_int(minutes) && minutes > 0, "cache time must be a number of minutes")
+            inputCache = minutes * times.minute
+            return self
+        },
+
+
+
+
+
+
+        cacheInputsHours: func(hours) {
+            ll.assert(is_int(hours) && hours > 0, "cache time must be a number of hours")
+            inputCache = hours * times.hour
+            return self
+        },
+
+
+
+
+
+
+        cacheInputsDays: func(days) {
+            ll.assert(is_int(days) && days > 0, "cache time must be a number of days")
+            inputCache = days * times.hour * 24
+            return self
+        },
+
+
+
+
+
+
         cpu: func(amount) {
             cpu = amount
             return self
@@ -623,6 +694,9 @@ xsvFileBuilder := func(xsvType) {
             if !is_undefined(queue) {
                 ops.queue = queue
             }
+            if !is_undefined(inputCache) {
+                ops.inputCache = inputCache
+            }
 
             return xsv.exportFrame(pFrame, xsvType, currentExportParams, ops)
         },
@@ -672,6 +746,9 @@ xsvFileBuilder := func(xsvType) {
             if !is_undefined(queue) {
                 ops.queue = queue
             }
+            if !is_undefined(inputCache) {
+                ops.inputCache = inputCache
+            }
 
             tableResource := xsv.exportFrame(pFrame, xsvType, finalExportParams, ops)
 

package/dist/tengo/lib/pframes.xsv-import-file.lib.tengo

@@ -79,6 +79,7 @@ getColumnSpec := func(axesSpec, col) {
 
 
 
+
 
 
 importFile := func(xsvFile, xsvType, spec, ...ops) {
@@ -96,7 +97,7 @@ importFile := func(xsvFile, xsvType, spec, ...ops) {
 
 	xsvFileName := "file." + xsvType
 
-	ops := renderOps({ dataOnly: false, splitDataAndSpec: false, queue: execConstants.LIGHT_QUEUE }, ops...)
+	ops := renderOps({ dataOnly: false, splitDataAndSpec: false, queue: execConstants.LIGHT_QUEUE, inputCache: undefined }, ops...)
 
 	if ops.transpose != undefined {
 
@@ -118,6 +119,9 @@ importFile := func(xsvFile, xsvType, spec, ...ops) {
 		if ops.mem != undefined {
 			transposeXsv.mem(ops.mem)
 		}
+		if ops.inputCache != undefined && ops.inputCache > 0 {
+			transposeXsv.cacheInputs(ops.inputCache)
+		}
 
 		if (tops.separator != undefined) {
 			transposeXsv = transposeXsv.arg("-input-separator").arg(tops.separator)
@@ -181,6 +185,9 @@ importFile := func(xsvFile, xsvType, spec, ...ops) {
 	if ops.mem != undefined {
 		pfconv.mem(ops.mem)
 	}
+	if ops.inputCache != undefined && ops.inputCache > 0 {
+		pfconv.cacheInputs(ops.inputCache)
+	}
 
 	pfconv = pfconv.run()
 

package/dist/tengo/lib/pframes.xsv.lib.tengo

@@ -85,6 +85,7 @@ getColumnSpec := func(axesSpec, col) {
 
 
 
+
 
 
 importFile := func(xsvFile, xsvType, spec, ...ops) {
@@ -141,6 +142,7 @@ importFile := func(xsvFile, xsvType, spec, ...ops) {
 
 
 
+
 
 
 importFileMap := func(xsvMap, xsvType, spec, ...ops) {
@@ -151,7 +153,8 @@ importFileMap := func(xsvMap, xsvType, spec, ...ops) {
 		dataOnly: false,
 		splitDataAndSpec: false,
 		additionalAxesSpec: [],
-		transpose: undefined
+		transpose: undefined,
+		inputCache: undefined
 	}, ops...)
 
 
@@ -172,6 +175,9 @@ importFileMap := func(xsvMap, xsvType, spec, ...ops) {
 	if !is_undefined(ops.queue) {
 		templateOps.queue = ops.queue
 	}
+	if !is_undefined(ops.inputCache) && ops.inputCache > 0 {
+		templateOps.inputCache = ops.inputCache
+	}
 
 	r := render.createEphemeral(importXsvMapTpl, {
 		xsvMap: xsvMap,
@@ -282,6 +288,7 @@ isStructuredPfMap := func(pf) {
 
 
 
+
 
 
 exportFrame := func(pf, xsvType, params, ...ops) {

package/dist/tengo/lib/pt.expression.lib.tengo

@@ -318,32 +318,37 @@ _newExpression = func(expression, currentAlias) {
 
 
 
-		strSlice: func(start, ...lengthArgs) { // Primary method with optional length via varargs
-			ll.assert(is_int(start), "start must be an integer")
-			ll.assert(len(lengthArgs) <= 1, "strSlice expects at most one optional length argument.")
-
-			exprDetails := {type: "substring", value: expression, start: start}
-			if len(lengthArgs) == 1 {
-				lengthVal := lengthArgs[0]
-				ll.assert(is_int(lengthVal), "length, if provided, must be an integer")
-				exprDetails.length = lengthVal
-			}
-
-			return _newExpression(exprDetails, undefined)
-		},
-
 
 
 
 
+		strSlice: func(start, ...args) {
+			ll.assert(len(args) <= 1, "strSlice expects at most one additional argument.")
 
+			expr := {
+				type: "substring",
+				value: expression,
+				start: _mapToSingleExpressionStruct(start, "col")
+			}
 
-		strSliceEnd: func(start, endIdx) { // Method with end index
-			ll.assert(is_int(start), "start must be an integer")
-			ll.assert(is_int(endIdx), "endIdx must be an integer")
+			if len(args) > 0 {
+				arg := args[0]
+				if is_map(arg) {
+					if arg.length != undefined && arg.end != undefined {
+						ll.panic("strSlice cannot have both 'length' and 'end' options.")
+					}
+					if !is_undefined(arg.length) {
+						expr.length = _mapToSingleExpressionStruct(arg.length, "col")
+					}
+					if !is_undefined(arg.end) {
+						expr.end = _mapToSingleExpressionStruct(arg.end, "col")
+					}
+				} else {
+					expr.length = _mapToSingleExpressionStruct(arg, "col")
+				}
+			}
 
-			exprDetails := {type: "substring", value: expression, start: start, end: endIdx}
-			return _newExpression(exprDetails, undefined)
+			return _newExpression(expr, undefined)
 		},
 
 
@@ -391,6 +396,23 @@ _newExpression = func(expression, currentAlias) {
 
 
 
+		strReplaceAll: func(pattern, replacement, ...options) {
+			opts := {}
+			if len(options) > 0 {
+				opts = options[0]
+			}
+			opts.replaceAll = true
+			return self.strReplace(pattern, replacement, opts)
+		},
+
+
+
+
+
+
+
+
+
 		strDistance: func(string2, metric, returnSimilarity) {
 			ll.assert(_isExpression(string2), "string2 must be an expression object")
 			ll.assert(is_string(metric), "metric must be a string")
@@ -571,6 +593,13 @@ _newExpression = func(expression, currentAlias) {
 				partitionBy: [],
 				descending: descendingVal
 			}, undefined, undefined)
+		},
+
+
+
+		
+		toString: func() {
+			return self.cast("string")
 		}
 	})
 	return self

package/dist/tengo/lib/pt.lib.tengo

@@ -6,6 +6,7 @@ exec := import("@platforma-sdk/workflow-tengo:exec")
 json := import("json")
 text := import("text")
 slices := import("@platforma-sdk/workflow-tengo:slices")
+validation := import("@platforma-sdk/workflow-tengo:validation")
 execConstants := import("@platforma-sdk/workflow-tengo:exec.constants")
 
 
@@ -166,6 +167,7 @@ workflow := func() {
 				if smart.isReference(frameInput) {
 					fileRef = frameInput
 				} else {
+					validation.assertType(frameInput, ["or", "string", "bytes"])
 					fileContent = frameInput
 				}
 			}
@@ -434,6 +436,29 @@ _newDataFrame = func(parentWorkflow, dfName) {
 		return cols
 	}
 
+	_mapExprsToStepColsAllowingStrings := func(exprs, methodName) {
+		ll.assert(len(exprs) > 0, methodName + " requires at least one expression argument.")
+		cols := []
+		for expr in exprs {
+			if is_string(expr) {
+
+				colExpr := exp.col(expr)
+				cols = append(cols, {
+					name: colExpr.getAlias(),
+					expression: colExpr.getExpression()
+				})
+			} else if exp._isExpression(expr) {
+				cols = append(cols, {
+					name: expr.getAlias(),
+					expression: expr.getExpression()
+				})
+			} else {
+				ll.panic("Invalid argument to " + methodName + ": Expected an expression object or string column name, got %v", expr)
+			}
+		}
+		return cols
+	}
+
 	_addSaveStep := func(outputFile, ...options) {
 		opts := {}
 		if len(options) > 0 {
@@ -523,8 +548,9 @@ _newDataFrame = func(parentWorkflow, dfName) {
 
 
 
+
 		select: func(...expressions) {
-			stepCols := _mapExprsToStepCols(expressions, "select")
+			stepCols := _mapExprsToStepColsAllowingStrings(expressions, "select")
 			outputDfName := parentWorkflow._newAnonymousDataFrameId()
 			parentWorkflow.addRawStep({
 				type: "select",

package/dist/tengo/lib/render.lib.tengo

@@ -28,8 +28,21 @@ _SUBSCRIPTION_FIELD := "subscription"
 
 
 
+
+
+
 createUniversal := func(tpl, isEph, inputs, ...opts) {
-	metaInputs := opts[0]
+	ll.assert(len(opts) <= 1, "too many arguments, expected at most one options object")
+	metaInputs := undefined
+	inputCache := undefined
+	if len(opts) == 1 && opts[0] {
+		metaInputs = opts[0].metaInputs
+		inputCache = opts[0].inputCache
+	}
+
+	if !is_undefined(inputCache) && inputCache > 0 && isEph {
+		ll.panic("inputCache option cannot be used with ephemeral templates")
+	}
 
 
 	rbuilder := undefined
@@ -49,20 +62,30 @@ createUniversal := func(tpl, isEph, inputs, ...opts) {
 
 
 	inputsMap := isEph ? smart.ephemeralMapBuilder() : smart.mapBuilder()
-	for name, value in inputs {
-		if !is_undefined(value) {
-			inputsMap.add(name, value)
-		}
+	inputAddOpts := undefined
+	if !is_undefined(inputCache) && inputCache > 0 {
+		inputAddOpts = { cache: inputCache }
 	}
-	for name, value in metaInputs {
+	for name, value in inputs {
 		if !is_undefined(value) {
-			if feats.serviceFields {
-				inputsMap.addMeta(name, value)
+			if !is_undefined(inputAddOpts) {
+				inputsMap.add(name, value, inputAddOpts)
 			} else {
 				inputsMap.add(name, value)
 			}
 		}
 	}
+	if !is_undefined(metaInputs) {
+		for name, value in metaInputs {
+			if !is_undefined(value) {
+				if feats.serviceFields {
+					inputsMap.addMeta(name, value)
+				} else {
+					inputsMap.add(name, value)
+				}
+			}
+		}
+	}
 
 	rbuilder.createInputField(tplutil.INPUTS_MAP_FIELD).set(inputsMap.build())
 
@@ -154,6 +177,8 @@ createUniversal := func(tpl, isEph, inputs, ...opts) {
 
 
 
+
+
 create := func(tpl, inputs, ...opts) {
 	return createUniversal(tpl, false, inputs, opts...)
 }
@@ -169,6 +194,7 @@ create := func(tpl, inputs, ...opts) {
 
 
 
+
 createEphemeral := func(tpl, inputs, ...opts) {
 	return createUniversal(tpl, true, inputs, opts...)
 }

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

@@ -926,7 +926,7 @@ field = func(f) {
 				"smart.field.setCache: cache time must be an integer >= millisecond. Did you forget to import a standard tengo library 'times'?")
 
 			tx.cacheSetToField(self.id, time)
-			return self
+			return strictSelf
 		},
 
 
@@ -1013,6 +1013,7 @@ field = func(f) {
 
 		setJson: func(value) {
 			self.set(createJsonResource(value))
+			return strictSelf
 		},
 
 
@@ -1022,6 +1023,7 @@ field = func(f) {
 
 		setMap: func(keyToValue) {
 			self.set(createMapResource(keyToValue))
+			return strictSelf
 		},
 
 
@@ -1039,6 +1041,8 @@ field = func(f) {
 			} else {
 				ll.panic("smart resource or smart field expected (target field %v), got %#v: ", self.name(), reference)
 			}
+
+			return strictSelf
 		},
 
 
@@ -1329,7 +1333,7 @@ resourceBuilder = func(r) {
 
 structBuilder = func(resourceType, ...data) {
 	id := undefined
-	if len(data) > 0 {
+	if len(data) > 0 && !is_undefined(data[0]) {
 		id = tx.createStruct(resourceType.Name, resourceType.Version, data[0])
 	} else {
 		id = tx.createStruct(resourceType.Name, resourceType.Version)
@@ -1356,6 +1360,15 @@ _mapBuilder := func(isEph, ...resourceType) {
 
 	self := undefined
 
+	applyCache := func(field, ...opts) {
+		if len(opts) > 0 {
+			opt := opts[0]
+			if is_map(opt) && !is_undefined(opt.cache) && opt.cache > 0 {
+				field.setCache(opt.cache)
+			}
+		}
+	}
+
 	self = ll.toStrict(oop.inherit(builder, {
 
 
@@ -1364,8 +1377,11 @@ _mapBuilder := func(isEph, ...resourceType) {
 
 
 
-		addRef: func(key, value) {
-			builder.createInputField(key).set(value)
+
+		addRef: func(key, value, ...opts) {
+			field := builder.createInputField(key)
+			applyCache(field, opts...)
+			field.set(value)
 			return self
 		},
 
@@ -1376,8 +1392,11 @@ _mapBuilder := func(isEph, ...resourceType) {
 
 
 
-		addJson: func(key, value) {
-			builder.createInputField(key).set(createJsonResource(value))
+
+		addJson: func(key, value, ...opts) {
+			field := builder.createInputField(key)
+			applyCache(field, opts...)
+			field.set(createJsonResource(value))
 			return self
 		},
 
@@ -1388,8 +1407,11 @@ _mapBuilder := func(isEph, ...resourceType) {
 
 
 
-		add: func(key, value) {
-			builder.createInputField(key).setRefOrJson(value)
+
+		add: func(key, value, ...opts) {
+			field := builder.createInputField(key)
+			applyCache(field, opts...)
+			field.setRefOrJson(value)
 			return self
 		},
 

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

@@ -2,6 +2,7 @@ tx := import("tx")
 ll := import("@platforma-sdk/workflow-tengo:ll")
 render := import("@platforma-sdk/workflow-tengo:render")
 smart := import("@platforma-sdk/workflow-tengo:smart")
+times := import("times")
 sets := import("@platforma-sdk/workflow-tengo:sets")
 maps := import("@platforma-sdk/workflow-tengo:maps")
 tplutil := import("@platforma-sdk/workflow-tengo:tpl.util")
@@ -53,7 +54,7 @@ _unmarshal := func(resource, preprocessors) {
 
 		result := {}
 
-		for field, value in resource.inputs() {
+		for field, value in maps.merge(resource.inputs(), resource.metaInputs()) {
 			if value.isErrorSet() {
 				decodedError := value.getError().getDataAsJson()
 				if is_map(decodedError) && decodedError.message != undefined {
@@ -68,16 +69,6 @@ _unmarshal := func(resource, preprocessors) {
 			}
 		}
 
-		for field, value in resource.metaInputs() {
-			if value.isErrorSet() {
-				ll.panic("meta input %v field has error: %v", field, field.getError().getDataAsJson().message)
-			} else if value.isSet() {
-				result[field] = _unmarshal(value.getValue(), preprocessors)
-			} else {
-				result[field] = value
-			}
-		}
-
 		return result
 	} else {
 
@@ -232,6 +223,11 @@ tpl := func(ops) {
 
 
 
+		outputCache: 0,
+
+
+
+
 
 
 
@@ -251,6 +247,75 @@ tpl := func(ops) {
 
 
 
+		setOutputCache: func(time) {
+			ll.assert(is_int(time) && time >= times.millisecond,
+				"tpl.setOutputCache: cache time must be an integer >= millisecond. Did you forget to import a standard tengo library 'times'?")
+
+			self.outputCache = time
+			return self
+		},
+
+
+
+
+
+
+		setOutputCacheMillis: func(millis) {
+			ll.assert(is_int(millis) && millis > 0,
+				"tpl.setOutputCacheMillis: cache time must be a number of milliseconds (> 0)")
+			return self.setOutputCache(millis * times.millisecond)
+		},
+
+
+
+
+
+
+		setOutputCacheSeconds: func(seconds) {
+			ll.assert(is_int(seconds) && seconds > 0,
+				"tpl.setOutputCacheSeconds: cache time must be a number of seconds (> 0)")
+			return self.setOutputCache(seconds * times.second)
+		},
+
+
+
+
+
+
+		setOutputCacheMinutes: func(minutes) {
+			ll.assert(is_int(minutes) && minutes > 0,
+				"tpl.setOutputCacheMinutes: cache time must be a number of minutes (> 0)")
+			return self.setOutputCache(minutes * times.minute)
+		},
+
+
+
+
+
+
+		setOutputCacheHours: func(hours) {
+			ll.assert(is_int(hours) && hours > 0, "tpl.setOutputCacheHours: cache time must be a number of hours (> 0)")
+			return self.setOutputCache(hours * times.hour)
+		},
+
+
+
+
+
+
+		setOutputCacheDays: func(days) {
+			ll.assert(is_int(days) && days > 0, "tpl.setOutputCacheDays: cache time must be a number of days (> 0)")
+			return self.setOutputCache(days * 24 * times.hour)
+		},
+
+
+
+
+
+
+
+
+
 
 
 
@@ -475,7 +540,10 @@ tpl := func(ops) {
 
 		createOutputsAndLock: func(outputs) {
 			for name in outputs {
-				self.renderer().createOutputField(tplutil.TEMPLATE_OUTPUT_PREFIX + name)
+				field := self.renderer().createOutputField(tplutil.TEMPLATE_OUTPUT_PREFIX + name)
+				if self.outputCache > 0 {
+					field.setCache(self.outputCache)
+				}
 			}
 			self.renderer().lockOutputs()
 		},
@@ -660,6 +728,12 @@ tpl := func(ops) {
 				hasInput                : self.hasInput,
 				inputs                  : self.inputs,
 				defineOutputs           : self.defineOutputs,
+				setOutputCache			: self.setOutputCache,
+				setOutputCacheMillis	: self.setOutputCacheMillis,
+				setOutputCacheSeconds	: self.setOutputCacheSeconds,
+				setOutputCacheMinutes	: self.setOutputCacheMinutes,
+				setOutputCacheHours		: self.setOutputCacheHours,
+				setOutputCacheDays		: self.setOutputCacheDays,
 				prepare                 : self.prepare,
 				awaitState              : self.awaitState,
 				awaitStateIfEphemeral   : self.awaitStateIfEphemeral,

package/dist/tengo/lib/workflow.lib.tengo

@@ -405,6 +405,7 @@ export ll.toStrict({
 	resolve: resolve,
 	anchoredQuery: anchoredQuery,
 	prepare: prepare,
+	rawInputs: self.rawInputs,
 	body: body,
 	setPreRun: setPreRun,
 	blockId: blockId,