@platforma-sdk/workflow-tengo 2.14.0 → 2.15.1

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

@@ -1,6 +1,6 @@
-/*
- * Library provides smart.Resource and smart.Field primitives.
- */
+
+
+
 
 tx := import("tx")
 ll := import("@platforma-sdk/workflow-tengo:ll")
@@ -11,120 +11,128 @@ maps := import("@platforma-sdk/workflow-tengo:maps")
 json := import("json")
 times := import("times")
 constants := import("@platforma-sdk/workflow-tengo:constants")
+ffDefault := import("@platforma-sdk/workflow-tengo:ll.get-future-field-default")
+
+
+
+
 
-//////////////// definitions ////////////////
 
-/**
- * A read-only wrapper object around raw platforma resource
- */
 resource := undefined
 
-/**
- * A wrapper object around raw platforma resource field
- */
+
+
+
 field := undefined
 
-/**
- * A convenient builder for resource objects
- */
+
+
+
 resourceBuilder := undefined
 
-/**
- * Builder for structural resource
- *
- * @param resourceType { Name: "", Version: "" }
- */
+
+
+
+
+
 structBuilder := undefined
 
-/**
- * Builder for map resource
- */
+
+
+
 mapBuilder := undefined
 
-/**
- * Builder for ephemeral map resource
- */
+
+
+
 ephemeralMapBuilder := undefined
 
-/**
- * Builder for emphemeral resources
- *
- * @param resourceType { Name: "", Version: "" }
- */
+
+
+
+
+
 ephemeralBuilder := undefined
 
-/**
- * Create value resource
- *
- * @param resourceType { Name: "", Version: "" }
- * @param data optional data
- */
+
+
+
+
+
+createNullResource := undefined
+
+
+
+
+
+
+
 createValueResource := undefined
 
-/**
- * Create Json resource
- *
- * @param value value to save in the resource
- */
+
+
+
+
+
 createJsonResource := undefined
 
-/**
- * Create map resource
- *
- * @param keyToValue: map[string]anyResource
- * @return resource
- */
+
+
+
+
+
+
 createMapResource := undefined
 
-/**
- * Create binary map resource
- *
- * @param keyToValue: map[string]valueResource
- * @return resource
- */
+
+
+
+
+
+
 createBinaryMapResource := undefined
 
-/**
- * Create blob map resource
- *
- * @param keyToValue: map[string]blobResource
- * @return resource
- */
+
+
+
+
+
+
 createBlobMapResource := undefined
 
-////////////////// helpers ///////////////////////////
 
-/**
- * Returns true if given object is a smart.Resource
- */
+
+
+
+
 isResource := func(f) {
 	return ll.isStrict(f) && maps.containsKey(f, "_type") && f["_type"] == "resource"
 }
 
-/**
- * Returns true if given object is a smart.Field
- */
+
+
+
 isField := func(f) {
 	return ll.isStrict(f) && maps.containsKey(f, "_type") && f["_type"] == "field"
 }
 
-/**
- * Returns true if given object is a smart.Field or smart.Resource
- */
+
+
+
 isReference := func(f) {
 	return isField(f) || isResource(f)
 }
 
-/**
- * Gets future field by given field name and field type.
- *
- * @param from: reference - whether a resource or a field we get a field from.
- * @param name: string - field name
- * @param fieldType: field type: input, output
- * @param isEph: bool - resolve in ephemeral or pure mode
- *
- * @return field: smart field
- */
+
+
+
+
+
+
+
+
+
+
 _getFutureField := func(from, name, fieldType, isEph) {
 	ll.assert(isReference(from), "'from' must be either a resource or a field, got: %#v", from)
 
@@ -134,9 +142,80 @@ _getFutureField := func(from, name, fieldType, isEph) {
 
 	return field(futureField.ResultFID)
 }
-/**
- * Returns true if given object is a StdMap resource
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+_buildFutureField := func(resourceOrField, nameOrPath, ...eph) {
+	globalIsEph := undefined
+	if len(eph) > 0 && is_bool(eph[0]) {
+		globalIsEph = eph[0]
+	}
+
+
+	optional := false
+
+
+	processSingleElement := func(resource, element) {
+
+		fieldType := "input"
+		fieldName := undefined
+		isEph := globalIsEph
+
+		if is_map(element) {
+			if !is_undefined(globalIsEph) {
+				ll.panic("global eph is not supported for structural path elements")
+			}
+
+			if !is_undefined(element.type) {
+				fieldType = element.type
+			}
+
+			fieldName = element.name
+			optional = optional || element.optional
+			isEph = element.eph
+		} else {
+			fieldName = element
+		}
+
+		if optional {
+			return resource.getFutureFieldOptional(fieldName, fieldType, isEph)
+		} else {
+			return resource.getFutureField(fieldName, fieldType, isEph)
+		}
+	}
+
+	if is_array(nameOrPath) {
+		current := resourceOrField
+		for i, pathElement in nameOrPath {
+			current = processSingleElement(current, pathElement)
+		}
+		return current
+	} else {
+		return processSingleElement(resourceOrField, nameOrPath)
+	}
+}
+
+
+
+
+_getFutureInputField := func(resourceOrField, nameOrPath, ...eph) {
+	return _buildFutureField(resourceOrField, nameOrPath, eph...)
+}
+
+
+
+
 isMapResource := func(r) {
 	return isResource(r) && (
 		r.info().Type.Name == constants.RTYPE_MAP.Name ||
@@ -144,38 +223,45 @@ isMapResource := func(r) {
 
 }
 
-/**
- * Returns true if given object is an ephemeral std map resource
- */
+
+
+
 isEphMapResource := func(r) {
 	return isResource(r) &&  r.info().Type.Name == constants.RTYPE_MAP_EPH.Name
 }
 
-/**
- * Returns true if given object is an ephemeral std map resource with locked inputs (so the list of inputs is final)
- */
+
+
+
 isLockedEphMapResource := func(r) {
 	return isEphMapResource(r) && r.info().InputsLocked
 }
 
-/**
- * Returns true if given object is a map or ephemeral map resource
- */
+
+
+
 isAnyMapResource := func(r) {
 	return isMapResource(r) || isEphMapResource(r)
 }
 
-/**
- * Returns true if given object is a json resource
- */
+
+
+
 isJsonResource := func(r) {
 	return isResource(r) && r.info().Type.Name == constants.RTYPE_JSON.Name
 }
 
-// deep check whether map has resources somewhere inside
+
+
+
+isNullResource := func(r) {
+	return isResource(r) && r.info().Type.Name == constants.RTYPE_NULL.Name
+}
+
+
 _hasReferenceValues := func(object) {
 	if isReference(object) {
-		// first check is reference since resource/field will return true on ll.isMap
+
 		return true
 	} else if ll.isMap(object) {
 		for _, v in object {
@@ -193,17 +279,17 @@ _hasReferenceValues := func(object) {
 	return false
 }
 
-/**
- * Convert given object to resource. If object is a true json, then
- * a simple Json resource will be created, otherwise a resource map.
- */
+
+
+
+
 _toRefOrJson := func(object) {
 	if isReference(object) {
-		// first check is reference since resource/field will return true on ll.isMap
+
 		return object
 	} else if ll.isMap(object) {
 
-		// just json if there are no nested resources
+
 		if !_hasReferenceValues(object)  {
 			return createJsonResource(object)
 		}
@@ -216,7 +302,7 @@ _toRefOrJson := func(object) {
 		return mb.build()
 	} else if is_array(object) {
 
-		// assert we are not having refs inside
+
 		ll.assert(!_hasReferenceValues(object), "array can't contain references")
 
 		return createJsonResource(object)
@@ -229,11 +315,11 @@ resourceTypesEqual := func(rType1, rType2) {
 	return rType1.Name == rType2.Name && rType1.Version == rType2.Version
 }
 
-////////////////// implementation ///////////////////////////
 
-/**
- * @param r either resource id or resource info
- */
+
+
+
+
 resource = func(r) {
 	self := undefined
 	strictSelf := undefined
@@ -255,47 +341,47 @@ resource = func(r) {
 	self = {
 		_type: "resource",
 
-		/**
-		 * Resource id (int64)
-		 */
+
+
+
 		id: id,
 
-		/**
-		 * Resource info:
-		 *
-		 *	ID:			   int64
-		 *	Data:		   byte[],
-		 *	Type:		   { Name: string, Version: string }
-		 *	Features:	   { ephemeral: bool }
-		 *	Inputs:		   strict map
-		 *	Outputs:	   strict map
-		 *	Dynamic:	   strict map
-		 *	OTW:		   strict map
-		 *	ResourceReady: bool
-		 *	AllInputsSet:  bool
-		 *	AllOutputsSet: bool
-		 *	IsDuplicate:   bool
-		 *	InputsLocked:  bool
-		 *	OutputsLocked: bool
-		 *	HasErrors:	   bool
-		 */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 		info: func() {
 			return tx.getResource(self.id)
 		},
 
-		/**
-		 * Returns true if resource has type equal to the one provided as an agrument.
-		 *
-		 * @param expectedType type to compare resource type with
-		 * @return true if type matches, false otherwise
-		 */
+
+
+
+
+
+
 		checkResourceType: func(expectedType) {
 			return resourceTypesEqual(self.info().Type, expectedType)
 		},
 
-		/**
-		 * Resource is ready when all inputs are set to the terminal values.
-		 */
+
+
+
 		isReady: func() {
 			return self.info().ResourceReady
 		},
@@ -304,20 +390,20 @@ resource = func(r) {
 			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
-		 *
-		 * @return data: []byte - raw resource data
-		 */
+
+
+
+
+
 		getData: func() {
 			if self.hasError() {
 				ll.panic("resource has errors: ", self.info())
@@ -325,31 +411,31 @@ resource = func(r) {
 			return self.info().Data;
 		},
 
-		/**
-		 * Get resource data as Json
-		 */
+
+
+
 		getDataAsJson: func() {
 			return json.decode(self.getData());
 		},
 
-		/**
-		 * Whether this resource has error
-		 */
+
+
+
 		hasError: func() {
 			return self._hasField("OneTimeWritables", "resourceError")
 		},
 
-		/**
-		 * Whether any of the input fields have errors. The resource itself may still not have
-		 * error status because error propagation was not yet happened.
-		 */
+
+
+
+
 		hasInputErrors: func() {
 			return self.info().HasErrors
 		},
 
-		/**
-		 * Return error set in the resource
-		 */
+
+
+
 		getError: func() {
 			if !self.info().HasErrors {
 				ll.panic("no error set in resource")
@@ -361,29 +447,29 @@ resource = func(r) {
 			return ll.fromStrict(self.info()[fieldMapName])[fieldName] != undefined
 		},
 
-		/**
-		 * Whether resource has input field with specified name
-		 *
-		 * @param name field name
-		 */
+
+
+
+
+
 		hasInputField: func(name) {
 			return self._hasField("Inputs", name)
 		},
 
-		/**
-		 * Whether resource has output field with specified name
-		 *
-		 * @param name field name
-		 */
+
+
+
+
+
 		hasOutputField: func(name) {
 			return self._hasField("Outputs", name)
 		},
 
-		/**
-		 * Whether resource has any field with specified name
-		 *
-		 * @param name field name
-		 */
+
+
+
+
+
 		hasField: func(name) {
 			return self._hasField("Inputs", name) ||
 				self._hasField("Outputs", name) ||
@@ -391,11 +477,11 @@ resource = func(r) {
 				self._hasField("OneTimeWritables", name)
 		},
 
-		// cached _inputs
+
 		_inputs: undefined,
-		/**
-		 * Returns resource inputs map name -> smart.Field
-		 */
+
+
+
 		inputs: func() {
 			if self._inputs == undefined {
 				info := self.info()
@@ -408,11 +494,11 @@ resource = func(r) {
 			return self._inputs
 		},
 
-		// cached _outputs
+
 		_outputs: undefined,
-		/**
-		 * Returns resource outputs map name -> smart.Field
-		 */
+
+
+
 		outputs: func() {
 			if(self._outputs == undefined) {
 				info := self.info()
@@ -425,11 +511,11 @@ resource = func(r) {
 			return self._outputs
 		},
 
-		/**
-		 * Get smart.Field by name
-		 *
-		 * @param name field name
-		 */
+
+
+
+
+
 		getField: func(name) {
 			if(!self.hasField(name)) {
 				ll.panic("field %v is not found", name)
@@ -438,59 +524,70 @@ resource = func(r) {
 			return field(ll.fieldId(self.id, name))
 		},
 
-		/**
-		 * Get future field given field name and field type.
-		 *
-		 * @param name: string - field name
-		 * @param fieldType: field type - input, output
-		 * @param eph: bool (optional) - when false, the operation becomes pure function, waiting for resource
-		 *                               to pass deduplication before resolution.
-		 *
-		 * @return field: smart.field
-		 */
+
+
+
+
+
+
+
+
+
+
 		getFutureField: func(name, fieldType, ...eph) {
 			isEph := strictSelf.isEphemeral()
-			if len(eph) > 0 {
+			if len(eph) > 0 && is_bool(eph[0]) {
 				isEph = eph[0]
 			}
 			return _getFutureField(strictSelf, name, fieldType, isEph)
 		},
 
-		/**
-		 * Get future input field given field name or a path
-		 *
-		 * @param nameOrPath: string|string[] - field name or an array representing a path to be traversed
-		 * @param eph: bool (optional) - when false, the operation becomes pure function, waiting for resource
-		 *                               to pass deduplication before resolution.
-		 *
-		 * @return field: smart.field
-		 */
-		getFutureInputField: func(nameOrPath, ...eph) {
+
+
+
+
+
+
+
+
+
+
+
+		getFutureFieldOptional: func(name, fieldType, ...eph) {
 			isEph := strictSelf.isEphemeral()
-			if len(eph) > 0 {
+			if len(eph) > 0 && is_bool(eph[0]) {
 				isEph = eph[0]
 			}
 
-			if is_array(nameOrPath) {
-				current := strictSelf
-				for name in nameOrPath {
-					current = current.getFutureField(name, "input", isEph)
-				}
-				return current
-			} else {
-				return self.getFutureField(nameOrPath, "input", isEph)
-			}
+			fieldId := ffDefault.getFutureFieldWithDefault(self.id, name, fieldType, isEph)
+			return field(fieldId)
 		},
 
-		/**
-		 * Get future output field given field name
-		 *
-		 * @param name: string - field name
-		 * @param eph: bool (optional) - when false, the operation becomes pure function, waiting for resource
-		 *                               to pass deduplication before resolution.
-		 *
-		 * @return field: smart.field
-		 */
+
+
+
+
+
+
+
+
+
+
+
+
+		getFutureInputField: func(nameOrPath, ...eph) {
+			return _getFutureInputField(strictSelf, nameOrPath, eph...)
+		},
+
+
+
+
+
+
+
+
+
+
 		getFutureOutputField: func(name, ...eph) {
 			isEph := strictSelf.isEphemeral()
 			if len(eph) > 0 {
@@ -498,52 +595,66 @@ resource = func(r) {
 			}
 
 			if !feats.pureFutureFields && !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)
 		},
 
-		/**
-		 * Get a resource set in field of a given field name
-		 *
-		 * @param name field name
-		 */
+
+
+
+
+
+
+
+
+
+
+		buildFutureField: func(nameOrPath) {
+			return _buildFutureField(self, nameOrPath)
+		},
+
+
+
+
+
+
 		get: func(name) {
 			return self.getField(name).getValue()
 		},
 
-		/**
-		 * Gets value from key value storage associated with resource if corresponding
-		 * record exists.
-		 *
-		 * @param key string key
-		 * @return bytes or undefined
-		 */
+
+
+
+
+
+
+
 		kvGet: func(key) {
 			return tx.resourceKeyValueGet(self.id, key)
 		},
 
-		/**
-		 * Sets bytes or string value to a key value storage associated
-		 * with resource.
-		 *
-		 * @param key string key
-		 * @param value to be set
-		 */
+
+
+
+
+
+
+
 		kvSet: func(key, value) {
 			tx.resourceKeyValueSet(self.id, key, value)
 		},
 
-		/**
-		 * Gets value as string from key value storage associated with resource if
-		 * corresponding record exists.
-		 *
-		 * @param key string key
-		 * @return string or undefined
-		 */
+
+
+
+
+
+
+
 		kvGetAsString: func(key) {
 			value := tx.resourceKeyValueGet(self.id, key)
 			if is_undefined(value) {
@@ -553,13 +664,13 @@ resource = func(r) {
 			}
 		},
 
-		/**
-		 * Gets value from key value storage associated with resource and
-		 * decodes as json if corresponding record exists.
-		 *
-		 * @param key string key
-		 * @return value or undefined
-		 */
+
+
+
+
+
+
+
 		kvGetAsJson: func(key) {
 			bytes := self.kvGet(key)
 			if is_undefined(bytes){
@@ -569,12 +680,12 @@ resource = func(r) {
 			}
 		},
 
-		/**
-		 * Sets json value to a key value storage associated with resource.
-		 *
-		 * @param key string key
-		 * @param value to be set
-		 */
+
+
+
+
+
+
 		kvSetJson: func(key, value) {
 			self.kvSet(key, json.encode(value))
 		}
@@ -598,77 +709,77 @@ field = func(f) {
 	self = {
 		_type: "field",
 
-		/**
-		 * Field id struct:
-		 *
-		 *	ResourceID: int64
-		 *	Name:		string
-		 *
-		 */
+
+
+
+
+
+
+
 		id: id,
 
-		/**
-		 * Field name
-		 */
+
+
+
 		name: func() {
 			return self.id.Name
 		},
 
-		/**
-		 * Associated smart.Resource
-		 */
+
+
+
 		resource: func() {
 			return resource(self.id.ResourceID)
 		},
 
-		/**
-		 * Field info:
-		 *
-		 *	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)
 		},
 
-		/**
-		 * Whether the field points to resource or error
-		 */
+
+
+
 		isSet: func() {
 			return self.info().IsSet
 		},
 
-		/**
-		 * Whether field is resolved to a value
-		 */
+
+
+
 		isValueSet: func() {
 			return self.info().Value != 0
 		},
 
-		/**
-		 * Whether field is resolved to a error
-		 */
+
+
+
 		isErrorSet: func() {
 			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
 			}
 
@@ -687,12 +798,12 @@ field = func(f) {
 			return rr
 		},
 
-		/**
-		 * Use cacheMillis, cacheSeconds, cacheMinutes, cacheHours and cacheDays to not make hidden mistakes in cache time ranges.
-		 * Sets the cache time.
-		 *
-		 * @param time: duration - the cache time from 'times' library.
-		 */
+
+
+
+
+
+
 		setCache: func(time) {
 			ll.assert(is_int(time) && time >= times.millisecond,
 				"smart.field.setCache: cache time must be an integer >= millisecond. Did you forget to import a standard tengo library 'times'?")
@@ -701,62 +812,62 @@ field = func(f) {
 			return self
 		},
 
-		/**
-		 * Sets the cache time in milliseconds.
-		 *
-		 * @param millis: number
-		 */
+
+
+
+
+
 		setCacheMillis: func(millis) {
 			ll.assert(is_int(millis) && millis > 0,
 				"smart.field.setCacheMillis: cache time must be a number of milliseconds (> 0)")
 			return self.setCache(millis * times.millisecond)
 		},
 
-		/**
-		 * Sets the cache time in seconds.
-		 *
-		 * @param seconds: number
-		 */
+
+
+
+
+
 		setCacheSeconds: func(seconds) {
 			ll.assert(is_int(seconds) && seconds > 0,
 				"smart.field.setCacheSeconds: cache time must be a number of seconds (> 0)")
 			return self.setCache(seconds * times.second)
 		},
 
-		/**
-		 * Sets the cache time in minutes.
-		 *
-		 * @param minutes: number
-		 */
+
+
+
+
+
 		setCacheMinutes: func(minutes) {
 			ll.assert(is_int(minutes) && minutes > 0,
 				"smart.field.setCacheMinutes: cache time must be a number of minutes (> 0)")
 			return self.setCache(minutes * times.minute)
 		},
 
-		/**
-		 * Sets the cache time in hours.
-		 *
-		 * @param hours: number
-		 */
+
+
+
+
+
 		setCacheHours: func(hours) {
 			ll.assert(is_int(hours) && hours > 0, "smart.field.setCacheHours: cache time must be a number of hours (> 0)")
 			return self.setCache(hours * times.hour)
 		},
 
-		/**
-		 * Sets the cache time in days
-		 *
-		 * @param days: number
-		 */
+
+
+
+
+
 		setCacheDays: func(days) {
 			ll.assert(is_int(days) && days > 0, "smart.field.setCacheDays: cache time must be a number of days (> 0)")
 			return self.setCache(days * 24 * times.hour)
 		},
 
-		/**
-		 * Returns a smart.Resource object from the resolved field value
-		 */
+
+
+
 		getValue: func() {
 			if self.isErrorSet() {
 				err := self.getError().getDataAsJson()
@@ -771,36 +882,36 @@ field = func(f) {
 			return resource(self.info().Value)
 		},
 
-		/**
-		 * Returns a smart.Resource object from the resolved field error
-		 */
+
+
+
 		getError: func() {
 			return resource(self.info().Error)
 		},
 
-		/**
-		 * Set (resolve) this field to a Json resource
-		 *
-		 * @param value any
-		 */
+
+
+
+
+
 		setJson: func(value) {
 			self.set(createJsonResource(value))
 		},
 
-		/**
-		 * Set (resolve) this field to a Map resource
-		 *
-		 * @param keyToValue any
-		 */
+
+
+
+
+
 		setMap: func(keyToValue) {
 			self.set(createMapResource(keyToValue))
 		},
 
-		/**
-		 * Set (resolve) this field to either another resource or field
-		 *
-		 * @param reference smart.resource or smart.field
-		 */
+
+
+
+
+
 		set: func(reference) {
 			ll.assert(!self.isSet(), "field ", self.name(), " is already set")
 
@@ -813,12 +924,12 @@ field = func(f) {
 			}
 		},
 
-		/**
-		 * Sets this field to either another resource, field or a JSON value.
-		 *
-		 * @param refOrJson: resource|field|JSON
-		 * @return nothing
-		 */
+
+
+
+
+
+
 		setRefOrJson: func(refOrJson) {
 			if is_undefined(refOrJson) {
 				ll.panic("attempt to assign undefined value to field %v", self.name())
@@ -826,66 +937,77 @@ field = func(f) {
 			self.set(_toRefOrJson(refOrJson))
 		},
 
-		/**
-		 * Returns a json encoded data of the resolved value resource
-		 */
+
+
+
 		getValueAsJson: func() {
 			return self.getValue().getDataAsJson()
 		},
 
-		/**
-		 * Get future field given field name and field type.
-		 *
-		 * @param name: string - field name
-		 * @param fieldType: field type: input, output
-		 * @param eph: bool (optional) - when false, the operation becomes pure function, waiting for resource
-		 *                               to pass deduplication before resolution.
-		 *
-		 * @return field: smart.field
-		 */
+
+
+
+
+
+
+
+
+
+
 		getFutureField: func(name, fieldType, ...eph) {
 			isEph := strictSelf.isEphemeral()
-			if len(eph) > 0 {
+			if len(eph) > 0 && is_bool(eph[0]) {
 				isEph = eph[0]
 			}
 			return _getFutureField(strictSelf, name, fieldType, isEph)
 		},
 
-		/**
-		 * Get future input field given field name or a path
-		 *
-		 * @param nameOrPath: string|string[] - field name or an array representing a path to be traversed
-		 * @param eph: bool (optional) - when false, the operation becomes pure function, waiting for resource
-		 *                               to pass deduplication before resolution.
-		 *
-		 * @return field: smart field
-		 */
-		getFutureInputField: func(nameOrPath, ...eph) {
+
+
+
+
+
+
+
+
+
+
+
+		getFutureFieldOptional: func(name, fieldType, ...eph) {
 			isEph := strictSelf.isEphemeral()
-			if len(eph) > 0 {
+			if len(eph) > 0 && is_bool(eph[0]) {
 				isEph = eph[0]
 			}
 
-			if is_array(nameOrPath) {
-				current := strictSelf
-				for name in nameOrPath {
-					current = current.getFutureField(name, "input", eph...)
-				}
-				return current
-			} else {
-				return self.getFutureField(nameOrPath, "input", eph...)
-			}
+			fieldId := ffDefault.getFutureFieldWithDefault(self.id, name, fieldType, isEph)
+			return field(fieldId)
+		},
+
+
+
+
+
+
+
+
+
+
+
+
+
+		getFutureInputField: func(nameOrPath, ...eph) {
+			return _getFutureInputField(strictSelf, nameOrPath, eph...)
 		},
 
-		/**
-		 * Get future output field given field name
-		 *
-		 * @param name: string - field name
-		 * @param eph: bool (optional) - when false, the operation becomes pure function, waiting for resource
-		 *                               to pass deduplication before resolution.
-		 *
-		 * @return field: smart field
-		 */
+
+
+
+
+
+
+
+
+
 		getFutureOutputField: func(name, ...eph) {
 			isEph := strictSelf.isEphemeral()
 			if len(eph) > 0 {
@@ -893,12 +1015,26 @@ field = func(f) {
 			}
 
 			if !feats.pureFutureFields && !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)
+		},
+
+
+
+
+
+
+
+
+
+
+
+		buildFutureField: func(nameOrPath) {
+			return _buildFutureField(strictSelf, nameOrPath)
 		}
 	}
 
@@ -908,29 +1044,29 @@ field = func(f) {
 }
 
 
-/**
- * Universal resource builder.
- *
- * @param r either resource id or resource info
- */
+
+
+
+
+
 resourceBuilder = func(r) {
 	super := resource(r)
 
 	self := undefined
 
-	// Mutator methods of the builder cannot be used after it was built.
+
 	built := false
 	assertNotBuilt := func() {
 		ll.assert(!built, "builder methods must not be used after a build() was called")
 	}
 
 	self = ll.toStrict(oop.inherit(super, {
-		/**
-		 * Create new field with given name and field type.
-		 *
-		 * @param name field name
-		 * @param fieldType: field type - input, output, dynamic, service, OTW. Use FTYPE_* constants.
-		 */
+
+
+
+
+
+
 		createField: func(name, fieldType) {
 			assertNotBuilt()
 			fid := ll.fieldId(super.id, name)
@@ -938,92 +1074,92 @@ resourceBuilder = func(r) {
 			return field(fid)
 		},
 
-		/**
-		 * Create service field with given name.
-		 * Service fields behave very like inputs, but with deduplication disabled.
-		 * This means, that if you create 2 resources, each having 1 input field with value "A" and the service
-		 * field with different values, they would be considered the same by backend.
-		 */
+
+
+
+
+
+
 		createServiceField: func(name) {
 			assertNotBuilt()
 			return self.createField(name, constants.FTYPE_SERVICE)
 		},
 
-		/**
-		 * Create new input field with given name.
-		 *
-		 * @param name field name
-		 */
+
+
+
+
+
 		createInputField: func(name) {
 			assertNotBuilt()
 			return self.createField(name, constants.FTYPE_INPUT)
 		},
 
-		/**
-		 * Create new output field with given name.
-		 *
-		 * @param name field name
-		 */
+
+
+
+
+
 		createOutputField: func(name) {
 			assertNotBuilt()
 			return self.createField(name, constants.FTYPE_OUTPUT)
 		},
 
-		/**
-		 * Lock resource outputs
-		 */
+
+
+
 		lockOutputs: func() {
 			assertNotBuilt()
 			tx.lockOutputs(super.id)
 		},
 
-		/**
-		 * Lock resource inputs
-		 */
+
+
+
 		lockInputs: func() {
 			assertNotBuilt()
 			tx.lockInputs(super.id)
 		},
 
-		/**
-		 * Lock both resource inputs and outputs
-		 */
+
+
+
 		lock: func() {
 			assertNotBuilt()
 			self.lockInputs()
 			self.lockOutputs()
 		},
 
-		/**
-		 * Lock inputs and outputs and return resulting smart.Resource
-		 */
+
+
+
 		lockAndBuild: func() {
 			self.lock()
 			built = true
 			return super
 		},
 
-		/**
-		 * Lock outputs and return resulting smart.Resource
-		 */
+
+
+
 		lockOutputsAndBuild: func() {
 			self.lockOutputs()
 			built = true
 			return super
 		},
 
-		/**
-		 * Lock inputs and return resulting smart.Resource
-		 */
+
+
+
 		lockInputsAndBuild: func() {
 			self.lockInputs()
 			built = true
 			return super
 		},
 
-		/**
-		 * Return smart.Resource without locking inputs and outputs
-		 */
+
+
+
 		buildUnlocked: func() {
 			built = true
 			return super
@@ -1033,12 +1169,12 @@ resourceBuilder = func(r) {
 	return self
 }
 
-/**
- * Creates a structural resource and returns a builder from it.
- *
- * @params resourceType a resource type
- * @params data, optional, bytes that will go in Data of the resource.
- */
+
+
+
+
+
+
 structBuilder = func(resourceType, ...data) {
 	id := undefined
 	if len(data) > 0 {
@@ -1050,71 +1186,71 @@ structBuilder = func(resourceType, ...data) {
 	return resourceBuilder(id)
 }
 
-/**
- * @param isEph: is ephemeral map
- */
+
+
+
 _mapBuilder := func(isEph) {
 	builder := isEph ? ephemeralBuilder(constants.RTYPE_MAP_EPH) : structBuilder(constants.RTYPE_MAP)
-	// ensure no outputs will be created
+
 	builder.lockOutputs()
 
 	self := undefined
 
 	self = ll.toStrict(oop.inherit(builder, {
-		/**
-		 * Adds a reference to the map by a given key.
-		 *
-		 * @param key: string - how the field will be named in the map
-		 * @param value: reference - a field or resource that will be set in the field
-		 * @return self: mapBuilder
-		 */
+
+
+
+
+
+
+
 		addRef: func(key, value) {
 			builder.createInputField(key).set(value)
 			return self
 		},
 
-		/**
-		 * Adds a primitive value that can be converted to JSON to the map.
-		 *
-		 * @param key: string - how the field will be named in the map
-		 * @param value: any - a primitive value, e.g. Tengo's map.
-		 * @return self: mapBuilder
-		 */
+
+
+
+
+
+
+
 		addJson: func(key, value) {
 			builder.createInputField(key).set(createJsonResource(value))
 			return self
 		},
 
-		/**
-		 * Adds object automatically converting non-reference objects into Json values.
-		 *
-		 * @param key: string - how the field will be named in the map
-		 * @param value: any - a reference or a primitive value
-		 * @return self: mapBuilder
-		 */
+
+
+
+
+
+
+
 		add: func(key, value) {
 			builder.createInputField(key).setRefOrJson(value)
 			return self
 		},
 
-		/**
-		 * Adds object automatically converting non-reference objects into Json values.
-		 * The object is added into service field, meaning the value would not affect deduplication of the map.
-		 *
-		 * @param key: string - how the field will be named in the map
-		 * @param value: any - a reference or a primitive value
-		 * @return self: mapBuilder
-		 */
+
+
+
+
+
+
+
+
 		addService: func(key, value) {
 			builder.createServiceField(key).setRefOrJson(value)
 			return self
 		},
 
-		/**
-		 * Creates a map in the platforma
-		 *
-		 * @return nothing
-		 */
+
+
+
+
+
 		build: func() {
 			return builder.lockAndBuild()
 		}
@@ -1142,6 +1278,15 @@ ephemeralBuilder = func(resourceType, ...data) {
 	return resourceBuilder(id)
 }
 
+createNullResource = func(...data) {
+	ll.assert(len(data) <= 1, "can't create null resource with more than one argument")
+	if len(data) > 0 && !is_undefined(data[0]) {
+		return resource(tx.createValue(constants.RTYPE_NULL.Name, constants.RTYPE_NULL.Version, data[0]))
+	} else {
+		return resource(tx.createValue(constants.RTYPE_NULL.Name, constants.RTYPE_NULL.Version, ""))
+	}
+}
+
 createValueResource = func(resourceType, data) {
 	ll.assert(data != undefined, "can't create resource with undefined data")
 	return resource(tx.createValue(resourceType.Name, resourceType.Version, data))
@@ -1150,10 +1295,10 @@ createValueResource = func(resourceType, data) {
 createJsonResource = func(value) {
 	ll.assert(value != undefined, "can't create Json value from undefined")
 
-	// important: strict map can't be encoded to JSON
+
 
 	ll.assert(!ll.isStrict(value), "can't encode strict map: ", value)
-	// value = ll.ensureNonStrict(value)
+
 
 	encoded := json.encode(value)
 
@@ -1191,6 +1336,7 @@ export ll.toStrict({
 	isAnyMapResource: isAnyMapResource,
 	isLockedEphMapResource: isLockedEphMapResource,
 	isJsonResource: isJsonResource,
+	isNullResource: isNullResource,
 	resource: resource,
 	field: field,
 	resourceBuilder: resourceBuilder,
@@ -1203,5 +1349,6 @@ export ll.toStrict({
 	createMapResourceWithType: createMapResourceWithType,
 	createMapResource: createMapResource,
 	createBinaryMapResource: createBinaryMapResource,
-	createBlobMapResource: createBlobMapResource
+	createBlobMapResource: createBlobMapResource,
+	createNullResource: createNullResource
 })