@platforma-sdk/workflow-tengo 4.10.0 → 4.12.0

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

@@ -1,6 +1,8 @@
 ll := import("@platforma-sdk/workflow-tengo:ll")
 maps := import("@platforma-sdk/workflow-tengo:maps")
 slices := import("@platforma-sdk/workflow-tengo:slices")
+validation := import("@platforma-sdk/workflow-tengo:validation")
+fmt := import("fmt")
 
 
 
@@ -16,6 +18,24 @@ when := undefined
 rank := undefined
 
 
+
+
+_validateOptions := func(options, schema, functionName) {
+	if len(options) > 1 {
+		ll.panic("%s accepts at most one options map argument.", functionName)
+	}
+	if len(options) == 0 {
+		return {}
+	}
+
+	opsMap := options[0]
+	ll.assert(is_map(opsMap), "Options argument to %s(), if provided, must be an options map.", functionName)
+
+	validation.assertType(opsMap, schema, fmt.sprintf("%s options validation error", functionName))
+	return opsMap
+}
+
+
 _isExpression := func(item) {
 	return ll.isMap(item) && ll.methodExists(item, "getExpression")
 }
@@ -266,15 +286,13 @@ _newExpression = func(expression, currentAlias) {
 
 
 		cast: func(dtype, ...options) {
+			ops := _validateOptions(options, {
+				"__options__,closed": "",
+				"strict,?": "bool"
+			}, "cast")
 			strictVal := false
-			if len(options) > 0 {
-				ll.assert(len(options) == 1, "cast accepts at most one options map argument.")
-				opsMap := options[0]
-				ll.assert(is_map(opsMap), "Second argument to cast(), if provided, must be an options map.")
-				if !is_undefined(opsMap.strict) {
-					ll.assert(is_bool(opsMap.strict), "strict in options map must be a boolean")
-					strictVal = opsMap.strict
-				}
+			if !is_undefined(ops.strict) {
+				strictVal = ops.strict
 			}
 			return _newExpression(
 				{type: "cast", value: expression, dtype: dtype, strict: strictVal},
@@ -318,32 +336,42 @@ _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) {
+					ops := _validateOptions([arg], {
+						"__options__,closed": "",
+						"length,?": "any",
+						"end,?": "any"
+					}, "strSlice")
+					if ops.length != undefined && ops.end != undefined {
+						ll.panic("strSlice cannot have both 'length' and 'end' options.")
+					}
+					if !is_undefined(ops.length) {
+						expr.length = _mapToSingleExpressionStruct(ops.length, "col")
+					}
+					if !is_undefined(ops.end) {
+						expr.end = _mapToSingleExpressionStruct(ops.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)
 		},
 
 
@@ -356,21 +384,19 @@ _newExpression = func(expression, currentAlias) {
 
 
 		strReplace: func(pattern, replacement, ...options) {
+			ops := _validateOptions(options, {
+				"__options__,closed": "",
+				"replaceAll,?": "bool",
+				"literal,?": "bool"
+			}, "strReplace")
 			replaceAllVal := false
 			literalVal := false
 
-			if len(options) > 0 {
-				ll.assert(len(options) == 1, "strReplace accepts at most one options map argument.")
-				opsMap := options[0]
-				ll.assert(is_map(opsMap), "Third argument to strReplace(), if provided, must be an options map.")
-				if !is_undefined(opsMap.replaceAll) {
-					ll.assert(is_bool(opsMap.replaceAll), "replaceAll in options map must be a boolean")
-					replaceAllVal = opsMap.replaceAll
-				}
-				if !is_undefined(opsMap.literal) {
-					ll.assert(is_bool(opsMap.literal), "literal in options map must be a boolean")
-					literalVal = opsMap.literal
-				}
+			if !is_undefined(ops.replaceAll) {
+				replaceAllVal = ops.replaceAll
+			}
+			if !is_undefined(ops.literal) {
+				literalVal = ops.literal
 			}
 
 			return _newExpression({
@@ -391,6 +417,164 @@ _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)
+		},
+
+
+
+
+
+
+
+
+
+		strContains: func(pattern, ...options) {
+			ops := _validateOptions(options, {
+				"__options__,closed": "",
+				"literal,?": "bool",
+				"strict,?": "bool"
+			}, "strContains")
+			literalVal := false
+			strictVal := true
+
+			if !is_undefined(ops.literal) {
+				literalVal = ops.literal
+			}
+			if !is_undefined(ops.strict) {
+				strictVal = ops.strict
+			}
+
+			return _newExpression({
+				type: "str_contains",
+				value: expression,
+				pattern: _mapToSingleExpressionStruct(pattern, "lit"),
+				literal: literalVal,
+				strict: strictVal
+			}, undefined)
+		},
+
+
+
+
+
+
+
+
+		strContainsAny: func(patterns, ...options) {
+			ll.assert(is_array(patterns), "patterns must be an array of strings")
+			for pattern in patterns {
+				ll.assert(is_string(pattern), "all patterns must be strings")
+			}
+
+			ops := _validateOptions(options, {
+				"__options__,closed": "",
+				"asciiCaseInsensitive,?": "bool"
+			}, "strContainsAny")
+			asciiCaseInsensitiveVal := false
+			if !is_undefined(ops.asciiCaseInsensitive) {
+				asciiCaseInsensitiveVal = ops.asciiCaseInsensitive
+			}
+
+			return _newExpression({
+				type: "str_contains_any",
+				value: expression,
+				patterns: patterns,
+				asciiCaseInsensitive: asciiCaseInsensitiveVal
+			}, undefined)
+		},
+
+
+
+
+
+
+
+
+		strCountMatches: func(pattern, ...options) {
+			ops := _validateOptions(options, {
+				"__options__,closed": "",
+				"literal,?": "bool"
+			}, "strCountMatches")
+			literalVal := false
+
+			if !is_undefined(ops.literal) {
+				literalVal = ops.literal
+			}
+
+			return _newExpression({
+				type: "str_count_matches",
+				value: expression,
+				pattern: _mapToSingleExpressionStruct(pattern, "lit"),
+				literal: literalVal
+			}, undefined)
+		},
+
+
+
+
+
+
+
+
+		strExtract: func(pattern, ...options) {
+			ops := _validateOptions(options, {
+				"__options__,closed": "",
+				"groupIndex,?": "number"
+			}, "strExtract")
+			groupIndexVal := 0
+
+			if !is_undefined(ops.groupIndex) {
+				groupIndexVal = ops.groupIndex
+			}
+
+			return _newExpression({
+				type: "str_extract",
+				value: expression,
+				pattern: _mapToSingleExpressionStruct(pattern, "lit"),
+				groupIndex: groupIndexVal
+			}, undefined)
+		},
+
+
+
+
+
+
+		strStartsWith: func(prefix) {
+			return _newExpression({
+				type: "str_starts_with",
+				value: expression,
+				prefix: _mapToSingleExpressionStruct(prefix, "lit")
+			}, undefined)
+		},
+
+
+
+
+
+
+		strEndsWith: func(suffix) {
+			return _newExpression({
+				type: "str_ends_with",
+				value: expression,
+				suffix: _mapToSingleExpressionStruct(suffix, "lit")
+			}, undefined)
+		},
+
+
+
+
+
+
+
+
+
 		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")
@@ -539,13 +723,16 @@ _newExpression = func(expression, currentAlias) {
 			actualArgs := args
 
 			if len(args) > 0 && is_map(args[len(args)-1]) && !(_isExpression(args[len(args)-1])) {
-				ops := args[len(args)-1]
+				ops := _validateOptions([args[len(args)-1]], {
+					"__options__,closed": "",
+					"orderBy,?": "any",
+					"descending,?": "bool"
+				}, "cumsum")
 				actualArgs = args[0:len(args)-1]
-				if maps.containsKey(ops, "orderBy") {
+				if !is_undefined(ops.orderBy) {
 					additionalOrderByVal = _mapToExpressionStructList(ops.orderBy, "col")
 				}
-				if maps.containsKey(ops, "descending") {
-					ll.assert(is_bool(ops.descending), "descending in options map must be a boolean")
+				if !is_undefined(ops.descending) {
 					descendingVal = ops.descending
 				}
 			}
@@ -571,6 +758,13 @@ _newExpression = func(expression, currentAlias) {
 				partitionBy: [],
 				descending: descendingVal
 			}, undefined, undefined)
+		},
+
+
+
+		
+		toString: func() {
+			return self.cast("string")
 		}
 	})
 	return self
@@ -616,15 +810,13 @@ concatStr := func(expressions, ...options) {
 	ll.assert(is_array(expressions), "First argument to concatStr must be an array of expressions")
 	ll.assert(len(expressions) > 0, "Expression array for concatStr cannot be empty")
 
+	ops := _validateOptions(options, {
+		"__options__,closed": "",
+		"delimiter,?": "string"
+	}, "concatStr")
 	delimiterVal := "" // Default to empty string
-	if len(options) > 0 {
-		ll.assert(len(options) == 1, "concatStr accepts at most one options map argument.")
-		opsMap := options[0]
-		ll.assert(is_map(opsMap), "Second argument to concatStr(), if provided, must be an options map.")
-		if !is_undefined(opsMap.delimiter) {
-			ll.assert(is_string(opsMap.delimiter), "delimiter in options map must be a string")
-			delimiterVal = opsMap.delimiter
-		}
+	if !is_undefined(ops.delimiter) {
+		delimiterVal = ops.delimiter
 	}
 
 	return _newExpression({
@@ -771,14 +963,12 @@ rank = func(orderByExpressions, ...options) {
 	orderByVal = _mapToExpressionStructList(orderByExpressions, "col")
 	ll.assert(len(orderByVal) > 0, "rank() 'orderBy' list cannot be empty after processing arguments.")
 
-	if len(options) > 0 {
-		ll.assert(len(options) == 1, "rank() accepts at most one options map argument.")
-		opsMap := options[0]
-		ll.assert(is_map(opsMap), "Second argument to rank(), if provided, must be an options map.")
-		if maps.containsKey(opsMap, "descending") {
-			ll.assert(is_bool(opsMap.descending), "descending in options map must be a boolean")
-			descendingVal = opsMap.descending
-		}
+	ops := _validateOptions(options, {
+		"__options__,closed": "",
+		"descending,?": "bool"
+	}, "rank")
+	if !is_undefined(ops.descending) {
+		descendingVal = ops.descending
 	}
 
 	return _newWindowExpression({

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

@@ -436,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 {
@@ -525,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "4.10.0",
+  "version": "4.12.0",
   "description": "Tengo SDK library",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -18,7 +18,7 @@
   "dependencies": {
     "@milaboratories/software-pframes-conv": "2.2.2",
     "@platforma-open/milaboratories.software-small-binaries": "^1.15.21",
-    "@platforma-open/milaboratories.software-ptabler": "1.6.0"
+    "@platforma-open/milaboratories.software-ptabler": "1.8.0"
   },
   "devDependencies": {
     "@platforma-sdk/tengo-builder": "^2.1.12"