@platforma-sdk/workflow-tengo 1.6.4 → 1.7.1

package/dist/tengo/lib/assets.lib.tengo

@@ -34,6 +34,7 @@ importSoftware := func(swName) {
 	sw := plapi.getSoftwareInfo(swName)
 	return ll.toStrict({
 		_type: "softwareDescriptor",
+		_id: sw.id,
 
 		resource: smart.resource(sw.id),
 		name: sw.name,
@@ -43,6 +44,21 @@ importSoftware := func(swName) {
 	})
 }
 
+/**
+ * Checks if given item is a software info
+ *
+ * @param toCheck: any - item to check
+ *
+ * @return isSoftware: boolean - true for software info, loaded with importSoftware()
+ */
+isSoftwareInfo := func(toCheck) {
+	if !ll.isMap(toCheck) {
+		return false
+	}
+
+	return (ll.fromStrict(toCheck)._type) == "softwareDescriptor"
+}
+
 /**
  * Returns asset description suitable for 'exec' operations.
  * Asset is the way to put static files into working directory before execution of the command.
@@ -53,10 +69,11 @@ importSoftware := func(swName) {
  *                              - "@company/package:some-oftware"
  *                              - ":my-local-software"
  */
-importAsset := func(swName) {
-	asset := plapi.getSoftwareInfo(swName)
+importAsset := func(assetName) {
+	asset := plapi.getSoftwareInfo(assetName)
 	return ll.toStrict({
 		_type: "assetDescriptor",
+		_id: asset.id,
 
 		resource: smart.resource(asset.id),
 		name: asset.name,
@@ -67,22 +84,24 @@ importAsset := func(swName) {
 }
 
 /**
- * Checks if given item is a software info
+ * Checks if given item is an asset info
  *
  * @param toCheck: any - item to check
  *
- * @return isSoftware: boolean - true for software info, loaded with importSoftware()
+ * @return isAsset: boolean - true for asset info, loaded with importAsset()
  */
-isSoftwareInfo := func(toCheck) {
+isAssetInfo := func(toCheck) {
 	if !ll.isMap(toCheck) {
 		return false
 	}
 
-	return (ll.fromStrict(toCheck)._type) == "softwareDescriptor"
+	return (ll.fromStrict(toCheck)._type) == "assetDescriptor"
 }
 
 export ll.toStrict({
 	importTemplate: importTemplate,
 	importSoftware: importSoftware,
-	isSoftwareInfo: isSoftwareInfo
+	isSoftwareInfo: isSoftwareInfo,
+	importAsset:    importAsset,
+	isAssetInfo:    isAssetInfo
 })

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

@@ -65,6 +65,11 @@ builder := func() {
 	// workdir processors
 	wdProcessors := {}
 
+	// assets to be extracted into workdir before execution
+	assetInfos := {}
+	assetDescriptors := {}
+	assetRules := {}
+
 	stdout := "stdout.txt"
 	stderr := "stderr.txt"
 
@@ -94,7 +99,7 @@ builder := func() {
 		software: func(sw) {
 			assertEntrypointNotSet()
 			ll.assert(assets.isSoftwareInfo(sw),
-				"exec.builder.software: <software> parameter is not a software info. Provide the value obtained from ll.importSoftware() here"
+				"exec.builder.software: <software> parameter is not a software info. Provide the value obtained from assets.importSoftware() here"
 			)
 
 			soft = sw
@@ -247,7 +252,7 @@ builder := func() {
 			cache = days * times.hour * 24
 			return self
 		},
-		
+
 		/**
 		 * Sets the number of error lines to be captured.
 		 *
@@ -262,6 +267,39 @@ builder := func() {
 			return self
 		},
 
+		/**
+		 * Adds files from given asset into working directory.
+		 *
+		 * @param asset: assetInfo - asset info loaded from assets.importAsset()
+		 * @param destinationDir: string - path inside working directory for files to be extracted from archive.
+		 * @param pathsInArchive: string[] - paths inside the archive to be extracted into destinationDir.
+		 *                                   Empty array means 'unpack full archive'.
+		 */
+		addAsset: func(asset, destinationDir, pathsInArchive) {
+			ll.assert(assets.isAssetInfo(asset),
+				"exec.builder.addAsset: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
+
+			validation.assertJsonSchema(destinationDir, "string", "exec.builder.addAsset: <destinationDir> is not a string. It must be a path inside working directory")
+			validation.assertJsonSchema(pathsInArchive, ["string"], "exec.builder.addAsset: <pathsInArchive> must contain list of strings with paths inside archive")
+
+			assetIdKey := ll.idToString(asset._id)
+			if is_undefined(assetRules[assetIdKey]) {
+				assetInfos[assetIdKey] = asset.resource
+				assetDescriptors[assetIdKey] = ll.fromStrict(asset.descriptor)
+				assetRules[assetIdKey] = {}
+			}
+
+			if len(pathsInArchive) == 0 || is_undefined(assetRules[assetIdKey][destinationDir]) {
+				assetRules[assetIdKey][destinationDir] = []
+			}
+
+			if (len(pathsInArchive) > 0) {
+				assetRules[assetIdKey][destinationDir] = append(assetRules[assetIdKey][destinationDir], pathsInArchive...)
+			}
+
+			return self
+		},
+
 		/**
 		 * Adds a file to the working directory
 		 *
@@ -474,7 +512,10 @@ builder := func() {
 				fileSetsToSave: fileSetsToSave,
 				fileSetsContentToSave: fileSetsContentToSave,
 				filesToStream: slices.fromSet(filesToStream),
-				wdProcessors: wdProcessors
+				wdProcessors: wdProcessors,
+				assets: smart.createMapResource(assetInfos),
+				assetDescriptors: assetDescriptors,
+				assetRules: assetRules
 			}
 
 			if !is_undefined(soft) {

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

@@ -24,6 +24,12 @@ binaryDescriptorScheme := {
 	runEnv: runEnvDescriptorScheme
 }
 
+assetDescriptorScheme := {
+	registry: "string",
+	package: "string",
+	url: "string"
+}
+
 localDescriptorScheme := {
 	hash: "string",
 	path: "string",
@@ -34,6 +40,7 @@ localDescriptorScheme := {
 descriptorScheme := {
 	"isDev,omitempty": "bool",
 	"binary,omitempty": binaryDescriptorScheme,
+	"asset,omitempty": assetDescriptorScheme,
 	"local,omitempty": localDescriptorScheme
 }
 
@@ -135,22 +142,21 @@ use := func(settings) {
 	return self
 }
 
-
 _RTYPE_PACKAGE_PUT_ASSET := { Name: "PackagePutAssetsToWD", Version: "1" }
 _INPUT_PACKAGE := "package"
 _INPUT_WD_IN := "workdirIn"
 _OUTPUT_WD_OUT := "workdirOut"
 
 /**
- * Load assets and provide them as files or raw content.
+ * Load static files from software package into working directory or value resources.
  *
  * @param pkg: package - installed package (usually from package.install(<archive>))
  *
- * @return loader: assetsLoader - builder that provides requested files and content after load() call
+ * @return loader: pkgFileLoader - builder that provides requested files and content after load() call
  */
-assetsLoader := func(pkg) {
+pkgFileLoader := func(pkg) {
 	ll.assert(smart.isReference(pkg),
-		"package.loadAssets: <pkg> must be reference to installed package. It is usually obtained from package.install().package")
+		"package.pkgFileLoader: <pkg> must be reference to installed package. It is usually obtained from package.install().package")
 
 	filePaths := []
 	fileContentPaths := []
@@ -159,14 +165,14 @@ assetsLoader := func(pkg) {
 
 	self = {
 		saveFile: func(path) {
-			validation.assertJsonSchema(path, "string", "package.assetsLoader.saveFile: <path> must be string")
+			validation.assertJsonSchema(path, "string", "package.pkgFileLoader.saveFile: <path> must be string")
 			filePaths = append(filePaths, path)
 
 			return self
 		},
 
 		saveFiles: func(paths) {
-			validation.assertJsonSchema(paths, ["string"], "package.assetsLoader.saveFiles: <paths> must be array of strings")
+			validation.assertJsonSchema(paths, ["string"], "package.pkgFileLoader.saveFiles: <paths> must be array of strings")
 			for p in paths {
 				self.saveFile(p)
 			}
@@ -175,13 +181,13 @@ assetsLoader := func(pkg) {
 		},
 
 		saveFileContent: func(path) {
-			validation.assertJsonSchema(path, "string", "package.assetsLoader.saveFileContent: <path> must be string")
+			validation.assertJsonSchema(path, "string", "package.pkgFileLoader.saveFileContent: <path> must be string")
 			fileContentPaths = append(fileContentPaths, path)
 			return self
 		},
 
 		saveFilesContent: func(paths) {
-			validation.assertJsonSchema(paths, ["string"], "package.assetsLoader.saveFilesContent: <paths> must be array of strings")
+			validation.assertJsonSchema(paths, ["string"], "package.pkgFileLoader.saveFilesContent: <paths> must be array of strings")
 			for p in paths {
 				self.saveFileContent(p)
 			}
@@ -252,8 +258,8 @@ assetsLoader := func(pkg) {
  *
  * @return file: singleAsset - object with reference to the file resource and progress report
  */
-loadAssetFile := func(pkg, assetPath) {
-	assets := assetsLoader(pkg).
+loadPackageFile := func(pkg, assetPath) {
+	assets := pkgFileLoader(pkg).
 		saveFile(assetPath).
 		load()
 
@@ -271,8 +277,8 @@ loadAssetFile := func(pkg, assetPath) {
  *
  * @return content: singleAsset - object with reference to the asset content resource and progress report
  */
-loadAssetContent := func(pkg, assetPath) {
-	assets := assetsLoader(pkg).
+loadPackageFileContent := func(pkg, assetPath) {
+	assets := pkgFileLoader(pkg).
 		saveFileContent(assetPath).
 		load()
 
@@ -285,6 +291,8 @@ loadAssetContent := func(pkg, assetPath) {
 
 export ll.toStrict({
 	softwareInfoScheme                 : softwareInfoScheme,
+	descriptorScheme                   : descriptorScheme,
+	assetDescriptorScheme              : assetDescriptorScheme,
 	binaryDescriptorScheme             : binaryDescriptorScheme,
 	localDescriptorScheme              : localDescriptorScheme,
 	runEnvDescriptorScheme             : runEnvDescriptorScheme,
@@ -294,7 +302,7 @@ export ll.toStrict({
 	get                                : get,
 	install                            : install,
 	use                                : use,
-	assetsLoader                       : assetsLoader,
-	loadAssetFile                      : loadAssetFile,
-	loadAssetContent                   : loadAssetContent
+	pkgFileLoader                      : pkgFileLoader,
+	loadPackageFile                    : loadPackageFile,
+	loadPackageFileContent             : loadPackageFileContent
 })

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

@@ -113,7 +113,7 @@ loadDependencyFiles := func(packageRef, dependencies) {
 
 	depsMap := {}
 
-	loader := pkg.assetsLoader(packageRef)
+	loader := pkg.pkgFileLoader(packageRef)
 	for depName, fileName in dependencies {
 		loader.saveFile(fileName)
 	}

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

@@ -0,0 +1,101 @@
+/**
+ * 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")
+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.assertJsonSchema(settings, {
+        "dataURL": "string",
+        "dataHeaders,omitempty": [["string"]],
+        "dataVersion,omitempty": "string"
+    })
+
+    importer := smart.structBuilder(RTYPE_BLOB_IMPORT_EXTERNAL, json.encode(settings)).lockAndBuild()
+
+    return ll.toStrict({
+        file: importer.getField("blob"),
+        handle: importer.getField("handle")
+    })
+}
+
+/**
+ * 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.assertJsonSchema(settings, {
+        "path": "string",
+        "storageId": "string",
+        "maxSpeedBytes,omitempty": "number",
+        "dataVersion,omitempty": "string"
+    })
+
+    importer := smart.structBuilder(RTYPE_BLOB_IMPORT_INTERNAL, json.encode(settings)).lockAndBuild()
+
+    return ll.toStrict({
+        file: importer.getField("blob"),
+        handle: importer.getField("handle")
+    })
+}
+
+/**
+ * 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.assertJsonSchema(settings, {
+        "modificationTime": "string",
+        "localPath": "string",
+        "pathSignature": "string",
+        "sizeBytes": "string"
+    })
+
+    uploader := smart.structBuilder(RTYPE_BLOB_UPLOAD, json.encode(settings)).lockAndBuild()
+
+    return ll.toStrict({
+        file: uploader.getField("blob"),
+        handle: uploader.getField("handle")
+    })
+}
+
+export ll.toStrict({
+    RTYPE_BLOB_IMPORT_EXTERNAL      : RTYPE_BLOB_IMPORT_EXTERNAL,
+    RTYPE_BLOB_IMPORT_INTERNAL      : RTYPE_BLOB_IMPORT_INTERNAL,
+    RTYPE_BLOB_UPLOAD               : RTYPE_BLOB_UPLOAD,
+    RTYPE_BLOB_DOWNLOAD             : RTYPE_BLOB_DOWNLOAD,
+
+    createBlobImportExternal        : createBlobImportExternal,
+    createBlobImportInternal        : createBlobImportInternal,
+    createBlobUpload                : createBlobUpload
+})

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

@@ -14,49 +14,10 @@
 ll := import("@platforma-sdk/workflow-tengo:ll")
 smart := import("@platforma-sdk/workflow-tengo:smart")
 validation := import("@platforma-sdk/workflow-tengo:validation")
+blobs := import("@platforma-sdk/workflow-tengo:file.internal")
 
 json := import("json")
 
-//
-// Constants:
-//
-
-_RTYPE_BLOB_IMPORT_INTERNAL := { Name: "BlobImportInternal", Version: "1" }
-_RTYPE_BLOB_UPLOAD := { Name: "BlobUpload", Version: "1" }
-_RTYPE_BLOB_DOWNLOAD := { Name: "BlobDownload", Version: "2" }
-
-createBlobImportInternal := func(settings) {
-	validation.assertJsonSchema(settings, {
-		"path": "string",
-		"storageId": "string",
-		"maxSpeedBytes,omitempty": "number",
-		"dataVersion,omitempty": "string"
-	})
-
-	importer := smart.structBuilder(_RTYPE_BLOB_IMPORT_INTERNAL, json.encode(settings)).lockAndBuild()
-
-	return ll.toStrict({
-		file: importer.getField("blob"),
-		handle: importer.getField("handle")
-	})
-}
-
-createBlobUpload := func(settings) {
-	validation.assertJsonSchema(settings, {
-		"modificationTime": "string",
-		"localPath": "string",
-		"pathSignature": "string",
-		"sizeBytes": "string"
-	})
-
-	uploader := smart.structBuilder(_RTYPE_BLOB_UPLOAD, json.encode(settings)).lockAndBuild()
-
-	return ll.toStrict({
-		file: uploader.getField("blob"),
-		handle: uploader.getField("handle")
-	})
-}
-
 /**
  * Imports an external file into the workflow, either from pre-configured storage,
  * available from the pl instance, or from the client machine via upload.
@@ -82,11 +43,14 @@ importFile := func(importFileHandle) {
 	settings := json.decode(path)
 
 	if url.Scheme == "upload" {
-		ll.assert(url.Host == "upload", "unexpected host while parsing import file handle, expected upload found ", url.Host)
-		return createBlobUpload(settings)
+		ll.assert(url.Host == "upload", "wrong 'host' in import file handle. Expected: 'upload', found: '", url.Host, "'")
+		return blobs.createBlobUpload(settings)
 	} else if url.Scheme == "index" {
-		ll.assert(url.Host == "index", "unexpected host while parsing import file handle, expected index found ", url.Host)
-		return createBlobImportInternal(settings)
+		ll.assert(url.Host == "index", "wrong 'host' in import file handle. Expected 'index', found: '", url.Host, "'")
+		return blobs.createBlobImportInternal(settings)
+	} else if (url.Scheme == "download") {
+		ll.assert(url.Host == "download", "wrong 'host' in import file handle. Expected: 'download', found: '", url.Host, "'")
+		return blobs.createBlobImportExternal(settings)
 	} else {
 		ll.panic("Unknown file import handle schema: ", url.Scheme)
 	}
@@ -97,7 +61,7 @@ importFile := func(importFileHandle) {
  * downloaded from the UI side.
  */
 exportFile := func(blob) {
-	builder := smart.structBuilder(_RTYPE_BLOB_DOWNLOAD)
+	builder := smart.structBuilder(blobs.RTYPE_BLOB_DOWNLOAD)
 
 	builder.createInputField("blob").set(blob)
 

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

@@ -93,15 +93,34 @@ ensureNonStrict := func(r) {
  * access to non-existing elements.
  *
  * @param m: map|strictMap
+ * @param recursive: boolean - convert also all child maps
  *
  * @return strict: strictMap
  */
-toStrict := func(v) {
+toStrict := func(v, ...recursive) {
+	if len(recursive) > 0 && recursive[0] {
+		if isMap(v) {
+			for k, vv in v {
+				v[k] = toStrict(vv)
+			}
+		} else if is_array(v) {
+			for i, vv in v {
+				if isMap(vv) {
+					v[i] = toStrict(vv)
+				}
+			}
+		}
+
+		if !isMap(v) {
+			return v // for recursive transformation, accept the top-level value to be of any type (i.e. array of maps)
+		}
+	}
+
 	if isStrict(v) {
 		return v
 	}
 
-	if(!is_map(v)) {
+	if(!isMap(v)) {
 		panic("toStrict(<v>): <v> is not a map", v)
 	}
 	return plapi.mapToStrict(v)
@@ -114,6 +133,30 @@ 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
+	}
+	v := fromStrict(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)
+	}
+	if is_int(referenceID) {
+		return fmt.sprintf("0x%X", referenceID)
+	}
+	panic("ll.idToString: <referenceID> cannot be used as resource or field ID")
+ }
+
 /**
  * Returns current template renderer
  */
@@ -221,6 +264,8 @@ export toStrict({
 	ensureNonStrict: ensureNonStrict,
 	toStrict: toStrict,
 	fieldId: fieldId,
+	isFieldId: isFieldId,
+	idToString: idToString,
 	getCurrentTemplateRenderer: getCurrentTemplateRenderer,
 	isInitializing: isInitializing,
 	getExecutorsList: getExecutorsList,

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

@@ -91,11 +91,6 @@ createBlobMapResource := undefined
 
 ////////////////// helpers ///////////////////////////
 
-// internal helper function
-isFieldId := func(val) {
-	return ll.isStrict(val) && ll.fromStrict(val)["ResourceID"] != undefined
-}
-
 /**
  * Returns true if given object is a smart.Resource
  */
@@ -561,6 +556,12 @@ field = func(f) {
 	self := undefined
 	strictSelf := undefined
 
+	id := ll.isFieldId(f) ? f : f.ID
+
+	if (is_undefined(id)) {
+		ll.panic("undefined id in smart.field. <f>="+f)
+	}
+
 	self = {
 		_type: "field",
 
@@ -571,7 +572,7 @@ field = func(f) {
 		 *	Name:		string
 		 *
 		 */
-		id: isFieldId(f) ? f : f.ID,
+		id: id,
 
 		/**
 		 * Field name

package/dist/tengo/lib/tpl.lib.tengo

@@ -292,8 +292,8 @@ tpl := func() {
 				ll.assert(is_map(r), "expected map, got ", r)
 
 				for name, ref in r {
-					ll.assert(smart.isReference(ref), "expected reference, got ", ref)
-					ll.assert(is_undefined(newInputs[name]), "prepare name is already in use: ", name)
+					ll.assert(smart.isReference(ref), "expected reference, got %v", ref)
+					ll.assert(is_undefined(newInputs[name]), "prepare name is already in use: %s", name)
 
 					builder.add(name, ref)
 				}

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

@@ -15,6 +15,7 @@ path := import("@platforma-sdk/workflow-tengo:path")
 enum := import("enum")
 validation := import("@platforma-sdk/workflow-tengo:validation")
 render := import("@platforma-sdk/workflow-tengo:render")
+blobs := import("@platforma-sdk/workflow-tengo:file.internal")
 
 create := func() {
 	wd := smart.ephemeralBuilder(constants.RTYPE_WORKDIR_CREATE).lockAndBuild()
@@ -23,8 +24,8 @@ create := func() {
 
 _getFileFillRule := func(filePath, extension) {
 	return {
-		path: filePath,
 		type: "file",
+		path: filePath,
 		permissions: 0o600,
 		pathKey: filePath,
 		blobKey: filePath,
@@ -33,6 +34,26 @@ _getFileFillRule := func(filePath, extension) {
 	}
 }
 
+_getArchiveFillRule := func(dstDir, whatToExtract, archiveBlobKey) {
+	extractRules := []
+	for f in whatToExtract {
+		extractRules = append(extractRules, {
+			srcPath: f,
+			dstPath: f,
+			filePerms: 0o600,
+			dirPerms: 0o700
+		})
+	}
+
+	return {
+		type: "archive",
+		path: dstDir,
+		blobKey: archiveBlobKey,
+		archiveType: "zip",
+		extractRules: extractRules
+	}
+}
+
 /**
  * Generates a value fill rule for a given file path.
  *
@@ -41,8 +62,8 @@ _getFileFillRule := func(filePath, extension) {
  */
 _getValueFillRule := func(filePath) {
 	return {
-		path: filePath,
 		type: "value",
+		path: filePath,
 		permissions: 0o600,
 		pathKey: filePath,
 		valueKey: filePath
@@ -57,8 +78,8 @@ _getValueFillRule := func(filePath) {
  */
 _getDirFillRule := func(dir) {
 	return {
-		path: dir,
 		type: "dir",
+		path: dir,
 		permissions: 0o700,
 		pathKey: ""
 	}
@@ -75,7 +96,9 @@ _fill := func(workdir) {
 	wd := smart.ephemeralBuilder(constants.RTYPE_WORKDIR_FILL)
 	wd.getField("workdirIn").set(workdir)
 
+	blobs := {}
 	files := {}
+	zipExtractions := {}
 	values := {}
 	dirs := {}
 
@@ -91,6 +114,49 @@ _fill := func(workdir) {
 			sets.add(dirs, newDirs...)
 		},
 
+		/**
+		 * 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.assertJsonSchema(zipResource, validation.reference, "workdir.builder.addFromZip: <zipResource> is not smart.reference")
+			validation.assertJsonSchema(destinationDir, "string", "workdir.builder.addFromZip: <destinationDir> is not a string. It must be a path inside working directory")
+
+			if (is_undefined(pathsInArchive)) {
+				pathsInArchive = []
+			}
+			validation.assertJsonSchema(pathsInArchive, ["string"], "workdir.builder.addFromZip: <pathsInArchive> must contain list of strings with paths inside archive")
+
+			blobKey := ll.idToString(zipResource.id)
+
+			if is_undefined(blobs[blobKey]) {
+				blobs[blobKey] = zipResource
+			}
+
+			if is_undefined(zipExtractions[blobKey]) {
+				zipExtractions[blobKey] = {}
+			}
+
+			if is_undefined(zipExtractions[blobKey][destinationDir]) || len(pathsInArchive) == 0 {
+				zipExtractions[blobKey][destinationDir] = pathsInArchive
+				return self
+			}
+
+			if (len(pathsInArchive) > 0) {
+				zipExtractions[blobKey][destinationDir] = append(zipExtractions[blobKey][destinationDir], pathsInArchive...)
+			}
+
+			return self
+		},
+
 		/**
 		 * Adds a file to the workdir.
 		 *
@@ -102,6 +168,7 @@ _fill := func(workdir) {
 			validation.assertJsonSchema(fileResource, validation.reference)
 
 			files[fileName] = fileResource
+			blobs[fileName] = fileResource
 			self._addDirs(fileName)
 
 			return self
@@ -168,6 +235,12 @@ _fill := func(workdir) {
 				rules = append(rules, _getValueFillRule(fileName))
 			}
 
+			for blobKey, directories in zipExtractions {
+				for dstDir, whatToExtract in directories {
+					rules = append(rules, _getArchiveFillRule(dstDir, whatToExtract, blobKey))
+				}
+			}
+
 			rulesRes := smart.createValueResource(
 				constants.RTYPE_WORKDIR_FILL_RULES,
 				json.encode(rules)
@@ -175,7 +248,7 @@ _fill := func(workdir) {
 			self.getField("rules").set(rulesRes)
 
 			self.getField("dataIn").set(smart.createBinaryMapResource(values))
-			self.getField("blobsIn").set(smart.createBlobMapResource(files))
+			self.getField("blobsIn").set(smart.createBlobMapResource(blobs))
 
 			return self.lockAndBuild().outputs().workdirOut
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "1.6.4",
+  "version": "1.7.1",
   "description": "Tengo SDK library",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -16,11 +16,11 @@
     "./dist/**/*"
   ],
   "dependencies": {
-    "@milaboratories/software-pframes-conv": "^1.6.4",
-    "@platforma-open/milaboratories.software-small-binaries": "^1.14.4"
+    "@milaboratories/software-pframes-conv": "^1.6.6",
+    "@platforma-open/milaboratories.software-small-binaries": "^1.14.5"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "^1.15.0"
+    "@platforma-sdk/tengo-builder": "^1.16.0"
   },
   "scripts": {
     "type-check": "pl-tengo check",
@@ -28,7 +28,7 @@
     "test": "pl-tengo test",
     "format": "/usr/bin/env emacs --quick --script ./format.el",
     "format-stdin": "/usr/bin/env emacs --quick --script ./format-stdin.el",
-    "vscode-tags": "./create_tags.sh .tags false",
+    "vscode-tags": "cd ../../ && bash ./sdk/workflow-tengo/create_tags.sh .tags false",
     "emacs-tags": "./create_tags.sh ../TAGS false -e",
     "do-pack": "rm -f *.tgz && pnpm pack && mv *.tgz package.tgz"
   }