@platforma-sdk/workflow-tengo 2.0.1 → 2.2.0

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

@@ -69,6 +69,7 @@ builder := func() {
 	assetInfos := {}
 	assetDescriptors := {}
 	assetRules := {}
+	assetCache := {}
 
 	stdout := "stdout.txt"
 	stderr := "stderr.txt"
@@ -184,7 +185,7 @@ builder := func() {
 		},
 
 		/**
-		 * @deprecated, use cacheMillis, cacheSeconds, cacheMinutes, cacheHours and cacheDays instead.
+		 * Use cacheMillis, cacheSeconds, cacheMinutes, cacheHours and cacheDays to not make hidden mistakes in cache time ranges.
 		 * Sets the cache time.
 		 *
 		 * @param time: duration - the cache time from 'times' library.
@@ -275,10 +276,18 @@ builder := func() {
 		 * @param pathsInArchive: string[] - paths inside the archive to be extracted into destinationDir.
 		 *                                   Empty array means 'unpack full archive'.
 		 */
-		addAsset: func(asset, destinationDir, pathsInArchive) {
+		addAsset: func(asset, destinationDir, ...pathsInArchive) {
+			if (len(pathsInArchive) == 1 && is_array(pathsInArchive[0])) {
+				// support [<paths>] single argument
+				pathsInArchive = pathsInArchive[0]
+			}
+			if len(pathsInArchive) == 0 {
+				// default for 'no paths' is to extract all
+				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")
 
@@ -300,6 +309,86 @@ builder := func() {
 			return self
 		},
 
+		/**
+		 * Set custom cache time for given asset. By default, cache time of 1 day is applied to all assets.
+		 * This allows to customize cache time on per-asset basis
+		 */
+		cacheAssetMillis: func (asset, millis) {
+			ll.assert(assets.isAssetInfo(asset),
+				"exec.builder.cacheAssetMillis: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
+			ll.assert(is_int(millis),
+				"exec.builder.cacheAssetMillis: asset cache time must be a number of milliseconds.")
+
+			assetIdKey := ll.idToString(asset._id)
+			assetCache[assetIdKey] = millis * times.millisecond
+
+			return self
+		},
+
+		/**
+		 * Set custom cache time for given asset. By default, cache time of 1 day is applied to all assets.
+		 * This allows to customize cache time on per-asset basis
+		 */
+		cacheAssetSeconds: func (asset, seconds) {
+			ll.assert(assets.isAssetInfo(asset),
+				"exec.builder.cacheAssetSeconds: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
+			ll.assert(is_int(seconds),
+				"exec.builder.cacheAssetSeconds: asset cache time must be a number of seconds.")
+
+			assetIdKey := ll.idToString(asset._id)
+			assetCache[assetIdKey] = seconds * times.second
+
+			return self
+		},
+
+		/**
+		 * Set custom cache time for given asset. By default, cache time of 1 day is applied to all assets.
+		 * This allows to customize cache time on per-asset basis
+		 */
+		cacheAssetMinutes: func (asset, minutes) {
+			ll.assert(assets.isAssetInfo(asset),
+				"exec.builder.cacheAssetMinutes: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
+			ll.assert(is_int(minutes),
+				"exec.builder.cacheAssetMinutes: asset cache time must be a number of minutes.")
+
+			assetIdKey := ll.idToString(asset._id)
+			assetCache[assetIdKey] = minutes * times.minute
+
+			return self
+		},
+
+		/**
+		 * Set custom cache time for given asset. By default, cache time of 1 day is applied to all assets.
+		 * This allows to customize cache time on per-asset basis
+		 */
+		cacheAssetHours: func (asset, hours) {
+			ll.assert(assets.isAssetInfo(asset),
+				"exec.builder.cacheAssetHours: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
+			ll.assert(is_int(hours),
+				"exec.builder.cacheAssetHours: asset cache time must be a number of hours.")
+
+			assetIdKey := ll.idToString(asset._id)
+			assetCache[assetIdKey] = hours * times.hour
+
+			return self
+		},
+
+		/**
+		 * Set custom cache time for given asset. By default, cache time of 1 day is applied to all assets.
+		 * This allows to customize cache time on per-asset basis
+		 */
+		cacheAssetDays: func (asset, days) {
+			ll.assert(assets.isAssetInfo(asset),
+				"exec.builder.cacheAssetHours: <asset> parameter is not an asset info. Provide the value obtained from assets.importAsset() here")
+			ll.assert(is_int(days),
+				"exec.builder.cacheAssetHours: asset cache time must be a number of days.")
+
+			assetIdKey := ll.idToString(asset._id)
+			assetCache[assetIdKey] = days * 24 * times.hour
+
+			return self
+		},
+
 		/**
 		 * Adds a file to the working directory
 		 *
@@ -515,7 +604,8 @@ builder := func() {
 				wdProcessors: wdProcessors,
 				assets: smart.createMapResource(assetInfos),
 				assetDescriptors: assetDescriptors,
-				assetRules: assetRules
+				assetRules: assetRules,
+				assetCache: assetCache
 			}
 
 			if !is_undefined(soft) {

package/dist/tengo/lib/pframes.xsv.lib.tengo

@@ -267,12 +267,27 @@ importFileMap := func(xsvMap, xsvType, spec, ...ops) {
 /**
  * Export p-frame into xsv file
  *
- * @param pf: p-frame - a collection of p-columns
+ * @param pf: p-frame - a list of p-columns ({data, spec}) or a frame-like map of col.data col.spec entries
  * @param xsvType: string - "csv" or "tsv"
  * @param params: map - export params
  */
 exportFrame := func(pf, xsvType, params) {
 	exportPfTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.xsv-export-pframe")
+
+	if is_array(pf) {
+		// transform into .data .spec map
+
+		pfm := {}
+		i := 0
+		for col in pf {
+			ll.assert(!is_undefined(col.spec), "expected array of {spec, data} maps as a list of columns, but spec is undefined for: ", col)
+			ll.assert(!is_undefined(col.data), "expected array of {spec, data} maps as a list of columns, but data is undefined for: ", col)
+			pfm["" + i + ".spec"] = col.spec
+			pfm["" + i + ".data"] = col.data
+			i = i + 1
+		}
+		pf = pfm
+	}
 	
 	r := render.create(exportPfTpl, {
 		pf: pf,

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

@@ -7,6 +7,7 @@ ll := import("@platforma-sdk/workflow-tengo:ll")
 oop := import("@platforma-sdk/workflow-tengo:oop")
 maps := import("@platforma-sdk/workflow-tengo:maps")
 json := import("json")
+times := import("times")
 constants := import("@platforma-sdk/workflow-tengo:constants")
 
 //////////////// definitions ////////////////
@@ -621,6 +622,73 @@ field = func(f) {
 			return self.info().Error != 0
 		},
 
+		/**
+		 * Use cacheMillis, cacheSeconds, cacheMinutes, cacheHours and cacheDays to not make hidden mistakes in cache time ranges.
+		 * Sets the cache time.
+		 *
+		 * @param time: duration - the cache time from 'times' library.
+		 */
+		setCache: func(time) {
+			ll.assert(is_int(time) && time >= times.millisecond,
+				"smart.field.setCache: cache time must be an integer >= millisecond. Did you forget to import a standard tengo library 'times'?")
+
+			tx.cacheSetToField(self.id, time)
+			return self
+		},
+
+		/**
+		 * Sets the cache time in milliseconds.
+		 *
+		 * @param millis: number
+		 */
+		setCacheMillis: func(millis) {
+			ll.assert(is_int(millis),
+				"smart.field.setCacheMillis: cache time must be a number of milliseconds")
+			return self.setCache(millis * times.millisecond)
+		},
+
+		/**
+		 * Sets the cache time in seconds.
+		 *
+		 * @param seconds: number
+		 */
+		setCacheSeconds: func(seconds) {
+			ll.assert(is_int(seconds),
+				"smart.field.setCacheSeconds: cache time must be a number of seconds")
+			return self.setCache(seconds * times.second)
+		},
+
+		/**
+		 * Sets the cache time in minutes.
+		 *
+		 * @param minutes: number
+		 */
+		setCacheMinutes: func(minutes) {
+			ll.assert(is_int(minutes),
+				"smart.field.setCacheMinutes: cache time must be a number of minutes")
+			return self.setCache(minutes * times.minute)
+		},
+
+		/**
+		 * Sets the cache time in hours.
+		 *
+		 * @param hours: number
+		 */
+		setCacheHours: func(hours) {
+			ll.assert(is_int(hours), "smart.field.setCacheHours: cache time must be a number of hours")
+			return self.setCache(hours * times.hour)
+		},
+
+		/**
+		 * Sets the cache time in days
+		 *
+		 * @param days: number
+		 */
+		setCacheDays: func(days) {
+			ll.assert(is_int(days), "smart.field.setCacheDays: cache time must be a number of days")
+			return self.setCache(days * 24 * times.hour)
+		},
+
 		/**
 		 * Returns a smart.Resource object from the resolved field value
 		 */

package/dist/tengo/lib/workflow.bquery.lib.tengo

@@ -59,7 +59,6 @@ create := func(spec, ctx, ...options) {
 		setErrorIfMissing: ops.errIfMissing
 	})
 
-
 	builder := undefined
 	if ops.first {
 		builder = smart.ephemeralBuilder(constants.RTYPE_BRESOLVE_FIRST, query)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "2.0.1",
+  "version": "2.2.0",
   "description": "Tengo SDK library",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",