@platforma-sdk/workflow-tengo 2.14.0 → 2.15.0

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

@@ -1,14 +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({

package/dist/tengo/lib/units.lib.tengo

@@ -1,12 +1,12 @@
 ll := import("@platforma-sdk/workflow-tengo:ll")
 
 export ll.toStrict({
-	// Base-2 size modifiers:
+
 	KiB: 1024,
 	MiB: 1024 * 1024,
 	GiB: 1024 * 1024 * 1024,
 
-	// Decimal modifiers:
+
 	KB: 1000,
 	MB: 1000000,
 	GB: 1000000000

package/dist/tengo/lib/validation.lib.tengo

@@ -7,9 +7,9 @@ smart := import("@platforma-sdk/workflow-tengo:smart")
 
 json := import("json")
 
-//
-// Tools for implementing your own checks:
-//
+
+
+
 
 _formatKeyPath := func(current, format, key) {
 	if current == "" {
@@ -23,18 +23,18 @@ _formatKeyPath := func(current, format, key) {
 	return fmt.sprintf(format, current, key)
 }
 
-/**
- * Validation success result.
- */
+
+
+
 success := { result: true }
 
-/**
- * Validation failure result with a message.
- *
- * @param keyPath: string - the current stack state.
- * @param msg: string - the failure message.
- * @param args: ...any - additional arguments for the message.
- */
+
+
+
+
+
+
+
 fail := func(keyPath, msg, ...args) {
 	return {
 		result: false,
@@ -46,23 +46,23 @@ isSuccess := func(r) {
 	return r.result == true
 }
 
-/**
- * Returns true if the validation failed.
- *
- * @param r: either fail or success.
- */
+
+
+
+
+
 isFail := func(r) {
 	return r.result == false
 }
 
-/**
- * Checks a condition and returns success or failure.
- *
- * @param condition: bool - the condition to check.
- * @param stack: any - the current stack state.
- * @param msg: string - the failure message if the condition is false.
- * @param args: variadic any - additional arguments for the message.
- */
+
+
+
+
+
+
+
+
 check := func(condition, keyPath, msg, ...args) {
 	if condition {
 		return success
@@ -71,17 +71,17 @@ check := func(condition, keyPath, msg, ...args) {
 	return fail(keyPath, msg, args...)
 }
 
-//
-// Validation:
-//
-
-/**
- * Validates JSON types based on tags when the schema is a string.
- *
- * @param js: any - the JSON to validate.
- * @param tags: { key: string, tags: []tag } - the tags to validate against.
- * @param stack: ...any - the current stack state.
- */
+
+
+
+
+
+
+
+
+
+
+
 _validateTypes := func(js, tags, keyPath, ...stack) {
 	k := tags.key
 
@@ -125,12 +125,12 @@ _validateTypes := func(js, tags, keyPath, ...stack) {
 	return fail(keyPath, "js %q is not one of a type: %s", js, tags.key)
 }
 
-/**
- * Parses JSON tags from a string rule.
- *
- * @param rule: string - a key with tags, e.g. "any,type=string,regex=abc.*"
- * @return parsedRule: { key: string, tags: map } - the key and tags parsed from the rule.
- */
+
+
+
+
+
+
 _parseTags := func(rule) {
 	tagsKV := text.split(rule, ",")
 	key := tagsKV[0]
@@ -153,14 +153,14 @@ _parseTags := func(rule) {
 	})
 }
 
-/**
- * Validates JSON against a schema.
- *
- * @param js: any - the JSON to validate.
- * @param schema: any - the schema to validate against.
- * @param stack: ...any - the current stack state.
- * @return either fail or success
- */
+
+
+
+
+
+
+
+
 _validateJson := func(js, schema, keyPath, ...stack) {
 	if is_undefined(schema) {
 		if len(stack) == 0 {
@@ -170,8 +170,8 @@ _validateJson := func(js, schema, keyPath, ...stack) {
 		return fail(keyPath, "key is not defined by schema, but exists in the JSON. Validated item: %#v", stack[0])
 	}
 
-	// if the schema is a string, then
-	// we check the predefined type.
+
+
 	if is_string(schema) {
 		if schema == "any" {
 			return success
@@ -181,16 +181,16 @@ _validateJson := func(js, schema, keyPath, ...stack) {
 		return _validateTypes(js, tags, keyPath, stack...)
 	}
 
-	// if the schema is a function, call it
-	// with the element and the path of how we
-	// got this element, i.e. recursion history.
+
+
+
 	if is_callable(schema) {
 		return schema(js, keyPath, stack)
 	}
 
-	// if the schema is an array with "or" at the beginning,
-	// we should check if the element is succeed with
-	// any of the following elements.
+
+
+
 	if is_array(schema) && len(schema) > 0 && schema[0] == "or" {
 		for i, elem in schema[1:] {
 			r := _validateJson(js, elem, keyPath, stack...)
@@ -202,9 +202,9 @@ _validateJson := func(js, schema, keyPath, ...stack) {
 		return fail(keyPath, "js %q does not fit any of the following rules: %q", js, schema)
 	}
 
-	// if the schema is an array, then check that every
-	// element of the json has the schema that is the first element
-	// of the schema.
+
+
+
 	if is_array(schema) {
 		if !is_array(js) {
 			return fail(keyPath, "js %q must be array", js)
@@ -221,19 +221,19 @@ _validateJson := func(js, schema, keyPath, ...stack) {
 		return success
 	}
 
-	// only map left, since schema can't be undefined
-	// if the schema is a map, check that every key
-	// in json-object is in the schema and vice-versa,
-	// unless there are tags "any" or "omitempty".
+
+
+
+
 	if !ll.isMap(js) {
 		return fail(keyPath, "js %#v must be map", js)
 	}
 
-	// schema.key -> tags
+
 	schemaTags := {}
-	// schema.key -> rule
+
 	schemaRules := {}
-	// js padded with all keys from schema
+
 	jsFull := {}
 
 	for k, v in schema {
@@ -243,7 +243,7 @@ _validateJson := func(js, schema, keyPath, ...stack) {
 		jsFull[p.key] = undefined
 	}
 
-	// tags that should be applied to all elements
+
 	any := schemaTags["any"]
 	if !is_undefined(any) {
 		if is_undefined(jsFull["any"]) { // in case actual object has field named "any"
@@ -262,7 +262,7 @@ _validateJson := func(js, schema, keyPath, ...stack) {
 		}
 	}
 
-	// transferring fields from input map into padded map
+
 	for k, v in js {
 		jsFull[k] = v
 	}
@@ -284,7 +284,7 @@ _validateJson := func(js, schema, keyPath, ...stack) {
 			continue
 		}
 
-		// tags for the key
+
 		key := schemaTags[_key]
 
 		if is_undefined(key) {
@@ -318,51 +318,51 @@ _validateJson := func(js, schema, keyPath, ...stack) {
 	return success
 }
 
-/**
- * Checks if the given JSON conforms to the given schema.
- *
- * @param js: any - the JSON to check.
- * @param schema: any - the schema to check against.
- * @return either fail or success
- */
+
+
+
+
+
+
+
 checkJson := func(js, schema) {
 	return _validateJson(js, schema, "")
 }
 
-/**
- * Checks if the given JSON is valid according to the given schema.
- *
- * @param js: any - the JSON to check.
- * @param schema: any - the schema to check against.
- * @return result: bool - the result of the validation (true/false).
- */
+
+
+
+
+
+
+
 isValid := func(js, schema) {
 	return _validateJson(js, schema, "").result
 }
 
-/**
- * Alias to ll.assert just for usage convenience
- */
+
+
+
 assert := func(condition, msg, ...args) {
 	ll.assert(condition, msg, args...)
 }
 
-/**
- * Asserts that a given variable conforms to a given schema.
- *
- * Schema field value examples:
- *  - for scalar type checks:
- *     "string", "number", "char", "bytes", "bool" to check presence of value of given type
- *     "null" - value must be undefined
- *     "any" - any value is accepted (even undefined)
- *     ["or", "string", "number"] - value must be string or number
- *  - for arrays: ["string"], ["number"], ... (any valid scalar type)
- *  - for maps: {"name": "string", "age": "number"} - make sure <value> is map with "name" and "age" keys with given value types.
- *
- * @param value: any - the value to check.
- * @param schema: any - the schema to assert against (see comments above)
- * @param failMsg: string - optional parameter with custom message to be printed on validation error
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 assertType := func(value, schema, ...failMsg) {
 	r := _validateJson(value, schema, "")
 
@@ -376,22 +376,22 @@ assertType := func(value, schema, ...failMsg) {
 	}
 }
 
-/**
- * Alias to 'assertType' for backward compatibility
- */
+
+
+
 assertJsonSchema := func(js, schema, ...failMsg) {
 	assertType(js, schema, failMsg...)
 }
 
-//
-// Domain-specific schemas and checks:
-//
 
-/**
- * Checks if the given element is a resource.
- *
- * @param options: object - resource validation options
- */
+
+
+
+
+
+
+
+
 resource := func(...args) {
 
 	ops := {}
@@ -428,30 +428,30 @@ resource := func(...args) {
 	return checker
 }
 
-/**
- * Checks if the given element is a resource with specified type.
- *
- * @param rt: ResourceType - desired resource type
- */
+
+
+
+
+
 resourceType := func(rt) {
 	return func(elem, keyPath, stack) {
 		return check(smart.isResource(elem) && elem.info().Type.Name == rt.Name, keyPath, "the element " + elem + " must be a resource")
 	}
 }
 
-/**
- * Checks if the given element is a reference.
- *
- * @param elem: any - the element to check.
- * @param stack: any - the current stack state.
- */
+
+
+
+
+
+
 reference := func(elem, keyPath, stack) {
 	return check(smart.isReference(elem), keyPath, "the element " + elem + " must be a resource or a field")
 }
 
-/**
- * Schema for reference
- */
+
+
+
 refSchema := {
 	blockId: `string`,
 	name:  `string`

package/dist/tengo/lib/waiter.lib.tengo

@@ -6,25 +6,25 @@ assets := import("@platforma-sdk/workflow-tengo:assets")
 
 waiterTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:waiter.waiter")
 
-/**
- * Create new waiter, that will wait for all resources given to wait() and pass <pass> to <output> afterwards.
- *
- * @param pass: smart.field | smart.resource - reference to something that should be passed to the output
- *                                             once all waits get ready.
- */
+
+
+
+
+
+
 builder := func(pass) {
 	self := undefined
 
-	/** type: smart.reference[] */
+
 	whatToWait := []
 
 	self = ll.toStrict({
-		/**
-		 * Wait for given reference to become ready.
-		 *
-		 * @param ref: smart.field | smart.resource - reference to resource to wait for ResourceReady
-		 *                                            state before passing <pass> to the output of waiter
-		 */
+
+
+
+
+
+
 		wait: func(ref) {
 			validation.assertJsonSchema(ref, validation.reference, "waiter.builder.wait(ref): ref should be a reference to resource or field")
 			whatToWait = append(whatToWait, ref)