@platforma-sdk/workflow-tengo 6.17.3 → 6.19.0

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

@@ -10,6 +10,8 @@ oop := import("@platforma-sdk/workflow-tengo:oop")
 tx := import("tx")
 maps := import("@platforma-sdk/workflow-tengo:maps")
 feats := import("@platforma-sdk/workflow-tengo:feats")
+assets := import("@platforma-sdk/workflow-tengo:assets")
+actionContext := import("@platforma-sdk/workflow-tengo:action-context")
 
 
 _SUBSCRIPTION_FIELD := "subscription"
@@ -27,15 +29,29 @@ _SUBSCRIPTION_FIELD := "subscription"
 
 
 
+
+
+
+
+
+
 
 
 createUniversal := func(tpl, isEph, inputs, ...opts) {
 	ll.assert(len(opts) <= 1, "too many arguments, expected at most one options object")
 	metaInputs := undefined
 	inputCache := undefined
+	actionContextName := undefined
+	actionContextOff := false
+	actionContextBaggage := undefined
 	if len(opts) == 1 && opts[0] {
 		metaInputs = opts[0].metaInputs
 		inputCache = opts[0].inputCache
+		actionContextName = opts[0].name
+		actionContextOff = opts[0].actionContext == false
+		if is_map(opts[0].actionContext) {
+			actionContextBaggage = opts[0].actionContext
+		}
 	}
 
 	if !is_undefined(inputCache) && inputCache > 0 && isEph {
@@ -87,6 +103,20 @@ createUniversal := func(tpl, isEph, inputs, ...opts) {
 
 	rbuilder.createInputField(tplutil.INPUTS_MAP_FIELD).set(inputsMap.build())
 
+
+
+	if is_undefined(actionContextName) {
+		actionContextName = assets.templateName(tpl)
+	}
+	if !is_undefined(actionContextBaggage) {
+		actionContext.createContext(rbuilder.id, actionContextBaggage)
+	} else if actionContextOff {
+		actionContext.sinkhole(rbuilder.id, actionContextName)
+	} else {
+		actionContext.createChild(rbuilder.id, actionContextName)
+	}
+
+
 	renderer := rbuilder.lockInputsAndBuild()
 
 	self := undefined

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

@@ -12,6 +12,7 @@ json := import("json")
 times := import("times")
 constants := import("@platforma-sdk/workflow-tengo:constants")
 ffDefault := import("@platforma-sdk/workflow-tengo:ll.get-future-field-default")
+actionContext := import("@platforma-sdk/workflow-tengo:action-context")
 
 
 
@@ -758,6 +759,15 @@ resource = func(r) {
 
 
 
+		actionContext: func() {
+			return actionContext.of(self.id)
+		},
+
+
+
+
+
+
 
 		kvSetFlag: func(key, flag) {
 			ll.assert(feats.fullFeaturedApi, "smart.resource.kvSetFlag: the feature is not available on older backends. Please, update the backend.")

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

@@ -1,6 +1,7 @@
 ll := import("@platforma-sdk/workflow-tengo:ll")
 render := import("@platforma-sdk/workflow-tengo:render")
 smart := import("@platforma-sdk/workflow-tengo:smart")
+actionContext := import("@platforma-sdk/workflow-tengo:action-context")
 times := import("times")
 sets := import("@platforma-sdk/workflow-tengo:sets")
 maps := import("@platforma-sdk/workflow-tengo:maps")
@@ -152,6 +153,14 @@ tpl := func(ops) {
 
 
 
+
+		actionContext: func() {
+			return actionContext.self()
+		},
+
+
+
+
 		isEphemeral: func() {
 			return _isEphemeral
 		},
@@ -732,6 +741,7 @@ tpl := func(ops) {
 		api: func() {
 			return ll.toStrict({
 				renderer                : self.renderer,
+				actionContext           : self.actionContext,
 				registerUnmarshaller    : self.registerUnmarshaller,
 				rawInputs               : self.rawInputs,
 				rawServiceInputs        : self.rawServiceInputs,
@@ -739,6 +749,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
+})

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

@@ -0,0 +1,281 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+text := import("text")
+smart := import("@platforma-sdk/workflow-tengo:smart")
+sets := import("@platforma-sdk/workflow-tengo:sets")
+oop := import("@platforma-sdk/workflow-tengo:oop")
+bquery := import("@platforma-sdk/workflow-tengo:v2.bquery")
+exports := import("@platforma-sdk/workflow-tengo:v2.exports")
+pBundle := import("@platforma-sdk/workflow-tengo:pframes.bundle")
+pTableBuilder := import("@platforma-sdk/workflow-tengo:pframes.table-builder")
+
+self := import("@platforma-sdk/workflow-tengo:tpl")
+
+_RESULT_OUTPUT := "result"
+_EXPORTS_OUTPUT := "exports"
+_INPUT_CONTEXT := "context"
+
+
+_PREPARED_INPUTS_PREFIX := "prepared/"
+
+
+
+self.defineOutputs([_RESULT_OUTPUT, _EXPORTS_OUTPUT])
+
+
+
+
+isProduction := func() {
+	return self.rawInputs().isProduction.getValueAsJson() == true
+}
+
+_args := undefined
+
+
+
+
+args := func() {
+	if is_undefined(_args) {
+		inputs := self.inputs()
+
+		_args = inputs.args
+		if is_undefined(_args) || smart.isReference(_args) {
+			ll.panic("Unexpected args type: %v", _args)
+		}
+
+		for k, v in inputs {
+			if text.has_prefix(k, _PREPARED_INPUTS_PREFIX) {
+				name := text.trim_prefix(k, _PREPARED_INPUTS_PREFIX)
+				ll.assert(is_undefined(_args[name]), "prepare name is already in use in inputs: %s", name)
+				_args[name] = v
+			}
+		}
+	}
+	return _args
+}
+
+_blockId := undefined
+
+
+
+
+blockId := func() {
+	if is_undefined(_blockId) {
+		_blockId = self.inputs().blockId
+		ll.assert(!is_undefined(_blockId), "block id is not set in workflow inputs")
+	}
+	return _blockId
+}
+
+
+
+
+getBlockId := func() {
+	ret := blockId().getDataAsJson()
+	ll.assert(is_string(ret), "block id is not a string")
+	return ret
+}
+
+_parentContext := undefined
+
+
+
+
+
+getParentBCtx := func() {
+	if is_undefined(_parentContext) {
+		_parentContext = self.inputs()[_INPUT_CONTEXT]
+		if is_undefined(_parentContext) {
+			ll.panic("parent context is not set in inputs")
+		}
+	}
+	return _parentContext
+}
+
+
+
+
+
+
+
+
+
+
+query := func(spec, ...options) {
+	return bquery.create(spec, getParentBCtx(), options...)
+}
+
+_resolveOne := func(r, ...options) {
+	res := bquery.resolve(r, getParentBCtx(), options...)
+	return ll.toStrict(oop.inherit(res, {
+		spec: res.getFutureInputField("spec"),
+		data: res.getFutureInputField("data")
+	}))
+}
+
+
+
+
+
+
+
+
+resolve := func(ref, ...options) {
+	return _resolveOne(ref, options...)
+}
+
+
+
+
+
+anchoredQuery := func(anchors, queryMap, ...opts) {
+	return bquery.anchoredQuery(getParentBCtx(), anchors, queryMap, opts...)
+}
+
+
+
+
+
+
+
+prepare := func(cb) {
+	self.prepare(func(_) {
+		raw := cb(args())
+		prefixed := {}
+		for k, v in raw {
+			prefixed[_PREPARED_INPUTS_PREFIX + k] = v
+		}
+		return prefixed
+	})
+}
+
+
+
+
+validateArgs := func(argsSchema) {
+	self.validateInputs({
+		args: argsSchema
+	})
+}
+
+
+
+
+
+createPBundleBuilder := func() {
+	return pBundle.createBuilderWith(bquery, getParentBCtx())
+}
+
+
+
+
+
+
+
+
+
+
+tableBuilder := func(format) {
+	return pTableBuilder.tableBuilderWith(bquery, format, getParentBCtx())
+}
+
+
+
+
+_assertOwnOutputs := func() {
+	defined := sets.fromSlice(self.definedOutputs())
+	if defined != sets.fromSlice([_RESULT_OUTPUT, _EXPORTS_OUTPUT]) {
+		ll.panic("a v2 workflow's outputs are exactly result and exports, but this template defines %v; " +
+			"is something it imports using @platforma-sdk/workflow-tengo:workflow?", sets.toSlice(defined))
+	}
+}
+
+_buildOutputs := func(results) {
+	ll.assert(ll.isMap(results) && !smart.isReference(results), "expected to see map result from body function")
+	ll.assert(
+		sets.fromSlice(["outputs", "exports"]) == sets.fromMapKeys(results),
+		"expected only outputs and exports in the returned map, found %v", sets.toSlice(sets.fromMapKeys(results))
+	)
+	ll.assert(ll.isMap(results.outputs) && !smart.isReference(results.outputs),
+		"expected a map in outputs returned from workflow.body")
+
+	exports.assertNode(results.exports, "exports")
+
+	resBuilder := smart.mapBuilder()
+	for name, value in results.outputs {
+		ll.assert(!is_undefined(value), "value is undefined for output %s", name)
+		resBuilder.add(name, value)
+	}
+
+	tplOutputs := {}
+	tplOutputs[_RESULT_OUTPUT] = resBuilder.build()
+	tplOutputs[_EXPORTS_OUTPUT] = results.exports
+	return tplOutputs
+}
+
+
+
+
+
+
+
+body := func(fn) {
+	_assertOwnOutputs()
+	self.body(func(_) {
+		return _buildOutputs(fn(args()))
+	})
+}
+
+export ll.toStrict({
+	getParentBCtx: getParentBCtx,
+	query: query,
+	resolve: resolve,
+	anchoredQuery: anchoredQuery,
+	prepare: prepare,
+	args: args,
+	rawInputs: self.rawInputs,
+	body: body,
+	isProduction: isProduction,
+	blockId: blockId,
+	getBlockId: getBlockId,
+	validateArgs: validateArgs,
+	createPBundleBuilder: createPBundleBuilder,
+	tableBuilder: tableBuilder
+})

package/dist/tengo/lib/workdir.lib.tengo

@@ -19,6 +19,7 @@ path := import("@platforma-sdk/workflow-tengo:path")
 workdirDirs := import("@platforma-sdk/workflow-tengo:workdir.dirs")
 render := import("@platforma-sdk/workflow-tengo:render")
 maps := import("@platforma-sdk/workflow-tengo:maps")
+actionContext := import("@platforma-sdk/workflow-tengo:action-context")
 
 _WD_CREATE_FIELD_ALLOCATION := "allocation"
 _WD_CREATE_FIELD_WORKDIR    := "workdir"
@@ -411,6 +412,9 @@ _fill := func() {
 			self.getField("dataIn").set(smart.createBinaryMapResource(values))
 			self.getField("blobsIn").set(smart.createBlobMapResource(blobs))
 
+
+			actionContext.inherit(wd.id)
+
 			return self.lockAndBuild().outputs()[_WD_FILL_FIELD_WORKDIR_OUT]
 		}
 	}))

package/dist/tengo/lib/workdir.save.lib.tengo

@@ -6,6 +6,7 @@ json := import("json")
 sets := import("@platforma-sdk/workflow-tengo:sets")
 smart := import("@platforma-sdk/workflow-tengo:smart")
 constants := import("@platforma-sdk/workflow-tengo:constants")
+actionContext := import("@platforma-sdk/workflow-tengo:action-context")
 
 _WORKDIR_IN_FIELD := "workdirIn"
 _RULES_FIELD := "rules"
@@ -143,6 +144,8 @@ builder := func(wdBefore) {
 				)
 			)
 
+
+			actionContext.inherit(super.id)
 			resource := super.lockAndBuild()