@platforma-sdk/workflow-tengo 2.8.1 → 2.8.3

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

@@ -1,255 +1,240 @@
-/**
- * Library implementing state machine to await certain resource states in
- * ephemeral templates.
- */
+
+
+
 
 tx := import("tx")
 ll := import("@platforma-sdk/workflow-tengo:ll")
-sets := import("@platforma-sdk/workflow-tengo:sets")
 text := import("text")
 
 createContext := func() {
-	return {
-		activeSubscriptions: {},
-		resolvedStates: {}
-	}
+return {
+activeSubscriptions: {},
+resolvedStates: {}
+}
 }
 
 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" }
-	}
-
-	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 */
+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)
+}
+}
+}
+}
+
 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 = {}
-	}
-
-	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
+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
 }
 
 export ll.toStrict({
-	await: await
+await: await
 })

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

@@ -1,19 +1,14 @@
-/* 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
 })