@platforma-sdk/workflow-tengo 5.17.0 → 5.19.0

package/dist/tengo/lib/pframes.spec.lib.tengo

@@ -70,6 +70,8 @@ D_BLOCK := "pl7.app/block"
 
 A_LABEL := "pl7.app/label"
 
+A_IS_LINKER_COLUMN := "pl7.app/isLinkerColumn"
+
 
 
 
@@ -424,8 +426,17 @@ createSpecDistiller := func(specs) {
 	distillEntity := func(entity, entityName) {
 		result := maps.clone(entity)
 
+
+
 		if !is_undefined(result.annotations) {
-			delete(result, "annotations")
+			linkerVal := result.annotations[A_IS_LINKER_COLUMN]
+			if is_undefined(linkerVal) {
+				delete(result, "annotations")
+			} else {
+				keptAnnotations := {}
+				keptAnnotations[A_IS_LINKER_COLUMN] = linkerVal
+				result.annotations = keptAnnotations
+			}
 		}
 
 

package/dist/tengo/lib/pframes.table-builder.lib.tengo

@@ -28,6 +28,7 @@
 
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
+json := import("json")
 render := import("@platforma-sdk/workflow-tengo:render")
 assets := import("@platforma-sdk/workflow-tengo:assets")
 maps := import("@platforma-sdk/workflow-tengo:maps")
@@ -82,6 +83,42 @@ isPrimaryRef := func(value) {
 	return ll.isMap(value) && value.__isPrimaryRef == "v1"
 }
 
+isEnrichmentRef := func(value) {
+	return ll.isMap(value) && value.__isEnrichment == "v1"
+}
+
+
+
+isLabeledEnrichment := func(value) {
+	return ll.isMap(value) &&
+		is_string(value.label) &&
+		isEnrichmentRef(value.ref)
+}
+
+decodeGlobalPObjectId := func(id) {
+	ll.assert(is_string(id),
+		"expected PObjectId string, got %v", id)
+	decoded := json.decode(id)
+	ll.assert(ll.isMap(decoded) && is_string(decoded.blockId) && is_string(decoded.name),
+		"EnrichmentRef id is not a global PlRef; local-form ids must be " +
+		"pre-resolved to {spec, data} on the model side. Got: %v", decoded)
+	return { __isRef: true, blockId: decoded.blockId, name: decoded.name }
+}
+
+
+enrichmentStepColumn := func(step) {
+	ll.assert(step.type == "linker",
+		"unsupported enrichment step type %q (only \"linker\" is allowed)", step.type)
+	ll.assert(!is_undefined(step.linker),
+		"linker step missing 'linker' field: %v", step)
+	return step.linker
+}
+
+
+isQuerySpec := func(q) {
+	return !isUnresolved(q) && !isResolvedColumn(q) && !isEnrichmentRef(q)
+}
+
 
 
 
@@ -163,7 +200,7 @@ tableBuilder := func(format, ...ctxArg) {
 			if len(opts) > 0 && ll.isMap(opts[0]) {
 				header = opts[0].header
 			}
-			if isUnresolved(query) {
+			if isUnresolved(query) || isEnrichmentRef(query) {
 				_hasUnresolved = true
 			}
 			_columns = append(_columns, {
@@ -191,21 +228,39 @@ tableBuilder := func(format, ...ctxArg) {
 			}
 
 
+
 			if is_array(query) {
 				for col in query {
-					ll.assert(isResolvedColumn(col),
-						"array elements must be resolved columns {spec, data}")
+					ll.assert(isResolvedColumn(col) || isEnrichmentRef(col) || isLabeledEnrichment(col),
+						"array elements must be resolved columns {spec, data}, EnrichmentRefs, " +
+						"or labeled enrichments {ref, label}; got: %v", col)
+
+					entryQuery := col
+					entryHeader := undefined
+					entryPrefix := headerPrefix
+					entrySuffix := headerSuffix
+					if isLabeledEnrichment(col) {
+						entryQuery = col.ref
+						entryHeader = col.label
+						entryPrefix = undefined
+						entrySuffix = undefined
+					}
+
+					if isUnresolved(entryQuery) || isEnrichmentRef(entryQuery) {
+						_hasUnresolved = true
+					}
 					_columns = append(_columns, {
-						query: col,
-						headerPrefix: headerPrefix,
-						headerSuffix: headerSuffix,
+						query: entryQuery,
+						header: entryHeader,
+						headerPrefix: entryPrefix,
+						headerSuffix: entrySuffix,
 						mode: "multi"
 					})
 				}
 				return self
 			}
 
-			if isUnresolved(query) {
+			if isUnresolved(query) || isEnrichmentRef(query) {
 				_hasUnresolved = true
 			}
 			_columns = append(_columns, {
@@ -273,9 +328,6 @@ tableBuilder := func(format, ...ctxArg) {
 
 
 
-
-
-
 		cacheInputs: func(time) {
 			ll.assert(is_int(time),
 				"time must be an integer duration " +
@@ -296,7 +348,7 @@ tableBuilder := func(format, ...ctxArg) {
 
 			hasQuerySpec := false
 			for _, c in _columns {
-				if !isUnresolved(c.query) && !isResolvedColumn(c.query) {
+				if isQuerySpec(c.query) {
 					hasQuerySpec = true
 					break
 				}
@@ -308,7 +360,16 @@ tableBuilder := func(format, ...ctxArg) {
 			}
 
 
+
 			resolveColumn := func(value) {
+				if is_string(value) {
+					ref := decodeGlobalPObjectId(value)
+					r := bquery.resolve(ref, _ctx)
+					return {
+						spec: r.getFutureInputField("spec"),
+						data: r.getFutureInputField("data")
+					}
+				}
 				if isUnresolved(value) {
 					r := bquery.resolve(value, _ctx)
 					return {
@@ -323,8 +384,6 @@ tableBuilder := func(format, ...ctxArg) {
 
 
 
-
-
 			primaryEntries := []
 			primaryPlRefs := {}
 			for _, p in _primaries {
@@ -363,13 +422,11 @@ tableBuilder := func(format, ...ctxArg) {
 
 
 
-
-
 			singleQueryByIdx := {}
 			multiQueryResultByIdx := {}
 			qMap := {}
 			for idx, c in _columns {
-				if !isUnresolved(c.query) && !isResolvedColumn(c.query) {
+				if isQuerySpec(c.query) {
 					strategy := "expectSingle"
 					if c.mode == "multi" { strategy = "expectMultiple" }
 					qMap["q" + string(idx)] = maps.deepMerge(c.query, {
@@ -384,7 +441,7 @@ tableBuilder := func(format, ...ctxArg) {
 
 				qResult := bquery.anchoredQuery(_ctx, primaryPlRefs, qMap)
 				for idx, c in _columns {
-					if !isUnresolved(c.query) && !isResolvedColumn(c.query) {
+					if isQuerySpec(c.query) {
 						r := qResult.getResult("q" + string(idx))
 						if c.mode == "multi" {
 
@@ -402,6 +459,7 @@ tableBuilder := func(format, ...ctxArg) {
 
 
 
+
 			columnEntries := []
 			for idx, c in _columns {
 				entry := {
@@ -410,7 +468,26 @@ tableBuilder := func(format, ...ctxArg) {
 					headerPrefix: c.headerPrefix,
 					headerSuffix: c.headerSuffix
 				}
-				if isResolvedColumn(c.query) {
+				if isEnrichmentRef(c.query) {
+					resolvedHit := resolveColumn(c.query.hit)
+					entry.spec = resolvedHit.spec
+					entry.data = resolvedHit.data
+					steps := []
+					if !is_undefined(c.query.path) {
+						for _, step in c.query.path {
+							resolvedStep := resolveColumn(enrichmentStepColumn(step))
+							steps = append(steps, {
+								type: step.type,
+								spec: resolvedStep.spec,
+								data: resolvedStep.data
+							})
+						}
+					}
+					entry.path = steps
+					if !is_undefined(c.query.qualifications) && len(c.query.qualifications) > 0 {
+						entry.qualifications = c.query.qualifications
+					}
+				} else if isResolvedColumn(c.query) {
 					entry.spec = c.query.spec
 					entry.data = c.query.data
 				} else if isUnresolved(c.query) {
@@ -431,7 +508,6 @@ tableBuilder := func(format, ...ctxArg) {
 
 
 
-
 			primariesMap := {}
 			for idx, p in primaryEntries {
 				entry := {
@@ -461,6 +537,23 @@ tableBuilder := func(format, ...ctxArg) {
 					entry.spec = c.spec
 					entry.data = c.data
 				}
+				if !is_undefined(c.path) && len(c.path) > 0 {
+
+
+					steps := {}
+					for stepIdx, step in c.path {
+						steps[string(stepIdx)] = {
+							type: step.type,
+							spec: step.spec,
+							data: step.data
+						}
+					}
+					entry.path = steps
+					entry.pathLength = len(c.path)
+				}
+				if !is_undefined(c.qualifications) && len(c.qualifications) > 0 {
+					entry.qualifications = c.qualifications
+				}
 				if !is_undefined(c.header) { entry.header = c.header }
 				if !is_undefined(c.headerPrefix) { entry.headerPrefix = c.headerPrefix }
 				if !is_undefined(c.headerSuffix) { entry.headerSuffix = c.headerSuffix }

package/dist/tengo/lib/pt.lib.tengo

@@ -278,12 +278,43 @@ p := ll.toStrict({
 		ll.assert(ll.isMap(linkerQuery) && linkerQuery.type == "column",
 			"linkerJoin: linker entry must be a plain p.column(...) result, got: %v", linkerQuery)
 
+
+
+		linkerSpec := linkerColumnEntry._getColumnsMap()[linkerQuery.column].spec
+		if ll.isMap(linkerSpec) {
+			annotations := linkerSpec.annotations
+			isLinker := ll.isMap(annotations) && annotations[pframesSpec.A_IS_LINKER_COLUMN] == "true"
+			ll.assert(isLinker,
+				"linkerJoin: linker column %q must carry annotation %q == \"true\", got spec: %v",
+				linkerQuery.column, pframesSpec.A_IS_LINKER_COLUMN, linkerSpec)
+		}
+
 		merged := _mergePEntries([linkerColumnEntry, secondaryEntry])
 		return _newPEntry(merged.columns, {
 			type: "linkerJoin",
 			linker: { column: linkerQuery.column },
 			secondary: [_asJoinEntry(merged.specQueries[1])]
 		})
+	},
+
+
+
+
+
+
+
+
+
+
+
+	_rawQueryEntry: func(columnsByName, joinEntry) {
+		ll.assert(ll.isMap(columnsByName), "columnsByName must be a map")
+		ll.assert(ll.isMap(joinEntry) && !is_undefined(joinEntry.entry),
+			"joinEntry must be a SpecQueryJoinEntry { entry, qualifications? }, got: %v", joinEntry)
+		for name, info in columnsByName {
+			_validateColumn(name, info)
+		}
+		return _newPEntry(columnsByName, joinEntry.entry)
 	}
 })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "5.17.0",
+  "version": "5.19.0",
   "description": "Tengo SDK library",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -18,11 +18,11 @@
   "dependencies": {
     "@milaboratories/software-pframes-conv": "2.2.9",
     "@platforma-open/milaboratories.software-small-binaries": "^2.0.3",
-    "@platforma-open/milaboratories.software-ptabler": "1.16.0",
+    "@platforma-open/milaboratories.software-ptabler": "1.16.1",
     "@platforma-open/milaboratories.software-ptexter": "1.2.2"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "2.5.18"
+    "@platforma-sdk/tengo-builder": "2.5.20"
   },
   "scripts": {
     "type-check": "pl-tengo check",