@platforma-sdk/workflow-tengo 5.2.0 → 5.2.2

package/README.md

@@ -19,4 +19,8 @@ Perfect for researchers who need flexible data processing that can intelligently
 - [Tengo syntax](https://github.com/d5/tengo/blob/master/docs/tutorial.md)
 - [Tengo builtin functions](https://github.com/d5/tengo/blob/master/docs/builtins.md)
 
+# Running single test
 
+```sh
+pnpm build:dev --filter='@platforma-sdk/workflow-tengo-tests...' && (cd tests/workflow-tengo && PL_ADDRESS="http://127.0.0.1:6345" PL_TEST_USER="default" PL_TEST_PASSWORD="__password__" pnpm run test pt -t "pt write frame test" --retry 0)
+```

package/dist/index.cjs

@@ -3,6 +3,7 @@ module.exports = { Templates: {
   'pframes.export-single-pcolumn': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.export-single-pcolumn.plj.gz') },
   'pframes.import-dir': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.import-dir.plj.gz') },
   'pframes.remove-nulls': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.remove-nulls.plj.gz') },
+  'pt.import-dir': { type: 'from-file', path: require.resolve('./tengo/tpl/pt.import-dir.plj.gz') },
   'waiter.waiter': { type: 'from-file', path: require.resolve('./tengo/tpl/waiter.waiter.plj.gz') },
   'workdir.save': { type: 'from-file', path: require.resolve('./tengo/tpl/workdir.save.plj.gz') },
   'workflow.build-ctx': { type: 'from-file', path: require.resolve('./tengo/tpl/workflow.build-ctx.plj.gz') },

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 declare type TemplateFromFile = { readonly type: "from-file"; readonly path: string; };
-declare type TplName = "ll.get-field" | "pframes.export-single-pcolumn" | "pframes.import-dir" | "pframes.remove-nulls" | "waiter.waiter" | "workdir.save" | "workflow.build-ctx" | "workflow.query-anchored" | "anonymize.deanonymize" | "anonymize.impl" | "check_network.workdir_type_name_extractor" | "exec.delayed-compute-allocation.impl" | "exec.monetization_to_json" | "exec.python.install-deps" | "exec.python.venv-bin-path" | "pframes.export-multiple-pcolumns" | "pframes.slice-data" | "check_network.create_workdir_from_storage" | "check_network.download_blob" | "check_network.upload_blob" | "check_network.upload_template" | "exec.R.create-renv" | "exec.exec-impl" | "exec.monetization_info" | "exec.python.create-venv" | "pframes.parse-to-json" | "exec.load-software.impl" | "exec.exec" | "pframes.xsv-export-pframe" | "pframes.xsv-import-if-not-null" | "pframes.xsv-import-map" | "check_network.run_hello_world" | "check_network.run_hello_world_py" | "pframes.process-pcolumn-data" | "pframes.export-pframe" | "pframes.export-pframe-for-ui";
+declare type TplName = "ll.get-field" | "pframes.export-single-pcolumn" | "pframes.import-dir" | "pframes.remove-nulls" | "pt.import-dir" | "waiter.waiter" | "workdir.save" | "workflow.build-ctx" | "workflow.query-anchored" | "anonymize.deanonymize" | "anonymize.impl" | "check_network.workdir_type_name_extractor" | "exec.delayed-compute-allocation.impl" | "exec.monetization_to_json" | "exec.python.install-deps" | "exec.python.venv-bin-path" | "pframes.export-multiple-pcolumns" | "pframes.slice-data" | "check_network.create_workdir_from_storage" | "check_network.download_blob" | "check_network.upload_blob" | "check_network.upload_template" | "exec.R.create-renv" | "exec.exec-impl" | "exec.monetization_info" | "exec.python.create-venv" | "pframes.parse-to-json" | "exec.load-software.impl" | "exec.exec" | "pframes.xsv-export-pframe" | "pframes.xsv-import-if-not-null" | "pframes.xsv-import-map" | "check_network.run_hello_world" | "check_network.run_hello_world_py" | "pframes.process-pcolumn-data" | "pframes.export-pframe" | "pframes.export-pframe-for-ui";
 declare const Templates: Record<TplName, TemplateFromFile>;
 export { Templates };

package/dist/index.js

@@ -4,6 +4,7 @@ export const Templates = {
   'pframes.export-single-pcolumn': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.export-single-pcolumn.plj.gz') },
   'pframes.import-dir': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.import-dir.plj.gz') },
   'pframes.remove-nulls': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.remove-nulls.plj.gz') },
+  'pt.import-dir': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pt.import-dir.plj.gz') },
   'waiter.waiter': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/waiter.waiter.plj.gz') },
   'workdir.save': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/workdir.save.plj.gz') },
   'workflow.build-ctx': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/workflow.build-ctx.plj.gz') },

package/dist/tengo/lib/pframes.constants.lib.tengo

@@ -44,12 +44,15 @@ RTYPE_P_COLUMN_DATA_RESOURCE_MAP := { Name: P_COLUMN_DATA_TYPE_PREFIX + "Resourc
 RTYPE_P_COLUMN_DATA_RESOURCE_MAP_PARTITIONED := { Name: P_COLUMN_DATA_TYPE_PREFIX + "Partitioned/ResourceMap", Version: "1" }
 RTYPE_P_COLUMN_DATA_JSON_PARTITIONED := { Name: P_COLUMN_DATA_TYPE_PREFIX + "JsonPartitioned", Version: "1" }
 RTYPE_P_COLUMN_DATA_BINARY_PARTITIONED := { Name: P_COLUMN_DATA_TYPE_PREFIX + "BinaryPartitioned", Version: "1" }
+RTYPE_P_COLUMN_DATA_PARQUET_PARTITIONED := { Name: P_COLUMN_DATA_TYPE_PREFIX + "ParquetPartitioned", Version: "1" }
 
 P_COLUMN_SUPER_PARTITIONED_DATA_TYPE_PREFIX := P_COLUMN_DATA_TYPE_PREFIX + "Partitioned/"
 RTYPE_P_COLUMN_DATA_JSON_SUPER_PARTITIONED := { Name: P_COLUMN_SUPER_PARTITIONED_DATA_TYPE_PREFIX + "JsonPartitioned", Version: "1" }
 RTYPE_P_COLUMN_DATA_BINARY_SUPER_PARTITIONED := { Name: P_COLUMN_SUPER_PARTITIONED_DATA_TYPE_PREFIX + "BinaryPartitioned", Version: "1" }
+RTYPE_P_COLUMN_DATA_PARQUET_SUPER_PARTITIONED := { Name: P_COLUMN_SUPER_PARTITIONED_DATA_TYPE_PREFIX + "ParquetPartitioned", Version: "1" }
 
 RTYPE_P_COLUMN_BUNDLE := { Name: "PColumnBundle", Version: "1" }
+RTYPE_PARQUET_CHUNK := { Name: "ParquetChunk", Version: "1" }
 
 KIND_P_COLUMN := "PColumn"
 
@@ -71,8 +74,11 @@ export ll.toStrict({
 	RTYPE_P_COLUMN_DATA_RESOURCE_MAP_PARTITIONED  : RTYPE_P_COLUMN_DATA_RESOURCE_MAP_PARTITIONED,
 	RTYPE_P_COLUMN_DATA_JSON_PARTITIONED          : RTYPE_P_COLUMN_DATA_JSON_PARTITIONED,
 	RTYPE_P_COLUMN_DATA_BINARY_PARTITIONED        : RTYPE_P_COLUMN_DATA_BINARY_PARTITIONED,
+	RTYPE_P_COLUMN_DATA_PARQUET_PARTITIONED       : RTYPE_P_COLUMN_DATA_PARQUET_PARTITIONED,
 	RTYPE_P_COLUMN_DATA_JSON_SUPER_PARTITIONED    : RTYPE_P_COLUMN_DATA_JSON_SUPER_PARTITIONED,
 	RTYPE_P_COLUMN_DATA_BINARY_SUPER_PARTITIONED  : RTYPE_P_COLUMN_DATA_BINARY_SUPER_PARTITIONED,
+	RTYPE_P_COLUMN_DATA_PARQUET_SUPER_PARTITIONED : RTYPE_P_COLUMN_DATA_PARQUET_SUPER_PARTITIONED,
 
-	RTYPE_P_COLUMN_BUNDLE                         : RTYPE_P_COLUMN_BUNDLE
+	RTYPE_P_COLUMN_BUNDLE                         : RTYPE_P_COLUMN_BUNDLE,
+	RTYPE_PARQUET_CHUNK                           : RTYPE_PARQUET_CHUNK
 })

package/dist/tengo/lib/pframes.export-pcolumn.lib.tengo

@@ -4,15 +4,19 @@ render := import("@platforma-sdk/workflow-tengo:render")
 file := import("@platforma-sdk/workflow-tengo:file")
 ll := import("@platforma-sdk/workflow-tengo:ll")
 assets := import("@platforma-sdk/workflow-tengo:assets")
+json := import("json")
 
 
 nestedTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.export-single-pcolumn")
 
 
 exportPColumnData := func(data) {
+	ll.assert(data.info().InputsLocked, "column data resource not locked for export: %v", data.info().Type)
+
 	if data.checkResourceType(pConstants.RTYPE_P_COLUMN_DATA_RESOURCE_MAP_PARTITIONED) ||
 		data.checkResourceType(pConstants.RTYPE_P_COLUMN_DATA_JSON_SUPER_PARTITIONED) ||
-		data.checkResourceType(pConstants.RTYPE_P_COLUMN_DATA_BINARY_SUPER_PARTITIONED) {
+		data.checkResourceType(pConstants.RTYPE_P_COLUMN_DATA_BINARY_SUPER_PARTITIONED) ||
+		data.checkResourceType(pConstants.RTYPE_P_COLUMN_DATA_PARQUET_SUPER_PARTITIONED) {
 
 
 		newData := smart.structBuilder(data.info().Type, data.info().Data)
@@ -32,13 +36,44 @@ exportPColumnData := func(data) {
 		}
 		return newData.lockAndBuild()
 
+	} else if data.checkResourceType(pConstants.RTYPE_P_COLUMN_DATA_PARQUET_PARTITIONED) {
+
+
+		newData := smart.structBuilder(data.info().Type, data.info().Data)
+		for key, partData in data.inputs() {
+			partDataResource := partData.getValue()
+			ll.assert(
+				partDataResource.checkResourceType(pConstants.RTYPE_PARQUET_CHUNK),
+				"expected resource %v for axis key %v, got %v",
+				pConstants.RTYPE_PARQUET_CHUNK,
+				key,
+				partDataResource.info().Type
+			)
+			ll.assert(partDataResource.info().InputsLocked, "resource %v inputs not locked", partDataResource.info().Type)
+
+
+
+
+			chunkMetadata := partDataResource.getDataAsJson()
+			chunkMetadata.isDownloadable = true
+
+			parquetChunkResource := smart.structBuilder(partDataResource.info().Type, json.encode(chunkMetadata))
+
+			partDataFields := partDataResource.metaInputs()
+			parquetChunkResource.createMetaField("blob").set(file.exportFile(partDataFields["blob"]))
+			parquetChunkResource.createMetaField("mapping").set(partDataFields["mapping"])
+
+			newData.createInputField(key).set(parquetChunkResource.lockAndBuild())
+		}
+		return newData.lockAndBuild()
+
 	} else if data.checkResourceType(pConstants.RTYPE_P_COLUMN_DATA_JSON) {
 
 
 		return data
 
 	} else {
-		ll.panic("unknonw resource type: %v", data.info().Type)
+		ll.panic("unknown resource type: %v", data.info().Type)
 	}
 }
 

package/dist/tengo/lib/pframes.export-pframe.lib.tengo

@@ -23,6 +23,8 @@ exportPFrame := func(pfResource, skipHideDataFromUI) {
 
 	fields := pfResource.inputs()
 
+	ll.assert(pfResource.info().InputsLocked, "pframe resource not locked for export: %v", pfResource.info().Type)
+
 
 	if pfResource.checkResourceType(constants.RTYPE_CONTEXT) {
 		newFields := {}

package/dist/tengo/lib/pframes.spec.lib.tengo

@@ -15,32 +15,32 @@ json := import("json")
 
 
 
-P_AXIS_SPEC_SCHEMA := {
-
-	`type`: `string,regex=Int|Long|Float|Double|String`,
+P_UNTYPED_SPEC_SCHEMA := {
 	`name`: `string`,
 	`domain,?`: { any: `string` },
 	`annotations,?`: { any: `string` },
-	`parentAxes,?`: `any` // [ `number` ]
+	`parentAxes,?`: [ `number` ]
 }
 
-P_COLUMN_SPEC_SCHEMA := {
+P_AXIS_SPEC_SCHEMA := ["and", P_UNTYPED_SPEC_SCHEMA, {
+	`type`: `string,regex=Int|Long|String`
+}]
 
+P_COLUMN_OWN_SPEC_SCHEMA := ["and", P_UNTYPED_SPEC_SCHEMA, {
+	`valueType`: `string,regex=Int|Long|Float|Double|String`
+}]
+
+P_COLUMN_SPEC_SCHEMA := ["and", P_UNTYPED_SPEC_SCHEMA, {
 	`kind`: `string,regex=PColumn`,
 	`valueType`: `string`,
-	`name`: `string`,
-	`domain,?`: { any: `string` },
-	`annotations,?`: { any: `string` },
-	`parentAxes,?`: `any`, // [ `number` ]
 	`axesSpec,?`: [ P_AXIS_SPEC_SCHEMA ]
-}
+}]
 
 P_OBJECT_SPEC_SCHEMA := ["or", P_COLUMN_SPEC_SCHEMA, {
 	`kind`: `string`,
 	`annotations,?`: { any: `string` }
 }]
 
-
 KIND_P_COLUMN := "PColumn"
 
 
@@ -531,7 +531,9 @@ axisSpecToMatcher := func(axisSpec) {
 }
 
 export ll.toStrict({
+	P_UNTYPED_SPEC_SCHEMA: P_UNTYPED_SPEC_SCHEMA,
 	P_AXIS_SPEC_SCHEMA: P_AXIS_SPEC_SCHEMA,
+	P_COLUMN_OWN_SPEC_SCHEMA: P_COLUMN_OWN_SPEC_SCHEMA,
 	P_COLUMN_SPEC_SCHEMA: P_COLUMN_SPEC_SCHEMA,
 	P_OBJECT_SPEC_SCHEMA: P_OBJECT_SPEC_SCHEMA,
 

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

@@ -1,5 +1,6 @@
 ll := import("@platforma-sdk/workflow-tengo:ll")
 exp := import("@platforma-sdk/workflow-tengo:pt.expression")
+util := import("@platforma-sdk/workflow-tengo:pt.util")
 assets := import("@platforma-sdk/workflow-tengo:assets")
 smart := import("@platforma-sdk/workflow-tengo:smart")
 exec := import("@platforma-sdk/workflow-tengo:exec")
@@ -8,6 +9,11 @@ text := import("text")
 slices := import("@platforma-sdk/workflow-tengo:slices")
 validation := import("@platforma-sdk/workflow-tengo:validation")
 execConstants := import("@platforma-sdk/workflow-tengo:exec.constants")
+oop := import("@platforma-sdk/workflow-tengo:oop")
+pframes := import("@platforma-sdk/workflow-tengo:pframes")
+
+
+importDirTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pt.import-dir")
 
 
 
@@ -59,6 +65,8 @@ _detectFormatFromFileName := func(fileName) {
 		return "tsv"
 	} else if text.has_suffix(fileName, ".ndjson") || text.has_suffix(fileName, ".jsonl") {
 		return "ndjson"
+	} else if text.has_suffix(fileName, ".parquet") {
+		return "parquet"
 	}
 	return undefined // No format detected
 }
@@ -79,6 +87,8 @@ workflow := func() {
 
 	outContentFiles := []
 
+	outFramesSpecs := {}
+
 	anonymousFilesCounter := 0
 	anonymousDFCounter := 0
 
@@ -282,7 +292,13 @@ workflow := func() {
 
 
 			step := undefined
-			if finalFormat == "ndjson" {
+			if finalFormat == "parquet" {
+				step = {
+					type: "read_parquet",
+					file: finalFileName,
+					name: finalDataFrameId
+				}
+			} else if finalFormat == "ndjson" {
 				step = {
 					type: "read_ndjson",
 					file: finalFileName,
@@ -345,6 +361,14 @@ workflow := func() {
 		_saveFileContent: func(name) {
 			outContentFiles = append(outContentFiles, name)
 		},
+		_saveFrameSpecs: func(name, specs) {
+			ll.assert(
+				outFramesSpecs[name] == undefined,
+				"frame with name '%s' already saved, please pick a different name",
+				name
+			)
+			outFramesSpecs[name] = specs
+		},
 
 
 
@@ -447,7 +471,44 @@ workflow := func() {
 				ptablerCmdBuilder.saveFileContent(outContentFile)
 			}
 
-			return ptablerCmdBuilder.run()
+			tplArgs := {}
+			for frameName, specsById in outFramesSpecs {
+				columnIds := []
+				for columnId, _ in specsById {
+					columnIds = append(columnIds, columnId)
+				}
+				tplArgs[frameName] = columnIds;
+			}
+            workdirProcessorName := "import_dir";
+			if len(tplArgs) > 0 {
+				ptablerCmdBuilder.processWorkdir(workdirProcessorName, importDirTpl, tplArgs)
+			}
+
+			execResult := ptablerCmdBuilder.run()
+
+			self := undefined
+			self = ll.toStrict(oop.inherit(execResult, {
+
+
+
+
+
+
+				getFrameDirect: func(frameName) {
+					specs := outFramesSpecs[frameName]
+					ll.assert(!is_undefined(specs), "saveFrameDirect was not called for frame '%s'", frameName)
+					savedFrames := execResult.getProcessorResult(workdirProcessorName)
+
+					pf := pframes.pFrameBuilder()
+					for pColumnId, pColumnSpec in specs {
+						pColumnRef := util.makeFrameColumnRef(frameName, pColumnId)
+						pColumnData := savedFrames.getFutureInputField(pColumnRef)
+						pf.add(pColumnId, pColumnSpec, pColumnData)
+					}
+					return pf.build()
+				}
+			}))
+			return self
 		}
 	}
 
@@ -568,7 +629,13 @@ _newDataFrame = func(parentWorkflow, dfName) {
 		}
 
 		step := undefined
-		if finalFormat == "ndjson" {
+		if finalFormat == "parquet" {
+			step = {
+				type: "write_parquet",
+				table: dfName,
+				file: outputFile
+			}
+		} else if finalFormat == "ndjson" {
 			step = {
 				type: "write_ndjson",
 				table: dfName,
@@ -756,6 +823,31 @@ _newDataFrame = func(parentWorkflow, dfName) {
 
 
 
+
+
+
+
+		saveFrameDirect: func(frameName, params) {
+			ll.assert(len(frameName) > 0, "frameName must be a non-empty string")
+			util.validateParams(params)
+
+			specs := util.makeFrameSpecs(params)
+			parentWorkflow._saveFrameSpecs(frameName, specs)
+
+			step := util.makeWriteFrameStep(frameName, dfName, params)
+			parentWorkflow.addRawStep(step)
+		},
+
+
+
+
+
+
+
+
+
+
+
 		groupBy: func(...expressions) {
 			ll.assert(len(expressions) > 0, "groupBy requires at least one expression argument.")
 

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

@@ -0,0 +1,178 @@
+ll := import("@platforma-sdk/workflow-tengo:ll")
+constants := import("@platforma-sdk/workflow-tengo:pframes.constants")
+spec := import("@platforma-sdk/workflow-tengo:pframes.spec")
+validation := import("@platforma-sdk/workflow-tengo:validation")
+slices := import("@platforma-sdk/workflow-tengo:slices")
+canonical := import("@platforma-sdk/workflow-tengo:canonical")
+
+_AXIS_SCHEMA := {
+
+	`column`: `string`,
+
+	`spec`: spec.P_AXIS_SPEC_SCHEMA
+}
+
+_COLUMN_SCHEMA := {
+
+	`column`: `string`,
+
+	`spec`: spec.P_COLUMN_OWN_SPEC_SCHEMA
+}
+
+_PARAMS_SCHEMA := {
+
+
+	`axes`: [_AXIS_SCHEMA],
+
+	`columns`: [_COLUMN_SCHEMA],
+
+
+	`partitionKeyLength,?` : `number`,
+
+
+    `strict,?` : `bool`
+}
+
+validateParams := func(params) {
+	validation.assertType(params, _PARAMS_SCHEMA, "Invalid params structure")
+
+    columns := {}
+    ll.assert(len(params.axes) > 0, "At least one axis is required")
+    for entry in params.axes {
+        if !is_undefined(columns[entry.column]) {
+            ll.assert(false, "Column (%s) used more then once which is prohibited", entry.column)
+        }
+        columns[entry.column] = 1
+        if !is_undefined(entry.spec.parentAxes) && len(entry.spec.parentAxes) > 0 {
+            for index in entry.spec.parentAxes {
+                ll.assert(
+                    index < len(params.axes),
+                    "Axis parent (%d) must be strictly less than the number of axes (%d)",
+                    index,
+                    len(params.axes)
+                )
+            }
+        }
+    }
+    ll.assert(len(params.columns) > 0, "At least one column is required")
+    for entry in params.columns {
+        if !is_undefined(columns[entry.column]) {
+            ll.assert(false, "Column (%s) used more then once which is prohibited", entry.column)
+        }
+        columns[entry.column] = 1
+        if !is_undefined(entry.spec.parentAxes) && len(entry.spec.parentAxes) > 0 {
+            for index in entry.spec.parentAxes {
+                ll.assert(
+                    index < len(params.axes),
+                    "Column parent (%d) must be strictly less than the number of axes (%d)",
+                    index,
+                    len(params.axes)
+                )
+            }
+        }
+    }
+
+
+    ll.assert(
+        params.partitionKeyLength == undefined ||
+            (params.partitionKeyLength >= 0 && params.partitionKeyLength < len(params.axes)),
+        "partitionKeyLength (%d) must be strictly less than the number of axes (%d)",
+        params.partitionKeyLength,
+        len(params.axes)
+    )
+}
+
+unique := func(list) {
+    uniqueMap := {}
+    for _, item in list {
+        uniqueMap[item] = item
+    }
+    uniqueList := []
+    for _, item in uniqueMap {
+        uniqueList = append(uniqueList, item)
+    }
+    return uniqueList
+}
+
+makeFrameSpecs := func(params) {
+	axes := []
+    for entry in params.axes {
+        spec := {
+            type: entry.spec.type,
+            name: entry.spec.name
+        }
+        if !is_undefined(entry.spec.domain) && len(entry.spec.domain) > 0 {
+            spec.domain = entry.spec.domain
+        }
+        if !is_undefined(entry.spec.annotations) && len(entry.spec.annotations) > 0 {
+            spec.annotations = entry.spec.annotations
+        }
+        if !is_undefined(entry.spec.parentAxes) && len(entry.spec.parentAxes) > 0 {
+            spec.parentAxes = unique(entry.spec.parentAxes)
+        }
+        axes = append(axes, spec)
+    }
+    columns := {}
+    for entry in params.columns {
+        spec := {
+            kind: constants.KIND_P_COLUMN,
+            axesSpec: axes,
+            valueType: entry.spec.valueType,
+            name: entry.spec.name
+        }
+        if !is_undefined(entry.spec.domain) && len(entry.spec.domain) > 0 {
+            spec.domain = entry.spec.domain
+        }
+        if !is_undefined(entry.spec.annotations) && len(entry.spec.annotations) > 0 {
+            spec.annotations = entry.spec.annotations
+        }
+        if !is_undefined(entry.spec.parentAxes) && len(entry.spec.parentAxes) > 0 {
+            spec.parentAxes = unique(entry.spec.parentAxes)
+        }
+        columns[entry.column] = spec
+    }
+    return columns
+}
+
+makeWriteFrameStep := func(frameName, dfName, params) {
+	step := {
+        type: "write_frame",
+        inputTable: dfName,
+        frameName: frameName,
+        axes: slices.map(params.axes, func(entry) {
+            return {
+                column: entry.column,
+                type: entry.spec.type
+            }
+        }),
+        columns: slices.map(params.columns, func(entry) {
+            return {
+                column: entry.column,
+                type: entry.spec.valueType
+            }
+        }),
+        partitionKeyLength: 0,
+        strict: false
+    }
+    if !is_undefined(params.partitionKeyLength) {
+        step.partitionKeyLength = params.partitionKeyLength
+    }
+    if !is_undefined(params.strict) {
+        step.strict = params.strict
+    }
+    return step
+}
+
+makeFrameColumnRef := func(frameName, columnId) {
+	return canonical.encode({
+		frame: frameName,
+		columnId: columnId
+	})
+}
+
+export ll.toStrict({
+	validateParams: validateParams,
+    makeFrameSpecs: makeFrameSpecs,
+    makeWriteFrameStep: makeWriteFrameStep,
+    makeFrameColumnRef: makeFrameColumnRef
+})

package/dist/tengo/lib/validation.lib.tengo

@@ -206,6 +206,20 @@ _validateJson := func(js, schema, keyPath, ...stack) {
 
 
 
+	if is_array(schema) && len(schema) > 0 && schema[0] == "and" {
+		for i, elem in schema[1:] {
+			r := _validateJson(js, elem, keyPath, stack...)
+			if isFail(r) {
+				return r
+			}
+		}
+
+		return success
+	}
+
+
+
+
 	if is_array(schema) {
 		if !is_array(js) {
 			return fail(keyPath, "js %q must be array", js)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "5.2.0",
+  "version": "5.2.2",
   "description": "Tengo SDK library",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -18,11 +18,11 @@
   "dependencies": {
     "@milaboratories/software-pframes-conv": "2.2.7",
     "@platforma-open/milaboratories.software-small-binaries": "^1.15.21",
-    "@platforma-open/milaboratories.software-ptabler": "1.12.2",
-    "@platforma-open/milaboratories.software-ptexter": "1.1.1"
+    "@platforma-open/milaboratories.software-ptexter": "1.1.1",
+    "@platforma-open/milaboratories.software-ptabler": "1.12.4"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "2.1.19"
+    "@platforma-sdk/tengo-builder": "2.1.21"
   },
   "scripts": {
     "type-check": "pl-tengo check",