@platforma-sdk/workflow-tengo 3.0.2 → 3.1.0

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

@@ -0,0 +1,582 @@
+tx := import("tx")
+ll := import("@platforma-sdk/workflow-tengo:ll")
+render := import("@platforma-sdk/workflow-tengo:render")
+smart := import("@platforma-sdk/workflow-tengo:smart")
+sets := import("@platforma-sdk/workflow-tengo:sets")
+maps := import("@platforma-sdk/workflow-tengo:maps")
+tplutil := import("@platforma-sdk/workflow-tengo:tpl.util")
+constants := import("@platforma-sdk/workflow-tengo:constants")
+stateAwait := import("@platforma-sdk/workflow-tengo:tpl.state-await")
+validation := import("@platforma-sdk/workflow-tengo:validation")
+
+
+
+
+
+
+
+
+
+
+_unmarshal := func(resource, preprocessors) {
+	ll.assert(smart.isResource(resource), "expected resource, found ", resource)
+
+
+	self := func(resource) { return _unmarshal(resource, preprocessors) }
+
+	for preproc in preprocessors {
+		if preproc.canParse(resource) {
+			return preproc.parse(resource, self)
+		}
+	}
+
+	if smart.isReference(resource) && resource.hasError() {
+		err := resource.getError().getDataAsJson()
+		if !is_undefined(err.message) {
+			err = err.message
+		}
+		ll.panic("input resource has errors: %v", err)
+	}
+
+	if smart.isResource(resource) && resource.checkResourceType(constants.RTYPE_NULL) {
+		return undefined
+	}
+
+	if smart.isJsonResource(resource) || resource.checkResourceType(constants.RTYPE_BOBJECT_SPEC) {
+
+
+		return resource.getDataAsJson()
+	} else if smart.isMapResource(resource) || smart.isLockedEphMapResource(resource) {
+
+
+		result := {}
+		for field, value in resource.inputs() {
+			if value.isErrorSet() {
+				ll.panic("input %v field has error: %v", field, field.getError().getDataAsJson().message)
+			} else if value.isSet() {
+				result[field] = _unmarshal(value.getValue(), preprocessors)
+			} else {
+				result[field] = value
+			}
+
+		}
+		return result
+	} else {
+
+		return resource
+	}
+}
+
+
+
+
+
+
+
+
+
+tpl := func(ops) {
+	self := undefined
+
+	_renderer := smart.resourceBuilder(ll.getCurrentTemplateRenderer())
+
+	_rendererType :=  _renderer.info().Type
+
+	_isEphemeral := _rendererType.Name == constants.RTYPE_RENDER_EPH_TEMPLATE.Name
+
+	_hasPrepared := _renderer.get(tplutil.INPUTS_MAP_FIELD).hasField(tplutil.PREPARE_MAP_FIELD_NAME)
+
+	_preparedMap := _hasPrepared ? _renderer.get(tplutil.INPUTS_MAP_FIELD).get(tplutil.PREPARE_MAP_FIELD_NAME) : undefined
+
+	_templateId := _renderer.get(tplutil.TEMPLATE_FIELD).id
+
+	_stateRequests := []
+	_delegatedOutputs := []
+
+	self = {
+
+
+
+
+		renderer: func() {
+			return _renderer
+		},
+
+
+
+
+		isEphemeral: func() {
+			return _isEphemeral
+		},
+
+
+
+
+		template: func() {
+			return smart.resource(_templateId)
+		},
+
+		_unmarshallers: copy(ops.unmarshallers),
+
+
+
+
+
+
+		registerUnmarshaller: func(preproc) {
+			ll.assert(is_undefined(self._inputs), "input preprocessors must be registered before getting inputs")
+			self._unmarshallers = append(self._unmarshallers, preproc)
+		},
+
+
+
+
+		rawInputs: func() {
+			return self.renderer().get(tplutil.INPUTS_MAP_FIELD).inputs()
+		},
+
+		_inputs: undefined,
+
+
+
+
+		inputs: func() {
+			if self._inputs == undefined {
+				inputs := _unmarshal(self.renderer().get(tplutil.INPUTS_MAP_FIELD), self._unmarshallers)
+
+
+				pp := inputs[tplutil.PREPARE_MAP_FIELD_NAME]
+				if !is_undefined(pp) {
+					delete(inputs, tplutil.PREPARE_MAP_FIELD_NAME)
+					for k, v in pp {
+						ll.assert(is_undefined(inputs[k]), k, " key already exists in inputs map")
+						inputs[k] = v
+					}
+				}
+
+				self._inputs = inputs
+			}
+			return self._inputs
+		},
+
+
+
+
+		hasInput: func(name) {
+			return self.renderer().get(tplutil.INPUTS_MAP_FIELD).hasField(name)
+		},
+
+
+		definedOutputs : [],
+
+
+
+
+
+
+
+		defineOutputs : func(...name) {
+			if len(name) == 1 && is_array(name[0]) {
+				for v in name[0] {
+					self.definedOutputs = append(self.definedOutputs, v)
+				}
+			} else {
+				self.definedOutputs = append(self.definedOutputs, name...)
+			}
+		},
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+		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]
+			_stateRequests = append(_stateRequests, {
+				path: path,
+				state: state
+			})
+		},
+
+
+
+
+
+		ignorePrepare: _hasPrepared,
+
+
+
+
+		preparedMapResource: func() {
+			return _preparedMap
+		},
+
+
+
+
+		prepareQueue : [],
+
+
+
+
+
+
+
+		prepare : func(codeFn) {
+			if self.ignorePrepare {
+				return
+			}
+
+			ll.assert(len(self.prepareQueue) == 0, "multiple prepare statements are not supported yet")
+
+			self.prepareQueue = append(self.prepareQueue, codeFn)
+		},
+
+
+
+
+
+		renderPrepare: func() {
+			ll.assert(!self.ignorePrepare, "expected !ignorePrepare")
+
+			inputs := self.inputs()
+
+
+			newInputs := copy(inputs)
+
+
+			builder := undefined
+			if self.isEphemeral() {
+				builder = smart.ephemeralMapBuilder()
+			} else {
+				builder = smart.mapBuilder()
+			}
+
+
+			self._validateInputs()
+			for cb in self.prepareQueue {
+
+				r := cb(inputs)
+
+				ll.assert(is_map(r), "expected map, got ", r)
+
+				for name, ref in r {
+					ll.assert(is_undefined(newInputs[name]), "prepare name is already in use: %s", name)
+
+					builder.add(name, ref)
+				}
+			}
+			newInputs[tplutil.PREPARE_MAP_FIELD_NAME] = builder.build()
+
+
+			renderer := undefined
+			if self.isEphemeral() {
+				renderer = render.createEphemeral(self.template(), newInputs)
+			} else {
+				renderer = render.create(self.template(), newInputs)
+			}
+
+			for output in self.definedOutputs {
+				self.getOutputField(output).set(renderer.output(output))
+			}
+		},
+
+
+
+
+
+		setOutputs : func(resultMap) {
+			ll.assert(ll.isMap(resultMap), "expected map, got ", resultMap)
+
+
+			for name, value in resultMap {
+				f := self.getOutputField(name)
+				if !f.isSet() {
+					f.setRefOrJson(value)
+				}
+			}
+		},
+
+
+
+
+		getOutputField: func(name) {
+			return self.renderer().getField(tplutil.TEMPLATE_OUTPUT_PREFIX + name)
+		},
+
+
+
+
+		createOutputsAndLock: func(outputs) {
+			for name in outputs {
+				self.renderer().createOutputField(tplutil.TEMPLATE_OUTPUT_PREFIX + name)
+			}
+			self.renderer().lockOutputs()
+		},
+
+		_inputsSchema: undefined,
+
+
+
+
+		validateInputs: func(schema) {
+			ll.assert(is_undefined(self._inputsSchema), "validateInputs was already invoked")
+			self._inputsSchema  = schema
+		},
+
+		_validateInputs: func() {
+			schema := self._inputsSchema
+			if is_undefined(schema) {
+				return
+			}
+			validation.assertType(self.inputs(), schema)
+		},
+
+
+
+
+		body: func(bodyFn){
+			if self.isEphemeral() {
+
+				self.routeEph(bodyFn)
+			} else {
+
+				self.routePure(bodyFn)
+			}
+		},
+
+
+
+
+		routePure: func(bodyFn){
+
+			if len(self.definedOutputs) == 0 {
+				ll.panic("please define outputs before template body")
+			}
+
+
+
+
+
+
+
+
+
+
+
+
+
+			if ll.isInitializing() {
+
+
+				self.createOutputsAndLock(self.definedOutputs)
+			} else {
+
+
+				if len(self.prepareQueue) != 0 {
+
+
+					self.renderPrepare()
+				} else {
+
+					self._validateInputs()
+					result := bodyFn(self.inputs())
+
+					ll.assert(ll.isMap(result),
+						"expected map from tpl.body() callback. Did you forget 'return' statement?")
+
+					outputsWithValues := sets.fromMapKeys(result)
+					outputsWithValues = sets.add(outputsWithValues, _delegatedOutputs...)
+
+					ll.assert(sets.fromSlice(self.definedOutputs) == outputsWithValues,
+						"tpl.body() callback must return the same list of outputs as were given to 'defineOutputs()'. Want %s, got %s",
+						self.definedOutputs, sets.toSlice(outputsWithValues))
+
+
+					self.setOutputs(result)
+				}
+			}
+		},
+
+
+
+
+		routeEph: func(bodyFn) {
+
+			if len(_stateRequests) == 0 {
+				_stateRequests = [{
+					path: [],
+					state: "AllInputsSet"
+				}]
+			}
+
+			if _hasPrepared {
+				_stateRequests = append(_stateRequests, {
+					path: [tplutil.PREPARE_MAP_FIELD_NAME],
+					state: "ResourceReady"
+				})
+			}
+
+			stateReached := stateAwait.await(
+				_renderer.getField(tplutil.INPUTS_MAP_FIELD),
+				_renderer,
+				_stateRequests
+			)
+
+			if stateReached {
+
+				if len(self.prepareQueue) > 0 {
+					ll.assert(len(self.definedOutputs) > 0, "outputs should be defined prior to prepare")
+
+					self.createOutputsAndLock(self.definedOutputs)
+
+					self.renderPrepare()
+				} else {
+
+
+					self._validateInputs()
+					result := bodyFn(self.inputs())
+					ll.assert(ll.isMap(result),
+						"expected map from tpl-eph.body() callback. Did you forget 'return' statement?")
+
+					self.createOutputsAndLock(maps.getKeys(result))
+
+
+					self.setOutputs(result)
+				}
+			}
+		},
+
+
+
+
+
+
+
+
+
+		routeDelegate: func(tpl, extraInputs, outputs) {
+			_delegatedOutputs = outputs
+
+			inputs := self.rawInputs()
+			for k, v in extraInputs {
+				inputs[k] = v
+			}
+
+			renderer := undefined
+			if self.isEphemeral() {
+				renderer = render.createEphemeral(tpl, inputs)
+			} else {
+				renderer = render.create(tpl, inputs)
+			}
+
+			tplOutputs := {}
+			for o in outputs {
+				tplOutputs[o] = renderer.output(o)
+			}
+
+			self.createOutputsAndLock(outputs)
+			self.setOutputs(tplOutputs)
+		},
+
+
+
+
+
+
+		api: func() {
+			return ll.toStrict({
+				renderer                : self.renderer,
+				registerUnmarshaller    : self.registerUnmarshaller,
+				rawInputs               : self.rawInputs,
+				hasInput                : self.hasInput,
+				inputs                  : self.inputs,
+				defineOutputs           : self.defineOutputs,
+				prepare                 : self.prepare,
+				awaitState              : self.awaitState,
+				awaitStateIfEphemeral   : self.awaitStateIfEphemeral,
+				delegate                : self.routeDelegate,
+				validateInputs          : self.validateInputs,
+				body                    : self.body,
+				template                : self.template
+			})
+		}
+	}
+	return self
+}
+
+export ll.toStrict({
+	tpl: tpl
+})