@xeplr/workflow-engine 3.0.0 → 3.0.1

package/README.md

@@ -207,6 +207,7 @@ Branch on how a job ended with a `decide` step: it does nothing itself, and the
 - **The period flows.** The next job gets the finished job's `window` unless the step's `inputs` set one, so a chain of workflows covers one period from its first job to its last.
 - **The next job is offered both earlier ranges**, as `@xeplr/jobs`' `previous.given` / `previous.used`.
 - **`carry`** (a `job-run` input) adds values for the jobs after it.
+- **`inputs` and `carry` keep their types.** A binding that is the whole value (`"{trigger.output.totalRows}"`) passes `7`, not `"7"`, and an object stays an object. Every other step's input is text, as bindings make it.
 - **Loops stop.** A job already on the path, or a path 25 jobs long, fails the step with a message.
 
 The next job takes only `window` and the inputs it lists in `acceptsInputs`; `@xeplr/jobs` refuses the rest, naming them.

package/lib/actions/jobRun.js

@@ -77,7 +77,14 @@ module.exports = {
     // this job unless the step sets one, carried values and the path travel
     // with it, and a job already on the path is refused as a loop
     // (jobs.nextJobCall). Any other run passes the step's inputs as they are.
-    var call = jobs.nextJobCall(ctx.system && ctx.system.trigger, input.jobId, input.inputs, input.carry);
+    // Inputs and carry KEEP THEIR TYPES ("{trigger.output.totalRows}" is 7,
+    // not "7"): they are handed on to a job, not printed.
+    var sys = ctx.system || {};
+    var raw = sys.rawValues || {};
+    var typed = typeof sys.resolveTyped === 'function';
+    var call = jobs.nextJobCall(sys.trigger, input.jobId,
+      typed && raw.inputs !== undefined ? sys.resolveTyped(raw.inputs) : input.inputs,
+      typed && raw.carry !== undefined ? sys.resolveTyped(raw.carry) : input.carry);
     var startJob = jobs.jobStarter();
     if (startJob) {
       call.chain.resumeKey = (ctx.system && ctx.system.resumeKey) || null;

package/lib/workflowRunner.js

@@ -112,6 +112,30 @@ async function finishRun(run, status, error) {
  * the two can differ), params/item are the run's own, resumeKey is injected
  * separately, only for the specific step that needs it.
  */
+/**
+ * Resolve `{path}` bindings KEEPING TYPES: a string that is exactly one
+ * binding takes the bound value as it is (an object stays an object, a number
+ * a number); anything else is text, as interpolate makes it.
+ */
+function resolveTyped(value, context) {
+  if (value == null) return value;
+  if (typeof value === 'string') {
+    var whole = /^\{([^{}]+)\}$/.exec(value.trim());
+    if (whole) {
+      var v = getPath(context, whole[1].trim());
+      return v === undefined ? null : v;
+    }
+    return interpolateAll(value, context);
+  }
+  if (Array.isArray(value)) return value.map(function(v) { return resolveTyped(v, context); });
+  if (typeof value === 'object') {
+    var out = {};
+    Object.keys(value).forEach(function(k) { out[k] = resolveTyped(value[k], context); });
+    return out;
+  }
+  return value;
+}
+
 // What started a run, as {trigger.*} reads it — in bindings AND in the
 // conditions on arrows. A run started by hand has just its kind.
 function triggerOf(run) {
@@ -359,8 +383,14 @@ async function executeFrom(workflow, steps, run, startStepKey) {
         // started in-process reports back through jobs.jobFinished).
         // trigger: what started the run, for an action that carries it on
         // (job-run passes a job's period to the next job).
+        // resolveTyped: a binding that is the WHOLE value keeps its type
+        // ("{trigger.output.totalRows}" stays 7, "{trigger.window}" an object),
+        // for an action that passes values on rather than printing them
+        // (job-run's inputs and carry). Every other action takes `input`, as
+        // resolved above, unchanged.
         system: { runId: run.id, stepId: step.id, stepKey: step.stepKey, resumeKey: resumeKey,
-          trigger: triggerOf(run) }
+          trigger: triggerOf(run), rawValues: step.values || {},
+          resolveTyped: function(value) { return resolveTyped(value, context); } }
       });
 
       if (result.status !== 'success') {
@@ -664,4 +694,5 @@ async function resumeByKey(key, output, opts) {
 // resolveParams and collectParams are exported for their own sake: they are
 // the pieces of the engine that are pure — rows in, a schema or a resolved
 // set out, or a throw — and testing them needs no database.
-module.exports = { startRun: startRun, resumeByKey: resumeByKey, resolveParams: resolveParams, collectParams: collectParams };
+module.exports = {
+  resolveTyped: resolveTyped, startRun: startRun, resumeByKey: resumeByKey, resolveParams: resolveParams, collectParams: collectParams };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xeplr/workflow-engine",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "license": "MIT",
   "description": "The workflow engine — workflow's own database and tables, the action catalog, starting and resuming runs, and the flows facade. No HTTP: @xeplr/workflow-api puts the routes on top.",
   "main": "index.js",