@platforma-sdk/workflow-tengo 2.8.1 → 2.8.2

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

@@ -1,107 +1,101 @@
-/** API to retrieve assets packed with template code (like other templates). */
 
 plapi := import("plapi")
 json := import("json")
 ll := import("@platforma-sdk/workflow-tengo:ll")
 smart := import("@platforma-sdk/workflow-tengo:smart")
 
-/**
- * Returns internal template identifier for loaded templates
- *
- * @param tplName: string - full name of a template, including namespace (package name).
- * Local templates (within the same package) can omit namespace part and start the name with colon:
- *  - "@company/package:someTemplateName"
- *  - ":myLocalTemplate"
- *
- * @return template: smart.resource - resource of tengo template with given name.
- */
+
+
+
+
+
+
+
+
+
 importTemplate := func(tplName) {
-	return smart.resource(plapi.getTemplateId(tplName))
+return smart.resource(plapi.getTemplateId(tplName))
 }
 
-/**
- * Returns software description suitable for 'exec' operations.
- *
- * @param swName: string - full name of the software entrypoint, including namespace (NPM package name).
- *                         Local software entrypoints (within the same package) can omit namespace part
- *                         and start the name with colon:
- *                           - "@company/package:some-oftware"
- *                           - ":my-local-software"
- *
- * @return softwareInfo: softwareInfo - structure with software info.
- */
+
+
+
+
+
+
+
+
+
+
 importSoftware := func(swName) {
-	sw := plapi.getSoftwareInfo(swName)
-	return ll.toStrict({
-		_type: "softwareDescriptor",
-		_id: sw.id,
-
-		resource: smart.resource(sw.id),
-		name: sw.name,
-		version: sw.version,
-		blobRef: sw.blobRef,
-		descriptor: ll.toStrict(json.decode(sw.descriptor)) // raw sw.json data with software entrypoint descriptor
-	})
+sw := plapi.getSoftwareInfo(swName)
+return ll.toStrict({
+_type: "softwareDescriptor",
+_id: sw.id,
+
+resource: smart.resource(sw.id),
+name: sw.name,
+version: sw.version,
+blobRef: sw.blobRef,
+descriptor: ll.toStrict(json.decode(sw.descriptor)) // raw sw.json data with software entrypoint descriptor
+})
 }
 
-/**
- * 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
-	}
+if !ll.isMap(toCheck) {
+return false
+}
 
-	return (ll.fromStrict(toCheck)._type) == "softwareDescriptor"
+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.
- *
- * @param assetName: string - full name of asset entrypoint, including namespace (NPM package name).
- *                            Local software entrypoints (within the same package) can omit namespace
- *                            part and start the name with colon:
- *                              - "@company/package:some-software"
- *                              - ":my-local-software"
- */
+
+
+
+
+
+
+
+
+
 importAsset := func(assetName) {
-	asset := plapi.getSoftwareInfo(assetName)
-	return ll.toStrict({
-		_type: "assetDescriptor",
-		_id: asset.id,
-
-		resource: smart.resource(asset.id),
-		name: asset.name,
-		version: asset.version,
-		blobRef: asset.blobRef,
-		descriptor: ll.toStrict(json.decode(asset.descriptor)) // raw sw.json data with asset entrypoint descriptor
-	})
+asset := plapi.getSoftwareInfo(assetName)
+return ll.toStrict({
+_type: "assetDescriptor",
+_id: asset.id,
+
+resource: smart.resource(asset.id),
+name: asset.name,
+version: asset.version,
+blobRef: asset.blobRef,
+descriptor: ll.toStrict(json.decode(asset.descriptor)) // raw sw.json data with asset entrypoint descriptor
+})
 }
 
-/**
- * Checks if given item is an asset info
- *
- * @param toCheck: any - item to check
- *
- * @return isAsset: boolean - true for asset info, loaded with importAsset()
- */
+
+
+
+
+
+
 isAssetInfo := func(toCheck) {
-	if !ll.isMap(toCheck) {
-		return false
-	}
+if !ll.isMap(toCheck) {
+return false
+}
 
-	return (ll.fromStrict(toCheck)._type) == "assetDescriptor"
+return (ll.fromStrict(toCheck)._type) == "assetDescriptor"
 }
 
 export ll.toStrict({
-	importTemplate: importTemplate,
-	importSoftware: importSoftware,
-	isSoftwareInfo: isSoftwareInfo,
-	importAsset:    importAsset,
-	isAssetInfo:    isAssetInfo
+importTemplate: importTemplate,
+importSoftware: importSoftware,
+isSoftwareInfo: isSoftwareInfo,
+importAsset:    importAsset,
+isAssetInfo:    isAssetInfo
 })

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

@@ -1,11 +1,9 @@
-// constants
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 
 RTYPE_JSON                := { Name: "json/object",       Version: "1" }
 
 RTYPE_MAP                 := { Name: "std/map",           Version: "1" }
-// @TODO this should be deleted once we align on map type name
 RTYPE_MAP_ALT             := { Name: "StdMap",            Version: "1" }
 RTYPE_MAP_EPH             := { Name: "EphStdMap",         Version: "1" }
 
@@ -33,7 +31,6 @@ RTYPE_WORKDIR_FILL_RULES  := { Name: "WorkdirFill/rules", Version: "1" }
 RTYPE_WORKDIR_SAVE        := { Name: "WorkdirSave",       Version: "1" }
 RTYPE_WORKDIR_SAVE_RULES  := { Name: "WorkdirSave/rules", Version: "1" }
 
-/** Main resource type of representing a PL error */
 RTYPE_JSON_ERROR          := { Name: "json/resourceError", Version: "1"}
 
 FTYPE_OTW                 := "OTW" // Generic one-time writable field. The value of this field can be set only once.
@@ -43,33 +40,33 @@ FTYPE_OUTPUT              := "output"
 FTYPE_DYNAMIC             := "dynamic"
 
 export ll.toStrict({
-	FTYPE_OTW                   : FTYPE_OTW,
-	FTYPE_SERVICE               : FTYPE_SERVICE,
-	FTYPE_INPUT                 : FTYPE_INPUT,
-	FTYPE_OUTPUT                : FTYPE_OUTPUT,
-	FTYPE_DYNAMIC               : FTYPE_DYNAMIC,
+FTYPE_OTW                   : FTYPE_OTW,
+FTYPE_SERVICE               : FTYPE_SERVICE,
+FTYPE_INPUT                 : FTYPE_INPUT,
+FTYPE_OUTPUT                : FTYPE_OUTPUT,
+FTYPE_DYNAMIC               : FTYPE_DYNAMIC,
 
-	RTYPE_BINARY_MAP            : RTYPE_BINARY_MAP,
-	RTYPE_BINARY_VALUE          : RTYPE_BINARY_VALUE,
-	RTYPE_BLOB_MAP              : RTYPE_BLOB_MAP,
-	RTYPE_BOBJECT_SPEC          : RTYPE_BOBJECT_SPEC,
-	RTYPE_BRESOLVE_CHOICE       : RTYPE_BRESOLVE_CHOICE,
-	RTYPE_BRESOLVE_FIRST        : RTYPE_BRESOLVE_FIRST,
-	RTYPE_BRESOLVE_NO_RESULT    : RTYPE_BRESOLVE_NO_RESULT,
-	RTYPE_CONTEXT               : RTYPE_CONTEXT,
-	RTYPE_CONTEXT_END           : RTYPE_CONTEXT_END,
-	RTYPE_JSON                  : RTYPE_JSON,
-	RTYPE_MAP                   : RTYPE_MAP,
-	RTYPE_MAP_ALT               : RTYPE_MAP_ALT,
-	RTYPE_MAP_EPH               : RTYPE_MAP_EPH,
-	RTYPE_QUERY_RESULT          : RTYPE_QUERY_RESULT,
-	RTYPE_OBJECT_SPEC           : RTYPE_OBJECT_SPEC,
-	RTYPE_RENDER_EPH_TEMPLATE   : RTYPE_RENDER_EPH_TEMPLATE,
-	RTYPE_RENDER_TEMPLATE       : RTYPE_RENDER_TEMPLATE,
-	RTYPE_WORKDIR_CREATE        : RTYPE_WORKDIR_CREATE,
-	RTYPE_WORKDIR_FILL          : RTYPE_WORKDIR_FILL,
-	RTYPE_WORKDIR_FILL_RULES    : RTYPE_WORKDIR_FILL_RULES,
-	RTYPE_WORKDIR_SAVE          : RTYPE_WORKDIR_SAVE,
-	RTYPE_WORKDIR_SAVE_RULES    : RTYPE_WORKDIR_SAVE_RULES,
-	RTYPE_JSON_ERROR            : RTYPE_JSON_ERROR
+RTYPE_BINARY_MAP            : RTYPE_BINARY_MAP,
+RTYPE_BINARY_VALUE          : RTYPE_BINARY_VALUE,
+RTYPE_BLOB_MAP              : RTYPE_BLOB_MAP,
+RTYPE_BOBJECT_SPEC          : RTYPE_BOBJECT_SPEC,
+RTYPE_BRESOLVE_CHOICE       : RTYPE_BRESOLVE_CHOICE,
+RTYPE_BRESOLVE_FIRST        : RTYPE_BRESOLVE_FIRST,
+RTYPE_BRESOLVE_NO_RESULT    : RTYPE_BRESOLVE_NO_RESULT,
+RTYPE_CONTEXT               : RTYPE_CONTEXT,
+RTYPE_CONTEXT_END           : RTYPE_CONTEXT_END,
+RTYPE_JSON                  : RTYPE_JSON,
+RTYPE_MAP                   : RTYPE_MAP,
+RTYPE_MAP_ALT               : RTYPE_MAP_ALT,
+RTYPE_MAP_EPH               : RTYPE_MAP_EPH,
+RTYPE_QUERY_RESULT          : RTYPE_QUERY_RESULT,
+RTYPE_OBJECT_SPEC           : RTYPE_OBJECT_SPEC,
+RTYPE_RENDER_EPH_TEMPLATE   : RTYPE_RENDER_EPH_TEMPLATE,
+RTYPE_RENDER_TEMPLATE       : RTYPE_RENDER_TEMPLATE,
+RTYPE_WORKDIR_CREATE        : RTYPE_WORKDIR_CREATE,
+RTYPE_WORKDIR_FILL          : RTYPE_WORKDIR_FILL,
+RTYPE_WORKDIR_FILL_RULES    : RTYPE_WORKDIR_FILL_RULES,
+RTYPE_WORKDIR_SAVE          : RTYPE_WORKDIR_SAVE,
+RTYPE_WORKDIR_SAVE_RULES    : RTYPE_WORKDIR_SAVE_RULES,
+RTYPE_JSON_ERROR            : RTYPE_JSON_ERROR
 })

package/dist/tengo/lib/exec.R.internal.lib.tengo

@@ -5,25 +5,25 @@ pkg := import("@platforma-sdk/workflow-tengo:exec.package")
 path := import("@platforma-sdk/workflow-tengo:path")
 
 rVenvInputSchema := {
-	operationMode: "string",
-	toolset: "string",
-	dependencies: {"any": "string"},
-	software: validation.reference,
+operationMode: "string",
+toolset: "string",
+dependencies: {"any": "string"},
+software: validation.reference,
 
-	rDescriptor: pkg.runEnvDescriptorScheme,
-	R: validation.reference
+rDescriptor: pkg.runEnvDescriptorScheme,
+R: validation.reference
 }
 
 runRBuilder := func(wd, rPackage, rDescriptor) {
-	return runcmd.builder(wd).
-		ref("r-run-environment", rPackage).
-		substitutionRule("{R}", "r-run-environment").
-		addToPath(path.join("{R}", rDescriptor.binDir), true).
-		envVar("R_HOME_DIR", "{R}").
-		envVar("RENV_PATHS_ROOT", path.join("{R}", "renv-root"))
+return runcmd.builder(wd).
+ref("r-run-environment", rPackage).
+substitutionRule("{R}", "r-run-environment").
+addToPath(path.join("{R}", rDescriptor.binDir), true).
+envVar("R_HOME_DIR", "{R}").
+envVar("RENV_PATHS_ROOT", path.join("{R}", "renv-root"))
 }
 
 export ll.toStrict({
-	rVenvInputSchema                   : rVenvInputSchema,
-	runRBuilder                        : runRBuilder
+rVenvInputSchema                   : rVenvInputSchema,
+runRBuilder                        : runRBuilder
 })

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

@@ -8,179 +8,170 @@ smart := import("@platforma-sdk/workflow-tengo:smart")
 render := import("@platforma-sdk/workflow-tengo:render")
 pkg := import("@platforma-sdk/workflow-tengo:exec.package")
 internal := import("@platforma-sdk/workflow-tengo:exec.R.internal")
-runenv := import("@platforma-sdk/workflow-tengo:exec.runenv")
 
 _OUTPUT_RUN_ENV       := "runEnv"
 
 rVenvBuilder := func() {
-	self := undefined
-
-	opMode := "remote"
-	toolset := "renv"
-	rDescriptor := undefined
-	softwareRef := undefined
-	dependencies := undefined
-	cache := 0
-
-	self = {
-		operationMode: func(mode) {
-			validation.assertJsonSchema(mode, "string",
-				"exec.R.operationMode: <mode> must be string")
-
-			ll.assert(mode == "remote" || mode == "dev-local",
-				"exec.R.operationMode: unsupported operation mode: 'remote', 'dev-local' are valid in this version of workflow-tengo SDK")
-
-			opMode = mode
-			return self
-		},
-
-		useToolset: func(name) {
-			validation.assertJsonSchema(name, "string",
-				"exec.R.useToolset: <name> must be valid name of R packaging toolset (i.e. 'renv')")
-			ll.assert(name != "", "exec.R.useToolset: toolset name must not be empty")
-
-			toolset = name
-			return self
-		},
-
-		runEnvDescriptor: func(descriptor) {
-			validation.assertJsonSchema(descriptor, pkg.runEnvDescriptorScheme, "exec.R.runEnvDescriptor: <descriptor> must be run environment specification")
-			ll.assert(descriptor.type == "R", "exec.R.runEnvDescriptor: not a 'R' run environment: %q", descriptor.type)
-
-			rDescriptor = ll.fromStrict(descriptor)
-			return self
-		},
-
-		software: func(pkgRef) {
-			validation.assertJsonSchema(pkgRef, validation.reference, "exec.R.software: <pkgRef> must be a reference to software package")
-
-			softwareRef = pkgRef
-			return self
-		},
-
-		dependencies: func(deps) {
-			validation.assertJsonSchema(deps, { "any": "string" }, "exec.R.dependencies: <deps> must be map of reference file paths")
-
-			dependencies = deps
-			return self
-		},
-
-		/**
-		 * Sets the cache time in milliseconds.
-		 *
-		 * @param millis: number
-		 */
-		cacheMillis: func(millis) {
-			ll.assert(is_int(millis) && millis > 0, "exec.R.cacheMillis: cache time must be a number of milliseconds")
-			cache = millis * times.millisecond
-			return self
-		},
-
-		/**
-		 * Sets the cache time in seconds.
-		 *
-		 * @param seconds: number
-		 */
-		cacheSeconds: func(seconds) {
-			ll.assert(is_int(seconds) && seconds > 0, "exec.R.cacheSeconds: cache time must be a number of seconds")
-			cache = seconds * times.second
-			return self
-		},
-
-		/**
-		 * Sets the cache time in minutes.
-		 *
-		 * @param minutes: number
-		 */
-		cacheMinutes: func(minutes) {
-			ll.assert(is_int(minutes) && minutes > 0, "exec.R.cacheMinutes: cache time must be a number of minutes")
-			cache = minutes * times.minute
-			return self
-		},
-
-		/**
-		 * Sets the cache time in hours.
-		 *
-		 * @param hours: number
-		 */
-		cacheHours: func(hours) {
-			ll.assert(is_int(hours) && hours > 0, "exec.R.cacheHours: cache time must be a number of hours")
-			cache = hours * times.hour
-			return self
-		},
-
-		/**
-		 * Sets the cache time in days
-		 *
-		 * @param days: number
-		 */
-		cacheDays: func(days) {
-			ll.assert(is_int(days) && days > 0, "exec.R.cacheDays: cache time must be a number of days")
-			cache = days * times.hour * 24
-			return self
-		},
-
-		/**
-		 * @deprecated, use cacheMillis, cacheSeconds, cacheMinutes, cacheHours and cacheDays instead.
-		 * Sets the cache time.
-		 *
-		 * @param time: duration - the cache time from 'times' library.
-		 */
-		cache: func(time) {
-			ll.assert(
-				is_int(time) && time > times.millisecond,
-				"exec.R.cache: cache time must be an integer. " +
-					"Did you forget to import a standard tengo library 'times'?")
-			cache = time
-			return self
-		},
-
-		build: func() {
-			archive := pkg.get(rDescriptor.registry, rDescriptor.package).archive()
-			rPkg := pkg.install(archive).package()
-
-			rVenvInputs := {
-				operationMode: opMode,
-				toolset: toolset,
-				dependencies: dependencies,
-				software: softwareRef,
-				rDescriptor: rDescriptor,
-				R: rPkg
-			}
-
-			validation.assertJsonSchema(rVenvInputs, internal.rVenvInputSchema, "incomplete R runenv configuration")
-
-			tpl := render.create(assets.importTemplate("@platforma-sdk/workflow-tengo:exec.R.create-renv"), rVenvInputs)
-
-			self := undefined
-			self = ll.toStrict(oop.inherit(tpl, {
-				/**
-				 * R virtual environment with all dependencies installed.
-				 *
-				 * @return renv: smart.field - a reference to the R portable run environment.
-				 */
-				venv: func() {
-					return tpl.output(_OUTPUT_RUN_ENV, cache)
-				},
-
-				/**
-				 * R runtime used for R virtual environment creation.
-				 *
-				 * @return R: smart.Field - a reference to the R runtime.
-				 */
-				R: func() {
-					return rPkg
-				}
-			}))
-
-			return self
-		}
-	}
-
-	return self
+self := undefined
+
+opMode := "remote"
+toolset := "renv"
+rDescriptor := undefined
+softwareRef := undefined
+dependencies := undefined
+cache := 0
+
+self = {
+operationMode: func(mode) {
+validation.assertJsonSchema(mode, "string",
+"exec.R.operationMode: <mode> must be string")
+
+ll.assert(mode == "remote" || mode == "dev-local",
+"exec.R.operationMode: unsupported operation mode: 'remote', 'dev-local' are valid in this version of workflow-tengo SDK")
+
+opMode = mode
+return self
+},
+
+useToolset: func(name) {
+validation.assertJsonSchema(name, "string",
+"exec.R.useToolset: <name> must be valid name of R packaging toolset (i.e. 'renv')")
+ll.assert(name != "", "exec.R.useToolset: toolset name must not be empty")
+
+toolset = name
+return self
+},
+
+runEnvDescriptor: func(descriptor) {
+validation.assertJsonSchema(descriptor, pkg.runEnvDescriptorScheme, "exec.R.runEnvDescriptor: <descriptor> must be run environment specification")
+ll.assert(descriptor.type == "R", "exec.R.runEnvDescriptor: not a 'R' run environment: %q", descriptor.type)
+
+rDescriptor = ll.fromStrict(descriptor)
+return self
+},
+
+software: func(pkgRef) {
+validation.assertJsonSchema(pkgRef, validation.reference, "exec.R.software: <pkgRef> must be a reference to software package")
+
+softwareRef = pkgRef
+return self
+},
+
+dependencies: func(deps) {
+validation.assertJsonSchema(deps, { "any": "string" }, "exec.R.dependencies: <deps> must be map of reference file paths")
+
+dependencies = deps
+return self
+},
+
+
+
+
+
+cacheMillis: func(millis) {
+ll.assert(is_int(millis) && millis > 0, "exec.R.cacheMillis: cache time must be a number of milliseconds")
+cache = millis * times.millisecond
+return self
+},
+
+
+
+
+
+cacheSeconds: func(seconds) {
+ll.assert(is_int(seconds) && seconds > 0, "exec.R.cacheSeconds: cache time must be a number of seconds")
+cache = seconds * times.second
+return self
+},
+
+
+
+
+
+cacheMinutes: func(minutes) {
+ll.assert(is_int(minutes) && minutes > 0, "exec.R.cacheMinutes: cache time must be a number of minutes")
+cache = minutes * times.minute
+return self
+},
+
+
+
+
+
+cacheHours: func(hours) {
+ll.assert(is_int(hours) && hours > 0, "exec.R.cacheHours: cache time must be a number of hours")
+cache = hours * times.hour
+return self
+},
+
+
+
+
+
+cacheDays: func(days) {
+ll.assert(is_int(days) && days > 0, "exec.R.cacheDays: cache time must be a number of days")
+cache = days * times.hour * 24
+return self
+},
+
+
+
+
+
+
+cache: func(time) {
+ll.assert(
+is_int(time) && time > times.millisecond,
+"exec.R.cache: cache time must be an integer. " +
+"Did you forget to import a standard tengo library 'times'?")
+cache = time
+return self
+},
+
+build: func() {
+archive := pkg.get(rDescriptor.registry, rDescriptor.package).archive()
+rPkg := pkg.install(archive).package()
+
+rVenvInputs := {
+operationMode: opMode,
+toolset: toolset,
+dependencies: dependencies,
+software: softwareRef,
+rDescriptor: rDescriptor,
+R: rPkg
+}
+
+validation.assertJsonSchema(rVenvInputs, internal.rVenvInputSchema, "incomplete R runenv configuration")
+
+tpl := render.create(assets.importTemplate("@platforma-sdk/workflow-tengo:exec.R.create-renv"), rVenvInputs)
+
+self := undefined
+self = ll.toStrict(oop.inherit(tpl, {
+
+
+
+
+venv: func() {
+return tpl.output(_OUTPUT_RUN_ENV, cache)
+},
+
+
+
+
+
+R: func() {
+return rPkg
+}
+}))
+
+return self
+}
+}
+
+return self
 }
 
 
 export ll.toStrict({
-	rVenvBuilder                        : rVenvBuilder
+rVenvBuilder                        : rVenvBuilder
 })