@platforma-sdk/workflow-tengo 2.3.1 → 2.4.1

package/dist/tengo/lib/exec.lib.tengo

@@ -651,7 +651,7 @@ builder := func() {
 				 * @return field - a reference to the file stream resource.
 				 */
 				getFileStream: func(fileName) {
-					return tpl.output("fileStreams", cache).getFutureInputField(fileName)
+					return tpl.output("fileStreams", cache).getFutureInputField(fileName, true)
 				},
 
 				/**

package/dist/tengo/lib/ll.lib.tengo

@@ -6,6 +6,13 @@ fmt := import("fmt")
 log := import("log")
 text := import("text")
 
+/**
+ * Provides current API version available at runtime
+ */
+apiVersion := func() {
+	return 0 // stub code. Real API checker will appear here.
+}
+
 /**
  * Prints message to the pl log
  */
@@ -74,6 +81,35 @@ fromStrict := func(r) {
 	return plapi.strictToMap(r)
 }
 
+/**
+ * Safe way to check if method exists in a builtin module or a library
+ *
+ * @param module: module - builtin module or tengo library
+ * @param methodName: string - name of a method to be checked
+ *
+ * @return bool - true when method exists, false otherwise
+ */
+methodExists := func(module, methodName) {
+	if isStrict(module) {
+		if !is_callable(plapi.mapHasKey) {
+			module = fromStrict(module)
+
+		} else {
+			if !plapi.mapHasKey(module, methodName) {
+				return false
+			}
+		}
+	}
+
+	method := module[methodName]
+
+	if is_undefined(method) {
+        return false
+    }
+
+    return is_callable(method)
+}
+
 /**
  * If input is a strict map, converts it to a normal one, otherwise returns the object as is
  *
@@ -255,9 +291,11 @@ getCtx := func() {
 }
 
 export toStrict({
+	apiVersion: apiVersion,
 	print: print,
 	panic: panic,
 	assert: assert,
+	methodExists: methodExists,
 	isStrict: isStrict,
 	isMap: isMap,
 	fromStrict: fromStrict,

package/dist/tengo/lib/maps.lib.tengo

@@ -29,6 +29,14 @@ containsKey := func(map, key) {
 	return false
 }
 
+// Load effective version of map key checker if it exists in controller's API
+plapi := import("plapi")
+if ll.methodExists(plapi, "mapHasKey") {
+	containsKey = func(map, key) {
+		return plapi.mapHasKey(map, key)
+	}
+}
+
 /**
  * Transforms all keys of the map with a function and returns a new map with these keys.
  *

package/dist/tengo/lib/render.lib.tengo

@@ -59,7 +59,7 @@ createUniversal := func(tpl, isEph, inputs) {
 		 */
 		output: func(name, ...cache) {
 			ll.assert(len(cache) == 0 || is_int(cache[0]), "cache should be a number (use 'times' tengo library), got: %v", cache)
-			out := renderer.getFutureOutputField(tplutil.TEMPLATE_OUTPUT_PREFIX + name)
+			out := renderer.getFutureOutputField(tplutil.TEMPLATE_OUTPUT_PREFIX + name, isEph)
 			if len(cache) > 0 && cache[0] > 0 {
 				cache = cache[0]
 				tx.cacheSetToField(out.id, cache)

package/dist/tengo/lib/smart.lib.tengo

@@ -264,6 +264,7 @@ resource = func(r) {
 		 *	ID:			   int64
 		 *	Data:		   byte[],
 		 *	Type:		   { Name: string, Version: string }
+		 *	Features:	   { ephemeral: bool }
 		 *	Inputs:		   strict map
 		 *	Outputs:	   strict map
 		 *	Dynamic:	   strict map
@@ -297,6 +298,19 @@ resource = func(r) {
 			return self.info().ResourceReady
 		},
 
+		isEphemeral: func() {
+			resourceInfo := self.info()
+
+			if !maps.containsKey(resourceInfo, "Features") {
+				// by default we consider all resources to be ephemeral for backward compatiblity to keep stable logic
+				// in platforma backend before v1.16.0.
+				// TODO: once we consider this version old enough, we can panic here instead of 'return true'
+				return true
+			}
+
+			return resourceInfo.Features.ephemeral
+		},
+
 		/**
 		 * Get raw resource data
 		 *
@@ -433,7 +447,7 @@ resource = func(r) {
 		 * @return field: smart.field
 		 */
 		getFutureField: func(name, fieldType, ...eph) {
-			isEph := true
+			isEph := strictSelf.isEphemeral()
 			if len(eph) > 0 {
 				isEph = eph[0]
 			}
@@ -450,14 +464,19 @@ resource = func(r) {
 		 * @return field: smart.field
 		 */
 		getFutureInputField: func(nameOrPath, ...eph) {
+			isEph := strictSelf.isEphemeral()
+			if len(eph) > 0 {
+				isEph = eph[0]
+			}
+
 			if is_array(nameOrPath) {
 				current := strictSelf
 				for name in nameOrPath {
-					current = current.getFutureField(name, "input", eph...)
+					current = current.getFutureField(name, "input", isEph)
 				}
 				return current
 			} else {
-				return self.getFutureField(nameOrPath, "input", eph...)
+				return self.getFutureField(nameOrPath, "input", isEph)
 			}
 		},
 
@@ -471,7 +490,18 @@ resource = func(r) {
 		 * @return field: smart.field
 		 */
 		getFutureOutputField: func(name, ...eph) {
-			return self.getFutureField(name, "output", eph...)
+			isEph := strictSelf.isEphemeral()
+			if len(eph) > 0 {
+				isEph = eph[0]
+			}
+
+			if ll.apiVersion() < 1 && !isEph {
+				// Dirty hack that saves from issues with buggy pure getField before v1.16.1
+				// We can safely drop it when we consider v1.16.0 old enough.
+				return self.getFutureField(name, "output", true).expectNonEphemeral()
+			}
+
+			return self.getFutureField(name, "output", isEph)
 		},
 
 		/**
@@ -592,10 +622,12 @@ field = func(f) {
 		/**
 		 * Field info:
 		 *
-		 *	ID:	   { ResourceId: int64, Name: string }
-		 *	Value: int64 - value resource id
-		 *	Error: int64 - error resource id
-		 *	IsSet: bool	 - whether field is set
+		 *	ID:			{ ResourceId: int64, Name: string }
+		 *	Type:		string - see constants.FTYPE_* for possible values
+		 *	Features:	{ ephemeral: bool }
+		 *	Value:		int64 - value resource id
+		 *	Error:		int64 - error resource id
+		 *	IsSet:		bool  - whether field is set
 		 */
 		info: func() {
 			return tx.getField(self.id)
@@ -622,6 +654,37 @@ field = func(f) {
 			return self.info().Error != 0
 		},
 
+		/**
+		 * Some fields cannot point to ephemeral resources.
+		 * This method checks, if current field can.
+		 *
+		 * @return bool - "true' when field can point to ephemeral resource, 'false' when not
+		 */
+		isEphemeral: func() {
+			fieldInfo := self.info()
+
+			if !maps.containsKey(fieldInfo, "Features") {
+				// by default we consider all fields can point to ephemeral resources for backward compatiblity to keep stable logic
+				// in platforma backend before v1.16.0.
+				// TODO: once we consider this version old enough, we can panic here instead of 'return true'
+				return true
+			}
+
+			isParentResourceEphemeral := fieldInfo.Features.ephemeral
+			if isParentResourceEphemeral {
+				return true
+			}
+
+			return fieldInfo.Type != constants.FTYPE_INPUT &&
+				fieldInfo.Type != constants.FTYPE_OUTPUT
+		},
+
+		expectNonEphemeral: func() {
+			rr := field(self.id)
+			rr.isEphemeral = func() { return false }
+			return rr
+		},
+
 		/**
 		 * Use cacheMillis, cacheSeconds, cacheMinutes, cacheHours and cacheDays to not make hidden mistakes in cache time ranges.
 		 * Sets the cache time.
@@ -779,7 +842,7 @@ field = func(f) {
 		 * @return field: smart.field
 		 */
 		getFutureField: func(name, fieldType, ...eph) {
-			isEph := true
+			isEph := strictSelf.isEphemeral()
 			if len(eph) > 0 {
 				isEph = eph[0]
 			}
@@ -796,6 +859,11 @@ field = func(f) {
 		 * @return field: smart field
 		 */
 		getFutureInputField: func(nameOrPath, ...eph) {
+			isEph := strictSelf.isEphemeral()
+			if len(eph) > 0 {
+				isEph = eph[0]
+			}
+
 			if is_array(nameOrPath) {
 				current := strictSelf
 				for name in nameOrPath {
@@ -817,7 +885,18 @@ field = func(f) {
 		 * @return field: smart field
 		 */
 		getFutureOutputField: func(name, ...eph) {
-			return self.getFutureField(name, "output", eph...)
+			isEph := strictSelf.isEphemeral()
+			if len(eph) > 0 {
+				isEph = eph[0]
+			}
+
+			if ll.apiVersion() < 1 && !isEph {
+				// Dirty hack that saves from issues with buggy pure getField before v1.16.1
+				// We can safely drop it when we consider v1.16.0 old enough.
+				return self.getFutureField(name, "output", true).expectNonEphemeral()
+			}
+
+			return self.getFutureField(name, "output", isEph)
 		}
 	}
 
@@ -848,7 +927,7 @@ resourceBuilder = func(r) {
 		 * Create new field with given name and field type.
 		 *
 		 * @param name field name
-		 * @param fieldType: field type - input, output, dynamic, service, OTW. Use F_TYPE_* constants.
+		 * @param fieldType: field type - input, output, dynamic, service, OTW. Use FfTYPE_* constants.
 		 */
 		createField: func(name, fieldType) {
 			assertNotBuilt()

package/dist/tengo/lib/test.lib.tengo

@@ -0,0 +1,204 @@
+/*
+ * Library for tengo unit tests.
+ * Contains collection of helpers, that make tengo unit tests more compact, easier for reading and writing.
+ *
+ * WARNING: It is designed to be imported ONLY in *.test.tengo files.
+ *          As it works ONLY in tengo unit tests context, it will break any workflow if imported
+ *          in .lib.tengo or .tpl.tengo file.
+ */
+
+test := import("test")
+
+//
+// Basic re-export from "test" builtin library with some conveniences
+//
+
+/**
+ * Skip the test writing given message to the console log.
+ *
+ * @param args: []any - message to be written. 
+ *                      Each argument is converted to string with its default formatter.
+ */
+skip := func(...args) {
+	test.skip(args...)
+}
+
+/**
+ * Formatted version of skip(). skipf(msg, ...args) == skip(format(msg, args...))
+ *
+ * @param msg: string - message with formatting directives.
+ * @param args: []any - arguments for directives in <msg>.
+ */
+skipf := func(msg, ...args) {
+	skip(format(msg, args...))
+}
+
+/**
+ * Fail the test in place. Interrupts execution of single test and prints a
+ * failure message to the console log.
+ *
+ * @param args: []any - message to be written. 
+ *                      Each argument is converted to string with its default formatter.
+ */
+fail := func(...args) {
+	test.fail(args...)
+}
+
+/**
+ * Formatted version of fail(). failf(msg, ...args) == fail(format(msg, args...))
+ *
+ * @param msg: string - message with formatting directives.
+ * @param args: []any - arguments for directives in <msg>.
+ */
+failf := func(msg, ...args) {
+	fail(format(msg, args...))
+}
+
+/**
+ * Write message to console log.
+ *
+ * @param args: []any - message to be written. 
+ *                      Each argument is converted to string with its default formatter.
+ */
+log := func(...args) {
+	test.log(args...)
+}
+
+/**
+ * Formatted version of log(). logf(msg, ...args) == log(format(msg, args...))
+ *
+ * @param msg: string - message with formatting directives.
+ * @param args: []any - arguments for directives in <msg>.
+ */
+logf := func(msg, ...args) {
+	test.log(format(msg, args...))
+}
+
+/**
+ * Mark test as executed for tengo testing engine.
+ * 
+ * Regular tengo file with tests contains bunch of fuctions starting with 'Test' prefix, like `TestMyFunction := func() { ... }`.
+ * You DO NOT need to call this Done() method if you have file with Test* functions.
+ * 
+ * For some rare cases, you may want to define your own custom testing script, that will call functions on its own instead 
+ * of using the standard test functions naming. In this case, testing engine needs to know the difference between "nothing was called at all"
+ * and "everything was done well". This is what this method for.
+ *
+ * You don't need it in 99.9% of cases.
+ * 
+ * This method does not interrupt test execution and is intended for use in custom test scripts
+ * without declared test functions.
+ */
+done := func() {
+	test.done()
+}
+
+//
+// Boolean assertions
+//
+
+/**
+ * Require <condition> to be true, failing test when not.
+ *
+ * @param condition: bool
+ * @param msg: []any - message to be printed on check failure
+ */
+isTrue := func(condition, ...msg) {
+	if !condition {
+		test.fail("<condition> != 'true': ", msg...)
+	}
+}
+
+/**
+ * Formatted version of isTrue(). isTruef(condition, msg, ...args) == isTrue(condition, format(msg, args...))
+ *
+ * @param condition: bool
+ * @param msg: string - message with formatting directives to be printed on check failure
+ * @param args: []any - arguments for formatting directives in <msg>
+ */
+isTruef := func(condition, msg, ...args) {
+    isTrue(condition, format(msg, args...))
+}
+
+/**
+ * Require <condition> to be false, failing test when not.
+ *
+ * @param condition: bool
+ * @param args: []any - message to be printed on check failure
+ */
+isFalse := func(condition, ...args) {
+	if condition {
+		test.fail("<condition> != 'false'", args...)
+	}
+}
+
+/**
+ * Formatted version of isFalse(). isFalsef(condition, msg, ..args) == isFalse(condition, format(msg, args...))
+ *
+ * @param condition: bool
+ * @param msg: string - message with formatting directives to be printed on check failure
+ * @param args: []any - arguments for formatting directives in <msg>
+ */
+isFalsef := func(condition, msg, ...args) {
+    isFalse(condition, format(msg, args...))
+}
+
+//
+// Equality assertions
+//
+
+/**
+ * Fails test when <expect> != <value>
+ *
+ * @param expect: any - expected value for the equality check
+ * @param value:  any - the value to be checked
+ * @param args: []any - the message to be printed on check failure
+ */
+isEqual := func(expect, value, ...args) {
+	if expect == value {
+		return
+	}
+
+	msg := format("%q != %q (expect: %#v, got %#v)", expect, value, expect, value)
+
+	fail(msg, args...)
+}
+
+/**
+ * Formatted version of isEqual(). isEqualf(expect, value, msg, ..args) == isEqual(expect, value, format(msg, args...))
+ *
+ * @param expect: any - expected value for the equality check
+ * @param value:  any - the value to be checked
+ * @param msg: string - message with formatting directives to be printed on check failure
+ * @param args: []any - arguments for formatting directives in <msg>
+ */
+isEqualf := func(expect, value, msg, ...args) {
+	isEqual(expect, value, format(msg, args...))
+}
+
+export {
+	//
+	// Builtin 'test' module method wrappers
+	//
+	done				: done,
+	skip				: skip,
+	skipf				: skipf,
+	fail				: fail,
+	failf				: failf,
+	log					: log,
+	logf				: logf,
+
+	//
+	// Boolean assertions
+	//
+	isTrue				: isTrue,
+	isTruef				: isTruef,
+	isFalse				: isFalse,
+	isFalsef			: isFalsef,
+
+	//
+	// Equality assertions
+	//
+	isEqual				: isEqual,
+	isEqualf			: isEqualf
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "2.3.1",
+  "version": "2.4.1",
   "description": "Tengo SDK library",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",