@platforma-sdk/workflow-tengo 4.7.0 → 4.7.1

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

@@ -37,5 +37,6 @@ export ll.toStrict({
 	pureFutureFields:           _isEnabled("pureFutureFields")   || _api >= 1, // 'pure' future fields magic that provides deduplication
 	commandExpressions:         _isEnabled("commandExpressions") || _api >= 2, // rich expressions in command arguments ( {{ system.ram_bytes / 20 }} )
 	workdirLimits:              _isEnabled("workdirLimits")      || _api >= 4, // workdir storage controller can limit concurrency
-	computeLimits:              _isEnabled("computeLimits")                    // runner can plan CPU and RAM
+	computeLimits:              _isEnabled("computeLimits"),                   // runner can plan CPU and RAM
+	resourceDuplicateEvent:     false                                          // template can subscribe to ResourceDuplicate event
 })

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

@@ -685,6 +685,22 @@ resource = func(r) {
 
 
 
+		createDynamicField: func(name) {
+			if is_bytes(name) {
+				name = string(name)
+			}
+			ll.assert(is_string(name) && name != "", "field name must be a non-empty string")
+			fid := ll.fieldId(self.id, name)
+			tx.createField(fid, constants.FTYPE_DYNAMIC)
+			return field(fid)
+		},
+
+
+
+
+
+
+
 
 		kvGet: func(key) {
 			return tx.resourceKeyValueGet(self.id, key)

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

@@ -102,7 +102,8 @@ AWAIT_TEMPLATES := {
 	"PColumnBundleWithPartitions": [
 		[{ wildcard: "*" }, { match: "^ref$" }, "ResourceReady"], // optional ref field
 		[{ wildcard: "*" }, "spec", "ResourceReady"],
-		[{ wildcard: "*" }, "data", "InputsLocked"]
+		[{ wildcard: "*" }, "data", "InputsLocked"],
+		[{ wildcard: "*" }, "data", { match: "^\\{.*\\}$" }, "InputsLocked"] // for multi-hit BQuery results; key is always ref
 	]
 }
 
@@ -568,7 +569,7 @@ tpl := func(ops) {
 			if _hasPrepared {
 				_stateRequests = append(_stateRequests, {
 					path: [tplutil.PREPARE_MAP_FIELD_NAME],
-					state: "ResourceReady"
+					state: "Final"
 				})
 			}
 

package/dist/tengo/lib/tpl.state-await.lib.tengo

@@ -7,6 +7,9 @@ tx := import("tx")
 ll := import("@platforma-sdk/workflow-tengo:ll")
 text := import("text")
 regexp := import("@platforma-sdk/workflow-tengo:regexp")
+smart := import("@platforma-sdk/workflow-tengo:smart")
+maps := import("@platforma-sdk/workflow-tengo:maps")
+feats := import("@platforma-sdk/workflow-tengo:feats")
 
 createContext := func() {
 	return {
@@ -15,6 +18,9 @@ createContext := func() {
 	}
 }
 
+
+RTYPE_AWAITER := { Name: "awaiter", Version: "1" }
+
 awaitOneState := func(field, path, state) {
 	if field.isErrorSet() && !field.isValueSet() {
 
@@ -51,9 +57,6 @@ awaitOneState := func(field, path, state) {
 					subscriptions: [{
 						resource: resource.id,
 						event: "FieldCreated"
-					},{
-						resource: resource.id,
-						event: "InputsLocked"
 					}]
 				}
 			}
@@ -93,19 +96,19 @@ awaitOneState := func(field, path, state) {
 			}
 
 			subscriptions := []
-			for nextFieldName, nextField in resource.inputs() {
+			maps.forEach(resource.inputs(), func(nextFieldName, nextField) {
 				if !matcher(nextFieldName) {
-					continue
+					return
 				}
 				res := awaitOneState(nextField, rPath, state)
 				if res.type == "Ready" {
-					continue
+					return
 				} else if res.type == "Subscribe" {
 					subscriptions = append(subscriptions, res.subscriptions...)
 				} else {
 					ll.panic("Unknown result type: %v", res.type)
 				}
-			}
+			})
 			if len(subscriptions) == 0 {
 				return { type: "Ready" }
 			} else {
@@ -157,7 +160,7 @@ awaitOneState := func(field, path, state) {
 						}]
 					}
 				}
-			} else if state == "ResourceReady" {
+			} else if state == "ResourceReady" || state == "Final" {
 
 
 				if resource.isFinal() {
@@ -167,7 +170,7 @@ awaitOneState := func(field, path, state) {
 						type: "Subscribe",
 						subscriptions: [{
 							resource: resource.id,
-							event: "ResourceReady"
+							event: "Final" // will also effectively subscribe to ResourceDuplicate and ResourceError
 						}]
 					}
 				}
@@ -178,19 +181,21 @@ awaitOneState := func(field, path, state) {
 	}
 }
 
+_renderer := smart.resource(ll.getCurrentTemplateRenderer())
+
 
 await := func(rootField, ctxStorageResource, requests) {
 	pssKey := "await:" + string(rootField.id.ResourceID) + ":" + rootField.id.Name
 	prevSubscriptions := ctxStorageResource.kvGetAsJson(pssKey)
 
-	if !is_undefined(prevSubscriptions) && len(prevSubscriptions) == 0 {
+	lastSubscriptionKey := undefined
+	if !is_undefined(prevSubscriptions) {
+		if is_undefined(prevSubscriptions.lastSubscriptionKey) {
 
-		ll.panic("Unexpected state, desired state was reached in the previous call")
-	}
-
-	if is_undefined(prevSubscriptions) {
-
-		prevSubscriptions = {}
+			ll.panic("Unexpected state, desired state was reached in the previous call")
+		} else {
+			lastSubscriptionKey = prevSubscriptions.lastSubscriptionKey
+		}
 	}
 
 	subscriptions := {}
@@ -222,34 +227,88 @@ await := func(rootField, ctxStorageResource, requests) {
 	}
 
 
-	for key, sub in subscriptions {
-		if !is_undefined(prevSubscriptions[key]) {
 
-			continue
+
+
+
+
+
+
+	firstSubscriptionKey := undefined
+	firstSubscription := undefined
+	lastSubscriptionKeyPresent := false
+	maps.forEach(subscriptions, func(key, sub) {
+		if is_undefined(firstSubscriptionKey) {
+			firstSubscriptionKey = key
+			firstSubscription = sub
 		}
-		e := {}
-		e[sub.event] = true
-		tx.subscribeTo(sub.resource, pssKey + ":" + key, e)
+		if !is_undefined(lastSubscriptionKey) && lastSubscriptionKey == key {
+			lastSubscriptionKeyPresent = true
+		}
+	})
+
+
+
+	if lastSubscriptionKeyPresent {
+		return false
 	}
 
 
-	for key, _ in prevSubscriptions {
-		if !is_undefined(subscriptions[key]) {
+	if !is_undefined(firstSubscriptionKey) {
 
-			continue
+		fullEventId := pssKey + ":" + firstSubscriptionKey
+		targetResource := firstSubscription.resource
+		targetEvents := [firstSubscription.event]
+
+		if firstSubscription.event == "Final" { // special case
+			if !feats.resourceDuplicateEvent {
+
+
+
+
+
+
+				target := smart.resource(targetResource)
+				isEphemeral := target.info().Features.ephemeral
+				if !isEphemeral { // doing proxy-object workaround for pure resources only
+					awaiterBuilder := smart.ephemeralBuilder(RTYPE_AWAITER)
+					awaiterBuilder.createInputField("target").set(target)
+					awaiter := awaiterBuilder.lockAndBuild()
+					_renderer.createDynamicField("tmp:" + fullEventId).set(awaiter)
+					targetResource = awaiter.info().ID // converting to global resource id; this is a hack to overcome the fact that tx.subscribeTo can't work with local ids
+				}
+				targetEvents = ["ResourceReady", "ResourceError"]
+
+			} else {
+				targetEvents = ["ResourceReady", "ResourceError", "ResourceDuplicate"]
+			}
+		} else if firstSubscription.event == "FieldCreated" { // another special case
+
+			targetEvents = ["FieldCreated", "InputsLocked"]
 		}
-		tx.unsubscribeFrom(pssKey + ":" + key)
+
+		e := {}
+		for event in targetEvents {
+			e[event] = true
+		}
+		tx.subscribeTo(targetResource, fullEventId, e)
+
+	}
+
+
+	if !is_undefined(lastSubscriptionKey) {
+		tx.unsubscribeFrom(pssKey + ":" + lastSubscriptionKey)
 	}
 
 
 	newPrevSubscriptions := {}
-	for key, _ in subscriptions {
-		newPrevSubscriptions[key] = true
+	if !is_undefined(firstSubscriptionKey) {
+		newPrevSubscriptions.lastSubscriptionKey = firstSubscriptionKey
 	}
 
 	ctxStorageResource.kvSetJson(pssKey, newPrevSubscriptions)
 
-	return len(subscriptions) == 0
+	return is_undefined(firstSubscriptionKey)
 }
 
 export ll.toStrict({

package/package.json

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