@platforma-sdk/workflow-tengo 2.14.0 → 2.15.1

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

@@ -1,6 +1,6 @@
-/**
- * A library that creates RunCommand resource.
- */
+
+
+
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 feats := import("@platforma-sdk/workflow-tengo:feats")
@@ -21,11 +21,11 @@ _RTYPE_RUN_COMMAND_REFS := { Name: "RunCommandRefs", Version: "1" }
 _FIELD_WORKDIR_IN := "workdirIn"
 _FIELD_WORKDIR_OUT := "workdirOut"
 
-/**
- * Creates a simple argument for the command.
- *
- * @param argument: string - the argument to create.
- */
+
+
+
+
+
 _createSimpleArg := func(argument) {
 	return {
 		type: constants.ARG_TYPE_STRING,
@@ -33,11 +33,11 @@ _createSimpleArg := func(argument) {
 	}
 }
 
-/**
- * @deprecated, use _createRenderedArg
- * Creates 'variableRef' argument.
- * @param argTpl: string - argument value in any form with variables inside (e.g. "file://{pkg}/some-file" or "o-{java}-o")
- */
+
+
+
+
+
 _createVariableArg := func(argTpl) {
 	return {
 		type: constants.ARG_TYPE_VAR,
@@ -45,13 +45,13 @@ _createVariableArg := func(argTpl) {
 	}
 }
 
-/**
- * Creates 'expressionRef' arguments
- * @param argTpl: string - arguments value in any form with expressions inside, e.g.:
- *   - `–Xms{env.PL_EXEC_HARD_MEMORY_LIMIT_MB * 80 / 100}m`
- *   - `file://{pkg}/some-file`
- *   - `o-{java}-o`
- */
+
+
+
+
+
+
+
 _createExpressionArg := func(argTpl) {
 	return {
 		type: constants.ARG_TYPE_EXPRESSION,
@@ -59,12 +59,12 @@ _createExpressionArg := func(argTpl) {
 	}
 }
 
-/**
- * Builder function for creating a RunCommand resource.
- *
- * @param workdir: string - the working directory for the command.
- * @return builder - the builder object with methods for configuring and building the RunCommand resource.
- */
+
+
+
+
+
+
 builder := func(workdir) {
 	res := smart.ephemeralBuilder(_RTYPE_RUN_COMMAND)
 	res.getField(_FIELD_WORKDIR_IN).set(workdir)
@@ -87,38 +87,38 @@ builder := func(workdir) {
 	nErrorLines := 200
 
 	self = ll.toStrict(oop.inherit(res, {
-		/**
-		 * Sets the command, e.g. /usr/bin/env or sh.
-		 *
-		 * @param commandName: string - the name of the command.
-		 */
+
+
+
+
+
 		cmd: func(commandName) {
 			cmd = _createSimpleArg(commandName)
 			return self
 		},
 
-		/**
-		 * Sets the command with variables inside to be rendered using rules
-		 * from .substitutionRules().
-		 *
-		 * @param commandTpl: string - string with '{varName}' substitutions to be replaced with
-		 *                             software paths. Replace rules are defined by .substitutionRule()
-		 *                             and .substitutionRules(),
-		 */
+
+
+
+
+
+
+
+
 		cmdVar: func(commandTpl) {
 			cmd = _createVariableArg(commandTpl)
 			hasPatternArgs = true
 			return self
 		},
 
-		/**
-		 * Sets the command with expressions inside to be rendered using rules
-		 * from .substitutionRules().
-		 *
-		 * @param commandTpl: string - string with '{any expression}' substitutions to be replaced with
-		 *                             software paths. Replace rules are defined by .substitutionRule()
-		 *                             and .substitutionRules(),
-		 */
+
+
+
+
+
+
+
+
 		cmdExpression: func(commandTpl) {
 			cmd = _createExpressionArg(commandTpl)
 			hasExpressionArgs = true
@@ -140,38 +140,38 @@ builder := func(workdir) {
 			ll.panic("runcmd.builder().cmdTyped: unknown type %s, expect: %v", type, constants.ARG_TYPES)
 		},
 
-		/**
-		 * Adds an argument to the command.
-		 *
-		 * @param arg: string - the argument to add.
-		 */
+
+
+
+
+
 		arg: func(arg) {
 			args = append(args, _createSimpleArg(arg))
 			return self
 		},
 
-		/**
-		 * Adds an argument with variables inside to be rendered using rules
-		 * from .substitutionRules().
-		 *
-		 * @param argTpl: string - string with '{varName}' substitutions to be replaced with
-		 *                         software paths. Replace rules are defined by .substitutionRule()
-		 *                         and .substitutionRules(),
-		 */
+
+
+
+
+
+
+
+
 		argVar: func(argTpl) {
 			args = append(args, _createVariableArg(argTpl))
 			hasPatternArgs = true
 			return self
 		},
 
-		/**
-		 * Adds an argument with variables inside to be rendered using rules
-		 * from .substitutionRules().
-		 *
-		 * @param argTpl: string - string with '{expression}' substitutions to be replaced with
-		 *                         expression value. Replace rules are defined by .substitutionRule()
-		 *                         and .substitutionRules(),
-		 */
+
+
+
+
+
+
+
+
 		argExpression: func(argTpl) {
 			args = append(args, _createExpressionArg(argTpl))
 			hasExpressionArgs = true
@@ -193,12 +193,12 @@ builder := func(workdir) {
 			ll.panic("runcmd.builder().argTyped: unknown type %s, expect: %v", type, constants.ARG_TYPES)
 		},
 
-		/**
-		 * Adds a reference for using it in expressions next.
-		 *
-		 * @param refKey: string - the name of the ref
-		 * @param ref: reference - a reference to the valid field or resource
-		 */
+
+
+
+
+
+
 		ref: func(refKey, ref) {
 			ll.assert(smart.isReference(ref),
 				"runcmd.builder().ref() must be a reference (valid field or resource)")
@@ -210,37 +210,37 @@ builder := func(workdir) {
 			return self
 		},
 
-		/**
-		 * Sets an environment variable for the command.
-		 *
-		 * @param name: string - the name of the environment variable.
-		 * @param value: string - the value of the environment variable.
-		 */
+
+
+
+
+
+
 		env: func(name, value) {
 			envs[name] = value
 			return self
 		},
 
-		/**
-		 * Sets environment variable with substitution inside value, to be rendered
-		 * using rules from .substitutionRules().
-		 *
-		 * @param name: string - the name of the environment variable.
-		 * @param valueTpl: string - the value of the environment variable.
-		 */
+
+
+
+
+
+
+
 		envVar: func(name, valueTpl) {
 			envs[name] = _createVariableArg(valueTpl)
 			hasPatternArgs = true
 			return self
 		},
 
-		/**
-		 * Sets environment variable with substitution inside value, to be rendered
-		 * using rules from .substitutionRules().
-		 *
-		 * @param name: string - the name of the environment variable.
-		 * @param valueTpl: string - the value of the environment variable.
-		 */
+
+
+
+
+
+
+
 		envExpression: func(name, valueTpl) {
 			envs[name] = _createExpressionArg(valueTpl)
 			hasExpressionArgs = true
@@ -262,12 +262,12 @@ builder := func(workdir) {
 			ll.panic("runcmd.builder().envTyped: unknown type %s, expect: %v", type, constants.ARG_TYPES)
 		},
 
-		/*
-		 * Patch 'PATH' environment variable, adding software path to it.
-		 *
-		 * @param type: constants.ARG_TYPES - whether Platforma Backend should try to substitute variables or expressions inside <value> on server side
-		 * @param value: string - the value of the environment variable with variables to be replaced to software path.
-		 */
+
+
+
+
+
+
 		addToPath: func(type, value) {
 			ll.assert(slices.hasElement(constants.ARG_TYPES, type),
 				"runcmd.builder().addToPath: unknown type %s, expect: %v", type, constants.ARG_TYPES)
@@ -287,23 +287,23 @@ builder := func(workdir) {
 			return self
 		},
 
-		/**
-		 * Define substitution variable for software args.
-		 *
-		 * @param varName: string - variable to be substituted in arg value ("var1" would be
-		 *                          substituted in place of {var1} of arg value)
-		 * @param refKey: string - key of ref (added with .ref()) that points to installed software.
-		 */
+
+
+
+
+
+
+
 		substitutionRule: func(varName, refKey) {
 			substRules[varName] = refKey
 			return self
 		},
 
-		/**
-		 * Batched .substitutionRule() call (add several rules in single call)
-		 *
-		 * @param rules: map[string]string - <var name> -> <ref key> pairs to be added to substitution rules.
-		 */
+
+
+
+
+
 		substitutionRules: func(rules) {
 			for k, v in rules {
 				substRules[k] = v
@@ -311,53 +311,53 @@ builder := func(workdir) {
 			return self
 		},
 
-		/**
-		 * Sets the queue name for the command.
-		 *
-		 * @param queueName: string - the name of the queue.
-		 */
+
+
+
+
+
 		inQueue: func(queueName) {
 			queue = queueName
 			return self
 		},
 
-		/**
-		 * Sets the stdout file name for the command.
-		 *
-		 * @param fileName: string - the name of the stdout file.
-		 */
+
+
+
+
+
 		stdout: func(fileName) {
 			stdout = fileName
 			return self
 		},
 
-		/**
-		 * Sets the stderr file name for the command.
-		 *
-		 * @param fileName: string - the name of the stderr file.
-		 */
+
+
+
+
+
 		stderr: func(fileName) {
 			stderr = fileName
 			return self
 		},
 
-		/**
-		 * Sets the number of error lines for the command.
-		 *
-		 * @param number: int - the number of error lines.
-		 */
+
+
+
+
+
 		nErrorLines: func(number) {
 			nErrorLines = number
 			return self
 		},
 
-		/**
-		 * Builds the RunCommand resource.
-		 *
-		 * @return object - the built RunCommand resource.
-		 */
+
+
+
+
+
 		build: func() {
-			// TODO: add assertions about the state
+
 
 			ll.assert(!hasPatternArgs || len(substRules) != 0,
 				"found pattern argument, but no substitution rules were set: hasPatternArgs: %v, substRules: %v, cmd: %v, args: %v, envs: %v",

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

@@ -1,6 +1,6 @@
-/**
- * A library for run environments creation and bootstrapping.
- */
+
+
+
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 smart := import("@platforma-sdk/workflow-tengo:smart")
@@ -40,9 +40,9 @@ saveBuilder := func(wd) {
 			return self
 		},
 
-		/**
-		 * Bind package to created run environment, holding it as long as run environment exists.
-		 */
+
+
+
 		addPackage: func(key, pkgRef) {
 			ll.assert(!maps.containsKey(packagesMap, key), "runenv.saveBuilder.addPackage: package %q was already added to SaveRunEnv builder", key)
 			validation.assertType(pkgRef, validation.reference, "runenv.saveBuilder.addPackage: <pkgRef> must be reference")
@@ -68,22 +68,22 @@ saveBuilder := func(wd) {
 				set(smart.createMapResource(packagesMap))
 
 			return oop.inherit(envSaver.lockAndBuild(), {
-				/**
-				 * Run environment reference
-				 *
-				 * @return runEnv: smart.field - field where run environment appears
-				 *                               after operation is done
-				 */
+
+
+
+
+
+
 				runEnv: func() {
 					return envSaver.getField(_OUTPUT_RUN_ENV)
 				},
 
-				/**
-				 * Working directory reference after operation is complete
-				 *
-				 * @return wd: smart.field - field where workdir appears after
-				 *                           operation is done
-				 */
+
+
+
+
+
+
 				workdir: func() {
 					return envSaver.getField(_OUTPUT_WD_OUT)
 				}

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

@@ -1,6 +1,6 @@
-/**
- * A library for working with streams.
- */
+
+
+
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 smart := import("@platforma-sdk/workflow-tengo:smart")
@@ -10,13 +10,13 @@ file := import("@platforma-sdk/workflow-tengo:file")
 _RTYPE_CREATE_STREAM := { Name: "CreateStream", Version: "2" }
 _RTYPE_STREAM_MANAGER := { Name: "StreamManager", Version: "2" }
 
-/**
- * Creates a stream in the specified workdir for the given file path.
- *
- * @param workdir: reference - a reference to the workdir.
- * @param filePath: string - the path of the file in the workdir.
- * @return stream: resource - a smart.resource to the created stream with an output field.
- */
+
+
+
+
+
+
+
 _create := func(workdir, filePath) {
 	stream := smart.ephemeralBuilder(_RTYPE_CREATE_STREAM)
 	stream.getField("workdir").set(workdir)
@@ -27,13 +27,13 @@ _create := func(workdir, filePath) {
 	}))
 }
 
-/**
- * Creates a special manager resource that has either a blob or a stream in the `stream` field.
- *
- * @param stream: reference - a reference to the stream.
- * @param downloadableRef: reference - a reference to the downloadable content.
- * @return manager: reference - a reference to the stream manager.
- */
+
+
+
+
+
+
+
 _manager := func(stream, downloadableRef) {
 	res := smart.structBuilder(_RTYPE_STREAM_MANAGER)
 
@@ -43,14 +43,14 @@ _manager := func(stream, downloadableRef) {
 	return res.lockAndBuild()
 }
 
-/**
- * Creates a stream and manages its downloadable content.
- *
- * @param workdirBefore: reference - a reference to the workdir before RunCommand were executed.
- * @param workdirAfter: reference - a reference to the resulted workdir field of RunCommand.
- * @param filePath: string - the path of the file in the workdir.
- * @return manager: reference - a reference to the stream manager.
- */
+
+
+
+
+
+
+
+
 create := func(workdirBefore, workdirAfter, filePath) {
 	stream := _create(workdirBefore, filePath)
 	fileFuture := workdirAfter.files.getFutureInputField(filePath)

package/dist/tengo/lib/feats.lib.tengo

@@ -1,6 +1,6 @@
-/**
- * Catalogue of features available in current execution context.
- */
+
+
+
 plapi := import("plapi")
 ll := import("@platforma-sdk/workflow-tengo:ll")
 

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

@@ -1,13 +1,13 @@
-/**
- * Internal functions to work with blobs.
- *
- * This file contains functions intended for use only within workflow tengo SDK.
- * Their parameters list, results and other parts of the interface may change from
- * vertion to version without prior notice.
- *
- * DO NOT USE them in workflows or templates directly.
- *
- */
+
+
+
+
+
+
+
+
+
+
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 smart := import("@platforma-sdk/workflow-tengo:smart")
@@ -15,21 +15,21 @@ validation := import("@platforma-sdk/workflow-tengo:validation")
 
 json := import("json")
 
-//
-// Resource types:
-//
+
+
+
 
 RTYPE_BLOB_IMPORT_EXTERNAL := { Name: "BlobImportExternal", Version: "1" }
 RTYPE_BLOB_IMPORT_INTERNAL := { Name: "BlobImportInternal", Version: "1" }
 RTYPE_BLOB_UPLOAD := { Name: "BlobUpload", Version: "1" }
 RTYPE_BLOB_DOWNLOAD := { Name: "BlobDownload", Version: "2" }
 
-/**
- * Create a task for importing blob from external service by URL
- * Produces 2 fields:
- *  'file' - reference to blob to appear once import gets finished.
- *  'handle' - reference to resource with 'progress' API.
- */
+
+
+
+
+
+
 createBlobImportExternal := func(settings) {
 	validation.assertType(settings, {
 		"dataURL": "string",
@@ -45,12 +45,12 @@ createBlobImportExternal := func(settings) {
 	})
 }
 
-/**
- * Create a task for importing blob from one of preconfigured storages.
- * Produces 2 fields:
- *  'file' - reference to blob to appear once import gets finished.
- *  'handle' - reference to resource with 'progress' API.
- */
+
+
+
+
+
+
 createBlobImportInternal := func(settings) {
 	validation.assertType(settings, {
 		"path": "string",
@@ -67,12 +67,12 @@ createBlobImportInternal := func(settings) {
 	})
 }
 
-/**
- * Create a task for getting a blob directly from the user via 'upload' procedure.
- * Produces 2 fields:
- *  'file' - reference to blob to appear once upload gets finished.
- *  'handle' - reference to resource with 'progress' and 'upload' APIs.
- */
+
+
+
+
+
+
 createBlobUpload := func(settings) {
 	validation.assertType(settings, {
 		"modificationTime": "string",