@platforma-sdk/workflow-tengo 2.9.6 → 2.9.7

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

@@ -6,201 +6,201 @@ 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 := {
-
-spec: true,
-
-data: true,
-
-single: false,
-
-first: false,
-
-errIfMissing: false
-}
-
-
-
-
-
-
-
-
-
+	/** 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)
+ */
 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
+		}
+	}
 
+	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)
+	}
 
-for k, v in options[0] {
-ops[k] = v
-}
-}
+	builder.createInputField(_CONTEXT_FIELD_NAME).set(ctx)
+	resolve := builder.lockInputsAndBuild()
 
-query := json.encode({
-query: spec,
-setErrorIfMissing: ops.errIfMissing
-})
 
-builder := undefined
-if ops.first {
-builder = smart.ephemeralBuilder(constants.RTYPE_BRESOLVE_FIRST, query)
-} else {
+	// create a special type to store query results
 
-builder = smart.ephemeralBuilder(constants.RTYPE_BRESOLVE_CHOICE, query)
-}
+	rb := smart.structBuilder(constants.RTYPE_QUERY_RESULT)
 
-builder.createInputField(_CONTEXT_FIELD_NAME).set(ctx)
-resolve := builder.lockInputsAndBuild()
+	// save options
+	rb.createInputField("ops").setJson(ops)
 
+	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"))
+	}
 
+	// 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"))
+	}
 
-rb := smart.structBuilder(constants.RTYPE_QUERY_RESULT)
-
-
-rb.createInputField("ops").setJson(ops)
-
-if ops.spec {
-rb.createInputField("spec").set(resolve.getFutureOutputField("spec"))
-}
-
-
-if ops.data {
-rb.createInputField("data").set(resolve.getFutureOutputField("data"))
-}
-
-
-
-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 {
-
-
-
-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
-}
-}
-}
-}
-
-
-
-
-
-
-
-
+	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
+ */
 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,8 @@
 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,4 @@
-
+/** Library to work with context resources */
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 smart := import("@platforma-sdk/workflow-tengo:smart")
@@ -9,48 +9,48 @@ _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.createInputField(_BLOCK_ID_FIELD).setRefOrJson(block)
+	super := smart.ephemeralBuilder(constants.RTYPE_CONTEXT)
 
+	// 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()
+		}
+	}))
 
-
-
-
-add: func(name, value) {
-field := super.createInputField(_EXPORTS_OUTPUT_PREFIX + name)
-
-field.setRefOrJson(value)
-
-return self
-},
-
-build: func() {
-return super.lockAndBuild()
-}
-}))
-
-return self
+	return self
 }
 
 export ll.toStrict({
-builder: builder
+	builder: builder
 })