Data & Templating

Databases, JQ, Liquid templating and run variables. Each function lists its parameters, defaults and return value.

DB Namespace

Database connection and query functions.

Scope: Network

Functions

Function	Description
db.connect()	Establish a database connection
db.query()	Execute a SQL query and return rows
db.exec()	Execute a SQL statement (INSERT, UPDATE, DELETE)
db.insert()	Insert rows into a table
db.update()	Update rows in a table
db.delete()	Delete rows from a table
db.bulk()	Perform bulk insert operations
db.close()	Close a database connection

db.connect()

Establish a database connection and return a connection handle for subsequent operations.

Parameters

Parameter	Type	Default	Description
driver	string	"postgres"	Database driver: "postgres", "mysql", "sqlite", "duckdb"
host	string	"localhost"	Database host
port	int	5432	Database port
database	string	—	Database name (required)
username	string	—	Username for authentication
password	string	—	Password for authentication
sslMode	string	"disable"	SSL mode: "disable", "require", "verify-ca", "verify-full"
path	string	—	File path for SQLite/DuckDB databases
readOnly	bool	false	Open in read-only mode

Returns

Field	Type	Description
success	bool	Whether connection succeeded
connectionId	string	Connection handle for subsequent operations

Examples

// Connect to PostgreSQL
let conn = db.connect({
  driver: "postgres",
  host: "localhost",
  port: 5432,
  database: "myapp",
  username: "admin",
  password: "secret"
})

// Connect to DuckDB
let conn = db.connect({
  driver: "duckdb",
  path: "/data/analytics.duckdb"
})

// Connect to SQLite (read-only)
let conn = db.connect({
  driver: "sqlite",
  path: "/data/app.db",
  readOnly: true
})

db.query()

Execute a SQL query and return rows.

Parameters

Parameter	Type	Default	Description
connectionId	string	—	Connection handle from db.connect() (required)
sql	string	—	SQL query to execute (required)
args	array	—	Positional arguments for parameterized queries
named	map	—	Named arguments for parameterized queries

Returns

Field	Type	Description
success	bool	Whether query succeeded
rows	array	Array of row objects

Examples

let conn = db.connect({
  driver: "postgres",
  database: "myapp",
  username: "admin",
  password: "secret"
})

// Simple query
let result = db.query({
  connectionId: conn.connectionId,
  sql: "SELECT id, name, email FROM users"
})
for (let row of result.rows) {
  log(row.name + ": " + row.email)
}

// Parameterized query
let result = db.query({
  connectionId: conn.connectionId,
  sql: "SELECT * FROM users WHERE status = $1 AND age > $2",
  args: ["active", 18]
})

// Named parameters
let result = db.query({
  connectionId: conn.connectionId,
  sql: "SELECT * FROM users WHERE department = :dept",
  named: { dept: "engineering" }
})

db.close({ connectionId: conn.connectionId })

db.exec()

Execute a SQL statement that doesn’t return rows (INSERT, UPDATE, DELETE, DDL).

Parameters

Parameter	Type	Default	Description
connectionId	string	—	Connection handle (required)
sql	string	—	SQL statement to execute (required)
args	array	—	Positional arguments
named	map	—	Named arguments

Returns

Field	Type	Description
success	bool	Whether execution succeeded
rowsAffected	int	Number of rows affected
lastInsertId	int	Last insert ID (if applicable)

Examples

// Create a table
db.exec({
  connectionId: conn.connectionId,
  sql: "CREATE TABLE IF NOT EXISTS logs (id SERIAL, message TEXT, created_at TIMESTAMP DEFAULT NOW())"
})

// Insert with parameters
db.exec({
  connectionId: conn.connectionId,
  sql: "INSERT INTO logs (message) VALUES ($1)",
  args: ["Application started"]
})

// Update with parameters
let result = db.exec({
  connectionId: conn.connectionId,
  sql: "UPDATE users SET status = $1 WHERE last_login < $2",
  args: ["inactive", "2024-01-01"]
})
log("Updated " + result.rowsAffected + " rows")

db.insert()

Insert rows into a database table using a structured API.

Parameters

Parameter	Type	Default	Description
connectionId	string	—	Connection handle (required)
table	string	—	Table name (required)
columns	array	—	Column names
values	array	—	Values to insert
returning	array	—	Columns to return after insert (e.g., ["id"])

Returns

Field	Type	Description
success	bool	Whether insert succeeded
rows	array	Returned rows (if returning specified)
rowsAffected	int	Number of rows inserted
lastInsertId	int	Last insert ID

Examples

// Insert a row
let result = db.insert({
  connectionId: conn.connectionId,
  table: "users",
  columns: ["name", "email", "role"],
  values: ["Alice", "[email protected]", "admin"],
  returning: ["id"]
})
log("New user ID: " + result.rows[0].id)

db.update()

Update rows in a database table.

Parameters

Parameter	Type	Default	Description
connectionId	string	—	Connection handle (required)
table	string	—	Table name (required)
set	map	—	Column-value pairs to update (required)
where	string	—	WHERE clause (without WHERE keyword)
whereArgs	array	—	Positional arguments for WHERE clause
returning	array	—	Columns to return after update

Returns

Field	Type	Description
success	bool	Whether update succeeded
rows	array	Returned rows (if returning specified)
rowsAffected	int	Number of rows updated

Examples

// Update rows
let result = db.update({
  connectionId: conn.connectionId,
  table: "users",
  set: { status: "active", verified: true },
  where: "email = $1",
  whereArgs: ["[email protected]"]
})
log("Updated " + result.rowsAffected + " rows")

db.delete()

Delete rows from a database table.

Parameters

Parameter	Type	Default	Description
connectionId	string	—	Connection handle (required)
table	string	—	Table name (required)
where	string	—	WHERE clause (without WHERE keyword)
whereArgs	array	—	Positional arguments for WHERE clause
returning	array	—	Columns to return after delete

Returns

Field	Type	Description
success	bool	Whether delete succeeded
rows	array	Returned rows (if returning specified)
rowsAffected	int	Number of rows deleted

Examples

// Delete rows
let result = db.delete({
  connectionId: conn.connectionId,
  table: "sessions",
  where: "expires_at < NOW()"
})
log("Deleted " + result.rowsAffected + " expired sessions")

db.bulk()

Perform efficient bulk insert operations.

Parameters

Parameter	Type	Default	Description
connectionId	string	—	Connection handle (required)
table	string	—	Table name (required)
columns	array	—	Column names (required)
rows	array	—	Array of arrays containing row values (required)
onConflict	string	—	Conflict handling (e.g., "DO NOTHING", "DO UPDATE SET ...")
batchSize	int	1000	Number of rows per batch

Returns

Field	Type	Description
success	bool	Whether bulk insert succeeded
rowsAffected	int	Total rows inserted

Examples

// Bulk insert
let result = db.bulk({
  connectionId: conn.connectionId,
  table: "events",
  columns: ["type", "payload", "timestamp"],
  rows: [
    ["click", '{"page": "/home"}', "2024-01-15T10:00:00Z"],
    ["view", '{"page": "/about"}', "2024-01-15T10:01:00Z"],
    ["click", '{"page": "/contact"}', "2024-01-15T10:02:00Z"]
  ],
  batchSize: 500
})
log("Inserted " + result.rowsAffected + " events")

// Upsert (insert or update on conflict)
db.bulk({
  connectionId: conn.connectionId,
  table: "metrics",
  columns: ["name", "value"],
  rows: [
    ["cpu_usage", 45.2],
    ["memory_usage", 72.1],
    ["disk_usage", 58.5]
  ],
  onConflict: "DO UPDATE SET value = EXCLUDED.value"
})

db.close()

Close a database connection and release resources.

Parameters

Parameter	Type	Default	Description
connectionId	string	—	Connection handle from db.connect() (required)

Returns

Field	Type	Description
success	bool	Whether connection was closed

Examples

// Full database lifecycle
let conn = db.connect({
  driver: "postgres",
  database: "myapp",
  username: "admin",
  password: "secret"
})

let users = db.query({
  connectionId: conn.connectionId,
  sql: "SELECT * FROM users WHERE active = true"
})

log("Found " + users.rows.length + " active users")

db.close({ connectionId: conn.connectionId })

JQ Namespace

JQ expression evaluation functions.

Scope: System

Functions

Function	Description
jq.query()	Evaluate a jq expression against provided data

jq.query()

Evaluate a jq expression against a data object. Uses the gojq library for jq-compatible query evaluation.

Parameters

Parameter	Type	Default	Description
expression	string	—	JQ expression to evaluate (required)
data	map	{}	Data object to query against

Returns

Field	Type	Description
success	bool	Whether evaluation succeeded
value	any	Query result

Examples

// Simple value extraction
let result = jq.query({
  expression: ".name",
  data: { name: "Alice", age: 30 }
})
log("Name: " + result.value) // "Alice"

// Count array elements
let result = jq.query({
  expression: ".users | length",
  data: { users: [{ name: "Alice" }, { name: "Bob" }] }
})
log("User count: " + result.value) // 2

// Filter arrays
let result = jq.query({
  expression: '[.[] | select(.status == "active") | .name]',
  data: [
    { name: "app1", status: "active" },
    { name: "app2", status: "inactive" },
    { name: "app3", status: "active" }
  ]
})
log("Active: " + JSON.stringify(result.value)) // ["app1", "app3"]

// Extract nested values
let result = jq.query({
  expression: ".config.database.host",
  data: {
    config: {
      database: { host: "localhost", port: 5432 }
    }
  }
})
log("DB host: " + result.value) // "localhost"

// Build new objects
let result = jq.query({
  expression: "{ host: .db_host, port: .db_port }",
  data: { db_host: "localhost", db_port: 5432, db_name: "myapp" }
})
log(JSON.stringify(result.value)) // {"host":"localhost","port":5432}

// Transform data
let result = jq.query({
  expression: '[.items[] | {name, total: (.price * .quantity)}]',
  data: {
    items: [
      { name: "Widget", price: 10, quantity: 5 },
      { name: "Gadget", price: 25, quantity: 2 }
    ]
  }
})
log(JSON.stringify(result.value))

// Parse JSON strings
let result = jq.query({
  expression: ".config | fromjson | .port",
  data: { config: '{"host":"localhost","port":8080}' }
})
log("Port: " + result.value) // 8080

Liquid Namespace

Liquid template rendering functions.

Scope: System

Functions

Function	Description
liquid.render()	Render a Liquid template with variables
liquid.process()	Process Liquid templates from a source directory

liquid.render()

Render a Liquid template string or file with provided variables.

Parameters

Parameter	Type	Default	Description
data	string	—	Inline template string
file	string	—	Path to template file (alternative to data)
path	string	—	Base path for {% include %} tags
vars	map	—	Variables to pass to the template

Either data or file must be provided.

Returns

Field	Type	Description
success	bool	Whether rendering succeeded
output	string	Rendered output

Examples

// Render inline template
let result = liquid.render({
  data: "Hello, {{name}}! You have {{count}} items.",
  vars: { name: "Alice", count: 42 }
})
log(result.output) // "Hello, Alice! You have 42 items."

// Render with conditionals
let result = liquid.render({
  data: `
    {% if environment == "production" %}
    server: prod.example.com
    {% else %}
    server: dev.example.com
    {% endif %}
  `,
  vars: { environment: "production" }
})
log(result.output)

// Render from file
let result = liquid.render({
  file: "/templates/config.yaml.liquid",
  vars: {
    host: "localhost",
    port: 8080,
    debug: false
  }
})
file.write({ path: "/config/config.yaml", content: result.output })

// Render with loops
let result = liquid.render({
  data: "{% for item in items %}{{item.name}}: {{item.value}}\n{% endfor %}",
  vars: {
    items: [
      { name: "cpu", value: "45%" },
      { name: "memory", value: "72%" }
    ]
  }
})
log(result.output)

liquid.process()

Process Liquid templates from a source directory to a destination directory.

Parameters

Parameter	Type	Default	Description
source	string	—	Source directory containing templates (required)
destination	string	—	Output directory for rendered files (required)
include	array	—	Glob patterns to include
exclude	array	—	Glob patterns to exclude
flatten	bool	false	Flatten directory structure in output
vars	map	—	Variables to pass to all templates

Returns

Field	Type	Description
success	bool	Whether processing succeeded
processed	int	Number of files processed

Examples

// Process all templates in a directory
let result = liquid.process({
  source: "/templates/kubernetes/",
  destination: "/output/k8s/",
  vars: {
    namespace: "production",
    replicas: 3,
    image: "myapp:v1.0"
  }
})
log("Processed " + result.processed + " templates")

// Process with include/exclude filters
liquid.process({
  source: "/templates/",
  destination: "/output/",
  include: ["*.yaml", "*.conf"],
  exclude: ["*.bak", "test-*"],
  vars: { environment: "staging" }
})

// Flatten directory structure
liquid.process({
  source: "/templates/nested/config/",
  destination: "/output/flat/",
  flatten: true,
  vars: { host: "localhost" }
})

Vars Namespace

Workflow variable functions.

Scope: System

Functions

Function	Description
vars.set()	Set workflow variables from a map
vars.readFile()	Read file contents into variables
vars.readGlob()	Read files matching a glob pattern into a map variable

vars.set()

Set workflow variables from a map of key-value pairs.

Parameters

Parameter	Type	Default	Description
vars	map	—	Map of variable name → value (required)

Returns

Field	Type	Description
success	bool	Whether variables were set
context	map	Map of set variables

Examples

// Set multiple variables
vars.set({
  vars: {
    environment: "production",
    version: "1.0.0",
    replicas: 3
  }
})

// Set computed variables
let timestamp = new Date().toISOString()
vars.set({
  vars: {
    build_time: timestamp,
    build_id: "build-" + Date.now()
  }
})

vars.readFile()

Read file contents into workflow variables. Supports single file or multiple files.

Parameters (Single File)

Parameter	Type	Default	Description
path	string	—	File path to read (required)
setvar	string	"content"	Variable name to store content

Parameters (Multiple Files)

Parameter	Type	Default	Description
files	map	—	Map of variable name → file path

Returns

Field	Type	Description
success	bool	Whether read succeeded
context	map	Map of variable name → file content

Examples

// Read a single file
let result = vars.readFile({
  path: "/config/settings.yaml",
  setvar: "config"
})
log("Config: " + result.context.config)

// Read multiple files
let result = vars.readFile({
  files: {
    cert: "/etc/ssl/cert.pem",
    key: "/etc/ssl/key.pem",
    ca: "/etc/ssl/ca.pem"
  }
})
log("Cert loaded: " + result.context.cert.substring(0, 30))
log("Key loaded: " + result.context.key.substring(0, 30))

vars.readGlob()

Read files matching a glob pattern into a map variable. Each matching file becomes a key-value entry (filepath → content).

Parameters (Single Glob)

Parameter	Type	Default	Description
pattern	string	—	Glob pattern to match files (required)
setvar	string	"files"	Variable name to store result map

Parameters (Multiple Globs)

Parameter	Type	Default	Description
globs	map	—	Map of variable name → glob pattern

Returns

Field	Type	Description
success	bool	Whether read succeeded
context	map	Map of variable name → map of filepath → content

Examples

// Read all YAML config files
let result = vars.readGlob({
  pattern: "/config/*.yaml",
  setvar: "configs"
})
log("Loaded " + Object.keys(result.context.configs).length + " config files")

// Read multiple glob patterns
let result = vars.readGlob({
  globs: {
    templates: "/templates/*.liquid",
    configs: "/config/*.yaml",
    scripts: "/scripts/*.sh"
  }
})
log("Templates: " + Object.keys(result.context.templates).length)
log("Configs: " + Object.keys(result.context.configs).length)

Compute Namespace

Numeric and string computation functions.

Scope: System

Functions

Function	Description
compute.sum()	Add two numeric values
compute.concat()	Concatenate two strings
compute.replicate()	Create a deep copy of a record

compute.sum()

Add two numeric values together.

Parameters

Parameter	Type	Default	Description
value	number	—	Base value (required)
add	number	—	Value to add (required)

Returns

Field	Type	Description
success	bool	Whether the computation succeeded
result	number	Sum of the two values
error	string	Error message if failed

Examples

// Add two numeric values
var result = compute.sum({ value: 42, add: 8 });
if (result.success) {
    console.log(result.result); // 50
}

compute.concat()

Concatenate two strings together.

Parameters

Parameter	Type	Default	Description
value	string	—	Base string (required)
add	string	—	String to concatenate (required)

Returns

Field	Type	Description
success	bool	Whether the computation succeeded
result	string	Concatenated string
error	string	Error message if failed

Examples

// Concatenate two strings
var result = compute.concat({ value: "Hello", add: " World" });
if (result.success) {
    console.log(result.result); // "Hello World"
}

compute.replicate()

Create a deep copy of a record (key-value map).

Parameters

Parameter	Type	Default	Description
record	map	—	Record to replicate (required)

Returns

Field	Type	Description
success	bool	Whether the replication succeeded
result	map	Deep copy of the input record
error	string	Error message if failed

Examples

// Create a deep copy of a record
var result = compute.replicate({
    record: { name: "Alice", age: 30, role: "admin" }
});
if (result.success) {
    var copy = result.result;
    console.log(copy.name); // "Alice"
}

Aggregate Namespace

Multi-field aggregation computations.

Scope: System

Functions

Function	Description
aggregate.compute()	Compute aggregate operations (sum, avg, min, max, count) on a set of records

aggregate.compute()

Perform multiple aggregate operations across multiple fields on an array of records. Returns a single result map with keys named {field}_{op}.

Parameters

Parameter	Type	Default	Description
fields	list	—	List of field specifications (required)
fields[].field	string	—	Field name to aggregate
fields[].ops	list	—	Operations to apply: sum, avg, min, max, count
records	list	—	List of key-value maps representing records (required)

Returns

Field	Type	Description
success	bool	Whether the computation succeeded
result	map	Aggregated values keyed as {field}_{op}, plus count (total records)
error	string	Error message if failed

Examples

// Compute sum and average of amounts
var result = aggregate.compute({
    fields: [
        { field: "amount", ops: ["sum", "avg", "min", "max"] },
        { field: "quantity", ops: ["sum"] }
    ],
    records: [
        { amount: 100, quantity: 5 },
        { amount: 200, quantity: 3 },
        { amount: 150, quantity: 8 }
    ]
});
// result.result = { amount_sum: 450, amount_avg: 150, amount_min: 100,
//                   amount_max: 200, quantity_sum: 16, count: 3 }

// Read CSV and aggregate in one script
var data = csv.read({ path: "/data/sales.csv" });
if (data.success) {
    var stats = aggregate.compute({
        fields: [
            { field: "revenue", ops: ["sum", "avg"] },
            { field: "units", ops: ["sum", "min", "max"] }
        ],
        records: data.records
    });
    if (stats.success) {
        console.log("Total revenue: " + stats.result.revenue_sum);
        console.log("Avg revenue: " + stats.result.revenue_avg);
        console.log("Total units: " + stats.result.units_sum);
    }
}

Lua Example

function main(input)
    local result = aggregate.compute({
        fields = {
            { field = "score", ops = {"avg", "min", "max"} }
        },
        records = {
            { score = 85 },
            { score = 92 },
            { score = 78 }
        }
    })
    return result.result
end

CSV Namespace

Read and write CSV files.

Scope: System

Functions

Function	Description
csv.read()	Read a CSV file into an array of records
csv.write()	Write records to a CSV file

csv.read()

Read a CSV file and return all rows as key-value records. The first row is used as the header.

Parameters

Parameter	Type	Default	Description
path	string	—	CSV file path (required)

Returns

Field	Type	Description
success	bool	Whether the read succeeded
records	array	Array of key-value maps (one per row)
error	string	Error message if failed

Examples

// Read a CSV file
var result = csv.read({
    path: "/data/users.csv"
});
if (result.success) {
    for (var i = 0; i < result.records.length; i++) {
        console.log(result.records[i].name + ": " + result.records[i].email);
    }
}

csv.write()

Write an array of key-value records to a CSV file.

Parameters

Parameter	Type	Default	Description
path	string	—	Output CSV file path (required)
records	array	—	Array of key-value maps to write (required)
headers	list	—	Column headers (inferred from first record if omitted)
overwrite	bool	false	Truncate file before writing (vs append)

Returns

Field	Type	Description
success	bool	Whether the write succeeded
count	int	Number of records written
error	string	Error message if failed

Examples

// Write records to a CSV file
var result = csv.write({
    path: "/output/data.csv",
    records: [
        { name: "Alice", age: "30" },
        { name: "Bob", age: "25" }
    ],
    overwrite: true
});
if (result.success) {
    console.log("Wrote " + result.count + " records");
}

// Read, transform, and write CSV
var data = csv.read({ path: "/data/input.csv" });
if (data.success) {
    var transformed = [];
    for (var i = 0; i < data.records.length; i++) {
        var r = data.records[i];
        transformed.push({
            full_name: r.first_name + " " + r.last_name,
            email: r.email
        });
    }
    csv.write({
        path: "/data/output.csv",
        records: transformed,
        overwrite: true
    });
}

Excel Namespace

Read and write Excel spreadsheet files.

Scope: System

Functions

Function	Description
excel.read()	Read an Excel file into an array of records
excel.write()	Write records to an Excel file

excel.read()

Read an Excel spreadsheet and return all rows as key-value records. The first row of each sheet is used as the header.

Parameters

Parameter	Type	Default	Description
path	string	—	Excel file path (required)
sheet	string	—	Sheet name (reads all sheets if omitted)

Returns

Field	Type	Description
success	bool	Whether the read succeeded
records	array	Array of key-value maps (one per row)
error	string	Error message if failed

Examples

// Read records from an Excel file
var result = excel.read({ path: "/data/report.xlsx", sheet: "Sales" });
if (result.success) {
    for (var i = 0; i < result.records.length; i++) {
        console.log(result.records[i].product + ": " + result.records[i].amount);
    }
}

excel.write()

Write an array of key-value records to an Excel spreadsheet.

Parameters

Parameter	Type	Default	Description
path	string	—	Output Excel file path (required)
sheet	string	—	Sheet name
records	array	—	Array of key-value maps to write (required)
overwrite	bool	false	Create new file (vs append to existing)

Returns

Field	Type	Description
success	bool	Whether the write succeeded
count	int	Number of records written
error	string	Error message if failed

Examples

// Write records to an Excel file
var result = excel.write({
    path: "/output/report.xlsx",
    sheet: "Results",
    records: [
        { name: "Alice", score: "95" },
        { name: "Bob", score: "87" }
    ],
    overwrite: true
});
if (result.success) {
    console.log("Wrote " + result.count + " records");
}

Parquet Namespace

Read and write Apache Parquet files.

Scope: System

Functions

Function	Description
parquet.read()	Read a Parquet file into an array of records
parquet.write()	Write records to a Parquet file

parquet.read()

Read an Apache Parquet file and return all rows as key-value records. All values are converted to strings.

Parameters

Parameter	Type	Default	Description
path	string	—	Parquet file path (required)

Returns

Field	Type	Description
success	bool	Whether the read succeeded
records	array	Array of key-value maps (one per row)
error	string	Error message if failed

Examples

// Read records from a Parquet file
var result = parquet.read({ path: "/data/events.parquet" });
if (result.success) {
    for (var i = 0; i < result.records.length; i++) {
        console.log(JSON.stringify(result.records[i]));
    }
}

parquet.write()

Write an array of key-value records to an Apache Parquet file. All fields are written as strings.

Parameters

Parameter	Type	Default	Description
path	string	—	Output Parquet file path (required)
records	array	—	Array of key-value maps to write (required)

Returns

Field	Type	Description
success	bool	Whether the write succeeded
count	int	Number of records written
error	string	Error message if failed

Examples

// Write records to a Parquet file
var result = parquet.write({
    path: "/output/data.parquet",
    records: [
        { id: "1", name: "Alice" },
        { id: "2", name: "Bob" }
    ]
});
if (result.success) {
    console.log("Wrote " + result.count + " records");
}

Entity Namespace

Query and mutate Data API entity stores.

Scope: System

Note: All entity functions require a pipeline environment with Data API EntityManager. The namespace functions are stubs in Script standalone mode and return errors directing to the YAML pipeline interface.

Functions

Function	Description
entity.query()	Query records from an entity store
entity.mutate()	Write records to an entity store

entity.query()

Query records from a Data API entity store.

Parameters

Parameter	Type	Default	Description
files	list	—	Entity definition file paths
dbpool	map	—	Database pool configuration
datastore	string	—	Datastore name (alternative to files/dbpool)
query	string	—	Entity query to execute (required)

Returns

Field	Type	Description
success	bool	Whether the query succeeded
records	array	Array of entity records
error	string	Error message (stub always returns error)

Examples

// Entity queries are not available in Script standalone mode.
// Use the YAML pipeline interface (readentity or readentity-in-datastore) instead.
var result = entity.query({
    files: ["/schemas/user.yaml"],
    dbpool: {},
    query: "SELECT * FROM user"
});
// result = { success: false, error: "entity operations require pipeline environment" }

entity.mutate()

Write records to a Data API entity store via bulk mutation.

Parameters

Parameter	Type	Default	Description
datastore	string	—	Datastore name (required)
record	map	—	Entity record data (required)

Returns

Field	Type	Description
success	bool	Whether the mutation succeeded
error	string	Error message (stub always returns error)

Examples

// Entity mutations are not available in Script standalone mode.
// Use the YAML pipeline interface (writeentity-in-datastore) instead.
var result = entity.mutate({
    datastore: "customer-db",
    record: { id: "1", name: "Alice" }
});
// result = { success: false, error: "entity operations require pipeline environment" }

Morph Namespace

Execute inline morph scripts with multi-language support.

Scope: System

Functions

Function	Description
morph.execute()	Run a morph script inline with specified language and input

morph.execute()

Execute a morph script from within another Script script. The target script must define a morph(input) function. Enables nested script execution for dynamically generating transformation code or running user-provided scripts.

Parameters

Parameter	Type	Default	Description
language	string	javascript	Script language: javascript, js, lua, starlark, javascript-v8, v8
code	string	—	Script source defining a morph(input) function (required)
input	any	—	Input data passed to the morph function

Returns

Field	Type	Description
success	bool	Whether the execution succeeded
result	any	Return value from the morph function
error	string	Error message if failed

Examples

// Execute a JavaScript morph inline
var result = morph.execute({
    language: "javascript",
    code: 'function morph(input) { return input.x * 2; }',
    input: { x: 21 }
});
// result = { success: true, result: 42 }

// Execute a Lua morph from JavaScript
var result = morph.execute({
    language: "lua",
    code: 'function morph(input) return input.name .. " processed" end',
    input: { name: "Alice" }
});
// result = { success: true, result: "Alice processed" }

// Combine csv.read + morph.execute for dynamic processing
var data = csv.read({ path: "/data/records.csv" });
if (data.success) {
    var transformCode = 'function morph(input) { return { upper: input.name.toUpperCase(), len: input.name.length }; }';
    for (var i = 0; i < data.records.length; i++) {
        var transformed = morph.execute({
            code: transformCode,
            input: data.records[i]
        });
        console.log(JSON.stringify(transformed.result));
    }
}

Stdout Namespace

Execute shell commands and parse CSV output.

Scope: System

Functions

Function	Description
stdout.exec()	Execute a command and parse its CSV output into records

stdout.exec()

Execute a shell command and parse its stdout as CSV into key-value records. The first line of output is used as the header.

Parameters

Parameter	Type	Default	Description
command	string	—	Shell command to execute (required)

Returns

Field	Type	Description
success	bool	Whether the execution succeeded
records	array	Array of key-value maps parsed from CSV output
output	string	Raw command output
error	string	Error message if failed

Examples

// Execute a command and parse CSV output
var result = stdout.exec({
    command: "echo 'name,age\nAlice,30\nBob,25'"
});
if (result.success) {
    for (var i = 0; i < result.records.length; i++) {
        console.log(result.records[i].name + " is " + result.records[i].age);
    }
}

// Read system process list
var result = stdout.exec({
    command: "ps aux --no-headers | awk '{print $1\",\"$2\",\"$11}'"
});
if (result.success) {
    console.log("Found " + result.records.length + " processes");
}