@openfn/cli 0.0.38 → 0.0.39

package/README.md

@@ -58,7 +58,6 @@ If you're coming to the CLI from the old openfn devtools, here are a couple of k
 
 * The CLI has a shorter, sleeker syntax, so your command should be much shorter
 * The CLI will automatically install adaptors for you (with full version control)
-* By default, the CLI will only write state.data to output. This is to encourage better state management. Pass `--no-strict-output` to save the entire state object.
 
 ## Basic Usage
 
@@ -76,8 +75,6 @@ Pass the `-i` flag to auto-install any required adaptors (it's safe to do this r
 
 When the finished, the CLI will write the resulting state to disk. By default the CLI will create an `output.json` next to the job file. You can pass a path to output by passing `-o path/to/output.json` and state by adding `-s path/to/state.json`. You can use `-S` and `-O` to pass state through stdin and return the output through stdout.
 
-Note that the CLI will only include the `state.data` key in the output. To write the entire state object (not just `data`), pass `--no-strict-output`.
-
 The CLI maintains a repo for auto-installed adaptors. Run `openfn repo list` to see where the repo is, and what's in it. Set the `OPENFN_REPO_DIR` env var to specify the repo folder. When autoinstalling, the CLI will check to see if a matching version is found in the repo. `openfn repo clean` will remove all adaptors from the repo. The repo also includes any documentation and metadata built with the CLI.
 
 You can specify adaptors with a shorthand (`http`) or use the full package name (`@openfn/language-http`). You can add a specific version like `http@2.0.0`. You can pass a path to a locally installed adaptor like `http=/repo/openfn/adaptors/my-http-build`.

package/dist/{chunk-DOKL2XM5.js → chunk-LV5XDERP.js}

@@ -123,7 +123,6 @@ function ensureOpts(basePath = ".", opts) {
     skipAdaptorValidation: opts.skipAdaptorValidation ?? false,
     specifier: opts.specifier,
     stateStdin: opts.stateStdin,
-    strictOutput: opts.strictOutput ?? true,
     timeout: opts.timeout
   };
   const set = (key, value) => {

package/dist/index.js

@@ -2,7 +2,7 @@
 import {
   DEFAULT_REPO_DIR,
   expand_adaptors_default
-} from "./chunk-DOKL2XM5.js";
+} from "./chunk-LV5XDERP.js";
 
 // src/process/spawn.ts
 import path from "node:path";
@@ -274,11 +274,28 @@ var start = {
 var strictOutput = {
   name: "no-strict-output",
   yargs: {
+    deprecated: true,
+    hidden: true,
+    boolean: true
+  },
+  ensure: (opts2) => {
+    if (!opts2.hasOwnProperty("strict")) {
+      opts2.strict = opts2.strictOutput;
+    }
+    delete opts2.strictOutput;
+  }
+};
+var strict = {
+  name: "no-strict",
+  yargs: {
+    default: false,
     boolean: true,
-    description: "Allow properties other than data to be returned in the output"
+    description: "Strict state handling, meaning only state.data is returned from a job."
   },
   ensure: (opts2) => {
-    setDefaultValue(opts2, "strictOutput", true);
+    if (!opts2.hasOwnProperty("strictOutput")) {
+      setDefaultValue(opts2, "strict", false);
+    }
   }
 };
 var skipAdaptorValidation = {
@@ -343,6 +360,7 @@ var options = [
   start,
   statePath,
   stateStdin,
+  strict,
   strictOutput,
   timeout,
   useAdaptorsMonorepo
@@ -353,7 +371,7 @@ var executeCommand = {
   
 Execute will run a job/workflow at the path and write the output state to disk (to ./state.json unless otherwise specified)
   
-By default only state.data will be written to the output. Include --no-strict-output to write the entire state object.
+By default only state.data will be returned fron a job. Include --no-strict to write the entire state object.
   
 Remember to include the adaptor name with -a. Auto install adaptors with the -i flag.`,
   aliases: ["$0"],

package/dist/process/runner.js

@@ -10,22 +10,51 @@ import {
   expand_adaptors_default,
   logger_default,
   printDuration
-} from "../chunk-DOKL2XM5.js";
+} from "../chunk-LV5XDERP.js";
 
 // src/execute/execute.ts
 import run, { getNameAndVersion } from "@openfn/runtime";
-var execute_default = (input, state, opts) => {
-  return run(input, state, {
-    start: opts.start,
-    timeout: opts.timeout,
-    immutableState: opts.immutable,
-    logger: logger_default(RUNTIME, opts),
-    jobLogger: logger_default(JOB, opts),
-    linker: {
-      repo: opts.repoDir,
-      modules: parseAdaptors(opts)
-    }
-  });
+
+// src/util/abort.ts
+var AbortError = class extends Error {
+  constructor(reason) {
+    super(reason);
+    this.handled = true;
+  }
+};
+var abort_default = (logger, reason, error, help) => {
+  const e = new AbortError(reason);
+  logger.error(reason);
+  if (error) {
+    logger.error(error.message);
+  }
+  if (help) {
+    logger.always(help);
+  }
+  logger.break();
+  logger.error("Critical error: aborting command");
+  throw e;
+};
+
+// src/execute/execute.ts
+var execute_default = async (input, state, opts, logger) => {
+  try {
+    const result = await run(input, state, {
+      strict: opts.strict,
+      start: opts.start,
+      timeout: opts.timeout,
+      immutableState: opts.immutable,
+      logger: logger_default(RUNTIME, opts),
+      jobLogger: logger_default(JOB, opts),
+      linker: {
+        repo: opts.repoDir,
+        modules: parseAdaptors(opts)
+      }
+    });
+    return result;
+  } catch (e) {
+    abort_default(logger, "Invalid workflow", e);
+  }
 };
 function parseAdaptors(opts) {
   const extractInfo = (specifier) => {
@@ -66,14 +95,14 @@ import { writeFile } from "node:fs/promises";
 var serializeOutput = async (options, result, logger) => {
   let output = result;
   if (output && (output.configuration || output.data)) {
-    const { data, configuration, ...rest } = result;
-    if (options.strictOutput !== false) {
-      output = { data };
+    if (options.strict) {
+      output = { data: output.data };
+      if (result.errors) {
+        output.errors = result.errors;
+      }
     } else {
-      output = {
-        data,
-        ...rest
-      };
+      const { configuration, ...rest } = result;
+      output = rest;
     }
   }
   if (output === void 0) {
@@ -83,10 +112,11 @@ var serializeOutput = async (options, result, logger) => {
   }
   if (options.outputStdout) {
     logger.success(`Result: `);
-    logger.success(output);
+    logger.always(output);
   } else if (options.outputPath) {
-    logger.success(`Writing output to ${options.outputPath}`);
+    logger.debug(`Writing output to ${options.outputPath}`);
     await writeFile(options.outputPath, output);
+    logger.success(`State written to ${options.outputPath}`);
   }
   return output;
 };
@@ -190,16 +220,28 @@ var compile_default = async (opts, log) => {
   if (opts.workflow) {
     job = compileWorkflow(opts.workflow, opts, log);
   } else {
-    const compilerOptions = await loadTransformOptions(opts, log);
-    job = compile(opts.job || opts.jobPath, compilerOptions);
+    job = await compileJob(opts.job || opts.jobPath, opts, log);
   }
   if (opts.jobPath) {
-    log.success(`Compiled job from ${opts.jobPath}`);
+    log.success(`Compiled from ${opts.jobPath}`);
   } else {
-    log.success("Compiled job");
+    log.success("Compilation complete");
   }
   return job;
 };
+var compileJob = async (job, opts, log, jobName) => {
+  try {
+    const compilerOptions = await loadTransformOptions(opts, log);
+    return compile(job, compilerOptions);
+  } catch (e) {
+    abort_default(
+      log,
+      `Failed to compile job ${jobName ?? ""}`.trim(),
+      e,
+      "Check the syntax of the job expression:\n\n" + job
+    );
+  }
+};
 var compileWorkflow = async (workflow, opts, log) => {
   for (const job of workflow.jobs) {
     const jobOpts = {
@@ -208,9 +250,13 @@ var compileWorkflow = async (workflow, opts, log) => {
     if (job.adaptor) {
       jobOpts.adaptors = [job.adaptor];
     }
-    const compilerOptions = await loadTransformOptions(jobOpts, log);
     if (job.expression) {
-      job.expression = compile(job.expression, compilerOptions);
+      job.expression = await compileJob(
+        job.expression,
+        jobOpts,
+        log,
+        job.id
+      );
     }
   }
   return workflow;
@@ -340,7 +386,6 @@ import path from "node:path";
 import fs2 from "node:fs/promises";
 import { isPath } from "@openfn/compiler";
 var load_input_default = async (opts, log) => {
-  log.debug("Loading input...");
   const { job, workflow, jobPath, workflowPath } = opts;
   if (workflow || workflowPath) {
     return loadWorkflow(opts, log);
@@ -349,36 +394,94 @@ var load_input_default = async (opts, log) => {
     return job;
   }
   if (jobPath) {
-    log.debug(`Loading job from ${jobPath}`);
-    opts.job = await fs2.readFile(jobPath, "utf8");
-    return opts.job;
+    try {
+      log.debug(`Loading job from ${jobPath}`);
+      opts.job = await fs2.readFile(jobPath, "utf8");
+      return opts.job;
+    } catch (e) {
+      abort_default(
+        log,
+        "Job not found",
+        void 0,
+        `Failed to load the job from ${jobPath}`
+      );
+    }
   }
 };
-var fetchFile = (rootDir, filePath) => {
-  const jobPath = filePath.startsWith("~") ? filePath : path.resolve(rootDir, filePath);
-  return fs2.readFile(jobPath, "utf8");
-};
 var loadWorkflow = async (opts, log) => {
   const { workflowPath, workflow } = opts;
+  const readWorkflow = async () => {
+    try {
+      const text = await fs2.readFile(workflowPath, "utf8");
+      return text;
+    } catch (e) {
+      abort_default(
+        log,
+        "Workflow not found",
+        void 0,
+        `Failed to load a workflow from ${workflowPath}`
+      );
+    }
+  };
+  const parseWorkflow = (contents) => {
+    try {
+      return JSON.parse(contents);
+    } catch (e) {
+      abort_default(
+        log,
+        "Invalid JSON in workflow",
+        e,
+        `Check the syntax of the JSON at ${workflowPath}`
+      );
+    }
+  };
+  const fetchWorkflowFile = async (jobId, rootDir = "", filePath) => {
+    try {
+      const fullPath = filePath.startsWith("~") ? filePath : path.resolve(rootDir, filePath);
+      const result = await fs2.readFile(fullPath, "utf8");
+      return result;
+    } catch (e) {
+      abort_default(
+        log,
+        `File not found for job ${jobId}: ${filePath}`,
+        void 0,
+        `This workflow references a file which cannot be found at ${filePath}
+
+Paths inside the workflow are relative to the workflow.json`
+      );
+    }
+  };
   log.debug(`Loading workflow from ${workflowPath}`);
   try {
     let wf;
     let rootDir = opts.baseDir;
     if (workflowPath) {
-      const workflowRaw = await fs2.readFile(workflowPath, "utf8");
-      wf = JSON.parse(workflowRaw);
+      let workflowRaw = await readWorkflow();
+      wf = parseWorkflow(workflowRaw);
       if (!rootDir) {
         rootDir = path.dirname(workflowPath);
       }
     } else {
       wf = workflow;
     }
+    let idx = 0;
     for (const job of wf.jobs) {
-      if (typeof job.expression === "string" && isPath(job.expression)) {
-        job.expression = await fetchFile(rootDir, job.expression);
+      idx += 1;
+      const expressionStr = typeof job.expression === "string" && job.expression?.trim();
+      const configurationStr = typeof job.configuration === "string" && job.configuration?.trim();
+      if (expressionStr && isPath(expressionStr)) {
+        job.expression = await fetchWorkflowFile(
+          job.id || `${idx}`,
+          rootDir,
+          expressionStr
+        );
       }
-      if (typeof job.configuration === "string" && isPath(job.configuration)) {
-        const configString = await fetchFile(rootDir, job.configuration);
+      if (configurationStr && isPath(configurationStr)) {
+        const configString = await fetchWorkflowFile(
+          job.id || `${idx}`,
+          rootDir,
+          configurationStr
+        );
         job.configuration = JSON.parse(configString);
       }
     }
@@ -418,15 +521,23 @@ var executeHandler = async (options, logger) => {
     logger.info("Skipping compilation as noCompile is set");
   }
   try {
-    const result = await execute_default(input, state, options);
+    const result = await execute_default(input, state, options, logger);
     await serialize_output_default(options, result, logger);
     const duration = printDuration(new Date().getTime() - start);
-    logger.success(`Done in ${duration}! \u2728`);
+    if (result.errors) {
+      logger.warn(
+        `Errors reported in ${Object.keys(result.errors).length} jobs`
+      );
+    }
+    logger.success(`Finished in ${duration}${result.errors ? "" : " \u2728"}`);
     return result;
-  } catch (error) {
-    logger.error(error);
+  } catch (err) {
+    if (!err.handled) {
+      logger.error("Unexpected error in execution");
+      logger.error(err);
+    }
     const duration = printDuration(new Date().getTime() - start);
-    logger.error(`Took ${duration}.`);
+    logger.always(`Workflow failed in ${duration}.`);
     process.exitCode = 1;
   }
 };
@@ -964,9 +1075,12 @@ var parse = async (basePath, options, log) => {
     if (!process.exitCode) {
       process.exitCode = e.exitCode || 1;
     }
-    logger.break();
-    logger.error("Command failed!");
-    logger.error(e);
+    if (e.handled) {
+    } else {
+      logger.break();
+      logger.error("Command failed!");
+      logger.error(e);
+    }
   }
 };
 var commands_default = parse;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfn/cli",
-  "version": "0.0.38",
+  "version": "0.0.39",
   "description": "CLI devtools for the openfn toolchain.",
   "engines": {
     "node": ">=18",
@@ -36,10 +36,10 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@openfn/compiler": "0.0.31",
+    "@openfn/compiler": "0.0.32",
     "@openfn/describe-package": "0.0.16",
-    "@openfn/logger": "0.0.12",
-    "@openfn/runtime": "0.0.23",
+    "@openfn/logger": "0.0.13",
+    "@openfn/runtime": "0.0.24",
     "figures": "^5.0.0",
     "rimraf": "^3.0.2",
     "treeify": "^1.1.0",