@platforma-sdk/workflow-tengo 2.8.1 → 2.8.3

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

@@ -1,207 +1,181 @@
 ll := import("@platforma-sdk/workflow-tengo:ll")
 smart := import("@platforma-sdk/workflow-tengo:smart")
 constants := import("@platforma-sdk/workflow-tengo:constants")
-render := import("@platforma-sdk/workflow-tengo:render")
 json := import("json")
 
 
 _CONTEXT_FIELD_NAME := "ctx"
 
-// options scheme for query
 _OPTIONS_SCHEME := {
-	"spec,?": `bool`,
-	"data,?": `bool`,
-	"single,?": `bool`,
-	"first,?": `bool`,
-	"errIfMissing,?": `bool`
+"spec,?": `bool`,
+"data,?": `bool`,
+"single,?": `bool`,
+"first,?": `bool`,
+"errIfMissing,?": `bool`
 }
 
-// default query options
 _DEFAULT_OPTIONS := {
-	/** Return specs in the results */
-	spec: true,
-	/** Return data in the results */
-	data: true,
-	/** Asserts that the resulting list has one element and returns it */
-	single: false,
-	/** Returns first available result of the query */
-	first: false,
-	/** Throw error if no results found */
-	errIfMissing: false
-}
-
-/**
- * Query results pool.
- *
- * @param spec: query spec
- * @param ctx: results pool (context) to query
- * @param options: an options map
- * @return result: a list of {ref: spec: data:} objects (data will be absent if not requested)
- */
+spec: true,
+data: true,
+single: false,
+first: false,
+errIfMissing: false
+}
+
+
+
+
+
+
+
+
 create := func(spec, ctx, ...options) {
 
-	// @TODO validate spec
 
-	ops := copy(_DEFAULT_OPTIONS)
-	if len(options) > 0 {
-		ll.assert(len(options) == 1, "expected map, got array: ", options)
+ops := copy(_DEFAULT_OPTIONS)
+if len(options) > 0 {
+ll.assert(len(options) == 1, "expected map, got array: ", options)
 
-		// @TODO validate options
 
-		// override defaults
-		for k, v in options[0] {
-			ops[k] = v
-		}
-	}
+for k, v in options[0] {
+ops[k] = v
+}
+}
 
-	query := json.encode({
-		query: spec,
-		setErrorIfMissing: ops.errIfMissing
-	})
+query := json.encode({
+query: spec,
+setErrorIfMissing: ops.errIfMissing
+})
 
-	builder := undefined
-	if ops.first {
-		builder = smart.ephemeralBuilder(constants.RTYPE_BRESOLVE_FIRST, query)
-	} else {
-		// return all query results
-		builder = smart.ephemeralBuilder(constants.RTYPE_BRESOLVE_CHOICE, query)
-	}
+builder := undefined
+if ops.first {
+builder = smart.ephemeralBuilder(constants.RTYPE_BRESOLVE_FIRST, query)
+} else {
+builder = smart.ephemeralBuilder(constants.RTYPE_BRESOLVE_CHOICE, query)
+}
 
-	builder.createInputField(_CONTEXT_FIELD_NAME).set(ctx)
-	resolve := builder.lockInputsAndBuild()
+builder.createInputField(_CONTEXT_FIELD_NAME).set(ctx)
+resolve := builder.lockInputsAndBuild()
 
 
-	// create a special type to store query results
 
-	rb := smart.structBuilder(constants.RTYPE_QUERY_RESULT)
+rb := smart.structBuilder(constants.RTYPE_QUERY_RESULT)
 
-	// save options
-	rb.createInputField("ops").setJson(ops)
+rb.createInputField("ops").setJson(ops)
 
-	if ops.spec {
-		rb.createInputField("spec").set(resolve.getFutureOutputField("spec"))
-	}
+if ops.spec {
+rb.createInputField("spec").set(resolve.getFutureOutputField("spec"))
+}
 
-	// pass data only if needed, otherwise we are not waiting for data to complete
-	if ops.data {
-		rb.createInputField("data").set(resolve.getFutureOutputField("data"))
-	}
+if ops.data {
+rb.createInputField("data").set(resolve.getFutureOutputField("data"))
+}
 
-	// the data structure differs in this case; the single ref, data and spec are stored
-	// directly as result fields
-	if ops.first {
-		rb.createInputField("ref").set(resolve.getFutureOutputField("address"))
-	}
+if ops.first {
+rb.createInputField("ref").set(resolve.getFutureOutputField("address"))
+}
 
-	return rb.lockAndBuild()
+return rb.lockAndBuild()
 }
 
-/**
- * Inputs preprocessor used to convert query result into array of {ref: spec: data:} objects
- */
+
+
 resultUnmarshaller := func() {
-	return  {
-		canParse: func(r) {
-			return smart.isResource(r) && r.info().Type.Name == constants.RTYPE_QUERY_RESULT.Name
-		},
-
-		parse: func(resource, parser)  {
-
-			ops := resource.get("ops").getDataAsJson()
-
-			if ops.first {
-				// special case, single element
-
-				// is no result
-				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(),
-					spec: resource.get("spec").getDataAsJson()
-				}
-
-				// only if the data is there
-				if resource.hasInputField("data") {
-
-					// even if spec is present, the data may be still not available
-					if isNR(resource.get("data")) {
-						result.data = undefined
-					} else {
-						result.data = parser(resource.get("data"))
-					}
-				}
-
-				return ll.toStrict(result)
-			} else {
-				// format list of results
-
-				spec := resource.get("spec").inputs()
-				data := undefined
-				if resource.hasInputField("data") {
-					data = resource.get("data").inputs()
-				}
-
-				result := []
-				for ref, s in spec {
-					r  := {
-						ref: json.decode(ref),
-						spec: s.getValueAsJson()
-					}
-
-					// only if the data is there
-					if !is_undefined(data) {
-						r.data = parser(data[ref].getValue())
-					}
-
-					result = append(result, ll.toStrict(r))
-				}
-
-				if ops.single {
-					ll.assert(len(result) == 1, "expected single element, got ", len(result))
-
-					result = result[0]
-				}
-
-				return result
-			}
-		}
-	}
-}
-
-/**
- * Query results pool to find spec & data for a given ref.
- *
- * @param ref: a ref object ({blockId: name:})
- * @param ctx: results pool (context) to query
- * @return result: a {ref: spec: data:} object
- */
+return  {
+canParse: func(r) {
+return smart.isResource(r) && r.info().Type.Name == constants.RTYPE_QUERY_RESULT.Name
+},
+
+parse: func(resource, parser)  {
+
+ops := resource.get("ops").getDataAsJson()
+
+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(),
+spec: resource.get("spec").getDataAsJson()
+}
+
+if resource.hasInputField("data") {
+
+if isNR(resource.get("data")) {
+result.data = undefined
+} else {
+result.data = parser(resource.get("data"))
+}
+}
+
+return ll.toStrict(result)
+} else {
+
+spec := resource.get("spec").inputs()
+data := undefined
+if resource.hasInputField("data") {
+data = resource.get("data").inputs()
+}
+
+result := []
+for ref, s in spec {
+r  := {
+ref: json.decode(ref),
+spec: s.getValueAsJson()
+}
+
+if !is_undefined(data) {
+r.data = parser(data[ref].getValue())
+}
+
+result = append(result, ll.toStrict(r))
+}
+
+if ops.single {
+ll.assert(len(result) == 1, "expected single element, got ", len(result))
+
+result = result[0]
+}
+
+return result
+}
+}
+}
+}
+
+
+
+
+
+
+
 resolve := func(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 := {
+type: "Direct",
+block_id: ref.blockId, 	// @TODO use consistent naming in pl
+output_name: ref.name 	// @TODO use consistent naming in pl
+}
 
-	ops := {}
+ops := {}
 
-	if len(options) > 0 {
-		ops = options[0]
-	}
+if len(options) > 0 {
+ops = options[0]
+}
 
-	ops.first = true
+ops.first = true
 
-	return create(spec, ctx, ops)
+return create(spec, ctx, ops)
 }
 
 export ll.toStrict({
-	create: create,
-	resolve: resolve,
-	resultUnmarshaller: resultUnmarshaller
+create: create,
+resolve: resolve,
+resultUnmarshaller: resultUnmarshaller
 })

package/dist/tengo/lib/workflow.constants.lib.tengo

@@ -1,8 +1,7 @@
 ll := import("@platforma-sdk/workflow-tengo:ll")
 
-// a dummy prefix used to mimic field with empty string name
 NO_PREFIX_EXPORT := "_"
 
 export ll.toStrict({
-	NO_PREFIX_EXPORT: NO_PREFIX_EXPORT
+NO_PREFIX_EXPORT: NO_PREFIX_EXPORT
 })

package/dist/tengo/lib/workflow.context.lib.tengo

@@ -1,4 +1,3 @@
-/** Library to work with context resources */
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 smart := import("@platforma-sdk/workflow-tengo:smart")
@@ -9,48 +8,44 @@ _BLOCK_ID_FIELD := "id"
 _PARENT_CTX_FIELD := "parent"
 _EXPORTS_OUTPUT_PREFIX := "values/"
 
-/**
- * Create a new context builder
- *
- * @param block block (smart.Resource)
- * @param parentContext parent context (smart.Resource)
- */
+
+
+
+
+
 builder := func(block, parentContext) {
 
-	super := smart.ephemeralBuilder(constants.RTYPE_CONTEXT)
+super := smart.ephemeralBuilder(constants.RTYPE_CONTEXT)
+
+super.createInputField(_BLOCK_ID_FIELD).setRefOrJson(block)
 
-	// set blockId associated with this context
-	super.createInputField(_BLOCK_ID_FIELD).setRefOrJson(block)
+super.createInputField(_PARENT_CTX_FIELD).set(parentContext)
 
-	// set parent context
-	super.createInputField(_PARENT_CTX_FIELD).set(parentContext)
+self := undefined
+self = ll.toStrict(oop.inherit(super, {
 
-	self := undefined
-	self = ll.toStrict(oop.inherit(super, {
 
-		/**
-		 * Add export to the context
-		 *
-		 * @param name string name of the export field
-		 * @param value resource/field value
-		 *
-		 */
-		add: func(name, value) {
-			field := super.createInputField(_EXPORTS_OUTPUT_PREFIX + name)
 
-			field.setRefOrJson(value)
 
-			return self
-		},
 
-		build: func() {
-			return super.lockAndBuild()
-		}
-	}))
 
-	return self
+
+add: func(name, value) {
+field := super.createInputField(_EXPORTS_OUTPUT_PREFIX + name)
+
+field.setRefOrJson(value)
+
+return self
+},
+
+build: func() {
+return super.lockAndBuild()
+}
+}))
+
+return self
 }
 
 export ll.toStrict({
-	builder: builder
+builder: builder
 })