@platforma-sdk/workflow-tengo 6.17.3 → 6.18.0

package/dist/index.cjs

@@ -43,5 +43,7 @@ module.exports = { Templates: {
   'pframes.process-pcolumn-batch': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.process-pcolumn-batch.plj.gz') },
   'pframes.process-pcolumn-data': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.process-pcolumn-data.plj.gz') },
   'pframes.export-pframe': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.export-pframe.plj.gz') },
+  'v2.export-collection-for-ui': { type: 'from-file', path: require.resolve('./tengo/tpl/v2.export-collection-for-ui.plj.gz') },
+  'v2.export-for-ui': { type: 'from-file', path: require.resolve('./tengo/tpl/v2.export-for-ui.plj.gz') },
   'pframes.export-pframe-for-ui': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.export-pframe-for-ui.plj.gz') }
 }};

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 declare type TemplateFromFile = { readonly type: "from-file"; readonly path: string; };
-declare type TplName = "ll.get-field" | "pframes.export-parquet-pcolumn-chunk" | "pframes.export-single-pcolumn" | "pframes.import-dir" | "pframes.merge-resource-maps" | "pframes.remove-nulls" | "pt.import-dir" | "waiter.waiter" | "workdir.save" | "workflow.build-ctx" | "workflow.query-context-filter" | "anonymize.deanonymize" | "anonymize.impl" | "check_network.workdir_type_name_extractor" | "exec.delayed-compute-allocation.impl" | "exec.monetization_to_json" | "exec.python.install-deps" | "exec.python.venv-bin-path" | "pframes.export-multiple-pcolumns" | "workflow.query-anchored" | "check_network.create_workdir_from_storage" | "exec.conda.create-env" | "exec.exec-impl" | "exec.monetization_info" | "exec.python.create-venv" | "pframes.slice-data" | "check_network.download_blob" | "check_network.upload_blob" | "check_network.upload_template" | "exec.load-software.impl" | "pframes.parse-to-json" | "exec.exec" | "pt.workflow-run" | "check_network.run_hello_world" | "check_network.run_hello_world_py" | "pframes.build-table" | "pframes.xsv-export-pframe" | "pframes.xsv-import-if-not-null" | "pframes.xsv-import-map" | "annotations.compute" | "pframes.process-pcolumn-batch-split" | "pframes.process-pcolumn-batch" | "pframes.process-pcolumn-data" | "pframes.export-pframe" | "pframes.export-pframe-for-ui";
+declare type TplName = "ll.get-field" | "pframes.export-parquet-pcolumn-chunk" | "pframes.export-single-pcolumn" | "pframes.import-dir" | "pframes.merge-resource-maps" | "pframes.remove-nulls" | "pt.import-dir" | "waiter.waiter" | "workdir.save" | "workflow.build-ctx" | "workflow.query-context-filter" | "anonymize.deanonymize" | "anonymize.impl" | "check_network.workdir_type_name_extractor" | "exec.delayed-compute-allocation.impl" | "exec.monetization_to_json" | "exec.python.install-deps" | "exec.python.venv-bin-path" | "pframes.export-multiple-pcolumns" | "workflow.query-anchored" | "check_network.create_workdir_from_storage" | "exec.conda.create-env" | "exec.exec-impl" | "exec.monetization_info" | "exec.python.create-venv" | "pframes.slice-data" | "check_network.download_blob" | "check_network.upload_blob" | "check_network.upload_template" | "exec.load-software.impl" | "pframes.parse-to-json" | "exec.exec" | "pt.workflow-run" | "check_network.run_hello_world" | "check_network.run_hello_world_py" | "pframes.build-table" | "pframes.xsv-export-pframe" | "pframes.xsv-import-if-not-null" | "pframes.xsv-import-map" | "annotations.compute" | "pframes.process-pcolumn-batch-split" | "pframes.process-pcolumn-batch" | "pframes.process-pcolumn-data" | "pframes.export-pframe" | "v2.export-collection-for-ui" | "v2.export-for-ui" | "pframes.export-pframe-for-ui";
 declare const Templates: Record<TplName, TemplateFromFile>;
 export { Templates };

package/dist/index.js

@@ -44,5 +44,7 @@ export const Templates = {
   'pframes.process-pcolumn-batch': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.process-pcolumn-batch.plj.gz') },
   'pframes.process-pcolumn-data': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.process-pcolumn-data.plj.gz') },
   'pframes.export-pframe': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.export-pframe.plj.gz') },
+  'v2.export-collection-for-ui': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/v2.export-collection-for-ui.plj.gz') },
+  'v2.export-for-ui': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/v2.export-for-ui.plj.gz') },
   'pframes.export-pframe-for-ui': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.export-pframe-for-ui.plj.gz') }
 };

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

@@ -65,7 +65,8 @@ render := import("@platforma-sdk/workflow-tengo:render")
 
 
 
-createBuilder := func(ctx) {
+
+createBuilderWith := func(q, ctx) {
 
 
 
@@ -117,6 +118,9 @@ createBuilder := func(ctx) {
 
 
 		isGlobalRef := is_map(decodedId) && decodedId.__isRef == true
+		if isGlobalRef && maps.containsKey(q, "isRef") {
+			ll.panic("serialized value ids are not supported by this query API; add a ref {block, workflow, name} with addRef, got %v", id)
+		}
 		if isGlobalRef {
 			refKey := is_string(id) ? id : canonical.encode(decodedId)
 			if !is_undefined(queryKey) {
@@ -305,7 +309,7 @@ createBuilder := func(ctx) {
 		build: func() {
 
 
-			resolveResult := bquery.anchoredQuery(ctx, anchors, queries, anchoredQueryOpts)
+			resolveResult := q.anchoredQuery(ctx, anchors, queries, anchoredQueryOpts)
 
 			bundle := smart.mapBuilder(pConstants.RTYPE_P_COLUMN_BUNDLE)
 
@@ -314,7 +318,7 @@ createBuilder := func(ctx) {
 					bundle.addRef(refKey, resolveResult.getAnchor(ref))
 					bundle.addRef(ref, resolveResult.getAnchor(ref))
 				} else {
-					bundle.addRef(refKey, bquery.resolve(ref, ctx))
+					bundle.addRef(refKey, q.resolve(ref, ctx))
 				}
 			}
 
@@ -334,6 +338,15 @@ createBuilder := func(ctx) {
 
 
 
+createBuilder := func(ctx) {
+	return createBuilderWith(bquery, ctx)
+}
+
+
+
+
+
+
 
 
 
@@ -392,6 +405,17 @@ pColumnBundleUnmarshaller := func() {
 
 				result := bResultUnmarshaller.parse(value.getValue(), parser)
 
+
+
+
+				dataOf := func(r) {
+					if !ll.isMap(r) || maps.containsKey(r, "data") || !maps.containsKey(r, "ref") ||
+						!ll.isMap(r.ref) || !maps.containsKey(r.ref, "block") {
+						return r.data
+					}
+					return undefined
+				}
+
 				if is_array(result) {
 					arr := []
 					for i, r in result {
@@ -400,7 +424,7 @@ pColumnBundleUnmarshaller := func() {
 						el := {
 							key: k,
 							spec: r.spec,
-							data: r.data
+							data: dataOf(r)
 						}
 						pool[k] = el
 						arr = append(arr, el)
@@ -410,7 +434,7 @@ pColumnBundleUnmarshaller := func() {
 					pool[resultKey] = {
 						key: resultKey,
 						spec: result.spec,
-						data: result.data
+						data: dataOf(result)
 					}
 				}
 			}
@@ -611,5 +635,6 @@ pColumnBundleUnmarshaller := func() {
 
 export ll.toStrict({
 	createBuilder: createBuilder,
+	createBuilderWith: createBuilderWith,
 	pColumnBundleUnmarshaller: pColumnBundleUnmarshaller
 })

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

@@ -22,8 +22,6 @@
 
 
 
-
-
 
 
 
@@ -148,6 +146,29 @@ isQuerySpec := func(q) {
 
 
 
+holdsRef := func(value, isRef) {
+	stack := [value]
+	si := 0
+	for si < len(stack) {
+		v := stack[si]
+		si += 1
+		if isRef(v) { return true }
+		if ll.isMap(v) {
+			if isResolvedColumn(v) { continue }
+			for _, child in v {
+				stack = append(stack, child)
+			}
+		} else if is_array(v) {
+			for _, child in v {
+				stack = append(stack, child)
+			}
+		}
+	}
+	return false
+}
+
+
+
 
 
 
@@ -157,7 +178,16 @@ isQuerySpec := func(q) {
 
 
 
-tableBuilder := func(format, ...ctxArg) {
+tableBuilderWith := func(q, format, ...ctxArg) {
+
+	unresolved := isUnresolved
+	if maps.containsKey(q, "isRef") {
+		unresolved = func(value) { return holdsRef(value, q.isRef) }
+	}
+	querySpec := func(v) {
+		return !unresolved(v) && !isResolvedColumn(v) && !isEnrichmentRef(v)
+	}
+
 	ll.assert(!is_undefined(VALID_FORMATS[format]),
 		"format must be one of [tsv, csv, parquet, ndjson], got '%s'", format)
 
@@ -194,7 +224,7 @@ tableBuilder := func(format, ...ctxArg) {
 				header = opts[0].header
 			}
 
-			unresolved := isUnresolved(value)
+			unresolved := unresolved(value)
 			if !unresolved {
 				ll.assert(
 					isResolvedColumn(value) ||
@@ -232,7 +262,7 @@ tableBuilder := func(format, ...ctxArg) {
 				header = opts[0].header
 			}
 			join := columnJoinOpt(opts)
-			if isUnresolved(query) || isEnrichmentRef(query) {
+			if unresolved(query) || isEnrichmentRef(query) {
 				_hasUnresolved = true
 			}
 			_columns = append(_columns, {
@@ -283,7 +313,7 @@ tableBuilder := func(format, ...ctxArg) {
 						entrySuffix = undefined
 					}
 
-					if isUnresolved(entryQuery) || isEnrichmentRef(entryQuery) {
+					if unresolved(entryQuery) || isEnrichmentRef(entryQuery) {
 						_hasUnresolved = true
 					}
 					_columns = append(_columns, {
@@ -298,7 +328,7 @@ tableBuilder := func(format, ...ctxArg) {
 				return self
 			}
 
-			if isUnresolved(query) || isEnrichmentRef(query) {
+			if unresolved(query) || isEnrichmentRef(query) {
 				_hasUnresolved = true
 			}
 			_columns = append(_columns, {
@@ -406,7 +436,7 @@ tableBuilder := func(format, ...ctxArg) {
 
 			hasQuerySpec := false
 			for _, c in _columns {
-				if isQuerySpec(c.query) {
+				if querySpec(c.query) {
 					hasQuerySpec = true
 					break
 				}
@@ -421,15 +451,18 @@ tableBuilder := func(format, ...ctxArg) {
 
 			resolveColumn := func(value) {
 				if is_string(value) {
+					if maps.containsKey(q, "isRef") {
+						ll.panic("serialized value ids are not supported by this query API; pass a ref {block, workflow, name}, got %v", value)
+					}
 					ref := decodeGlobalPObjectId(value)
-					r := bquery.resolve(ref, _ctx)
+					r := q.resolve(ref, _ctx)
 					return {
 						spec: r.getFutureInputField("spec"),
 						data: r.getFutureInputField("data")
 					}
 				}
-				if isUnresolved(value) {
-					r := bquery.resolve(value, _ctx)
+				if unresolved(value) {
+					r := q.resolve(value, _ctx)
 					return {
 						spec: r.getFutureInputField("spec"),
 						data: r.getFutureInputField("data")
@@ -462,7 +495,7 @@ tableBuilder := func(format, ...ctxArg) {
 					data: resolvedCol.data,
 					filters: []
 				}
-				if isUnresolved(column) {
+				if unresolved(column) {
 					primaryPlRefs[p.name] = column
 				}
 
@@ -487,7 +520,7 @@ tableBuilder := func(format, ...ctxArg) {
 			multiQueryResultByIdx := {}
 			qMap := {}
 			for idx, c in _columns {
-				if isQuerySpec(c.query) {
+				if querySpec(c.query) {
 					strategy := "expectSingle"
 					if c.mode == "multi" { strategy = "expectMultiple" }
 					qMap["q" + string(idx)] = maps.deepMerge(c.query, {
@@ -500,9 +533,9 @@ tableBuilder := func(format, ...ctxArg) {
 					"column query specs require at least one primary added as a PlRef " +
 					"or PrimaryRef (pre-resolved primaries cannot anchor column queries)")
 
-				qResult := bquery.anchoredQuery(_ctx, primaryPlRefs, qMap)
+				qResult := q.anchoredQuery(_ctx, primaryPlRefs, qMap)
 				for idx, c in _columns {
-					if isQuerySpec(c.query) {
+					if querySpec(c.query) {
 						r := qResult.getResult("q" + string(idx))
 						if c.mode == "multi" {
 
@@ -552,7 +585,7 @@ tableBuilder := func(format, ...ctxArg) {
 				} else if isResolvedColumn(c.query) {
 					entry.spec = c.query.spec
 					entry.data = c.query.data
-				} else if isUnresolved(c.query) {
+				} else if unresolved(c.query) {
 					resolved := resolveColumn(c.query)
 					entry.spec = resolved.spec
 					entry.data = resolved.data
@@ -646,6 +679,14 @@ tableBuilder := func(format, ...ctxArg) {
 	return ll.toStrict(self)
 }
 
+
+
+
+tableBuilder := func(format, ...ctxArg) {
+	return tableBuilderWith(bquery, format, ctxArg...)
+}
+
 export ll.toStrict({
-	tableBuilder: tableBuilder
+	tableBuilder: tableBuilder,
+	tableBuilderWith: tableBuilderWith
 })

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

@@ -739,6 +739,7 @@ tpl := func(ops) {
 				hasInput                : self.hasInput,
 				inputs                  : self.inputs,
 				defineOutputs           : self.defineOutputs,
+				definedOutputs          : func() { return copy(self.definedOutputs) },
 				setOutputCache			: self.setOutputCache,
 				setOutputCacheMillis	: self.setOutputCacheMillis,
 				setOutputCacheSeconds	: self.setOutputCacheSeconds,

package/dist/tengo/lib/v2.bquery.lib.tengo

@@ -0,0 +1,9 @@
+
+
+
+
+
+
+bquery := import("@platforma-sdk/workflow-tengo:workflow.bquery")
+
+export bquery.forFamily(2)

package/dist/tengo/lib/v2.exports.lib.tengo

@@ -0,0 +1,141 @@
+
+
+
+
+
+
+
+
+
+
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+smart := import("@platforma-sdk/workflow-tengo:smart")
+maps := import("@platforma-sdk/workflow-tengo:maps")
+constants := import("@platforma-sdk/workflow-tengo:constants")
+bobject := import("@platforma-sdk/workflow-tengo:workflow.bobject")
+rules := import("@platforma-sdk/workflow-tengo:v2.node-rules")
+
+_CONSTRUCTORS_HINT := "build it with v2.exports.folder or v2.exports.collection (or pframes.pFrameBuilder)"
+
+
+_see := func(value) {
+	if smart.isField(value) {
+		info := value.info()
+		if info.IsSet && info.Value != 0 {
+			return { kind: "resource", type: value.getValue().info().Type }
+		}
+		return { kind: "pending" }
+	}
+	if smart.isResource(value) {
+		return { kind: "resource", type: value.info().Type }
+	}
+	if ll.isMap(value) {
+		return { kind: "map", keys: maps.getKeys(value) }
+	}
+	return { kind: "other", typeName: type_name(value) }
+}
+
+
+
+
+
+
+
+
+
+assertNode := func(value, what) {
+	got := rules.refusal(_see(value))
+	if !is_undefined(got) {
+		ll.panic("%s must be a typed node — a folder or a collection — or a reference to one; got %s; %s",
+			what, got, _CONSTRUCTORS_HINT)
+	}
+}
+
+
+
+
+
+
+
+
+folder := func(entries) {
+	ll.assert(ll.isMap(entries) && !smart.isReference(entries),
+		"v2.exports.folder: expected a map of entry name to node, got %v", entries)
+
+	b := smart.mapBuilder()
+	for name in maps.getKeys(entries) {
+		rules.assertName(name, "folder entry name")
+		node := entries[name]
+		if !smart.isReference(node) && ll.isMap(node) && maps.containsKey(node, "spec") {
+			ll.panic("folder entry %q is not a node; items belong in a collection (v2.exports.collection)", name)
+		}
+		assertNode(node, "folder entry \"" + name + "\"")
+		b.add(name, node)
+	}
+	return b.build()
+}
+
+
+_isNoResult := func(data) {
+	if smart.isField(data) {
+		info := data.info()
+		if !(info.IsSet && info.Value != 0) {
+			return false
+		}
+		data = data.getValue()
+	}
+	return smart.isResource(data) && data.checkResourceType(constants.RTYPE_BRESOLVE_NO_RESULT)
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+collection := func(items) {
+	ll.assert(ll.isMap(items) && !smart.isReference(items),
+		"v2.exports.collection: expected a map of item name to {spec, data}, got %v", items)
+
+	b := smart.structBuilder(rules.COLLECTION_TYPE)
+	for name in maps.getKeys(items) {
+		rules.assertName(name, "item name")
+		item := items[name]
+		if smart.isReference(item) || !ll.isMap(item) {
+			ll.panic("item %q must be a map {spec, data}, got %v", name, item)
+		}
+		for key in maps.getKeys(item) {
+			if key != "spec" && key != "data" && key != "ref" {
+				ll.panic("item %q has key %q; an item has only spec and data", name, key)
+			}
+		}
+
+		if !maps.containsKey(item, "spec") || is_undefined(item.spec) {
+			ll.panic("item %q has no spec", name)
+		}
+		spec := item.spec
+		if !smart.isReference(spec) {
+			spec = bobject.createSpec(spec)
+		}
+		b.createInputField(name + ".spec").set(spec)
+
+		data := maps.containsKey(item, "data") ? item.data : undefined
+		if !is_undefined(data) && !_isNoResult(data) {
+			b.createInputField(name + ".data").setRefOrJson(data)
+		}
+	}
+	return b.lockAndBuild()
+}
+
+export ll.toStrict({
+	folder: folder,
+	collection: collection,
+	assertNode: assertNode
+})

package/dist/tengo/lib/v2.node-rules.lib.tengo

@@ -0,0 +1,102 @@
+
+
+
+
+
+
+
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+text := import("text")
+
+FOLDER_TYPE := { Name: "std/map", Version: "1" }
+COLLECTION_TYPE := { Name: "PFrame", Version: "1" }
+
+
+
+
+
+
+
+
+
+
+
+
+nameProblem := func(name) {
+	if !is_string(name) {
+		return "is not a string"
+	}
+	if name == "" {
+		return "is empty"
+	}
+	if text.contains(name, ".") {
+		return "contains \".\", which joins the names of a path"
+	}
+	if name == "resourceError" {
+		return "is reserved by the backend"
+	}
+	if text.has_prefix(name, "recovery/") {
+		return "starts with \"recovery/\", which the backend reserves"
+	}
+	return undefined
+}
+
+
+
+
+
+
+
+assertName := func(name, what) {
+	problem := nameProblem(name)
+	if !is_undefined(problem) {
+		ll.panic("%s %q %s", what, name, problem)
+	}
+}
+
+
+
+
+
+
+
+isNodeType := func(type) {
+	return (type.Name == FOLDER_TYPE.Name && type.Version == FOLDER_TYPE.Version) ||
+		(type.Name == COLLECTION_TYPE.Name && type.Version == COLLECTION_TYPE.Version)
+}
+
+
+
+
+
+
+
+
+
+
+
+refusal := func(seen) {
+	if seen.kind == "pending" {
+		return undefined
+	}
+	if seen.kind == "resource" {
+		if isNodeType(seen.type) {
+			return undefined
+		}
+		return "a resource of type " + seen.type.Name + "/" + seen.type.Version
+	}
+	if seen.kind == "map" {
+		return "a map with keys [" + text.join(seen.keys, ", ") + "]"
+	}
+	return "a value of type " + seen.typeName
+}
+
+export ll.toStrict({
+	FOLDER_TYPE: FOLDER_TYPE,
+	COLLECTION_TYPE: COLLECTION_TYPE,
+	nameProblem: nameProblem,
+	assertName: assertName,
+	isNodeType: isNodeType,
+	refusal: refusal
+})