@platforma-sdk/workflow-tengo 6.19.0 → 6.21.0

package/dist/tengo/lib/anonymize.impl.lib.tengo

@@ -1,6 +1,7 @@
 smart := import("@platforma-sdk/workflow-tengo:smart")
 ll := import("@platforma-sdk/workflow-tengo:ll")
 maps := import("@platforma-sdk/workflow-tengo:maps")
+canonicalIds := import("@platforma-sdk/workflow-tengo:ll.canonical-id")
 
 
 
@@ -109,7 +110,11 @@ anonymizeFields := func(targets, ...opts) {
 
 			groupId := groupBy(fieldName)
 			value := field.getValue()
-			cid := value.info().CanonicalID
+
+
+
+
+			cid := canonicalIds.get(value)
 
 			if is_undefined(groupCIDs[groupId]) {
 				groupCIDs[groupId] = bytes(0)

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

@@ -100,6 +100,15 @@ export ll.toStrict({
 	multiStepProgress:        _isEnabled("multiStepProgress"),
 
 
+
+
+
+
+	canonicalIdExposure:      _isEnabled("canonicalIDExposure") ||
+		_isEnabled("supportsScratchSpaceRequests") ||
+		_isEnabled("scratchSpace"),
+
+
 	kvAsync:                  _isEnabled("kvAsync"),
 
 

package/dist/tengo/lib/ll.canonical-id.lib.tengo

@@ -0,0 +1,194 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+maps := import("@platforma-sdk/workflow-tengo:maps")
+smart := import("@platforma-sdk/workflow-tengo:smart")
+plapi := import("plapi")
+hex := import("hex")
+
+_HEX_DIGITS := "0123456789abcdef"
+
+
+_CID_SIZE := 16
+
+
+
+
+
+
+
+_cache := undefined
+
+
+
+
+
+
+
+
+isSet := func(cid) {
+	if is_undefined(cid) {
+		return false
+	}
+
+	for b in cid {
+		if b != 0 {
+			return true
+		}
+	}
+
+	return false
+}
+
+
+
+
+_string8 := func(s) {
+	b := bytes(s)
+	n := len(b)
+	if n > 255 {
+		ll.panic("canonical ID: string is longer than 255 bytes: %v", s)
+	}
+
+	return hex.decode(_HEX_DIGITS[n / 16:n / 16 + 1] + _HEX_DIGITS[n % 16:n % 16 + 1]) + b
+}
+
+_hash := func(rid, data) {
+	if !ll.methodExists(plapi, "sha256Encode") {
+		ll.panic("canonical ID of resource %v is not available, and this backend cannot calculate it. " +
+			"Update the Platforma backend to v1.34.0 or later", rid)
+	}
+
+	return plapi.sha256Encode(data)[0:_CID_SIZE]
+}
+
+get := undefined
+
+
+
+
+
+
+
+
+
+_calculate := func(rid, info, inputCid) {
+	kind := info.Kind
+	buf := _string8(info.Type.Name) + _string8(info.Type.Version) + info.Data
+
+	if kind == "Value" || kind == "Singleton" {
+		return _hash(rid, buf)
+	}
+
+	if kind != "Structural" {
+		ll.panic("canonical ID: resource %v of kind %v has no canonical ID", rid, kind)
+	}
+
+	if maps.containsKey(info, "Features") && info.Features.ephemeral {
+		ll.panic("canonical ID: ephemeral resource %v has no canonical ID", rid)
+	}
+
+	if !info.InputsLocked {
+		ll.panic("canonical ID: cannot calculate the canonical ID of resource %v: its inputs are not locked", rid)
+	}
+
+	inputs := ll.fromStrict(info.Inputs)
+	for name in maps.getKeys(inputs) {
+		f := inputs[name]
+		if f.Error != 0 {
+			ll.panic("canonical ID: cannot calculate the canonical ID of resource %v: input %v has an error", rid, name)
+		}
+		if f.Value == 0 {
+			ll.panic("canonical ID: cannot calculate the canonical ID of resource %v: input %v has no value", rid, name)
+		}
+
+		buf += bytes(name) + inputCid(f.Value)
+	}
+
+	return _hash(rid, buf)
+}
+
+
+
+
+
+
+
+
+
+
+
+
+get = func(r) {
+	res := smart.resource(r)
+	key := string(res.id)
+
+	if is_undefined(_cache) {
+		_cache = ll.moduleVars("ll.canonical-id")
+	}
+
+	cached := _cache.get(key)
+	if !is_undefined(cached) {
+		return cached
+	}
+
+	info := res.info()
+	cid := undefined
+	if maps.containsKey(info, "CanonicalID") {
+		cid = info.CanonicalID
+	}
+
+	if !isSet(cid) {
+		cid = _calculate(res.id, info, get)
+	}
+
+	_cache.set(key, cid)
+	return cid
+}
+
+
+
+
+
+
+
+
+calculate := func(r) {
+	res := smart.resource(r)
+	return _calculate(res.id, res.info(), get)
+}
+
+export ll.toStrict({
+	isSet: isSet,
+	get: get,
+	calculate: calculate,
+
+
+	_calculate: _calculate
+})

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

@@ -322,6 +322,8 @@ getPersistentCtx := func() {
 
 
 
+
+
 getExecutionCtx := func() {
 	assert(methodExists(plapi, "getExecutionCtx"), "ll.getExecutionCtx: method does not exists in this backend instance.")
 	return plapi.getExecutionCtx()

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

@@ -9,6 +9,8 @@ tplutil := import("@platforma-sdk/workflow-tengo:tpl.util")
 constants := import("@platforma-sdk/workflow-tengo:constants")
 stateAwait := import("@platforma-sdk/workflow-tengo:tpl.state-await")
 validation := import("@platforma-sdk/workflow-tengo:validation")
+feats := import("@platforma-sdk/workflow-tengo:feats")
+canonicalIds := import("@platforma-sdk/workflow-tengo:ll.canonical-id")
 
 
 
@@ -171,6 +173,45 @@ tpl := func(ops) {
 		template: func() {
 			return smart.resource(_templateId)
 		},
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+		canonicalId: func() {
+			if _isEphemeral {
+				ll.panic("canonical ID is not available in ephemeral templates: renderer %v has type %v",
+					_renderer.id, _rendererType.Name)
+			}
+
+			if !feats.canonicalIdExposure {
+				return canonicalIds.get(_renderer)
+			}
+
+			cid := _renderer.info().CanonicalID
+			if !canonicalIds.isSet(cid) {
+				ll.panic("canonical ID of renderer %v is not set yet. Read it from the template body, not during initialization",
+					_renderer.id)
+			}
+
+			return cid
+		},
 
 		_unmarshallers: copy(ops.unmarshallers),
 
@@ -762,7 +803,8 @@ tpl := func(ops) {
 				delegate                : self.routeDelegate,
 				validateInputs          : self.validateInputs,
 				body                    : self.body,
-				template                : self.template
+				template                : self.template,
+				canonicalId             : self.canonicalId
 			})
 		}
 	}

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.19.0",
+  "version": "6.21.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.18"
   },
   "repository": {
     "type": "git",