@platforma-sdk/workflow-tengo 2.14.0 → 2.15.0

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

@@ -1,4 +1,4 @@
-/* A library exposing template functional components */
+
 
 tx := import("tx")
 ll := import("@platforma-sdk/workflow-tengo:ll")
@@ -13,21 +13,21 @@ validation := import("@platforma-sdk/workflow-tengo:validation")
 
 bquery := import("@platforma-sdk/workflow-tengo:workflow.bquery")
 
-/**
- * Unmarshal resource according by:
- *  - converting all json resources (potentially nested) into a tengo objects (maps)
- *  - converting all pl.maps (resource maps) into tengo maps
- *
- * @param resource: smart resource to unmarshal
- * @param preprocessors: input preprocessors
- * @return object: unmarshaled resource
- */
+
+
+
+
+
+
+
+
+
 _unmarshal := func(resource, preprocessors) {
 	ll.assert(smart.isResource(resource), "expected resource, found ", resource)
 
-	// instance of this
+
 	self := func(resource) { return _unmarshal(resource, preprocessors) }
-	// try preprocessors first
+
 	for preproc in preprocessors {
 		if preproc.canParse(resource) {
 			return preproc.parse(resource, self)
@@ -38,13 +38,17 @@ _unmarshal := func(resource, preprocessors) {
 		ll.panic("input resource has errors: ", resource, resource.getError())
 	}
 
+	if smart.isResource(resource) && resource.checkResourceType(constants.RTYPE_NULL) {
+		return undefined
+	}
+
 	if smart.isJsonResource(resource) || resource.checkResourceType(constants.RTYPE_BOBJECT_SPEC) {
 
-		// parse json data of the resource
+
 		return resource.getDataAsJson()
 	} else if smart.isMapResource(resource) || smart.isLockedEphMapResource(resource) {
 
-		// unmarshal map
+
 		result := {}
 		for field, value in resource.inputs() {
 			if value.isErrorSet() {
@@ -58,14 +62,14 @@ _unmarshal := func(resource, preprocessors) {
 		}
 		return result
 	} else {
-		// nothing todo
+
 		return resource
 	}
 }
 
-/**
- * A wrapper object around template functionality
- */
+
+
+
 tpl := func() {
 	self := undefined
 
@@ -86,56 +90,56 @@ tpl := func() {
 
 	self = {
 
-		/**
-		 * Current renderer smart resource
-		 */
+
+
+
 		renderer: func() {
 			return _renderer
 		},
 
-		/**
-		 * Whether this template is ephemeral (rendered by ephemeral template router)
-		 */
+
+
+
 		isEphemeral: func() {
 			return _isEphemeral
 		},
 
-		/**
-		 * Current template resource
-		 */
+
+
+
 		template: func() {
 			return smart.resource(_templateId)
 		},
 
 		_unmarshallers: [bquery.resultUnmarshaller()],
 
-		/**
-		 * Register a preprocessor of input resource. The preprocessor must have two
-		 * methods: `canParse(resource)` (bool) and `parse(resource)` (object). Registered
-		 * preprocessors will be used when unmarshaling resources.
-		 */
+
+
+
+
+
 		registerUnmarshaller: func(preproc) {
 			ll.assert(is_undefined(self._inputs), "input preprocessors must be registered before getting inputs")
 			self._unmarshallers = append(self._unmarshallers, preproc)
 		},
 
-		/**
-		 * @return map[string]field: - a map of inputs to the fields of the input map.
-		 */
+
+
+
 		rawInputs: func() {
 			return self.renderer().get(tplutil.INPUTS_MAP_FIELD).inputs()
 		},
 
 		_inputs: undefined,
 
-		/**
-		 * @return map: a map of the template inputs
-		 */
+
+
+
 		inputs: func() {
 			if self._inputs == undefined {
 				inputs := _unmarshal(self.renderer().get(tplutil.INPUTS_MAP_FIELD), self._unmarshallers)
 
-				// if we have prepared inputs, flatten them
+
 				pp := inputs[tplutil.PREPARE_MAP_FIELD_NAME]
 				if !is_undefined(pp) {
 					delete(inputs, tplutil.PREPARE_MAP_FIELD_NAME)
@@ -150,22 +154,22 @@ tpl := func() {
 			return self._inputs
 		},
 
-		/**
-		 * @return bool: whether there is input with a given name
-		 */
+
+
+
 		hasInput: func(name) {
 			return self.renderer().get(tplutil.INPUTS_MAP_FIELD).hasField(name)
 		},
 
-		// accumulated output definitions
+
 		definedOutputs : [],
 
-		/**
-		 * Defines current template output(s) names.
-		 *
-		 * For pure templates, all outputs must be defined before the template body, and only registered outputs can be used
-		 * inside. Optional for ephemeral templates.
-		 */
+
+
+
+
+
+
 		defineOutputs : func(...name) {
 			if len(name) == 1 && is_array(name[0]) {
 				for v in name[0] {
@@ -176,84 +180,115 @@ tpl := func() {
 			}
 		},
 
-		/**
-		 * In ephemeral template, body will only be executed when corresponding inputs state is
-		 * reached.
-		 *
-		 * Signature:
-		 *   awaitState(path..., requestedState)
-		 *
-		 * Usage examples:
-		 *   awaitState("AllInputsSet") - all inputs of the inputs map must be set
-		 *   awaitState("inputName1", "ResourceReady") - resource in the input inputName1 must be ready
-		 *   awaitState("inputName1", "nestedField", "Set") - nested input field in the input
-		 *                              inputName1 must exist and point to some resource
-		 *   awaitState("inputName1", { wildcard: "*" }, "InputsLocked") - nested resource by the
-		 *                              inputName1 field must exist and have locked inputs and all
-		 *                              resources referenced by those fields must have all inputs
-		 *                              locked
-		 *   awaitState("inputName1", { match: "^some_prefix\\." }, "InputsLocked") - nested resource
-		 *                              by the inputName1 field must exist and have locked inputs and
-		 *                              all resources referenced by inputs with "some_prefix." prefix
-		 *                              must have all inputs locked
-		 *
-		 * Example, the following two expressions are equivalent:
-		 *   awaitState("inputName1", { wildcard: "*" }, "Set")
-		 *   awaitState("inputName1", { match: "^some_prefix\\." }, "Set")
-		 *   awaitState("inputName1", "AllInputsSet")
-		 *
-		 * Allowed states:
-		 *   Exists - field exists
-		 *   Set - field points to existing resource
-		 *   InputsLocked - field points to resource with locked inputs
-		 *   AllInputsSet - field points to resource with all inputs set
-		 *   ResourceReady - field points to ready resource
-		 */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 		awaitState: func(...pathAndState) {
 			if !self.isEphemeral() {
 				ll.panic("awaitState allowed only in ephemeral templates")
 			}
+			self.awaitStateIfEphemeral(pathAndState...)
+		},
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+		awaitStateIfEphemeral: func(...pathAndState) {
+			if !self.isEphemeral() {
+				return
+			}
 			path := pathAndState[:len(pathAndState) - 1]
 			state := pathAndState[len(pathAndState) - 1]
-			// if len(self.prepareQueue) == 0 {
 			_stateRequests = append(_stateRequests, {
 				path: path,
 				state: state
 			})
-			// } else if len(self.prepareQueue) == 1 {
-			// 	_stateRequestsAfterPrepare = append(_stateRequestsAfterPrepare, {
-			// 		path: path,
-			// 		state: state
-			// 	})
-			// } else {
-			// 	ll.panic("Multiple prepare are not supported")
-			// }
 		},
 
-		/**
-		 * True means we are in the inner render cycle, when all "to be prepared" fields are passed
-		 * already to inputs and no need to call prepare callbacks again.
-		 */
+
+
+
+
 		ignorePrepare: _hasPrepared,
 
-		/**
-		 * Resource map with the resources passed
-		 */
+
+
+
 		preparedMapResource: func() {
 			return _preparedMap
 		},
 
-		/**
-		 * A queue of 'prepare' callbacks
-		 */
+
+
+
 		prepareQueue : [],
 
-		/**
-		 * Prepare additional resources for the template body. The body function of the workflow will be executed only when the references
-		 * returned from prepare method will be resolved into a ready resources. The resulting resources will be passed as an input to the body function.
-		 *
-		 * @param cb: a callback function returning a map of references to be resolved
-		 */
+
+
+
+
+
+
 		prepare : func(codeFn) {
 			if self.ignorePrepare {
 				return
@@ -264,19 +299,19 @@ tpl := func() {
 			self.prepareQueue = append(self.prepareQueue, codeFn)
 		},
 
-		/**
-		 * Creates renderer which is re-rendering the current template additionally passing
-		 * resolve references as extra inputs.
-		 */
+
+
+
+
 		renderPrepare: func() {
 			ll.assert(!self.ignorePrepare, "expected !ignorePrepare")
 
 			inputs := self.inputs()
 
-			// create new inputs map
+
 			newInputs := copy(inputs)
 
-			// build a prepare map
+
 			builder := undefined
 			if self.isEphemeral() {
 				builder = smart.ephemeralMapBuilder()
@@ -284,10 +319,10 @@ tpl := func() {
 				builder = smart.mapBuilder()
 			}
 
-			// validate inputs first if needed
+
 			self._validateInputs()
 			for cb in self.prepareQueue {
-				// run callback
+
 				r := cb(inputs)
 
 				ll.assert(is_map(r), "expected map, got ", r)
@@ -300,27 +335,27 @@ tpl := func() {
 			}
 			newInputs[tplutil.PREPARE_MAP_FIELD_NAME] = builder.build()
 
-			// re-render self
+
 			renderer := undefined
 			if self.isEphemeral() {
 				renderer = render.createEphemeral(self.template(), newInputs)
 			} else {
 				renderer = render.create(self.template(), newInputs)
 			}
-			// set outputs
+
 			for output in self.definedOutputs {
 				self.getOutputField(output).set(renderer.output(output))
 			}
 		},
 
-		/**
-		 * Sets results map to resource output fields. Non-resource objects in the result values
-		 * will be automatically converted into Json resources.
-		 */
+
+
+
+
 		setOutputs : func(resultMap) {
 			ll.assert(ll.isMap(resultMap), "expected map, got ", resultMap)
 
-			// set outputs
+
 			for name, value in resultMap {
 				f := self.getOutputField(name)
 				if !f.isSet() {
@@ -329,16 +364,16 @@ tpl := func() {
 			}
 		},
 
-		/**
-		 * Returns renderer's output field with a given name
-		 */
+
+
+
 		getOutputField: func(name) {
 			return self.renderer().getField(tplutil.TEMPLATE_OUTPUT_PREFIX + name)
 		},
 
-		/**
-		 * Creates relevant output fields and locks renderer's outputs
-		 */
+
+
+
 		createOutputsAndLock: func(outputs) {
 			for name in outputs {
 				self.renderer().createOutputField(tplutil.TEMPLATE_OUTPUT_PREFIX + name)
@@ -348,9 +383,9 @@ tpl := func() {
 
 		_inputsSchema: undefined,
 
-		/**
-		 * Validate inputs schema before passing inputs to body.
-		 */
+
+
+
 		validateInputs: func(schema) {
 			ll.assert(is_undefined(self._inputsSchema), "validateInputs was already invoked")
 			self._inputsSchema  = schema
@@ -364,9 +399,9 @@ tpl := func() {
 			validation.assertType(self.inputs(), schema)
 		},
 
-		/**
-		 * Routes template.
-		 */
+
+
+
 		body: func(bodyFn){
 			if self.isEphemeral() {
 
@@ -377,40 +412,40 @@ tpl := func() {
 			}
 		},
 
-		/**
-		 * Routes pure template.
-		 */
+
+
+
 		routePure: func(bodyFn){
-			// Checks
+
 			if len(self.definedOutputs) == 0 {
 				ll.panic("please define outputs before template body")
 			}
 
-			//
-			// Rules of pl guarantees that pure template code will be executed twice:
-			//
-			//   (1) once for initialization, at this point it must initialize all outputs, for the
-			//       deduplication and recovery mechanisms to pick them up and, if possible, populate them
-			//       with results from equivalent previous invocations
-			//
-			//   (2) after initialization is done and all deduplication and recovery algorithms did their
-			//       magic, if some (or all) of the outputs, our consumers demand are still absent, main
-			//       body of the template is executed, to calculate them
-			//
+
+
+
+
+
+
+
+
+
+
+
 
 			if ll.isInitializing() {
 
-				// Initialization
+
 				self.createOutputsAndLock(self.definedOutputs)
 			} else {
 
-				// processing resolves
+
 				if len(self.prepareQueue) != 0 {
 
-					// re-render self to
+
 					self.renderPrepare()
 				} else {
-					// run body func
+
 					self._validateInputs()
 					result := bodyFn(self.inputs())
 
@@ -424,15 +459,15 @@ tpl := func() {
 						"tpl.body() callback must return the same list of outputs as were given to 'defineOutputs()'. Want %s, got %s",
 						self.definedOutputs, sets.toSlice(outputsWithValues))
 
-					// set result to self outputs
+
 					self.setOutputs(result)
 				}
 			}
 		},
 
-		/**
-		 * Routes ephemeral template.
-		 */
+
+
+
 		routeEph: func(bodyFn) {
 
 			if len(_stateRequests) == 0 {
@@ -465,7 +500,7 @@ tpl := func() {
 					self.renderPrepare()
 				} else {
 
-					// run body func
+
 					self._validateInputs()
 					result := bodyFn(self.inputs())
 					ll.assert(ll.isMap(result),
@@ -473,20 +508,20 @@ tpl := func() {
 
 					self.createOutputsAndLock(maps.getKeys(result))
 
-					// set result to self outputs
+
 					self.setOutputs(result)
 				}
 			}
 		},
 
-		/**
-		 * Delegates itself to the specified template, i.e. runs specified template and
-		 * saves its outputs to this.
-		 *
-		 * @param tpl: template - specified template
-		 * @param extraInputs: map - additional inputs to pass to the template
-		 * @param outputs: array - array of expected outputs to save
-		 */
+
+
+
+
+
+
+
+
 		routeDelegate: func(tpl, extraInputs, outputs) {
 			_delegatedOutputs = outputs
 
@@ -514,9 +549,9 @@ tpl := func() {
 	return ll.toStrict(self)
 }
 
-/**
- * Singleton instance of this resource
- */
+
+
+
 instance := tpl()
 
 export ll.toStrict({
@@ -528,6 +563,7 @@ export ll.toStrict({
 	defineOutputs           : instance.defineOutputs,
 	prepare                 : instance.prepare,
 	awaitState              : instance.awaitState,
+	awaitStateIfEphemeral   : instance.awaitStateIfEphemeral,
 	delegate                : instance.routeDelegate,
 	validateInputs          : instance.validateInputs,
 	body                    : instance.body,

package/dist/tengo/lib/tpl.state-await.lib.tengo

@@ -1,7 +1,7 @@
-/**
- * Library implementing state machine to await certain resource states in
- * ephemeral templates.
- */
+
+
+
+
 
 tx := import("tx")
 ll := import("@platforma-sdk/workflow-tengo:ll")
@@ -16,10 +16,10 @@ createContext := func() {
 
 awaitOneState := func(field, path, state) {
 	if field.isErrorSet() && !field.isValueSet() {
-		// Field is in pure error state (just error and no referenced resource).
-		// This is a terminal state, so we stop any traversal here, and return value
-		// the same as we would return if we achieved the desired state. It is
-		// template's body responsibility to correctly handle the error state.
+
+
+
+
 		return { type: "Ready" }
 	}
 
@@ -175,18 +175,18 @@ awaitOneState := func(field, path, state) {
 	}
 }
 
-/** Returns true if all requested states are reached */
+
 await := func(rootField, ctxStorageResource, requests) {
 	pssKey := "await:" + string(rootField.id.ResourceID) + ":" + rootField.id.Name
 	prevSubscriptions := ctxStorageResource.kvGetAsJson(pssKey)
 
 	if !is_undefined(prevSubscriptions) && len(prevSubscriptions) == 0 {
-		// initialization was finished before, in a previous template execution
+
 		ll.panic("Unexpected state, desired state was reached in the previous call")
 	}
 
 	if is_undefined(prevSubscriptions) {
-		// initializing previous subscriptions set
+
 		prevSubscriptions = {}
 	}
 
@@ -218,10 +218,10 @@ await := func(rootField, ctxStorageResource, requests) {
 		}
 	}
 
-	// creating new subscriptions
+
 	for key, sub in subscriptions {
 		if !is_undefined(prevSubscriptions[key]) {
-			// don't create subscription, if it was created in the past
+
 			continue
 		}
 		e := {}
@@ -229,21 +229,21 @@ await := func(rootField, ctxStorageResource, requests) {
 		tx.subscribeTo(sub.resource, pssKey + ":" + key, e)
 	}
 
-	// unsubscribing from subscriptions we don't need anymore
+
 	for key, _ in prevSubscriptions {
 		if !is_undefined(subscriptions[key]) {
-			// don't unsubscribe from subscriptions, we still need
+
 			continue
 		}
 		tx.unsubscribeFrom(pssKey + ":" + key)
 	}
 
-	// creating and saving new context; savong only keys
+
 	newPrevSubscriptions := {}
 	for key, _ in subscriptions {
 		newPrevSubscriptions[key] = true
 	}
-	// saving the context
+
 	ctxStorageResource.kvSetJson(pssKey, newPrevSubscriptions)
 
 	return len(subscriptions) == 0