@platforma-sdk/workflow-tengo 2.13.6 → 2.15.0

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

@@ -1,6 +1,6 @@
-/**
- * Working with p-frames
- */
+
+
+
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 maps := import("@platforma-sdk/workflow-tengo:maps")
@@ -16,145 +16,153 @@ constants := import("@platforma-sdk/workflow-tengo:pframes.constants")
 
 llProcessTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.process-pcolumn-data")
 
-/**
- * Given a reference to the p-frame, converts all inner resource files into resources that can be
- * downloaded from the UI side.
- */
+
+
+
+
 exportFrame := func(pf) {
 	return render.createEphemeral(assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.export-pframe"), { pf: pf }).output("result")
 }
 
-/**
- * Export single PColumn data
- */
+
+
+
 exportColumnData := func(data) {
 	return render.createEphemeral(assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.export-single-pcolumn"), { data: data }).output("result")
 }
 
-/**
- * Creates a builder for a resource map p-column's data.
- */
+
+
+
 pColumnResourceMapDataBuilder := func(keyLength) {
 	ll.panic("pframes.pColumnResourceMapDataBuilder is not supported any more; use pcolumn.resourceMapBuilder")
 }
 
-/**
- * Constructs a mapping or aggregation pipeline for a given input PColumn and returns a specialized
- * output object for accessing the processing results.
- *
- * === Body Template Contract ===
- *
- *   Inputs:
- *     "__key__"   - When passKey is true, contains the JSON representation of the group/element key:
- *                     - Without aggregation: represents a single key
- *                     - With aggregation: represents all keys in positions not specified by indices
- *                   Not provided if passKey is false or omitted from ops
- *     "__aggregation_axes_spec__"
- *                 - When passAggregationAxesSpec is true, contains the axes specification for aggregation
- *                     Can be used to adapt body behavior when optional aggregation axes are unmatched
- *                   Not provided if passAggregationAxesSpec is false or omitted from ops
- *     "__aggregation_axes_names__"
- *                 - When passAggregationAxesNames is true, contains just the names of aggregation axes
- *                     as a simple array of strings, without domains, annotations, etc.
- *                   Not provided if passAggregationAxesNames is false or omitted from ops
- *     "__value__" - Content depends on aggregation setting:
- *                     - Without aggregation: single value (only for ResourceMap PColumns)
- *                     - With aggregation: "PColumnData/*" resource containing all records in current group
- *     ...extra    - Additional values/references passed via the options.extra parameter
- *                   are forwarded to the template unchanged
- *
- * === Parameters ===
- *
- * @param input         Primary input column data and specifications
- *
- *                      Required structure:
- * 							{
- * 							 	// PColumn specifications (must be explicit, not a reference)
- * 							 	spec: <PColumnSpec>,
- *
- * 							 	// Reference to the data resource
- * 							 	data: <resource ref>
- *							}
- *
- * @param bodyTpl       Template executed for each iteration (see contract above)
- * @param outputs 		Array of output configurations to collect from rendered templates
- *
- *                  Common fields for all types:
- *                     {
- *                       name:  string     // Output name
- *                       path?: string[]   // [Optional] Override path inside body template result
- *                                            First element interpreted as output name
- *                                            Defaults to [name] if omitted
- *                     }
- *
- *                  Available types:
- *                    | {
- *                        type: "Resource",     // Single resource output
- *                        spec: PColumnSpec     // Result column spec (must have zero axes specs,
- *                                              // input axes specs added automatically)
- *                      }
- *                    | {
- *                        type: "ResourceMap",  // ResourceMap output
- *                        spec: PColumnSpec     // Result column spec (list only axes specs
- *                                              // produced by body template, input axes added automatically)
- *                      }
- *                    | {
- *                        type: "BinaryPartitioned" | "JsonPartitioned",
- *                                              // Partitioned Json/Binary PColumn data
- *                        spec: PColumnSpec     // Result column spec (list only axes specs
- *                                              // produced by body template, input axes added automatically)
- *                        partitionKeyLength: number
- *                                              // Expected partition length per operation
- *                      }
- *                    | {
- *                        type: "Xsv",          // CSV/TSV formatted text file for xsv conversion
- *						  xsvType: "tsv"|"csv", // Expected file format
- *                        settings: object      // Xsv conversion specification
- *                      }
- *
- * @param opts 			Optional additional settings
- *
- *                    {
- *                      traceSteps?: array      // Array of trace steps to add to output specs
- *                                              // Each step should be an object with type, id, importance and label
- *
- *                      aggregate?: AxisMatcher[],
- *                                              // If specified, selected axes are combined and
- *                                              // passed to each iteration as a group. These axes
- *                                              // won't be automatically added to output specs
- *                                              // Examples:
- *                                              //   - "pl7.app/sequencing/readIndex"
- *                                              //   - { name: "pl7.app/sequencing/readIndex" }
- *                                              //   - { type: "String", name: "pl7.app/sequencing/lane" }
- *                                              //   - { type: "String", name: "pl7.app/sequencing/lane", optional: true }
- *                                              //   - { type: "String", name: "pl7.app/rna-seq/geneId", domain: { "pl7.app/species": "homo-sapiens" } }
- *                                              // With optional: true, matcher won't error if unmatched
- *                                              // Use passAggregationAxesSpec for custom handling in body template
- *
- *                      passKey?: boolean       // Pass __key__ to body template if true
- *
- *                      passAggregationAxesSpec?: boolean
- *                                              // Pass full aggregation axes specs to body template
- *                                              // via __aggregation_axes_spec__ input
- *
- *                      passAggregationAxesNames?: boolean
- *                                              // Pass array of aggregation axes names to body template
- *                                              // via __aggregation_axes_names__ input
- *
- *                      extra?: Map<string, Ref>,
- *                                              // Additional parameters passed to each body invocation
- *                                              // Keys match template input names
- *
- *                      isEphemeral?: boolean   // Whether to render mapping template in ephemeral mode
- *                                              // Defaults to false if omitted, template will be rendered
- *                                              // as pure resource
- *                    }
- *
- * === Return ===
- *
- * @returns Object with methods for retrieving processing results
- *          See source code for method documentation and signatures
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 processColumn := func(input, bodyTpl, outputs, ...opts) {
 	if len(opts) == 0 {
 		opts = {}
@@ -194,13 +202,13 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 		ll.panic("can't use passAggregationAxesSpec or passAggregationAxesNames without aggregate")
 	}
 
-	// Initialize trace if traceSteps provided
+
 	trace := undefined
 	if !is_undefined(opts.traceSteps) {
 		trace = pSpec.makeTrace(input.spec, opts.traceSteps...)
 	}
 
-	// JSON params passed as a single resource to the template
+
 	processTemplateParams := {
 		eph: opts.isEphemeral,
 		passKey: opts.passKey
@@ -217,7 +225,7 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 		aggregationIndices := pSpec.matchAxes(input.spec.axesSpec, opts.aggregate)
 		processTemplateParams.aggregationIndices = aggregationIndices
 
-		// calculate iteration axes spec
+
 		groupAxesIndices := pUtil.calculateGroupAxesIndices(len(input.spec.axesSpec), aggregationIndices)
 		iterationAxesSpec = []
 		for i in groupAxesIndices {
@@ -247,7 +255,7 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 	outputSpecs := {}
 	outputsMap := {}
 	for output in outputs {
-		// map output name to output settings provided in input
+
 		outputsMap[output.name] = output
 		if output.type == "Resource" || output.type == "BinaryPartitioned" || output.type == "JsonPartitioned" {
 			spec := maps.merge(output.spec, { axesSpec: iterationAxesSpec + slices.normalize(output.spec.axesSpec) })
@@ -303,17 +311,17 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 	self = ll.toStrict({
 		renderResult: renderResult,
 
-		/**
-		 * Returns output spec for the given output name and optional column name
-		 *
-		 * For normal outputs (Resource, ResourceMap, BinaryPartitioned, JsonPartitioned),
-		 * only the output name should be provided.
-		 * For Xsv outputs, both output name and column name should be provided.
-		 *
-		 * @param name - Name of the output
-		 * @param column - Optional. For Xsv outputs, name of the column
-		 * @returns Output spec
-		 */
+
+
+
+
+
+
+
+
+
+
+
 		outputSpec: func(name, ...column) {
 			output := outputsMap[name]
 			if is_undefined(output) {
@@ -339,17 +347,17 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 			}
 		},
 
-		/**
-		 * Returns data resource for the given output name and optional column name
-		 *
-		 * For normal outputs (Resource, ResourceMap, BinaryPartitioned, JsonPartitioned),
-		 * only the output name should be provided.
-		 * For Xsv outputs, both output name and column name should be provided.
-		 *
-		 * @param name - Name of the output
-		 * @param column - Optional. For Xsv outputs, name of the column
-		 * @returns data resource
-		 */
+
+
+
+
+
+
+
+
+
+
+
 		outputData: func(name, ...column) {
 			output := outputsMap[name]
 			if is_undefined(output) {
@@ -369,17 +377,17 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 			}
 		},
 
-		/**
-		 * Returns both data resource and spec for the given output name and optional column name
-		 *
-		 * For normal outputs (Resource, ResourceMap, BinaryPartitioned, JsonPartitioned),
-		 * only the output name should be provided.
-		 * For Xsv outputs, both output name and column name should be provided.
-		 *
-		 * @param name - Name of the output
-		 * @param column - Optional. For Xsv outputs, name of the column
-		 * @returns {data: Resource, spec: PColumnSpec} Object containing both data resource and spec
-		 */
+
+
+
+
+
+
+
+
+
+
+
 		output: func(name, ...column) {
 			output := outputsMap[name]
 			if is_undefined(output) {
@@ -410,12 +418,12 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 			}
 		},
 
-		/**
-		 * Returns a PFrame containing all columns from an Xsv output
-		 *
-		 * @param name - Name of the Xsv output
-		 * @returns PFrame containing all columns from the output
-		 */
+
+
+
+
+
+
 		xsvOutputFrame: func(name) {
 			output := outputsMap[name]
 			if is_undefined(output) {
@@ -433,12 +441,12 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 			return builder.build()
 		},
 
-		/**
-		 * Returns a PFrame containing all results, flattening Xsv outputs using the provided separator
-		 *
-		 * @param ...xsvNameSeparator - Optional separator for joining Xsv output and column names, defaults to "."
-		 * @returns PFrame containing all results
-		 */
+
+
+
+
+
+
 		allOutputsFrame: func(...xsvNameSeparator) {
 			sep := "."
 			if len(xsvNameSeparator) > 0 {
@@ -449,7 +457,7 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 
 			for name, output in outputsMap {
 				if output.type == "Xsv" {
-					// For Xsv outputs, add each column with name prefixed
+
 					for columnName, spec in outputSpecs[name] {
 						builder.add(
 							name + sep + columnName,
@@ -458,7 +466,7 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 						)
 					}
 				} else {
-					// For non-Xsv outputs, add directly
+
 					builder.add(
 						name,
 						outputSpecs[name],
@@ -470,11 +478,11 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 			return builder.build()
 		},
 
-		/**
-		 * Returns sorted list of all available output names
-		 *
-		 * @returns Array of output names
-		 */
+
+
+
+
+
 		listOutputs: func() {
 			outputs := []
 			for name, _ in outputsMap {
@@ -483,12 +491,12 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 			return slices.quickSort(outputs)
 		},
 
-		/**
-		 * Checks if given output is of Xsv type
-		 *
-		 * @param name - Output name to check
-		 * @returns true if output is Xsv, false otherwise
-		 */
+
+
+
+
+
+
 		isXsvOutput: func(name) {
 			output := outputsMap[name]
 			if is_undefined(output) {
@@ -497,12 +505,12 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 			return output.type == "Xsv"
 		},
 
-		/**
-		 * Returns sorted list of column names for given Xsv output
-		 *
-		 * @param name - Xsv output name
-		 * @returns Array of column names
-		 */
+
+
+
+
+
+
 		listXsvColumns: func(name) {
 			output := outputsMap[name]
 			if is_undefined(output) {

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

@@ -1,6 +1,6 @@
-/**
- * Set of basic operations for PColumn data payload
- */
+
+
+
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 assets := import("@platforma-sdk/workflow-tengo:assets")
@@ -9,59 +9,59 @@ render := import("@platforma-sdk/workflow-tengo:render")
 
 llProcessTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.process-pcolumn-data")
 
-/**
- * Instantiates an aggregation pipeline for the given inputs and returns rendered ephemeral template.
- * Use result.output("outputName") to get corresponding output, where result is the object returned by
- * this method.
- *
- * Contract for the body template:
- *   Inputs:
- *     "__key__": string     - JSON representation of the group key (i.e. keys in all positions not
- *                             specified in the indices parameter). Only provided if passKey is true.
- *     "__value__": Resource - PColumnData/ResourceMap resource containing all records in current group
- *     ...extra              - Additional values/references passed via the extra parameter are forwarded
- *                             to the template unchanged
- *
- * @param data: Resource                - Data resource (currently only PColumnData/ResourceMap supported)
- * @param aggregationIndices: number[]|undefined
- *                                      - Indices to aggregate over. These indices will be stripped from
- *                                       the input map (opposite of SQL GROUP BY). If undefined, works as
- *                                       "map" and passes each input value as raw resource.
- * @param bodyTpl: Template            - Template implementing the aggregation logic
- * @param outputs: OutputSpec[]        - Array of output specifications to collect from rendered templates
- *                                      Common fields for all output types:
- *                                        {
- *                                          name: string      - Name of the output
- *                                          path?: string[]   - Optional. Overrides path inside body template
- *                                                             result. First element is output name. Defaults
- *                                                             to [name] if not specified.
- *                                        }
- *                                      Output type variants:
- *                                        | { type: "Resource" }  - Normal singular resource
- *                                        | {                     - ResourceMap output
- *                                            type: "ResourceMap",
- *                                            keyLength: number   - Expected key length per operation
- *                                          }
- *                                        | {                     - Partitioned data output
- *                                            type: "BinaryPartitioned"|"JsonPartitioned",
- *                                            partitionKeyLength: number - Expected partition length per op
- *                                          }
- *                                        | {                     - CSV/TSV text file output
- *                                            type: "Xsv",
- *                                            xsvType: "tsv"|"csv",
- *                                            flattenWithDelimiter?: string,
- *                                                                - If present, flattens output by adding columns
- *                                                                  one by one using the specified delimiter:
- *                                                                  "{outputName}{flattenWithDelimiter}{columnId}"
- *                                            settings: object    - Xsv conversion specification
- *                                          }
- * @param isEph: boolean               - If true, body template will be rendered as ephemeral
- * @param passKey: boolean             - If true, body template will receive __key__ input
- * @param extra: object                - Optional map of parameters to pass to the template
- *
- * @returns RenderResult              - Rendered template result with output() method for accessing outputs
- * @panics                           - If extra parameter count is invalid
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 aggregateV2 := func(data, aggregationIndices, bodyTpl, outputs, isEph, passKey, ...extra) {
 	renderInputs := {
 		params: smart.createJsonResource({
@@ -86,9 +86,9 @@ aggregateV2 := func(data, aggregationIndices, bodyTpl, outputs, isEph, passKey,
 	return renderResult
 }
 
-/*
- * Read docs for aggregateV2
- */
+
+
+
 aggregate := func(data, aggregationIndices, bodyTpl, outputs, isEph, ...extra) {
 	return aggregateV2(data, aggregationIndices, bodyTpl, outputs, isEph, true, extra...)
 }