@platforma-sdk/workflow-tengo 6.17.3 → 6.18.0

package/dist/tengo/lib/v2.workflow.lib.tengo

@@ -0,0 +1,281 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+text := import("text")
+smart := import("@platforma-sdk/workflow-tengo:smart")
+sets := import("@platforma-sdk/workflow-tengo:sets")
+oop := import("@platforma-sdk/workflow-tengo:oop")
+bquery := import("@platforma-sdk/workflow-tengo:v2.bquery")
+exports := import("@platforma-sdk/workflow-tengo:v2.exports")
+pBundle := import("@platforma-sdk/workflow-tengo:pframes.bundle")
+pTableBuilder := import("@platforma-sdk/workflow-tengo:pframes.table-builder")
+
+self := import("@platforma-sdk/workflow-tengo:tpl")
+
+_RESULT_OUTPUT := "result"
+_EXPORTS_OUTPUT := "exports"
+_INPUT_CONTEXT := "context"
+
+
+_PREPARED_INPUTS_PREFIX := "prepared/"
+
+
+
+self.defineOutputs([_RESULT_OUTPUT, _EXPORTS_OUTPUT])
+
+
+
+
+isProduction := func() {
+	return self.rawInputs().isProduction.getValueAsJson() == true
+}
+
+_args := undefined
+
+
+
+
+args := func() {
+	if is_undefined(_args) {
+		inputs := self.inputs()
+
+		_args = inputs.args
+		if is_undefined(_args) || smart.isReference(_args) {
+			ll.panic("Unexpected args type: %v", _args)
+		}
+
+		for k, v in inputs {
+			if text.has_prefix(k, _PREPARED_INPUTS_PREFIX) {
+				name := text.trim_prefix(k, _PREPARED_INPUTS_PREFIX)
+				ll.assert(is_undefined(_args[name]), "prepare name is already in use in inputs: %s", name)
+				_args[name] = v
+			}
+		}
+	}
+	return _args
+}
+
+_blockId := undefined
+
+
+
+
+blockId := func() {
+	if is_undefined(_blockId) {
+		_blockId = self.inputs().blockId
+		ll.assert(!is_undefined(_blockId), "block id is not set in workflow inputs")
+	}
+	return _blockId
+}
+
+
+
+
+getBlockId := func() {
+	ret := blockId().getDataAsJson()
+	ll.assert(is_string(ret), "block id is not a string")
+	return ret
+}
+
+_parentContext := undefined
+
+
+
+
+
+getParentBCtx := func() {
+	if is_undefined(_parentContext) {
+		_parentContext = self.inputs()[_INPUT_CONTEXT]
+		if is_undefined(_parentContext) {
+			ll.panic("parent context is not set in inputs")
+		}
+	}
+	return _parentContext
+}
+
+
+
+
+
+
+
+
+
+
+query := func(spec, ...options) {
+	return bquery.create(spec, getParentBCtx(), options...)
+}
+
+_resolveOne := func(r, ...options) {
+	res := bquery.resolve(r, getParentBCtx(), options...)
+	return ll.toStrict(oop.inherit(res, {
+		spec: res.getFutureInputField("spec"),
+		data: res.getFutureInputField("data")
+	}))
+}
+
+
+
+
+
+
+
+
+resolve := func(ref, ...options) {
+	return _resolveOne(ref, options...)
+}
+
+
+
+
+
+anchoredQuery := func(anchors, queryMap, ...opts) {
+	return bquery.anchoredQuery(getParentBCtx(), anchors, queryMap, opts...)
+}
+
+
+
+
+
+
+
+prepare := func(cb) {
+	self.prepare(func(_) {
+		raw := cb(args())
+		prefixed := {}
+		for k, v in raw {
+			prefixed[_PREPARED_INPUTS_PREFIX + k] = v
+		}
+		return prefixed
+	})
+}
+
+
+
+
+validateArgs := func(argsSchema) {
+	self.validateInputs({
+		args: argsSchema
+	})
+}
+
+
+
+
+
+createPBundleBuilder := func() {
+	return pBundle.createBuilderWith(bquery, getParentBCtx())
+}
+
+
+
+
+
+
+
+
+
+
+tableBuilder := func(format) {
+	return pTableBuilder.tableBuilderWith(bquery, format, getParentBCtx())
+}
+
+
+
+
+_assertOwnOutputs := func() {
+	defined := sets.fromSlice(self.definedOutputs())
+	if defined != sets.fromSlice([_RESULT_OUTPUT, _EXPORTS_OUTPUT]) {
+		ll.panic("a v2 workflow's outputs are exactly result and exports, but this template defines %v; " +
+			"is something it imports using @platforma-sdk/workflow-tengo:workflow?", sets.toSlice(defined))
+	}
+}
+
+_buildOutputs := func(results) {
+	ll.assert(ll.isMap(results) && !smart.isReference(results), "expected to see map result from body function")
+	ll.assert(
+		sets.fromSlice(["outputs", "exports"]) == sets.fromMapKeys(results),
+		"expected only outputs and exports in the returned map, found %v", sets.toSlice(sets.fromMapKeys(results))
+	)
+	ll.assert(ll.isMap(results.outputs) && !smart.isReference(results.outputs),
+		"expected a map in outputs returned from workflow.body")
+
+	exports.assertNode(results.exports, "exports")
+
+	resBuilder := smart.mapBuilder()
+	for name, value in results.outputs {
+		ll.assert(!is_undefined(value), "value is undefined for output %s", name)
+		resBuilder.add(name, value)
+	}
+
+	tplOutputs := {}
+	tplOutputs[_RESULT_OUTPUT] = resBuilder.build()
+	tplOutputs[_EXPORTS_OUTPUT] = results.exports
+	return tplOutputs
+}
+
+
+
+
+
+
+
+body := func(fn) {
+	_assertOwnOutputs()
+	self.body(func(_) {
+		return _buildOutputs(fn(args()))
+	})
+}
+
+export ll.toStrict({
+	getParentBCtx: getParentBCtx,
+	query: query,
+	resolve: resolve,
+	anchoredQuery: anchoredQuery,
+	prepare: prepare,
+	args: args,
+	rawInputs: self.rawInputs,
+	body: body,
+	isProduction: isProduction,
+	blockId: blockId,
+	getBlockId: getBlockId,
+	validateArgs: validateArgs,
+	createPBundleBuilder: createPBundleBuilder,
+	tableBuilder: tableBuilder
+})

package/dist/tengo/lib/workflow.bquery.lib.tengo

@@ -3,6 +3,7 @@ smart := import("@platforma-sdk/workflow-tengo:smart")
 maps := import("@platforma-sdk/workflow-tengo:maps")
 constants := import("@platforma-sdk/workflow-tengo:constants")
 json := import("json")
+text := import("text")
 assets := import("@platforma-sdk/workflow-tengo:assets")
 render := import("@platforma-sdk/workflow-tengo:render")
 validation := import("@platforma-sdk/workflow-tengo:validation")
@@ -13,6 +14,19 @@ queryAnchoredTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:workflo
 _CONTEXT_FIELD_NAME := "ctx"
 
 
+
+_FAMILIES := {
+	"1": {
+		single: constants.RTYPE_BRESOLVE_FIRST,
+		choice: constants.RTYPE_BRESOLVE_CHOICE
+	},
+	"2": {
+		single: { Name: "BResolveSingle", Version: "2" },
+		choice: { Name: "BResolveChoice", Version: "2" }
+	}
+}
+
+
 _OPTIONS_SCHEME := {
 	"spec,?": `bool`,
 	"data,?": `bool`,
@@ -113,9 +127,11 @@ _QUERY_MAP_SCHEMA := {
 
 
 
-create := func(spec, ctx, ...options) {
+_create := func(family, spec, ctx, options) {
+
 
 
+	types := _FAMILIES[string(family)]
 
 	ops := copy(_DEFAULT_OPTIONS)
 	if len(options) > 0 {
@@ -136,10 +152,10 @@ create := func(spec, ctx, ...options) {
 
 	builder := undefined
 	if ops.first {
-		builder = smart.ephemeralBuilder(constants.RTYPE_BRESOLVE_FIRST, query)
+		builder = smart.ephemeralBuilder(types.single, query)
 	} else {
 
-		builder = smart.ephemeralBuilder(constants.RTYPE_BRESOLVE_CHOICE, query)
+		builder = smart.ephemeralBuilder(types.choice, query)
 	}
 
 	builder.createInputField(_CONTEXT_FIELD_NAME).set(ctx)
@@ -151,6 +167,9 @@ create := func(spec, ctx, ...options) {
 	rb := smart.structBuilder(constants.RTYPE_QUERY_RESULT)
 
 
+	if family != 1 {
+		ops.family = family
+	}
 	rb.createInputField("ops").setJson(ops)
 
 	if ops.spec {
@@ -171,6 +190,19 @@ create := func(spec, ctx, ...options) {
 	return rb.lockAndBuild()
 }
 
+create := func(spec, ctx, ...options) {
+	return _create(1, spec, ctx, options)
+}
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -183,6 +215,28 @@ resultUnmarshaller := func() {
 		parse: func(resource, parser)  {
 
 			ops := resource.get("ops").getDataAsJson()
+			isFamily2 := ops.family == 2
+
+
+			isNR := func(r) {
+				return r.info().Type.Name == constants.RTYPE_BRESOLVE_NO_RESULT.Name
+			}
+
+
+			isNoResultField := func(field) {
+				return field.isSet() && !field.isErrorSet() &&
+					field.getValue().checkResourceType(constants.RTYPE_BRESOLVE_NO_RESULT)
+			}
+
+
+			decodeRef := func(address) {
+				if !isFamily2 {
+					return address
+				}
+				parts := text.split_n(address.blockId, "/", 2)
+				ll.assert(len(parts) == 2, "unexpected address of a family-2 value: %v", address)
+				return { block: parts[0], workflow: parts[1], name: address.name }
+			}
 
 
 
@@ -200,22 +254,19 @@ resultUnmarshaller := func() {
 			if ops.first {
 
 
-
-				isNR := func(r) {
-					return r.info().Type.Name == constants.RTYPE_BRESOLVE_NO_RESULT.Name
-				}
-
 				if isNR(resource.get("ref")) {
 					return undefined
 				}
 
 				result := {
-					ref: resource.get("ref").getDataAsJson(),
+					ref: decodeRef(resource.get("ref").getDataAsJson()),
 					spec: resource.get("spec").getDataAsJson()
 				}
 
 				if resource.hasInputField("data") {
-					result.data = getData(resource, "data")
+					if !isFamily2 || !isNoResultField(resource.getField("data")) {
+						result.data = getData(resource, "data")
+					}
 				}
 
 				return ll.toStrict(result)
@@ -231,13 +282,18 @@ resultUnmarshaller := func() {
 				result := []
 				maps.forEach(specs, func(ref, s) {
 					r := {
-						ref: json.decode(ref),
+						ref: decodeRef(json.decode(ref)),
 						spec: s.getValueAsJson()
 					}
 
 
+
 					if !is_undefined(datas) {
-						r.data = getData(datas, ref)
+						if !isFamily2 {
+							r.data = getData(datas, ref)
+						} else if datas.hasInputField(ref) && !isNoResultField(datas.getField(ref)) {
+							r.data = getData(datas, ref)
+						}
 					}
 
 					result = append(result, ll.toStrict(r))
@@ -262,23 +318,86 @@ resultUnmarshaller := func() {
 
 
 
-resolve := func(ref, ctx, ...options) {
+_FAMILY2_REF_FIELDS := ["block", "workflow", "name"]
+
+
+
+_isFamily2Ref := func(value) {
+	if !ll.isMap(value) || smart.isReference(value) || len(value) != len(_FAMILY2_REF_FIELDS) {
+		return false
+	}
+	for f in _FAMILY2_REF_FIELDS {
+		if !maps.containsKey(value, f) || !is_string(value[f]) || value[f] == "" {
+			return false
+		}
+	}
+	return !text.contains(value.block, "/") && !text.contains(value.workflow, "/")
+}
+
+_assertFamily2Ref := func(ref) {
+	if !_isFamily2Ref(ref) {
+		ll.panic("a ref is {block, workflow, name}: three non-empty strings, block and workflow without \"/\"; got %v", ref)
+	}
+}
+
+
+
+_family2Options := func(options, allowed) {
+	ll.assert(len(options) <= 1, "expected at most one options map, got %v", options)
+	if len(options) == 0 {
+		return {}
+	}
+	o := options[0]
+	ll.assert(ll.isMap(o) && !smart.isReference(o), "expected a map of options, got %v", o)
+	for k, v in o {
+		ok := false
+		for a in allowed {
+			if a == k {
+				ok = true
+			}
+		}
+		if !ok {
+			ll.panic("query option %q is not allowed in the v2 query API; allowed: %v", k, allowed)
+		}
+		ll.assert(is_bool(v), "query option %q must be a boolean, got %v", k, v)
+	}
+	return copy(o)
+}
+
+_resolve := func(family, ref, ctx, options) {
 
-	spec := {
-		type: "Direct",
-		block_id: ref.blockId, 	// @TODO use consistent naming in pl
-		output_name: ref.name 	// @TODO use consistent naming in pl
+	spec := undefined
+	if family == 2 {
+		_assertFamily2Ref(ref)
+		spec = {
+			type: "Direct",
+			block_id: ref.block + "/" + ref.workflow,
+			output_name: ref.name
+		}
+	} else {
+		spec = {
+			type: "Direct",
+			block_id: ref.blockId, 	// @TODO use consistent naming in pl
+			output_name: ref.name 	// @TODO use consistent naming in pl
+		}
 	}
 
 	ops := {}
 
 	if len(options) > 0 {
-		ops = options[0]
+		ops = copy(options[0])
 	}
 
 	ops.first = true
+	if family == 2 {
+		ops.errIfMissing = true
+	}
+
+	return _create(family, spec, ctx, [ops])
+}
 
-	return create(spec, ctx, ops)
+resolve := func(ref, ctx, ...options) {
+	return _resolve(1, ref, ctx, options)
 }
 
 
@@ -310,7 +429,7 @@ _ANCHORED_QUERY_DEFAULT_OPTIONS := {
 
 
 
-anchoredQuery := func(ctx, anchors, queryMap, ...opts) {
+_anchoredQuery := func(family, ctx, anchors, queryMap, opts) {
 
 	validation.assertType(queryMap, _QUERY_MAP_SCHEMA, "invalid query map schema")
 
@@ -334,7 +453,7 @@ anchoredQuery := func(ctx, anchors, queryMap, ...opts) {
 			}
 		}
 
-		resolvedAnchors[anchorId] = resolve(ref, ctx, opts)
+		resolvedAnchors[anchorId] = _resolve(family, ref, ctx, [opts])
 	}
 
 
@@ -356,14 +475,19 @@ anchoredQuery := func(ctx, anchors, queryMap, ...opts) {
 		}
 	}
 
+	request := {
+		queryMap: processedQueryMap,
+		opts: normalizedOpts
+	}
+	if family != 1 {
+		request.family = family
+	}
+
 
 	queryResult := render.createEphemeral(queryAnchoredTpl, {
 		ctx: ctx,
 		anchorSpecs: smart.createMapResource(maps.mapValues(resolvedAnchors, func(v) { return v.inputs().spec })),
-		request: {
-			queryMap: processedQueryMap,
-			opts: normalizedOpts
-		}
+		request: request
 	})
 
 
@@ -422,9 +546,77 @@ anchoredQuery := func(ctx, anchors, queryMap, ...opts) {
 	return self
 }
 
+anchoredQuery := func(ctx, anchors, queryMap, ...opts) {
+	return _anchoredQuery(1, ctx, anchors, queryMap, opts)
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+forFamily := func(family) {
+	ll.assert(family == 1 || family == 2, "unknown resolver family: %v, expected 1 or 2", family)
+	if family == 1 {
+		return ll.toStrict({
+			create: func(spec, ctx, ...options) {
+				return _create(1, spec, ctx, options)
+			},
+			resolve: func(ref, ctx, ...options) {
+				return _resolve(1, ref, ctx, options)
+			},
+			anchoredQuery: func(ctx, anchors, queryMap, ...opts) {
+				return _anchoredQuery(1, ctx, anchors, queryMap, opts)
+			}
+		})
+	}
+	return ll.toStrict({
+		create: func(spec, ctx, ...options) {
+			ops := _family2Options(options, ["spec", "data", "single"])
+			if ops.single == true {
+				ops.first = true
+				ops.errIfMissing = true
+			}
+			delete(ops, "single")
+			return _create(2, spec, ctx, [ops])
+		},
+		resolve: func(ref, ctx, ...options) {
+			return _resolve(2, ref, ctx, [_family2Options(options, ["spec", "data"])])
+		},
+		anchoredQuery: func(ctx, anchors, queryMap, ...opts) {
+			return _anchoredQuery(2, ctx, anchors, queryMap, opts)
+		},
+		isRef: _isFamily2Ref
+	})
+}
+
 export ll.toStrict({
 	create: create,
 	resolve: resolve,
 	resultUnmarshaller: resultUnmarshaller,
-	anchoredQuery: anchoredQuery
+	anchoredQuery: anchoredQuery,
+	forFamily: forFamily
 })