@platforma-sdk/workflow-tengo 2.14.0 → 2.15.0

package/dist/tengo/lib/workdir.lib.tengo

@@ -1,6 +1,6 @@
-/**
- * Gives an interface for working with workdirs.
- */
+
+
+
 
 json := import("json")
 
@@ -24,25 +24,25 @@ _WD_CREATE_FIELD_WORKDIR    := "workdir"
 _WD_FILL_FIELD_WORKDIR_IN   := "workdirIn"
 _WD_FILL_FIELD_WORKDIR_OUT  := "workdirOut"
 
-/**
- * Create empty working directory
- *
- * @return smart.field - field where working directory will appear after creation
- */
+
+
+
+
+
 create := func() {
-	// working directories without quotas (old-style)
+
 	wdCreate := smart.ephemeralBuilder(constants.RTYPE_WORKDIR_CREATE).lockAndBuild()
 	return wdCreate.getField(_WD_CREATE_FIELD_WORKDIR)
 }
 
-/**
- * Create empry working directory for given allocation. This means, the WD would actually be created only
- * when allocation is ready for usage.
- *
- * @param allocation: smart.reference - a reference to storage space allocation.
- *                                      It is usually obtained from StorageSpaceRequest
- *                                      (see exec.limits.storageSpaceRequestBuilder)
- */
+
+
+
+
+
+
+
+
 createV2 := func(allocation) {
 	wdCreate := smart.ephemeralBuilder(constants.RTYPE_WORKDIR_CREATE_2).lockAndBuild()
 	wdCreate.getField(_WD_CREATE_FIELD_ALLOCATION).set(allocation)
@@ -82,12 +82,12 @@ _getArchiveFillRule := func(dstDir, whatToExtract, archiveBlobKey) {
 	}
 }
 
-/**
- * Generates a value fill rule for a given file path.
- *
- * @param filePath: string - the path of the file.
- * @return rule: map - the value fill rule.
- */
+
+
+
+
+
+
 _getValueFillRule := func(filePath) {
 	return {
 		type: "value",
@@ -98,12 +98,12 @@ _getValueFillRule := func(filePath) {
 	}
 }
 
-/**
- * Generates a directory fill rule for a given directory.
- *
- * @param dir: string - the path of the directory.
- * @return rule: map - the directory fill rule.
- */
+
+
+
+
+
+
 _getDirFillRule := func(dir) {
 	return {
 		type: "dir",
@@ -113,14 +113,14 @@ _getDirFillRule := func(dir) {
 	}
 }
 
-/**
- * Fills a workdir with files, values, and directories.
- *
- * @return self: builder - a builder that adds files and directories to the workdir. */
+
+
+
+
 _fill := func() {
 	wd := smart.ephemeralBuilder(constants.RTYPE_WORKDIR_FILL)
 
-	/** @type reference - space allocation to be used for WD */
+
 	_allocation := undefined
 	blobs := {}
 	files := {}
@@ -140,28 +140,28 @@ _fill := func() {
 			sets.add(dirs, newDirs...)
 		},
 
-		/**
-		 * Use given storage allocation for working directory.
-		 *
-		 * @param allocation: reference
-		 */
+
+
+
+
+
 		allocation: func(allocation) {
 			validation.assertType(allocation, validation.reference, "workdir.builder: allocation should be a valid reference")
 			_allocation = allocation
 		},
 
-		/**
-		 * Adds files from given zip archive into working directory.
-		 *
-		 * @param zipResource: smart.reference - reference to zip archive to be extracted.
-		 * @param destinationDir: string - path inside working directory for files to be extracted from archive.
-		 *                                 Consider it as 'cd' before extraction. It makes all extracted files to be
-		 *                                 stored inside this directory.
-		 * @param pathsInArchive: string[] - paths inside the archive to be extracted into destinationDir.
-		 *                                   Empty array means 'unpack full archive'.
-		 *                                   Full file paths are preserved during extraction: the file 'a/b/file.txt' would
-		 *                                   be extracted into '<destinationDir>/a/b/file.txt', NOT '<destinationDir>/file.txt',
-		 */
+
+
+
+
+
+
+
+
+
+
+
+
 		addFromZip: func(zipResource, destinationDir, pathsInArchive) {
 			validation.assertType(zipResource, validation.reference, "workdir.builder.addFromZip: <zipResource> is not smart.reference")
 			validation.assertType(destinationDir, "string", "workdir.builder.addFromZip: <destinationDir> is not a string. It must be a path inside working directory")
@@ -193,12 +193,12 @@ _fill := func() {
 			return self
 		},
 
-		/**
-		 * Adds a file to the workdir.
-		 *
-		 * @param fileName: string - the name of the file.
-		 * @param fileResource: reference - the file to add.
-		 */
+
+
+
+
+
+
 		addFile: func(fileName, fileResource) {
 			validation.assertType(fileName, "string")
 			validation.assertType(fileResource, validation.reference)
@@ -210,22 +210,22 @@ _fill := func() {
 			return self
 		},
 
-		/**
-		 * Adds multiple files to the workdir.
-		 *
-		 * @param fileMap: map[string]reference - a map of files.
-		 */
+
+
+
+
+
 		addFiles: func(fileMap) {
 			enum.each(fileMap, self.addFile)
 			return self
 		},
 
-		/**
-		 * Adds a file with a content to the workdir.
-		 *
-		 * @param fileName: string - the name of the file.
-		 * @param contentRef: reference|any - the content as a reference to add or the content itself.
-		 */
+
+
+
+
+
+
 		writeFile: func(fileName, contentRef) {
 			validation.assertType(fileName, "string")
 			values[fileName] = contentRef
@@ -234,27 +234,27 @@ _fill := func() {
 			return self
 		},
 
-		/**
-		 * Adds multiple files with contents to the workdir.
-		 *
-		 * @param contentMap: map[string]any|reference - a map of references to a content or to a content itself.
-		 */
+
+
+
+
+
 		writeFiles: func(contentRefMap) {
 			enum.each(contentRefMap, self.writeFile)
 			return self
 		},
 
-		/**
-		 * Creates a possibly nested directory in the workdir.
-		 *
-		 * @param dir: string - the path of the directory.
-		 */
+
+
+
+
+
 		mkDir: func(dir) {
 			sets.add(dirs, path.getBasenameDirs(dir))
 			return self
 		},
 
-		/** Creates nested dirs. */
+
 		mkDirs: func(dirs) {
 			for _, dir in dirs {
 				self.mkDir(dir)
@@ -263,11 +263,11 @@ _fill := func() {
 			return self
 		},
 
-		/**
-		 * Builds the filled workdir.
-		 *
-		 * @return wd: reference - a reference to the filled workdir.
-		 */
+
+
+
+
+
 		build: func() {
 			emptyWorkdir := undefined
 			if feats.workdirLimits && smart.isReference(_allocation) {
@@ -311,63 +311,63 @@ _fill := func() {
 	return self
 }
 
-/**
- * Creates and fills a workdir with files, contents, and directories. See _fill for futher documentation.
- *
- * @return self: builder - a builder that adds files and directories to the workdir.
- */
+
+
+
+
+
 builder := func() {
 	return _fill()
 }
 
-/**
- * Saves a workdir.
- *
- * @param workdir: reference - a reference to the workdir to save.
- * @return self: builder - the builder that helps adding save rules to the save workdir.
- */
+
+
+
+
+
+
 save := func(workdir) {
 	ll.assert(smart.isReference(workdir), "workdir must be a reference to a resource or field")
 
-	// files to save
+
 	files := {}
-	// files to save their content
+
 	filesContent := {}
-	// file sets to save by regex
+
 	fileSets := {}
-	// file sets to save their content by regex
+
 	fileSetsContent := {}
 
 	self := undefined
 	self = ll.toStrict({
-		/**
-		 * Saves a file from the workdir.
-		 *
-		 * @param fileName: string - the name of the file.
-		 */
+
+
+
+
+
 		saveFile: func(fileName) {
 			validation.assertType(fileName, "string")
 			sets.add(files, fileName)
 			return self
 		},
 
-		/**
-		 * Saves a file to a value resource from the workdir.
-		 *
-		 * @param fileName: string - the name of the file.
-		 */
+
+
+
+
+
 		saveFileContent: func(fileName) {
 			validation.assertType(fileName, "string")
 			sets.add(filesContent, fileName)
 			return self
 		},
 
-		/**
-		 * Save files which names satisfy given regex rule
-		 *
-		 * @param name: string - a name to refer this file set in the outputs
-		 * @param regex: string - regex
-		 */
+
+
+
+
+
+
 		saveFileSet: func(name, regex) {
 			validation.assertType(regex, "string")
 			ll.assert(is_undefined(fileSets[name]), "file set with name '", name, "' is already in added")
@@ -375,12 +375,12 @@ save := func(workdir) {
 			return self
 		},
 
-		/**
-		 * Save files content which names satisfy given regex rule
-		 *
-		 * @param name: string - a name to refer this file set in the outputs
-		 * @param regex: string - regex
-		 */
+
+
+
+
+
+
 		saveFileSetContent: func(name, regex) {
 			validation.assertType(regex, "string")
 			ll.assert(is_undefined(fileSetsContent[name]), "file set content with name '", name, "' is already in added")
@@ -388,11 +388,11 @@ save := func(workdir) {
 			return self
 		},
 
-		/**
-		 * Builds the saved workdir.
-		 *
-		 * @return wd: reference - the saved workdir with additional fields.
-		 */
+
+
+
+
+
 		build: func() {
 
 			tpl := assets.importTemplate("@platforma-sdk/workflow-tengo:workdir.save")

package/dist/tengo/lib/workdir.proc.lib.tengo

@@ -1,10 +1,10 @@
-/** Library for workdir processor templates */
+
 
 tpl := import("@platforma-sdk/workflow-tengo:tpl")
 ll := import("@platforma-sdk/workflow-tengo:ll")
 wdSave := import("@platforma-sdk/workflow-tengo:workdir.save")
 
-// the template has a defined outputs
+
 tpl.defineOutputs(["result", "workdir"])
 
 proc := func() {
@@ -13,9 +13,9 @@ proc := func() {
 	self = {
 
 		_wdBefore: undefined,
-		/**
-		 * @return wd: resource - initial working directory resource
-		 */
+
+
+
 		wdBefore: func() {
 			if is_undefined(self._wdBefore) {
 				self._wdBefore = tpl.inputs().workdir
@@ -24,9 +24,9 @@ proc := func() {
 		},
 
 		_filesInWd: undefined,
-		/**
-		 * @return fileNames: string[] - list of file paths currently existing in the working directory
-		 */
+
+
+
 		filesInWd: func() {
 			if is_undefined(self._filesInWd) {
 				self._filesInWd = self.wdBefore().getDataAsJson().files
@@ -36,22 +36,22 @@ proc := func() {
 		},
 
 		_wdAfterReadFiles: undefined,
-		/**
-		 * @return wd: resource - working directory resource after "readFiles" is done
-		 */
+
+
+
 		wdAfterReadFiles: func() {
 			if is_undefined(self._wdAfterReadFiles) {
 
 				if !is_undefined(tpl.inputs().wdAfterReadFiles) {
 
-					//
-					// this means readFiles was used and we are actually
-					// in the 'prepare' render
-					//
+
+
+
+
 					self._wdAfterReadFiles = tpl.inputs().wdAfterReadFiles
 				} else {
 
-					// no readFiles
+
 					self._wdAfterReadFiles = self.wdBefore()
 				}
 			}
@@ -59,17 +59,17 @@ proc := func() {
 			return self._wdAfterReadFiles
 		},
 
-		/**
-		 * Select files to read their content and pass it to the body function
-		 *
-		 * @param cb: callback - a callback which takes a list of file names (paths) existing in the working directory and
-		 *  returning a map of key -> file name containing files to get content from; each file content will be available in
-		 *  the body inputs with the corresponding key
-		 */
+
+
+
+
+
+
+
 		readFiles: func(cb) {
 			tpl.prepare(func(inputs){
 				inputs.files = self.filesInWd()
-				// key -> file name
+
 				files := cb(inputs)
 
 				wdBuilder := wdSave.builder(self.wdBefore())
@@ -78,7 +78,7 @@ proc := func() {
 				}
 				wd := wdBuilder.build()
 
-				// run prepare to get file contents in the inputs
+
 				preps := {}
 				for key, fName in files {
 					preps[key] = wd.getSavedFileContent(fName)
@@ -91,9 +91,9 @@ proc := func() {
 		},
 
 		_wdFinalBuilder: undefined,
-		/**
-		 * Final workdir builder, after prepare
-		 */
+
+
+
 		wdFinalBuilder: func() {
 			if is_undefined(self._wdFinalBuilder) {
 				self._wdFinalBuilder = wdSave.builder(self.wdAfterReadFiles())
@@ -101,34 +101,34 @@ proc := func() {
 			return self._wdFinalBuilder
 		},
 
-		/**
-		 * Save given file.
-		 *
-		 * @return ref: reference - a reference to saved file resource
-		 */
+
+
+
+
+
 		saveFile: func(fName) {
 			self.wdFinalBuilder().saveFile(fName)
 			return self.wdFinalBuilder().getSavedFile(fName)
 		},
 
-		/**
-		 * Save content of a given file.
-		 *
-		 * @return ref: reference - a reference to saved file content value resource
-		 */
+
+
+
+
+
 		saveFileContent: func(fName) {
 			self.wdFinalBuilder().saveFileContent(fName)
 			return self.wdFinalBuilder().getSavedFileContent(fName)
 		},
 
-		/**
-		 * Template body function
-		 *
-		 * @param cb: func - a callback function to run in template body; the inputs passed to the body will have the following fields:
-		 *   files: string[] - list of files in workdir
-		 *   args: map - additional arguments of the template processor
-		 *   ...filesContent: resources - fields with the content of files specified in 'readFiles'
-		 */
+
+
+
+
+
+
+
+
 		body: func(cb) {
 			tpl.body(func(inputs) {
 
@@ -147,7 +147,7 @@ proc := func() {
 	return ll.toStrict(self)
 }
 
-/** singleton instance  */
+
 instance := proc()
 
 export ll.toStrict({