@platforma-sdk/workflow-tengo 6.18.0 → 6.20.0

package/dist/tengo/lib/action-context.lib.tengo

@@ -0,0 +1,296 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+maps := import("@platforma-sdk/workflow-tengo:maps")
+feats := import("@platforma-sdk/workflow-tengo:feats")
+constants := import("@platforma-sdk/workflow-tengo:constants")
+json := import("json")
+slices := import("@platforma-sdk/workflow-tengo:slices")
+text := import("text")
+times := import("times")
+tx := import("tx")
+
+LINK_FIELD := "actionContext"
+STATES := ["WaitingForInputs", "Running", "WaitingWorkdirGate", "WaitingSubmissionGate", "PopulatingWorkdir",
+	"CollectingOutputs", "WaitingForScheduler", "WaitingForMachine", "Terminated", "Completed"]
+CHILD_FIELD_PREFIX := "child/"
+CONTEXT_TYPE := { Name: "ActionContext", Version: "1" }
+SINKHOLE_TYPE := { Name: "ActionSinkhole", Version: "1" }
+
+
+
+_vars := func() {
+	return ll.moduleVars("action-context")
+}
+
+
+
+
+
+
+
+linkOf := func(rid) {
+	fields := tx.getResource(rid).ServiceFields
+	if !maps.containsKey(fields, LINK_FIELD) || fields[LINK_FIELD].Value == 0 {
+		return { kind: "none" }
+	}
+	target := fields[LINK_FIELD].Value
+	if tx.getResource(target).Type.Name == CONTEXT_TYPE.Name {
+		return { kind: "context", id: target }
+	}
+	return { kind: "sinkhole", id: target }
+}
+
+
+
+
+
+contextOf := func(rid) {
+	link := linkOf(rid)
+	return link.kind == "context" ? link.id : undefined
+}
+
+_own := func() {
+	vars := _vars()
+	own := vars.get("own")
+	if is_undefined(own) {
+		own = linkOf(ll.getCurrentTemplateRenderer().ID)
+		vars.set("own", own)
+	}
+	return own
+}
+
+_ownBaggage := func() {
+	vars := _vars()
+	baggage := vars.get("ownBaggage")
+	if is_undefined(baggage) {
+		baggage = {}
+		raw := tx.getResource(_own().id).Data
+		if !is_undefined(raw) && len(raw) > 0 {
+			baggage = json.decode(raw)
+		}
+		vars.set("ownBaggage", baggage)
+	}
+	return copy(baggage)
+}
+
+_childFieldName := func() {
+	vars := _vars()
+	counter := vars.get("childCounter")
+	counter = is_undefined(counter) ? 0 : counter + 1
+	vars.set("childCounter", counter)
+	return CHILD_FIELD_PREFIX + string(times.time_unix_nano(times.now())) + "-" + string(counter)
+}
+
+
+
+_enabled := func() {
+	return feats.kvAsync && feats.optionalFieldsInSchemas
+}
+
+_link := func(rid, target) {
+	if !_enabled() {
+		return
+	}
+	field := ll.fieldId(rid, LINK_FIELD)
+	tx.createField(field, constants.FTYPE_SERVICE)
+	tx.setFieldToResource(field, target)
+}
+
+_validateKeyPart := func(name, part) {
+	ll.assert(is_string(part) && len(part) > 0, "action context: %s must be a non-empty string", name)
+	ll.assert(!text.contains(part, "/"), "action context: %s %q contains \"/\"", name, part)
+}
+
+_createLinked := func(rid, type, baggage) {
+	id := tx.createEphemeral(type.Name, type.Version, json.encode(baggage))
+	_link(rid, id)
+	return id
+}
+
+
+_childBaggage := func(name) {
+	baggage := _own().kind == "none" ? {} : _ownBaggage()
+	if !is_undefined(name) {
+		baggage.name = name
+	}
+	return baggage
+}
+
+
+
+
+
+
+
+
+
+
+sinkhole := func(rid, ...name) {
+	if _enabled() {
+		_createLinked(rid, SINKHOLE_TYPE, _childBaggage(len(name) > 0 ? name[0] : undefined))
+	}
+}
+
+
+
+
+
+
+
+
+
+inherit := func(rid) {
+	own := _own()
+	if own.kind != "none" {
+		_link(rid, own.id)
+	}
+}
+
+
+
+
+
+
+
+
+
+
+createContext := func(rid, baggage) {
+	return _enabled() ? _createLinked(rid, CONTEXT_TYPE, copy(baggage)) : undefined
+}
+
+
+
+
+
+
+
+
+
+
+createChild := func(rid, name) {
+	if !_enabled() {
+		return undefined
+	}
+	own := _own()
+	if own.kind == "none" {
+		return undefined
+	}
+	if own.kind == "sinkhole" {
+		sinkhole(rid, name)
+		return undefined
+	}
+
+	contextId := _createLinked(rid, CONTEXT_TYPE, _childBaggage(name))
+
+	childField := ll.fieldId(own.id, _childFieldName())
+	tx.createField(childField, constants.FTYPE_DYNAMIC)
+	tx.setFieldToResource(childField, contextId)
+
+	return contextId
+}
+
+
+
+
+
+
+
+
+
+
+of := func(rid) {
+	contextId := func() {
+		return _enabled() ? contextOf(rid) : undefined
+	}
+
+	return ll.toStrict({
+		setReading: func(namespace, key, value) {
+			_validateKeyPart("namespace", namespace)
+			_validateKeyPart("reading key", key)
+			ctx := contextId()
+			if !is_undefined(ctx) {
+				tx.resourceKeyValueSetAsync(ctx, "reading/" + namespace + "/" + string(rid) + "/" + key, value)
+			}
+		},
+
+		record: func(namespace, state, ...detail) {
+			_validateKeyPart("namespace", namespace)
+			ll.assert(slices.hasElement(STATES, state), "action context: unknown state %q", state)
+			ctx := contextId()
+			if !is_undefined(ctx) {
+				key := "transition/" + namespace + "/" + string(rid) + "/" + string(times.time_unix_nano(times.now()))
+				value := json.encode({ state: state, detail: len(detail) > 0 ? detail[0] : "", reason: "" })
+				tx.resourceKeyValueSetAsync(ctx, key, value)
+			}
+		}
+	})
+}
+
+
+
+
+
+
+
+
+
+
+self := func() {
+	renderer := ll.getCurrentTemplateRenderer().ID
+	handle := of(renderer)
+	return ll.toStrict({
+		setReading: handle.setReading,
+		record: handle.record,
+
+		baggage: func() {
+			return _own().kind == "none" ? undefined : _ownBaggage()
+		},
+
+		id: func() {
+			return _own().kind == "context" ? _own().id : undefined
+		}
+	})
+}
+
+export ll.toStrict({
+	LINK_FIELD: LINK_FIELD,
+	CHILD_FIELD_PREFIX: CHILD_FIELD_PREFIX,
+
+	linkOf: linkOf,
+	contextOf: contextOf,
+	createChild: createChild,
+	createContext: createContext,
+	inherit: inherit,
+	sinkhole: sinkhole,
+	of: of,
+	self: self
+})

package/dist/tengo/lib/assets.lib.tengo

@@ -18,8 +18,28 @@ maps := import("@platforma-sdk/workflow-tengo:maps")
 
 
 
+
+
+
+_templateNames := func() {
+	return ll.moduleVars("assets.templateNames")
+}
+
 importTemplate := func(tplName) {
-	return smart.resource(plapi.getTemplateId(tplName))
+	id := plapi.getTemplateId(tplName)
+	_templateNames().set(string(id), tplName)
+	return smart.resource(id)
+}
+
+
+
+
+
+
+
+templateName := func(tpl) {
+	id := smart.isResource(tpl) ? tpl.id : tpl
+	return _templateNames().get(string(id))
 }
 
 
@@ -66,6 +86,7 @@ isAssetInfo := func(toCheck) {
 
 export ll.toStrict({
 	importTemplate      : importTemplate,
+	templateName        : templateName,
 	importSoftware      : swinfo.importSoftware,
 	isSoftwareInfo      : swinfo.isSoftwareInfo,
 	importAsset         : importAsset,

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

@@ -13,6 +13,7 @@ smart := import("@platforma-sdk/workflow-tengo:smart")
 json := import("json")
 constants := import("@platforma-sdk/workflow-tengo:exec.constants")
 feats := import("@platforma-sdk/workflow-tengo:feats")
+actionContext := import("@platforma-sdk/workflow-tengo:action-context")
 
 _RTYPE_QUOTA := { Name: "Quota", Version: "1" }
 
@@ -278,6 +279,8 @@ computeRequestBuilder := func() {
 
 			requestBuilder.getField(_CR_FIELD_REQUEST).set(quota)
 
+
+			actionContext.inherit(requestBuilder.id)
 			requestRef := requestBuilder.lockAndBuild()
 
 			return ll.toStrict(

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

@@ -17,6 +17,7 @@ slices := import("@platforma-sdk/workflow-tengo:slices")
 limits := import("@platforma-sdk/workflow-tengo:exec.limits")
 
 delayedCompAlloc := import("@platforma-sdk/workflow-tengo:exec.delayed-compute-allocation")
+actionContext := import("@platforma-sdk/workflow-tengo:action-context")
 
 _RTYPE_RUN_COMMAND_V1 := { Name: "RunCommand/executor", Version: "1" }
 _RTYPE_RUN_COMMAND_CMD := { Name: "RunCommandCmd", Version: "1" }
@@ -776,6 +777,9 @@ builder := func(workdir, ...initialState) {
 			argsRes := smart.createValueResource(_RTYPE_RUN_COMMAND_ARGS, json.encode(options.args))
 			runRes.getField(_FIELD_ARGS).set(argsRes)
 
+
+			actionContext.inherit(runRes.id)
+
 			res := oop.inherit(runRes.lockAndBuild(), {
 				"workdir": runRes.outputs()[_FIELD_WORKDIR_OUT],
 				"options": buildOptions

package/dist/tengo/lib/feats.lib.tengo

@@ -97,5 +97,13 @@ export ll.toStrict({
 
 
 
-	multiStepProgress:        _isEnabled("multiStepProgress")
+	multiStepProgress:        _isEnabled("multiStepProgress"),
+
+
+	kvAsync:                  _isEnabled("kvAsync"),
+
+
+
+
+	optionalFieldsInSchemas:  _isEnabled("optionalFieldsInSchemas") || _isEnabled("optionalServiceField")
 })

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,

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()
 
 

package/dist/tengo/lib/workflow.column-value.lib.tengo

@@ -0,0 +1,118 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+json := import("json")
+text := import("text")
+
+_parseColumnValueId := undefined // Forward declaration
+
+
+
+
+
+
+
+
+isColumnValueId := func(s) {
+	return !is_undefined(_parseColumnValueId(s))
+}
+
+
+
+
+
+
+
+
+valueOf := func(x) {
+	key := _parseColumnValueId(x)
+	if is_undefined(key) {
+		return x
+	}
+
+	value := key.value
+	ll.assert(is_string(value), "column-value: value of a column value id must be a string, got %v", value)
+	return value
+}
+
+
+
+
+
+
+
+valuesOf := func(xs) {
+	ll.assert(is_array(xs) || is_immutable_array(xs), "column-value.valuesOf: expected an array, got %v", xs)
+
+	result := []
+	for x in xs {
+		result = append(result, valueOf(x))
+	}
+	return result
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+_parseColumnValueId = func(s) {
+	if !is_string(s) {
+		return undefined
+	}
+
+	current := s
+	for {
+		if !text.has_prefix(current, "{") && !text.has_prefix(current, "\"") {
+			return undefined
+		}
+
+		decoded := json.decode(current)
+		if is_error(decoded) {
+			return undefined
+		}
+
+		if is_string(decoded) {
+			if len(decoded) >= len(current) {
+				return undefined
+			}
+			current = decoded
+			continue
+		}
+
+		if !is_map(decoded) || decoded.__isColumnValue != true {
+			return undefined
+		}
+		return decoded
+	}
+}
+
+export ll.toStrict({
+	isColumnValueId: isColumnValueId,
+	valueOf: valueOf,
+	valuesOf: valuesOf
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "6.18.0",
+  "version": "6.20.0",
   "description": "Tengo SDK library",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -23,7 +23,7 @@
     "@platforma-open/milaboratories.software-ptexter": "1.2.6"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "4.1.15"
+    "@platforma-sdk/tengo-builder": "4.1.16"
   },
   "repository": {
     "type": "git",