@platforma-sdk/workflow-tengo 2.9.5 → 2.9.7

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

@@ -1,254 +1,254 @@
-
-
-
-
+/**
+ * Library implementing state machine to await certain resource states in
+ * ephemeral templates.
+ */
 
 tx := import("tx")
 ll := import("@platforma-sdk/workflow-tengo:ll")
 text := import("text")
 
 createContext := func() {
-return {
-activeSubscriptions: {},
-resolvedStates: {}
-}
+	return {
+		activeSubscriptions: {},
+		resolvedStates: {}
+	}
 }
 
 awaitOneState := func(field, path, state) {
-if field.isErrorSet() && !field.isValueSet() {
-
-
-
-
-return { type: "Ready" }
-}
-
-if len(path) > 0 {
-step := path[0]
-rPath := path[1:]
-
-if !field.isValueSet() {
-return {
-type: "Subscribe",
-subscriptions: [{
-resource: field.id.ResourceID,
-event: "InputSet"
-}]
-}
-}
-
-resource := field.getValue()
-
-if is_string(step) {
-nextField := resource.inputs()[step]
-if nextField == undefined {
-if resource.info().InputsLocked {
-ll.panic("field %v not found and inputs locked", step)
-}
-return {
-type: "Subscribe",
-subscriptions: [{
-resource: resource.id,
-event: "FieldCreated"
-},{
-resource: resource.id,
-event: "InputsLocked"
-}]
-}
-}
-return awaitOneState(nextField, rPath, state)
-} else if is_map(step) {
-if is_undefined(step.wildcard) == is_undefined(step.match) {
-ll.panic("Unknown step structure: %v", step)
-}
-
-matcher := undefined
-
-if !is_undefined(step.wildcard) {
-if step.wildcard != "*" {
-ll.panic("Complex wildcards are not supported, use { match: \"{regexp}\" }: %v", step.wildcard)
-}
-matcher = func(field) {
-return true
-}
-} else {
-regex := text.re_compile(step.match)
-if is_error(regex) {
-ll.panic("Error parsing regex %v: %v", step.match, regex)
-}
-matcher = func(field) {
-return regex.match(field)
-}
-}
-
-if !resource.info().InputsLocked {
-return {
-type: "Subscribe",
-subscriptions: [{
-resource: resource.id,
-event: "InputsLocked"
-}]
-}
-}
-
-subscriptions := []
-for nextFieldName, nextField in resource.inputs() {
-if !matcher(nextFieldName) {
-continue
-}
-res := awaitOneState(nextField, rPath, state)
-if res.type == "Ready" {
-continue
-} else if res.type == "Subscribe" {
-subscriptions = append(subscriptions, res.subscriptions...)
-} else {
-ll.panic("Unknown result type: %v", res.type)
-}
-}
-if len(subscriptions) == 0 {
-return { type: "Ready" }
-} else {
-return {
-type: "Subscribe",
-subscriptions: subscriptions
-}
-}
-} else {
-ll.panic("Malformed state await request path: %v", step)
-}
-} else {
-if state == "Exists" {
-return { type: "Ready" }
-} else {
-if !field.isSet() {
-return {
-type: "Subscribe",
-subscriptions: [{
-resource: field.id.ResourceID,
-event: "InputSet"
-}]
-}
-}
-resource := field.getValue()
-if state == "Set" {
-return { type: "Ready" }
-} else if state == "InputsLocked" {
-if resource.info().InputsLocked {
-return { type: "Ready" }
-} else {
-return {
-type: "Subscribe",
-subscriptions: [{
-resource: resource.id,
-event: "InputsLocked"
-}]
-}
-}
-} else if state == "AllInputsSet" {
-if resource.info().AllInputsSet {
-return { type: "Ready" }
-} else {
-return {
-type: "Subscribe",
-subscriptions: [{
-resource: resource.id,
-event: "AllInputsSet"
-}]
-}
-}
-} else if state == "ResourceReady" {
-if resource.info().ResourceReady {
-return { type: "Ready" }
-} else {
-return {
-type: "Subscribe",
-subscriptions: [{
-resource: resource.id,
-event: "ResourceReady"
-}]
-}
-}
-} else {
-ll.panic("Unknown await state: %v", 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" }
+	}
+
+	if len(path) > 0 {
+		step := path[0]
+		rPath := path[1:]
+
+		if !field.isValueSet() {
+			return {
+				type: "Subscribe",
+				subscriptions: [{
+					resource: field.id.ResourceID,
+					event: "InputSet"
+				}]
+			}
+		}
+
+		resource := field.getValue()
+
+		if is_string(step) {
+			nextField := resource.inputs()[step]
+			if nextField == undefined {
+				if resource.info().InputsLocked {
+					ll.panic("field %v not found and inputs locked", step)
+				}
+				return {
+					type: "Subscribe",
+					subscriptions: [{
+						resource: resource.id,
+						event: "FieldCreated"
+					},{
+						resource: resource.id,
+						event: "InputsLocked"
+					}]
+				}
+			}
+			return awaitOneState(nextField, rPath, state)
+		} else if is_map(step) {
+			if is_undefined(step.wildcard) == is_undefined(step.match) {
+				ll.panic("Unknown step structure: %v", step)
+			}
+
+			matcher := undefined
+
+			if !is_undefined(step.wildcard) {
+				if step.wildcard != "*" {
+					ll.panic("Complex wildcards are not supported, use { match: \"{regexp}\" }: %v", step.wildcard)
+				}
+				matcher = func(field) {
+					return true
+				}
+			} else {
+				regex := text.re_compile(step.match)
+				if is_error(regex) {
+					ll.panic("Error parsing regex %v: %v", step.match, regex)
+				}
+				matcher = func(field) {
+					return regex.match(field)
+				}
+			}
+
+			if !resource.info().InputsLocked {
+				return {
+					type: "Subscribe",
+					subscriptions: [{
+						resource: resource.id,
+						event: "InputsLocked"
+					}]
+				}
+			}
+
+			subscriptions := []
+			for nextFieldName, nextField in resource.inputs() {
+				if !matcher(nextFieldName) {
+					continue
+				}
+				res := awaitOneState(nextField, rPath, state)
+				if res.type == "Ready" {
+					continue
+				} else if res.type == "Subscribe" {
+					subscriptions = append(subscriptions, res.subscriptions...)
+				} else {
+					ll.panic("Unknown result type: %v", res.type)
+				}
+			}
+			if len(subscriptions) == 0 {
+				return { type: "Ready" }
+			} else {
+				return {
+					type: "Subscribe",
+					subscriptions: subscriptions
+				}
+			}
+		} else {
+			ll.panic("Malformed state await request path: %v", step)
+		}
+	} else {
+		if state == "Exists" {
+			return { type: "Ready" }
+		} else {
+			if !field.isSet() {
+				return {
+					type: "Subscribe",
+					subscriptions: [{
+						resource: field.id.ResourceID,
+						event: "InputSet"
+					}]
+				}
+			}
+			resource := field.getValue()
+			if state == "Set" {
+				return { type: "Ready" }
+			} else if state == "InputsLocked" {
+				if resource.info().InputsLocked {
+					return { type: "Ready" }
+				} else {
+					return {
+						type: "Subscribe",
+						subscriptions: [{
+							resource: resource.id,
+							event: "InputsLocked"
+						}]
+					}
+				}
+			} else if state == "AllInputsSet" {
+				if resource.info().AllInputsSet {
+					return { type: "Ready" }
+				} else {
+					return {
+						type: "Subscribe",
+						subscriptions: [{
+							resource: resource.id,
+							event: "AllInputsSet"
+						}]
+					}
+				}
+			} else if state == "ResourceReady" {
+				if resource.info().ResourceReady {
+					return { type: "Ready" }
+				} else {
+					return {
+						type: "Subscribe",
+						subscriptions: [{
+							resource: resource.id,
+							event: "ResourceReady"
+						}]
+					}
+				}
+			} else {
+				ll.panic("Unknown await state: %v", 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 {
-
-ll.panic("Unexpected state, desired state was reached in the previous call")
-}
-
-if is_undefined(prevSubscriptions) {
-
-prevSubscriptions = {}
-}
-
-subscriptions := {}
-
-addSubscription := func(subscription) {
-key := string(subscription.resource) + ":" + subscription.event
-if !is_undefined(subscriptions[key]) {
-return false
-} else {
-subscriptions[key] = subscription
-return true
-}
-}
-
-for _, request in requests {
-if !is_map(request) || !is_array(request.path) || !is_string(request.state) {
-ll.panic("Malformed state await request: %v", request)
-}
-res := awaitOneState(rootField, request.path, request.state)
-if res.type == "Ready" {
-continue
-} else if res.type == "Subscribe" {
-for subscription in res.subscriptions {
-addSubscription(subscription)
-}
-} else {
-ll.panic("Unknown result type %v", res.type)
-}
-}
-
-
-for key, sub in subscriptions {
-if !is_undefined(prevSubscriptions[key]) {
-
-continue
-}
-e := {}
-e[sub.event] = true
-tx.subscribeTo(sub.resource, pssKey + ":" + key, e)
-}
-
-
-for key, _ in prevSubscriptions {
-if !is_undefined(subscriptions[key]) {
-
-continue
-}
-tx.unsubscribeFrom(pssKey + ":" + key)
-}
-
-
-newPrevSubscriptions := {}
-for key, _ in subscriptions {
-newPrevSubscriptions[key] = true
-}
-
-ctxStorageResource.kvSetJson(pssKey, newPrevSubscriptions)
-
-return len(subscriptions) == 0
+	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 = {}
+	}
+
+	subscriptions := {}
+
+	addSubscription := func(subscription) {
+		key := string(subscription.resource) + ":" + subscription.event
+		if !is_undefined(subscriptions[key]) {
+			return false
+		} else {
+			subscriptions[key] = subscription
+			return true
+		}
+	}
+
+	for _, request in requests {
+		if !is_map(request) || !is_array(request.path) || !is_string(request.state) {
+			ll.panic("Malformed state await request: %v", request)
+		}
+		res := awaitOneState(rootField, request.path, request.state)
+		if res.type == "Ready" {
+			continue
+		} else if res.type == "Subscribe" {
+			for subscription in res.subscriptions {
+				addSubscription(subscription)
+			}
+		} else {
+			ll.panic("Unknown result type %v", res.type)
+		}
+	}
+
+	// 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 := {}
+		e[sub.event] = true
+		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
 }
 
 export ll.toStrict({
-await: await
+	await: await
 })

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

@@ -1,19 +1,19 @@
-
+/* Templates/renderers utils */
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 
-
+// template field name in renderer resource
 TEMPLATE_FIELD := "template"
-
+// field name of a resource map with the inputs in renderer resource
 INPUTS_MAP_FIELD := "inputs"
-
+// prefix of output fields template results in renderer resource
 TEMPLATE_OUTPUT_PREFIX := "outputs/"
-
+// input field containing a map with resources to prepare for the body
 PREPARE_MAP_FIELD_NAME := "__prepare__"
 
 export ll.toStrict({
-TEMPLATE_FIELD           : TEMPLATE_FIELD,
-INPUTS_MAP_FIELD         : INPUTS_MAP_FIELD,
-TEMPLATE_OUTPUT_PREFIX   : TEMPLATE_OUTPUT_PREFIX,
-PREPARE_MAP_FIELD_NAME   : PREPARE_MAP_FIELD_NAME
+	TEMPLATE_FIELD           : TEMPLATE_FIELD,
+	INPUTS_MAP_FIELD         : INPUTS_MAP_FIELD,
+	TEMPLATE_OUTPUT_PREFIX   : TEMPLATE_OUTPUT_PREFIX,
+	PREPARE_MAP_FIELD_NAME   : PREPARE_MAP_FIELD_NAME
 })