@platforma-sdk/workflow-tengo 4.7.1 → 4.7.3

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

@@ -219,6 +219,16 @@ builder := func() {
 
 
 
+
+
+		setQueue: func(newQueue) {
+			queue = newQueue
+			return self
+		},
+
+
+
+
 		inHeavyQueue: func() {
 			queue = execConstants.HEAVY_QUEUE
 			return self
@@ -272,9 +282,9 @@ builder := func() {
 
 
 
-		ram: func(amount) {
-			validation.assertType(amount, ["or", "number", "string"], "exec.builder.ram: RAM amount should be a number or string")
-			ll.assert(is_string(amount) || amount > 0, "exec.builder.ram: amount in bytes should be greater than 0")
+		mem: func(amount) {
+			validation.assertType(amount, ["or", "number", "string"], "exec.builder.mem: RAM amount should be a number or string")
+			ll.assert(is_string(amount) || amount > 0, "exec.builder.mem: amount in bytes should be greater than 0")
 			ramRequest = amount
 
 			return self
@@ -285,6 +295,16 @@ builder := func() {
 
 
 
+		ram: func(amount) {
+			self.mem(amount)
+			return self
+		},
+
+
+
+
+
+
 
 		cache: func(time) {
 			ll.assert(

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

@@ -38,5 +38,10 @@ export ll.toStrict({
 	commandExpressions:         _isEnabled("commandExpressions") || _api >= 2, // rich expressions in command arguments ( {{ system.ram_bytes / 20 }} )
 	workdirLimits:              _isEnabled("workdirLimits")      || _api >= 4, // workdir storage controller can limit concurrency
 	computeLimits:              _isEnabled("computeLimits"),                   // runner can plan CPU and RAM
-	resourceDuplicateEvent:     false                                          // template can subscribe to ResourceDuplicate event
+
+
+
+
+
+	fullFeaturedApi:        _isEnabled("fullFeaturedAPI")
 })

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

@@ -289,10 +289,137 @@ parseUrl := func(url) {
 
 
 
+
+
 getCtx := func() {
+	if methodExists(plapi, "getPersistentCtx") {
+		return plapi.getPersistentCtx()
+	}
+
+
+	return plapi.getCtx()
+}
+
+
+
+
+
+getPersistentCtx := func() {
+	if methodExists(plapi, "getPersistentCtx") {
+		return plapi.getPersistentCtx()
+	}
+
+
 	return plapi.getCtx()
 }
 
+
+
+
+
+
+
+
+
+
+
+getExecutionCtx := func() {
+	assert(methodExists(plapi, "getExecutionCtx"), "ll.getExecutionCtx: method does not exists in this backend instance.")
+	return plapi.getExecutionCtx()
+}
+
+
+
+
+
+
+
+moduleVars := func(moduleName) {
+	assert(is_string(moduleName), "ll.moduleVars: moduleName must be a string")
+
+	name := "module/" + moduleName
+
+	ctx := getExecutionCtx()
+	if is_undefined(ctx[name]) {
+		ctx[name] = {}
+	}
+
+	return {
+		get: func(k) {
+			return ctx[name][k]
+		},
+
+		set: func(k, v) {
+			ctx[name][k] = v
+		}
+	}
+}
+
+
+
+
+sha256Encode := func(b) {
+	assert(methodExists(plapi, "sha256Encode"), "ll.sha256Encode: method does not exists in this backend instance.")
+	return plapi.sha256Encode(b)
+}
+
+
+
+
+gzipEncode := func(b) {
+	assert(methodExists(plapi, "gzipEncode"), "ll.gzipEncode: method does not exists in this backend instance.")
+	return plapi.gzipEncode(b)
+}
+
+
+
+
+gzipDecode := func(b) {
+	assert(methodExists(plapi, "gzipDecode"), "ll.gzipDecode: method does not exists in this backend instance.")
+	return plapi.gzipDecode(b)
+}
+
+
+
+
+base32Encode := func(b) {
+	assert(methodExists(plapi, "base32Encode"), "ll.base32Encode: method does not exists in this backend instance.")
+	return plapi.base32Encode(b)
+}
+
+
+
+
+
+
+
+
+base32HexEncode := func(b) {
+	assert(methodExists(plapi, "base32HexEncode"), "ll.base32HexEncode: method does not exists in this backend instance.")
+	return plapi.base32HexEncode(b)
+}
+
+
+
+
+base32Decode := func(s) {
+	assert(methodExists(plapi, "base32Decode"), "ll.base32Decode: method does not exists in this backend instance.")
+	return plapi.base32Decode(s)
+}
+
+
+
+
+
+
+
+
+base32HexDecode := func(s) {
+	assert(methodExists(plapi, "base32HexDecode"), "ll.base32HexDecode: method does not exists in this backend instance.")
+	return plapi.base32HexDecode(s)
+}
+
+
 export toStrict({
 	apiVersion: apiVersion,
 	print: print,
@@ -315,5 +442,15 @@ export toStrict({
 	pathSeparator: pathSeparator,
 	filepathCanonize: filepathCanonize,
 	parseUrl: parseUrl,
-	getCtx: getCtx
+	getCtx: getCtx,
+	getPersistentCtx: getPersistentCtx,
+	getExecutionCtx: getExecutionCtx,
+	moduleVars: moduleVars,
+	sha256Encode: sha256Encode,
+	gzipEncode: gzipEncode,
+	gzipDecode: gzipDecode,
+	base32Encode: base32Encode,
+	base32HexEncode: base32HexEncode,
+	base32Decode: base32Decode,
+	base32HexDecode: base32HexDecode
 })

package/dist/tengo/lib/pt.lib.tengo

@@ -6,6 +6,7 @@ exec := import("@platforma-sdk/workflow-tengo:exec")
 json := import("json")
 text := import("text")
 slices := import("@platforma-sdk/workflow-tengo:slices")
+execConstants := import("@platforma-sdk/workflow-tengo:exec.constants")
 
 
 
@@ -67,6 +68,10 @@ workflow := func() {
 	anonymousFilesCounter := 0
 	anonymousDFCounter := 0
 
+	cpu := undefined
+	mem := undefined
+	queue := execConstants.MEDIUM_QUEUE
+
 	self := undefined
 
 	id := workflowCounter
@@ -266,13 +271,71 @@ workflow := func() {
 
 
 
+		inHeavyQueue: func() {
+			queue = execConstants.HEAVY_QUEUE
+			return self
+		},
+
+
+
+
+		inMediumQueue: func() {
+			queue = execConstants.MEDIUM_QUEUE
+			return self
+		},
+
+
+
+
+		inLightQueue: func() {
+			queue = execConstants.LIGHT_QUEUE
+			return self
+		},
+
+
+
+
+		inUiQueue: func() {
+			queue = execConstants.UI_TASKS_QUEUE
+			return self
+		},
+
+
+
+
+
+
+		cpu: func(amount) {
+			cpu = amount
+			return self
+		},
+
+
+
+
+
+
+
+
+
+
+
+
+		mem: func(amount) {
+			mem = amount
+			return self
+		},
+
+
+
+
 
 
 
 		run: func() {
 			ptablerSw := assets.importSoftware("@platforma-open/milaboratories.software-ptabler:main")
 			ptablerCmdBuilder := exec.builder().
-				inMediumQueue().
+				setQueue(queue).
 				printErrStreamToStdout().
 				dontSaveStdoutOrStderr().
 				software(ptablerSw).
@@ -281,6 +344,14 @@ workflow := func() {
 					workflow: steps
 				}));
 
+			if !is_undefined(cpu) {
+				ptablerCmdBuilder.cpu(cpu)
+			}
+
+			if !is_undefined(mem) {
+				ptablerCmdBuilder.mem(mem)
+			}
+
 			for inFile in inFiles {
 				if !is_undefined(inFile.file) {
 					ptablerCmdBuilder.addFile(inFile.name, inFile.file)

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

@@ -362,6 +362,13 @@ resource = func(r) {
 
 
 
+
+
+
+
+
+
+
 
 
 
@@ -390,7 +397,14 @@ resource = func(r) {
 
 
 		isFinal: func() {
-			return self.info().ResourceReady || self.info().IsDuplicate || self.info().HasErrors
+
+			if false  {
+				return self.info().IsFinal
+			}
+
+			info := self.info()
+
+			return info.ResourceReady || info.IsDuplicate || info.HasErrors
 		},
 
 		isEphemeral: func() {
@@ -702,6 +716,8 @@ resource = func(r) {
 
 
 
+
+
 		kvGet: func(key) {
 			return tx.resourceKeyValueGet(self.id, key)
 		},
@@ -712,6 +728,17 @@ resource = func(r) {
 
 
 
+		kvGetFlag: func(key) {
+			ll.assert(feats.fullFeaturedApi, "smart.resource.kvGetFlag: the feature is not available on older backends. Please, update the backend.")
+			return tx.resourceKeyValueGetFlag(self.id, key)
+		},
+
+
+
+
+
+
+
 
 		kvSet: func(key, value) {
 			tx.resourceKeyValueSet(self.id, key, value)
@@ -723,6 +750,17 @@ resource = func(r) {
 
 
 
+		kvSetFlag: func(key, flag) {
+			ll.assert(feats.fullFeaturedApi, "smart.resource.kvSetFlag: the feature is not available on older backends. Please, update the backend.")
+			tx.resourceKeyValueSetFlag(self.id, key, flag)
+		},
+
+
+
+
+
+
+
 
 		kvGetAsString: func(key) {
 			value := tx.resourceKeyValueGet(self.id, key)
@@ -1108,6 +1146,22 @@ field = func(f) {
 
 		buildFutureField: func(nameOrPath) {
 			return _buildFutureField(strictSelf, nameOrPath)
+		},
+
+
+
+
+		reset: func() {
+			ll.assert(feats.fullFeaturedApi, "smart.field.reset: the feature is not available on older backends. Please, update the backend.")
+			tx.resetField(self.id)
+		},
+
+
+
+
+		remove: func() {
+			ll.assert(feats.fullFeaturedApi, "smart.field.remove: the feature is not available on older backends. Please, update the backend.")
+			tx.removeField(self.id)
 		}
 	}
 

package/dist/tengo/lib/tpl.state-await.lib.tengo

@@ -261,7 +261,7 @@ await := func(rootField, ctxStorageResource, requests) {
 		targetEvents := [firstSubscription.event]
 
 		if firstSubscription.event == "Final" { // special case
-			if !feats.resourceDuplicateEvent {
+			if !feats.fullFeaturedApi {
 
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "4.7.1",
+  "version": "4.7.3",
   "description": "Tengo SDK library",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -21,7 +21,7 @@
     "@platforma-open/milaboratories.software-ptabler": "1.6.0"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "^2.1.6"
+    "@platforma-sdk/tengo-builder": "^2.1.10"
   },
   "scripts": {
     "type-check": "pl-tengo check",