@platforma-sdk/workflow-tengo 4.1.0 → 4.1.2

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

@@ -91,6 +91,9 @@ builder := func() {
 	stderrToValue := false
 	stderrToStdout := false
 
+	saveStdout := true
+	saveStderr := true
+
 	self = ll.toStrict({
 
 
@@ -668,16 +671,45 @@ builder := func() {
 
 
 
+		dontSaveStdout: func() {
+			saveStdout = false
+			return self
+		},
+
+
+
+
+		dontSaveStderr: func() {
+			saveStderr = false
+			return self
+		},
+
+
+
+
+		dontSaveStdoutOrStderr: func() {
+			saveStdout = false
+			saveStderr = false
+			return self
+		},
+
+
+
+
 
 
 		run: func() {
 			if stderrToStdout {
 				stderr = stdout
 			}
-			sets.add(filesToStream, stdout)
-			sets.add(filesToStream, stderr)
-			sets.add(filesToSave, stdout)
-			sets.add(filesToSave, stderr)
+			if saveStdout {
+				sets.add(filesToStream, stdout)
+				sets.add(filesToSave, stdout)
+			}
+			if saveStderr {
+				sets.add(filesToStream, stderr)
+				sets.add(filesToSave, stderr)
+			}
 			if stdoutToValue {
 				sets.add(filesContentToSave, stdout)
 			}
@@ -702,6 +734,8 @@ builder := func() {
 				envs: envs,
 				secrets: secrets,
 				queue: queue,
+
+
 				stdout: stdout,
 				stderr: stderr,
 				nErrorLines: nErrorLines

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

@@ -33,10 +33,7 @@ mnzClientStdoutSchema := ["or",
 			"result,?": {
 				productKey: "string",
 				canRun: "boolean",
-				mnz: {
-					type: "string",
-					details: "any"
-				}
+				mnz: "any"
 			}
 		}
 	}]

package/dist/tengo/lib/pframes.bundle.lib.tengo

@@ -48,6 +48,12 @@ strings := import("@platforma-sdk/workflow-tengo:strings")
 
 
 
+
+
+
+
+
+
 
 
 
@@ -65,6 +71,59 @@ createBuilder := func(ctx) {
 
 	queries := {}
 
+	anchoredQueryOpts := {
+		ignoreMissingDomains: true
+	}
+
+	addSingleInner := func(id, ...queryKey) {
+		ll.assert(len(queryKey) <= 1, "addSingle accepts at most one optional queryKey argument")
+
+		decodedId := undefined
+		if is_string(id) {
+			decodedId = json.decode(id)
+		} else if is_map(id) {
+			decodedId = id
+		} else {
+			ll.panic("Invalid column ID type. Expected string or object.")
+		}
+
+		isFiltered := is_map(decodedId) && !is_undefined(decodedId.source) && !is_undefined(decodedId.axisFilters)
+		if isFiltered && len(queryKey) > 0 {
+			ll.panic("FilteredPColumnId cannot be used with a queryKey.")
+		}
+
+		defaultKey := undefined
+		valueToStore := undefined
+		if isFiltered {
+			defaultKey = canonical.encode(decodedId.source)
+			valueToStore = decodedId.source
+		} else {
+
+			defaultKey = is_string(id) ? id : canonical.encode(decodedId)
+			valueToStore = decodedId // Store the decoded map itself
+		}
+
+		keyToUse := defaultKey
+		if len(queryKey) == 1 {
+			keyToUse = queryKey[0]
+		}
+
+		queries[keyToUse] = valueToStore
+	}
+
+	addMultiInner := func(query, ...queryKey) {
+		ll.assert(len(queryKey) <= 1, "addMulti accepts at most one optional queryKey argument")
+
+		keyToUse := undefined
+		if len(queryKey) == 1 {
+			keyToUse = queryKey[0]
+		} else {
+			keyToUse = canonical.encode(query)
+		}
+
+		queries[keyToUse] = query
+	}
+
 	self := undefined
 	self = {
 
@@ -72,6 +131,16 @@ createBuilder := func(ctx) {
 
 
 
+		ignoreMissingDomains: func() {
+			anchoredQueryOpts.ignoreMissingDomains = true
+			return self
+		},
+
+
+
+
+
+
 		addRef: func(ref) {
 			refKey := canonical.encode(ref)
 
@@ -79,6 +148,8 @@ createBuilder := func(ctx) {
 			if !is_string(refs[refKey]) {
 				refs[refKey] = ref
 			}
+
+			return self
 		},
 
 
@@ -95,6 +166,8 @@ createBuilder := func(ctx) {
 			} else {
 				refs[refKey] = ref
 			}
+
+			return self
 		},
 
 
@@ -104,29 +177,34 @@ createBuilder := func(ctx) {
 
 
 
+
+
+		addSingle: func(id, ...queryKey) {
+			addSingleInner(id, queryKey...)
+			return self
+		},
+
+
+
+
+
+
+
 		addById: func(id) {
-			encodedId := undefined
-			decodedId := undefined
-
-			if is_string(id) {
-				decodedId = json.decode(id)
-				encodedId = id
-			} else if is_map(id) {
-				decodedId = id
-			} else {
-				ll.panic("Invalid column ID type. Expected string or object.")
-			}
+			addSingleInner(id)
+			return self
+		},
 
-			if is_map(decodedId) && !is_undefined(decodedId.source) && !is_undefined(decodedId.axisFilters) {
 
-				columnKey := canonical.encode(decodedId.source)
-				queries[columnKey] = decodedId.source
-			} else {
-				if is_undefined(encodedId) {
-					encodedId = canonical.encode(decodedId)
-				}
-				queries[encodedId] = decodedId
-			}
+
+
+
+
+
+
+		addMulti: func(query, ...queryKey) {
+			addMultiInner(query, queryKey...)
+			return self
 		},
 
 
@@ -135,8 +213,10 @@ createBuilder := func(ctx) {
 
 
 
-		addQuery: func(queryId, query) {
-			queries[queryId] = query
+
+		addQuery: func(queryKey, query) {
+			addMultiInner(query, queryKey)
+			return self
 		},
 
 
@@ -145,6 +225,8 @@ createBuilder := func(ctx) {
 
 
 		build: func() {
+
+
 			resolveResult := bquery.anchoredQuery(ctx, anchors, queries)
 
 			bundle := smart.mapBuilder(pConstants.RTYPE_P_COLUMN_BUNDLE)
@@ -157,8 +239,8 @@ createBuilder := func(ctx) {
 				}
 			}
 
-			for queryId, query in queries {
-				bundle.addRef(queryId, resolveResult.getResult(queryId))
+			for queryKey, query in queries {
+				bundle.addRef(queryKey, resolveResult.getResult(queryKey))
 			}
 
 			return bundle.build()

package/dist/tengo/lib/pframes.constants.lib.tengo

@@ -29,6 +29,12 @@ AGGREGATION_AXES_SPEC_FIELD_NAME := "__aggregation_axes_spec__"
 
 AGGREGATION_AXES_NAMES_FIELD_NAME := "__aggregation_axes_names__"
 
+
+
+
+
+DISTILLED_AGGREGATION_SPEC_FIELD_NAME := "__distilled_aggregation_spec__"
+
 RTYPE_P_FRAME :=  { Name: "PFrame", Version: "1" }
 
 P_COLUMN_DATA_TYPE_PREFIX := "PColumnData/"
@@ -53,6 +59,7 @@ export ll.toStrict({
 	VALUE_FIELD_NAME                              : VALUE_FIELD_NAME,
 	AGGREGATION_AXES_SPEC_FIELD_NAME             : AGGREGATION_AXES_SPEC_FIELD_NAME,
 	AGGREGATION_AXES_NAMES_FIELD_NAME            : AGGREGATION_AXES_NAMES_FIELD_NAME,
+	DISTILLED_AGGREGATION_SPEC_FIELD_NAME         : DISTILLED_AGGREGATION_SPEC_FIELD_NAME,
 	P_COLUMN_DATA_TYPE_PREFIX                     : P_COLUMN_DATA_TYPE_PREFIX,
 	P_COLUMN_SUPER_PARTITIONED_DATA_TYPE_PREFIX   : P_COLUMN_SUPER_PARTITIONED_DATA_TYPE_PREFIX,
 

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

@@ -38,6 +38,22 @@ pColumnResourceMapDataBuilder := func(keyLength) {
 	ll.panic("pframes.pColumnResourceMapDataBuilder is not supported any more; use pcolumn.resourceMapBuilder")
 }
 
+__primitiveValueTypes := { "Int": true, "Long": true, "Float": true, "Double": true, "String": true, "Bytes": true }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -194,12 +210,16 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 		opts.passAggregationAxesNames = false
 	}
 
+	if is_undefined(opts.passDistilledAggregationSpec) {
+		opts.passDistilledAggregationSpec = false
+	}
+
 	if is_undefined(opts.isEphemeral) {
 		opts.isEphemeral = false
 	}
 
-	if (opts.passAggregationAxesSpec || opts.passAggregationAxesNames) && is_undefined(opts.aggregate) {
-		ll.panic("can't use passAggregationAxesSpec or passAggregationAxesNames without aggregate")
+	if (opts.passAggregationAxesSpec || opts.passAggregationAxesNames || opts.passDistilledAggregationSpec) && is_undefined(opts.aggregate) {
+		ll.panic("can't use passAggregationAxesSpec, passAggregationAxesNames or passDistilledAggregationSpec without aggregate")
 	}
 
 
@@ -214,13 +234,22 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 		passKey: opts.passKey
 	}
 
+
+
+	isPotentiallyPartitioned := __primitiveValueTypes[input.spec.valueType]
+
 	extra := opts.extra
 	if is_undefined(extra) {
 		extra = {}
 	}
 
 	iterationAxesSpec := input.spec.axesSpec
-	processTemplateParams.expectedKeyLength = len(input.spec.axesSpec)
+
+
+	if !isPotentiallyPartitioned {
+		processTemplateParams.expectedKeyLength = len(input.spec.axesSpec)
+	}
+
 	if !is_undefined(opts.aggregate) {
 		aggregationIndices := pSpec.matchAxes(input.spec.axesSpec, opts.aggregate)
 		processTemplateParams.aggregationIndices = aggregationIndices
@@ -249,6 +278,23 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 
 			extra[constants.AGGREGATION_AXES_NAMES_FIELD_NAME] = smart.createJsonResource(aggregationAxesNames)
 		}
+
+		if opts.passDistilledAggregationSpec {
+			distiller := pSpec.createSpecDistiller([input.spec])
+			distilledSpec := distiller.distill(input.spec)
+
+			passSpec := maps.deepTransform(distilledSpec, {
+				axesSpec: func(axesSpec) {
+					aggregationAxesSpec := []
+					for i in aggregationIndices {
+						aggregationAxesSpec = append(aggregationAxesSpec, axesSpec[i])
+					}
+					return aggregationAxesSpec
+				}
+			})
+
+			extra[constants.DISTILLED_AGGREGATION_SPEC_FIELD_NAME] = smart.createJsonResource(passSpec)
+		}
 	}
 
 	processedOutputs := []
@@ -457,7 +503,7 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 				sep = separator[0]
 			}
 
-			for name, output in outputsMap {
+			maps.forEach(outputsMap, func(name, output) {
 				if output.type == "Xsv" {
 
 					for columnName, spec in outputSpecs[name] {
@@ -475,7 +521,7 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 						renderResult.output(name)
 					)
 				}
-			}
+			})
 
 			return builder
 		},
@@ -498,11 +544,7 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 
 
 		listOutputs: func() {
-			outputs := []
-			for name, _ in outputsMap {
-				outputs = append(outputs, name)
-			}
-			return slices.quickSort(outputs)
+			return maps.getKeys(outputsMap)
 		},
 
 
@@ -534,11 +576,7 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 				ll.panic("output is not Xsv: " + name)
 			}
 
-			columns := []
-			for columnName, _ in outputSpecs[name] {
-				columns = append(columns, columnName)
-			}
-			return slices.quickSort(columns)
+			return maps.getKeys(outputSpecs[name])
 		},
 
 

package/dist/tengo/lib/pframes.ll.lib.tengo

@@ -55,6 +55,12 @@ llProcessTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.pro
 
 
 
+
+
+
+
+
+
 
 
 

package/dist/tengo/lib/pframes.spec.lib.tengo

@@ -101,7 +101,9 @@ _P_MATCHER_SCHEMA := {
 }
 
 _normalizeMatcher := func(matcher) {
-	if is_string(matcher) {
+	if is_int(matcher) {
+		return matcher
+	} else if is_string(matcher) {
 		return { name: matcher }
 	} else {
 		validation.assertType(matcher, _P_MATCHER_SCHEMA)
@@ -136,7 +138,11 @@ matchAxis := func(axesSpec, matcher) {
 	matcher = _normalizeMatcher(matcher)
 	found := -1
 	for idx, axisSpec in axesSpec {
-		if !_checkAxisMatch(axisSpec, matcher) {
+		if is_int(matcher) {
+			if idx != matcher {
+				continue
+			}
+		} else if !_checkAxisMatch(axisSpec, matcher) {
 			continue
 		}
 		if found != -1 {
@@ -175,6 +181,7 @@ matchAxis := func(axesSpec, matcher) {
 
 
 
+
 
 
 matchAxes := func(axesSpec, matchers, ...opts) {

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

@@ -276,6 +276,13 @@ resolve := func(ref, ctx, ...options) {
 }
 
 
+_ANCHORED_QUERY_DEFAULT_OPTIONS := {
+	
+	ignoreMissingDomains: false
+}
+
+
+
 
 
 
@@ -297,11 +304,18 @@ resolve := func(ref, ctx, ...options) {
 
 
 
-anchoredQuery := func(ctx, anchors, queryMap) {
+anchoredQuery := func(ctx, anchors, queryMap, ...opts) {
 
 	validation.assertType(queryMap, _QUERY_MAP_SCHEMA, "invalid query map schema")
 
 
+	normalizedOpts := _ANCHORED_QUERY_DEFAULT_OPTIONS
+	if len(opts) > 0 {
+		ll.assert(len(opts) == 1 && is_map(opts[0]), "expected single map for opts, got: ", opts)
+		normalizedOpts = maps.deepMerge(normalizedOpts, opts[0])
+	}
+
+
 	resolvedAnchors := {}
 	for anchorId, anchorValue in anchors {
 		opts := { spec: true, data: true }
@@ -340,7 +354,10 @@ anchoredQuery := func(ctx, anchors, queryMap) {
 	queryResult := render.createEphemeral(queryAnchoredTpl, {
 		ctx: ctx,
 		anchorSpecs: smart.createMapResource(maps.mapValues(resolvedAnchors, func(v) { return v.inputs().spec })),
-		queryMap: processedQueryMap
+		request: {
+			queryMap: processedQueryMap,
+			opts: normalizedOpts
+		}
 	})
 
 

package/package.json

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