@platforma-sdk/workflow-tengo 4.7.0 → 4.7.2

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

@@ -37,5 +37,11 @@ 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
+
+
+
+
+
+	fullFeaturedApi:        _isEnabled("fullFeaturedAPI")
 })

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

@@ -289,10 +289,137 @@ parseUrl := func(url) {
 
 
 
+
+
 getCtx := func() {
+	if methodExists(plapi, "getPersistentCtx") {
+		return plapi.getPersistentCtx()
+	}
+
+
+	return plapi.getCtx()
+}
+
+
+
+
+
+getPersistentCtx := func() {
+	if methodExists(plapi, "getPersistentCtx") {
+		return plapi.getPersistentCtx()
+	}
+
+
 	return plapi.getCtx()
 }
 
+
+
+
+
+
+
+
+
+
+
+getExecutionCtx := func() {
+	assert(methodExists(plapi, "getExecutionCtx"), "ll.getExecutionCtx: method does not exists in this backend instance.")
+	return plapi.getExecutionCtx()
+}
+
+
+
+
+
+
+
+moduleVars := func(moduleName) {
+	assert(is_string(moduleName), "ll.moduleVars: moduleName must be a string")
+
+	name := "module/" + moduleName
+
+	ctx := getExecutionCtx()
+	if is_undefined(ctx[name]) {
+		ctx[name] = {}
+	}
+
+	return {
+		get: func(k) {
+			return ctx[name][k]
+		},
+
+		set: func(k, v) {
+			ctx[name][k] = v
+		}
+	}
+}
+
+
+
+
+sha256Encode := func(b) {
+	assert(methodExists(plapi, "sha256Encode"), "ll.sha256Encode: method does not exists in this backend instance.")
+	return plapi.sha256Encode(b)
+}
+
+
+
+
+gzipEncode := func(b) {
+	assert(methodExists(plapi, "gzipEncode"), "ll.gzipEncode: method does not exists in this backend instance.")
+	return plapi.gzipEncode(b)
+}
+
+
+
+
+gzipDecode := func(b) {
+	assert(methodExists(plapi, "gzipDecode"), "ll.gzipDecode: method does not exists in this backend instance.")
+	return plapi.gzipDecode(b)
+}
+
+
+
+
+base32Encode := func(b) {
+	assert(methodExists(plapi, "base32Encode"), "ll.base32Encode: method does not exists in this backend instance.")
+	return plapi.base32Encode(b)
+}
+
+
+
+
+
+
+
+
+base32HexEncode := func(b) {
+	assert(methodExists(plapi, "base32HexEncode"), "ll.base32HexEncode: method does not exists in this backend instance.")
+	return plapi.base32HexEncode(b)
+}
+
+
+
+
+base32Decode := func(s) {
+	assert(methodExists(plapi, "base32Decode"), "ll.base32Decode: method does not exists in this backend instance.")
+	return plapi.base32Decode(s)
+}
+
+
+
+
+
+
+
+
+base32HexDecode := func(s) {
+	assert(methodExists(plapi, "base32HexDecode"), "ll.base32HexDecode: method does not exists in this backend instance.")
+	return plapi.base32HexDecode(s)
+}
+
+
 export toStrict({
 	apiVersion: apiVersion,
 	print: print,
@@ -315,5 +442,15 @@ export toStrict({
 	pathSeparator: pathSeparator,
 	filepathCanonize: filepathCanonize,
 	parseUrl: parseUrl,
-	getCtx: getCtx
+	getCtx: getCtx,
+	getPersistentCtx: getPersistentCtx,
+	getExecutionCtx: getExecutionCtx,
+	moduleVars: moduleVars,
+	sha256Encode: sha256Encode,
+	gzipEncode: gzipEncode,
+	gzipDecode: gzipDecode,
+	base32Encode: base32Encode,
+	base32HexEncode: base32HexEncode,
+	base32Decode: base32Decode,
+	base32HexDecode: base32HexDecode
 })

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

@@ -362,6 +362,13 @@ resource = func(r) {
 
 
 
+
+
+
+
+
+
+
 
 
 
@@ -390,7 +397,14 @@ resource = func(r) {
 
 
 		isFinal: func() {
-			return self.info().ResourceReady || self.info().IsDuplicate || self.info().HasErrors
+
+			if false  {
+				return self.info().IsFinal
+			}
+
+			info := self.info()
+
+			return info.ResourceReady || info.IsDuplicate || info.HasErrors
 		},
 
 		isEphemeral: func() {
@@ -685,6 +699,24 @@ 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)
@@ -696,6 +728,17 @@ resource = func(r) {
 
 
 
+		kvGetFlag: func(key) {
+			ll.assert(feats.fullFeaturedApi, "smart.resource.kvGetFlag: the feature is not available on older backends. Please, update the backend.")
+			return tx.resourceKeyValueGetFlag(self.id, key)
+		},
+
+
+
+
+
+
+
 
 		kvSet: func(key, value) {
 			tx.resourceKeyValueSet(self.id, key, value)
@@ -707,6 +750,17 @@ resource = func(r) {
 
 
 
+		kvSetFlag: func(key, flag) {
+			ll.assert(feats.fullFeaturedApi, "smart.resource.kvSetFlag: the feature is not available on older backends. Please, update the backend.")
+			tx.resourceKeyValueSetFlag(self.id, key, flag)
+		},
+
+
+
+
+
+
+
 
 		kvGetAsString: func(key) {
 			value := tx.resourceKeyValueGet(self.id, key)
@@ -1092,6 +1146,22 @@ field = func(f) {
 
 		buildFutureField: func(nameOrPath) {
 			return _buildFutureField(strictSelf, nameOrPath)
+		},
+
+
+
+
+		reset: func() {
+			ll.assert(feats.fullFeaturedApi, "smart.field.reset: the feature is not available on older backends. Please, update the backend.")
+			tx.resetField(self.id)
+		},
+
+
+
+
+		remove: func() {
+			ll.assert(feats.fullFeaturedApi, "smart.field.remove: the feature is not available on older backends. Please, update the backend.")
+			tx.removeField(self.id)
 		}
 	}
 

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.fullFeaturedApi {
+
+
+
+
+
+
+				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.2",
   "description": "Tengo SDK library",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -21,7 +21,7 @@
     "@platforma-open/milaboratories.software-ptabler": "1.6.0"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "^2.1.6"
+    "@platforma-sdk/tengo-builder": "^2.1.8"
   },
   "scripts": {
     "type-check": "pl-tengo check",