@platforma-sdk/workflow-tengo 2.14.0 → 2.15.0

package/dist/tengo/lib/file.lib.tengo

@@ -1,15 +1,15 @@
-/**
- * Functions to work with blobs / files.
- *
- * Allowing to create resources to import files from configured storages
- * as well as creation of resources to facilitate file upload from the
- * users machine.
- *
- * This library exposes rather high level functions working with
- * ImportFileHandle, encoding user intent to import a file from a pl-wide
- * configured storage or to upload file from users side in a universal
- * string representation.
- */
+
+
+
+
+
+
+
+
+
+
+
+
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 smart := import("@platforma-sdk/workflow-tengo:smart")
@@ -18,19 +18,19 @@ blobs := import("@platforma-sdk/workflow-tengo:file.internal")
 
 json := import("json")
 
-/**
- * Imports an external file into the workflow, either from pre-configured storage,
- * available from the pl instance, or from the client machine via upload.
- *
- * @param importFileHandle string a string file import handle, in most cases obtained via the
- *                         LS controller in UI
- *
- * @return a structure with two field references
- *         {
- *             file: field,
- *             handle: field
- *         }
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
 importFile := func(importFileHandle) {
 	validation.assertType(
 		importFileHandle,
@@ -56,10 +56,10 @@ importFile := func(importFileHandle) {
 	}
 }
 
-/**
- * Given a reference to the file, converts it into resource that can be
- * downloaded from the UI side.
- */
+
+
+
+
 exportFile := func(blob) {
 	builder := smart.structBuilder(blobs.RTYPE_BLOB_DOWNLOAD)
 

package/dist/tengo/lib/ll.get-future-field-default.lib.tengo

@@ -0,0 +1,137 @@
+tx := import("tx")
+plapi := import("plapi")
+fmt := import("fmt")
+json := import("json")
+
+
+
+
+
+
+
+isResourceId := func(value) {
+	return is_int(value)
+}
+
+
+
+
+
+
+
+isFieldId := func(value) {
+	return plapi.isStrictMap(value) &&
+		   plapi.mapHasKey(value, "ResourceID") &&
+		   plapi.mapHasKey(value, "Name")
+}
+
+
+
+
+
+
+
+
+
+
+
+
+getFutureFieldWithDefault := func(from, name, fieldType, isEph, ...options) {
+
+	fromIsResourceId := isResourceId(from)
+	fromIsFieldId := isFieldId(from)
+
+	if !fromIsResourceId && !fromIsFieldId {
+		txt := fmt.sprintf("'from' must be either a resource ID or a field ID, got: %#v", from)
+		plapi.print(txt)
+		plapi.setTemplateError(txt)
+		return 0
+	}
+
+	if len(options) > 1 {
+		txt := fmt.sprintf("expected at most 1 option, got: %d", len(options))
+		plapi.print(txt)
+		plapi.setTemplateError(txt)
+		return 0
+	}
+
+
+	defaultValue := 0
+	if len(options) == 1 {
+		defaultValue = options[0]
+	} else {
+		defaultValue = tx.createValue("Null", "1", "")
+	}
+
+
+	tplId := plapi.getTemplateId("@platforma-sdk/workflow-tengo:ll.get-field")
+
+
+	tplResource := 0
+	if isEph {
+		tplResource = tx.createEphemeral("EphRenderTemplate", "1")
+	} else {
+		tplResource = tx.createStruct("RenderTemplate", "1")
+	}
+
+	templateFieldId := plapi.newFieldID(tplResource, "template")
+	tx.createField(templateFieldId, "input")
+	tx.setFieldToResource(templateFieldId, tplId)
+
+
+	inputsMapResource := 0
+	if isEph {
+		inputsMapResource = tx.createEphemeral("std/map", "1")
+	} else {
+		inputsMapResource = tx.createStruct("std/map", "1")
+	}
+
+	resourceFieldId := plapi.newFieldID(inputsMapResource, "resource")
+	tx.createField(resourceFieldId, "input")
+
+	fieldNameFieldId := plapi.newFieldID(inputsMapResource, "fieldName")
+	tx.createField(fieldNameFieldId, "input")
+
+	fieldTypeFieldId := plapi.newFieldID(inputsMapResource, "fieldType")
+	tx.createField(fieldTypeFieldId, "input")
+
+	defaultValueFieldId := plapi.newFieldID(inputsMapResource, "defaultValue")
+	tx.createField(defaultValueFieldId, "input")
+
+	if fromIsResourceId {
+		tx.setFieldToResource(resourceFieldId, from)
+	} else {
+		tx.setFieldToField(resourceFieldId, from)
+	}
+
+	fieldNameResource := tx.createValue("json/object", "1", json.encode(name))
+	tx.setFieldToResource(fieldNameFieldId, fieldNameResource)
+
+	fieldTypeResource := tx.createValue("json/object", "1", json.encode(fieldType))
+	tx.setFieldToResource(fieldTypeFieldId, fieldTypeResource)
+
+	if isResourceId(defaultValue) {
+		tx.setFieldToResource(defaultValueFieldId, defaultValue)
+	} else {
+		tx.setFieldToField(defaultValueFieldId, defaultValue)
+	}
+
+	tx.lockInputs(inputsMapResource)
+
+	inputsMapFieldId := plapi.newFieldID(tplResource, "inputs")
+	tx.createField(inputsMapFieldId, "input")
+	tx.setFieldToResource(inputsMapFieldId, inputsMapResource)
+
+	tx.lockInputs(tplResource)
+
+	resultFieldId := plapi.newFieldID(tplResource, "outputs/result")
+	tx.createField(resultFieldId, "output")
+
+	tx.lockOutputs(tplResource)
+
+	return resultFieldId
+}
+
+export {
+	getFutureFieldWithDefault: getFutureFieldWithDefault
+}

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

@@ -1,66 +1,66 @@
-/* Low level pl API */
+
 
 plapi := import("plapi")
 fmt := import("fmt")
 log := import("log")
 text := import("text")
 
-/**
- * Prints message to the pl log
- */
+
+
+
 print := func(txt, ...args) {
 	plapi.print(txt, args...)
 }
 
-/**
- * Panics in a template, prints the error and
- * stops the execution of the template.
- * After that, the controller will set errors to outputs.
- */
+
+
+
+
+
 panic := func(msg, ...args) {
 	txt := fmt.sprintf(msg, args...)
 	plapi.print(txt)
 
-	// next statement actually terminates the execution
+
 	plapi.setTemplateError(txt)
 }
 
-/**
- * Asserts a given condition and panics if it is not met
- */
+
+
+
 assert := func(condition, msg, ...args) {
 	if !condition {
 		panic("assertion error: condition failed: "+msg, args...)
 	}
 }
 
-/**
- * Checks whether the given object is a strict map
- *
- * @param obj any
- * @return strict: bool - whether obj is a 'strict' map
- */
+
+
+
+
+
+
 isStrict := func(obj) {
 	return plapi.isStrictMap(obj)
 }
 
-/**
- * Checks whether the given object is a map, a strict map or an immutable map.
- *
- * @param obj any
- * @return bool whether obj is any kind of map object (map/immutable map/strict map)
- */
+
+
+
+
+
+
 isMap := func(obj) {
 	return is_map(obj) || is_immutable_map(obj) || isStrict(obj)
 }
 
-/**
- * Converts 'strict' map into a normal one
- *
- * @param r: map|strictMap (will panic if not)
- *
- * @return map: std map
- */
+
+
+
+
+
+
+
 fromStrict := func(r) {
 	if is_map(r) {
 		return r
@@ -73,12 +73,12 @@ fromStrict := func(r) {
 	return plapi.strictToMap(r)
 }
 
-/**
- * If input is a strict map, converts it to a normal one, otherwise returns the object as is
- *
- * @param r: any object (possible strict map)
- * @return map: tengo object
- */
+
+
+
+
+
+
 ensureNonStrict := func(r) {
 	if isStrict(r) {
 		return fromStrict(r)
@@ -87,15 +87,15 @@ ensureNonStrict := func(r) {
 	return r
 }
 
-/**
- * Converts map into a 'strict' map, which will panic on
- * access to non-existing elements.
- *
- * @param m: map|strictMap
- * @param recursive: boolean - convert also all child maps
- *
- * @return strict: strictMap
- */
+
+
+
+
+
+
+
+
+
 toStrict := func(v, ...recursive) {
 	if len(recursive) > 0 && recursive[0] {
 		if isMap(v) {
@@ -125,14 +125,14 @@ toStrict := func(v, ...recursive) {
 	return plapi.mapToStrict(v)
 }
 
-/**
- * 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) {
@@ -154,9 +154,9 @@ methodExists := func(module, methodName) {
 	return true
 }
 
-/**
- * Provides current API version available at runtime
- */
+
+
+
 apiVersion := func() {
 	if !methodExists(plapi, "apiVersion") {
 		return 0 // before we introduced apiVersion
@@ -165,16 +165,16 @@ apiVersion := func() {
 	return plapi.apiVersion
 }
 
-/**
- * Creates a field Id struct from given resource id and field name
- */
+
+
+
 fieldId := func(resourceId, fieldName) {
 	return plapi.newFieldID(resourceId, fieldName)
 }
 
-/**
- * Checks if <val> can be used as field ID
- */
+
+
+
 isFieldId := func(val) {
 	if !isStrict(val) {
 		return false
@@ -183,9 +183,9 @@ isFieldId := func(val) {
 	return v["ResourceID"] != undefined && v["Name"] != undefined
 }
 
-/**
- * Converts reference ID (resource ID or field ID) to stable string representation, suitable for use as map keys
- */
+
+
+
 idToString := func(referenceID) {
 	if isFieldId(referenceID) {
 		return fmt.sprintf("0x%X/%s", referenceID.ResourceID, referenceID.Name)
@@ -196,99 +196,99 @@ idToString := func(referenceID) {
 	panic("ll.idToString: <referenceID> cannot be used as resource or field ID")
 }
 
-/**
- * Returns current template renderer
- */
+
+
+
 getCurrentTemplateRenderer := func() {
 	return plapi.getTemplate()
 }
 
-/**
- * @return isInit: bool - true when current template is initializing (executed for the first time)
- */
+
+
+
 isInitializing := func() {
 	return plapi.isInit
 }
 
-/**
- * Get the list of executors available in current Platforma installation.
- *
- * @return executors: []string - list of executors, say ['executor', 'docker', ...]
- */
+
+
+
+
+
 getExecutorsList := func() {
 	return plapi.getExecutors()
 }
 
-/**
- * Joins path elements into a single path.
- *
- * @param elems: ...string - any number of elements.
- */
+
+
+
+
+
 filepathJoin := func(...elems) {
 	return plapi.filepathJoin(elems...)
 }
 
-/**
- * Like filepathJoin, joins elements to a single path,
- * but can be used safely in regexps.
- *
- * @param elems: ...string - any number of elements.
- */
+
+
+
+
+
+
 filepathRegexpJoin := func(...elems) {
 	escapedSeparator := plapi.regexpQuoteMeta(plapi.osSeparator)
 	return text.join(elems, escapedSeparator)
 }
 
-/**
- * Joins elements of the filepath and canonizes it, i.e.
- * semantically resolves ../ and ./ and changes slash
- * to a pathSeparator.
- *
- * @param elems: ...string - any number of elements.
- */
+
+
+
+
+
+
+
 filepathCanonize := func(...elem) {
 	return plapi.filepathCanonize(elem...)
 }
 
-/**
- * Returns a path separator. "/" on Unix-like systems, "\\" on Windows.
- *
- * @return separator: string
- */
+
+
+
+
+
 pathSeparator := plapi.osSeparator
 
-/**
- * Parses URL and returns a structure containing separe parts of the URL.
- *
- * The general form represented is:
- *
- *   [scheme:][//[userinfo@]host][/]path[?query][#fragment]
- *
- * URLs that do not start with a slash after the scheme are interpreted as:
- *
- *   scheme:opaque[?query][#fragment]
- *
- * Returns the floowing structure:
- *
- *   {
- *     Scheme: string,
- *     Host: string,
- *     Port: number,
- *     Path: string,
- *     RawPath: string,
- *     Query: string
- *   }
- *
- * @param url: string with the url
- * @return url structure: (see above)
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 parseUrl := func(url) {
 	return plapi.urlParse(url)
 }
 
-/**
- * Returns current execution context, which cab be used is a simple kv-store associated with the renderer instance.
- */
+
+
+
 getCtx := func() {
 	return plapi.getCtx()
 }