@openfn/cli 0.0.35 → 0.0.39

package/dist/process/runner.js

@@ -10,184 +10,136 @@ import {
   expand_adaptors_default,
   logger_default,
   printDuration
-} from "../chunk-XYZNU5CH.js";
+} from "../chunk-LV5XDERP.js";
 
-// src/execute/handler.ts
-import { readFile } from "node:fs/promises";
+// src/execute/execute.ts
+import run, { getNameAndVersion } from "@openfn/runtime";
 
-// src/execute/load-state.ts
-import fs from "node:fs/promises";
-var load_state_default = async (opts, log) => {
-  const { stateStdin, statePath } = opts;
-  log.debug("Load state...");
-  if (stateStdin) {
-    try {
-      const json = JSON.parse(stateStdin);
-      log.success("Read state from stdin");
-      log.debug("state:", json);
-      return json;
-    } catch (e) {
-      log.error("Failed to load state from stdin");
-      log.error(stateStdin);
-      log.error(e);
-      process.exit(1);
-    }
+// src/util/abort.ts
+var AbortError = class extends Error {
+  constructor(reason) {
+    super(reason);
+    this.handled = true;
   }
-  if (statePath) {
-    try {
-      const str = await fs.readFile(statePath, "utf8");
-      const json = JSON.parse(str);
-      log.success(`Loaded state from ${statePath}`);
-      log.debug("state:", json);
-      return json;
-    } catch (e) {
-      log.warn(`Error loading state from ${statePath}`);
-      log.warn(e);
-    }
+};
+var abort_default = (logger, reason, error, help) => {
+  const e = new AbortError(reason);
+  logger.error(reason);
+  if (error) {
+    logger.error(error.message);
   }
-  log.info(
-    "No state provided - using default state { data: {}, configuration: {}"
-  );
-  return {
-    data: {},
-    configuration: {}
-  };
+  if (help) {
+    logger.always(help);
+  }
+  logger.break();
+  logger.error("Critical error: aborting command");
+  throw e;
 };
 
 // src/execute/execute.ts
-import run, { getNameAndVersion } from "@openfn/runtime";
-var execute_default = (code, state, opts) => {
-  return run(code, state, {
-    timeout: opts.timeout,
-    immutableState: opts.immutable,
-    logger: logger_default(RUNTIME, opts),
-    jobLogger: logger_default(JOB, opts),
-    linker: {
-      repo: opts.repoDir,
-      modules: parseAdaptors(opts)
-    }
-  });
+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 adaptors = {};
-  opts.adaptors.reduce((obj, exp) => {
-    const [module, path5] = exp.split("=");
+  const extractInfo = (specifier) => {
+    const [module, path6] = specifier.split("=");
     const { name, version } = getNameAndVersion(module);
-    const info = {};
-    if (path5) {
-      info.path = path5;
+    const info = {
+      name
+    };
+    if (path6) {
+      info.path = path6;
     }
     if (version) {
       info.version = version;
     }
-    obj[name] = info;
-    return obj;
-  }, adaptors);
-  return adaptors;
-}
-
-// src/compile/compile.ts
-import compile, { preloadAdaptorExports } from "@openfn/compiler";
-import { getModulePath } from "@openfn/runtime";
-var compile_default = async (opts, log) => {
-  log.debug("Loading job...");
-  const compilerOptions = await loadTransformOptions(opts, log);
-  const job = compile(opts.jobSource || opts.jobPath, compilerOptions);
-  if (opts.jobPath) {
-    log.success(`Compiled job from ${opts.jobPath}`);
-  } else {
-    log.success("Compiled job");
-  }
-  return job;
-};
-var stripVersionSpecifier = (specifier) => {
-  const idx = specifier.lastIndexOf("@");
-  if (idx > 0) {
-    return specifier.substring(0, idx);
-  }
-  return specifier;
-};
-var resolveSpecifierPath = async (pattern, repoDir, log) => {
-  const [specifier, path5] = pattern.split("=");
-  if (path5) {
-    log.debug(`Resolved ${specifier} to path: ${path5}`);
-    return path5;
-  }
-  const repoPath = await getModulePath(specifier, repoDir, log);
-  if (repoPath) {
-    return repoPath;
-  }
-  return null;
-};
-var loadTransformOptions = async (opts, log) => {
-  const options = {
-    logger: log || logger_default(COMPILER, opts)
+    return info;
   };
-  if (opts.adaptors?.length && opts.ignoreImports != true) {
-    let exports;
-    const [pattern] = opts.adaptors;
-    const [specifier] = pattern.split("=");
-    log.debug(`Attempting to preload types for ${specifier}`);
-    const path5 = await resolveSpecifierPath(pattern, opts.repoDir, log);
-    if (path5) {
-      try {
-        exports = await preloadAdaptorExports(
-          path5,
-          opts.useAdaptorsMonorepo,
-          log
-        );
-      } catch (e) {
-        log.error(`Failed to load adaptor typedefs from path ${path5}`);
-        log.error(e);
-      }
-    }
-    if (!exports || exports.length === 0) {
-      log.debug(`No module exports found for ${pattern}`);
-    }
-    options["add-imports"] = {
-      ignore: opts.ignoreImports,
-      adaptor: {
-        name: stripVersionSpecifier(specifier),
-        exports,
-        exportAll: true
+  const adaptors = {};
+  if (opts.adaptors) {
+    opts.adaptors.reduce((obj, exp) => {
+      const { name, ...maybeVersionAndPath } = extractInfo(exp);
+      obj[name] = { ...maybeVersionAndPath };
+      return obj;
+    }, adaptors);
+  }
+  if (opts.workflow) {
+    Object.values(opts.workflow.jobs).forEach((job) => {
+      if (job.adaptor) {
+        const { name, ...maybeVersionAndPath } = extractInfo(job.adaptor);
+        adaptors[name] = { ...maybeVersionAndPath };
       }
-    };
+    });
   }
-  return options;
-};
+  return adaptors;
+}
 
 // src/execute/serialize-output.ts
 import { writeFile } from "node:fs/promises";
-import stringify from "fast-safe-stringify";
 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) {
     output = "";
   } else {
-    output = stringify(output, void 0, 2);
+    output = JSON.stringify(output, void 0, 2);
   }
   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;
 };
 var serialize_output_default = serializeOutput;
 
+// src/execute/get-autoinstall-targets.ts
+var getAutoinstallTargets = (options) => {
+  if (options.workflow) {
+    const adaptors = {};
+    Object.values(options.workflow.jobs).forEach((job) => {
+      if (job.adaptor) {
+        adaptors[job.adaptor] = true;
+      }
+    });
+    return Object.keys(adaptors);
+  }
+  if (options.adaptors) {
+    return options.adaptors?.filter((a) => !/=/.test(a));
+  }
+  return [];
+};
+var get_autoinstall_targets_default = getAutoinstallTargets;
+
 // src/repo/handler.ts
 import { exec } from "node:child_process";
 import treeify from "treeify";
@@ -199,9 +151,10 @@ var install = async (opts, log = defaultLogger) => {
     log.success("Installing packages...");
     log.debug("repoDir is set to:", repoDir);
     if (adaptor) {
-      packages = expand_adaptors_default(packages);
+      const expanded = expand_adaptors_default({ adaptors: packages });
+      packages = expanded.adaptors;
     }
-    await rtInstall(packages, repoDir, log);
+    await rtInstall(packages ?? [], repoDir, log);
     const duration = log.timer("install");
     log.success(`Installation complete in ${duration}`);
   }
@@ -258,12 +211,165 @@ var list = async (options, logger) => {
   logger.success("Installed packages:\n\n" + treeify.asTree(output));
 };
 
+// src/compile/compile.ts
+import compile, { preloadAdaptorExports } from "@openfn/compiler";
+import { getModulePath } from "@openfn/runtime";
+var compile_default = async (opts, log) => {
+  log.debug("Compiling...");
+  let job;
+  if (opts.workflow) {
+    job = compileWorkflow(opts.workflow, opts, log);
+  } else {
+    job = await compileJob(opts.job || opts.jobPath, opts, log);
+  }
+  if (opts.jobPath) {
+    log.success(`Compiled from ${opts.jobPath}`);
+  } else {
+    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 = {
+      ...opts
+    };
+    if (job.adaptor) {
+      jobOpts.adaptors = [job.adaptor];
+    }
+    if (job.expression) {
+      job.expression = await compileJob(
+        job.expression,
+        jobOpts,
+        log,
+        job.id
+      );
+    }
+  }
+  return workflow;
+};
+var stripVersionSpecifier = (specifier) => {
+  const idx = specifier.lastIndexOf("@");
+  if (idx > 0) {
+    return specifier.substring(0, idx);
+  }
+  return specifier;
+};
+var resolveSpecifierPath = async (pattern, repoDir, log) => {
+  const [specifier, path6] = pattern.split("=");
+  if (path6) {
+    log.debug(`Resolved ${specifier} to path: ${path6}`);
+    return path6;
+  }
+  const repoPath = await getModulePath(specifier, repoDir, log);
+  if (repoPath) {
+    return repoPath;
+  }
+  return null;
+};
+var loadTransformOptions = async (opts, log) => {
+  const options = {
+    logger: log || logger_default(COMPILER, opts)
+  };
+  if (opts.adaptors?.length && opts.ignoreImports != true) {
+    let exports;
+    const [pattern] = opts.adaptors;
+    const [specifier] = pattern.split("=");
+    log.debug(`Attempting to preload types for ${specifier}`);
+    const path6 = await resolveSpecifierPath(pattern, opts.repoDir, log);
+    if (path6) {
+      try {
+        exports = await preloadAdaptorExports(
+          path6,
+          opts.useAdaptorsMonorepo,
+          log
+        );
+      } catch (e) {
+        log.error(`Failed to load adaptor typedefs from path ${path6}`);
+        log.error(e);
+      }
+    }
+    if (!exports || exports.length === 0) {
+      log.debug(`No module exports found for ${pattern}`);
+    }
+    options["add-imports"] = {
+      ignore: opts.ignoreImports,
+      adaptor: {
+        name: stripVersionSpecifier(specifier),
+        exports,
+        exportAll: true
+      }
+    };
+  }
+  return options;
+};
+
+// src/util/load-state.ts
+import fs from "node:fs/promises";
+var load_state_default = async (opts, log) => {
+  const { stateStdin, statePath } = opts;
+  log.debug("Loading state...");
+  if (stateStdin) {
+    try {
+      const json = JSON.parse(stateStdin);
+      log.success("Read state from stdin");
+      log.debug("state:", json);
+      return json;
+    } catch (e) {
+      log.error("Failed to load state from stdin");
+      log.error(stateStdin);
+      log.error(e);
+      process.exit(1);
+    }
+  }
+  if (statePath) {
+    try {
+      const str = await fs.readFile(statePath, "utf8");
+      const json = JSON.parse(str);
+      log.success(`Loaded state from ${statePath}`);
+      log.debug("state:", json);
+      return json;
+    } catch (e) {
+      log.warn(`Error loading state from ${statePath}`);
+      log.warn(e);
+    }
+  }
+  log.info(
+    "No state provided - using default state { data: {}, configuration: {} }"
+  );
+  return {
+    data: {},
+    configuration: {}
+  };
+};
+
 // src/util/validate-adaptors.ts
 var validateAdaptors = async (options, logger) => {
   if (options.skipAdaptorValidation) {
     return;
   }
-  if (!options.adaptors || options.adaptors.length === 0) {
+  const hasDeclaredAdaptors = options.adaptors && options.adaptors.length > 0;
+  if (options.workflowPath && hasDeclaredAdaptors) {
+    logger.error("ERROR: adaptor and workflow provided");
+    logger.error(
+      "This is probably not what you meant to do. A workflow should declare an adaptor for each job."
+    );
+    throw new Error("adaptor and workflow provided");
+  }
+  if (!options.workflowPath && !hasDeclaredAdaptors) {
     logger.warn("WARNING: No adaptor provided!");
     logger.warn(
       "This job will probably fail. Pass an adaptor with the -a flag, eg:"
@@ -275,22 +381,133 @@ var validateAdaptors = async (options, logger) => {
 };
 var validate_adaptors_default = validateAdaptors;
 
-// src/execute/handler.ts
-var getAutoinstallTargets = (options) => {
-  if (options.adaptors) {
-    return options.adaptors?.filter((a) => !/=/.test(a));
+// src/util/load-input.ts
+import path from "node:path";
+import fs2 from "node:fs/promises";
+import { isPath } from "@openfn/compiler";
+var load_input_default = async (opts, log) => {
+  const { job, workflow, jobPath, workflowPath } = opts;
+  if (workflow || workflowPath) {
+    return loadWorkflow(opts, log);
+  }
+  if (job) {
+    return job;
+  }
+  if (jobPath) {
+    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 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) {
+      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) {
+      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 (configurationStr && isPath(configurationStr)) {
+        const configString = await fetchWorkflowFile(
+          job.id || `${idx}`,
+          rootDir,
+          configurationStr
+        );
+        job.configuration = JSON.parse(configString);
+      }
+    }
+    opts.workflow = wf;
+    log.debug("Workflow loaded!");
+    return opts.workflow;
+  } catch (e) {
+    log.error(`Error loading workflow from ${workflowPath}`);
+    throw e;
   }
-  return [];
 };
+
+// src/execute/handler.ts
 var executeHandler = async (options, logger) => {
   const start = new Date().getTime();
   await validate_adaptors_default(options, logger);
+  let input = await load_input_default(options, logger);
+  if (options.workflow) {
+    expand_adaptors_default(options);
+  }
   const { repoDir, monorepoPath, autoinstall } = options;
   if (autoinstall) {
     if (monorepoPath) {
       logger.warn("Skipping auto-install as monorepo is being used");
     } else {
-      const autoInstallTargets = getAutoinstallTargets(options);
+      const autoInstallTargets = get_autoinstall_targets_default(options);
       if (autoInstallTargets.length) {
         logger.info("Auto-installing language adaptors");
         await install({ packages: autoInstallTargets, repoDir }, logger);
@@ -298,25 +515,29 @@ var executeHandler = async (options, logger) => {
     }
   }
   const state = await load_state_default(options, logger);
-  let code = "";
   if (options.compile) {
-    code = await compile_default(options, logger);
+    input = await compile_default(options, logger);
   } else {
     logger.info("Skipping compilation as noCompile is set");
-    if (options.jobPath) {
-      code = await readFile(options.jobPath, "utf8");
-      logger.success(`Loaded job from ${options.jobPath} (no compilation)`);
-    }
   }
   try {
-    const result = await execute_default(code, 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`);
-  } catch (error) {
-    logger.error(error);
+    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 (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;
   }
 };
@@ -325,33 +546,65 @@ var handler_default = executeHandler;
 // src/compile/handler.ts
 import { writeFile as writeFile2 } from "node:fs/promises";
 var compileHandler = async (options, logger) => {
-  const code = await compile_default(options, logger);
+  await load_input_default(options, logger);
+  let result = await compile_default(options, logger);
+  if (options.workflow) {
+    result = JSON.stringify(result);
+  }
   if (options.outputStdout) {
     logger.success("Compiled code:");
-    logger.success("\n" + code);
+    logger.success("\n" + result);
   } else {
-    await writeFile2(options.outputPath, code);
+    await writeFile2(options.outputPath, result);
     logger.success(`Compiled to ${options.outputPath}`);
   }
 };
 var handler_default2 = compileHandler;
 
 // src/test/handler.ts
-var sillyMessage = "Calculating the answer to life, the universe, and everything...";
 var testHandler = async (options, logger) => {
   logger.log("Running test job...");
   options.compile = true;
-  options.jobSource = `const fn = () => state => { console.log('${sillyMessage}'); return state * 2; } ; fn()`;
-  delete options.jobPath;
+  options.adaptors = [];
+  options.workflow = {
+    start: "start",
+    jobs: [
+      {
+        id: "start",
+        data: { defaultAnswer: 42 },
+        expression: "const fn = () => (state) => { console.log('Starting computer...'); return state; }; fn()",
+        next: {
+          calculate: "!state.error"
+        }
+      },
+      {
+        id: "calculate",
+        expression: "const fn = () => (state) => { console.log('Calculating to life, the universe, and everything..'); return state }; fn()",
+        next: {
+          result: true
+        }
+      },
+      {
+        id: "result",
+        expression: "const fn = () => (state) => ({ data: { answer: state.data.answer || state.data.defaultAnswer } }); fn()"
+      }
+    ]
+  };
+  logger.break();
+  logger.info("Workflow object:");
+  logger.info(JSON.stringify(options.workflow, null, 2));
+  logger.break();
   if (!options.stateStdin) {
-    logger.debug("No state provided: try -S <number> to provide some state");
-    options.stateStdin = "21";
+    logger.debug(
+      "No state provided: pass an object with state.data.answer to provide custom input"
+    );
+    logger.debug('eg: -S "{ "data": { "answer": 33 }  }"');
   }
   const silentLogger = createNullLogger();
   const state = await load_state_default(options, silentLogger);
   const code = await compile_default(options, logger);
   const result = await execute_default(code, state, options);
-  logger.success(`Result: ${result}`);
+  logger.success(`Result: ${result.data.answer}`);
   return result;
 };
 var handler_default3 = testHandler;
@@ -359,28 +612,28 @@ var handler_default3 = testHandler;
 // src/docgen/handler.ts
 import { writeFile as writeFile3 } from "node:fs/promises";
 import { readFileSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
-import path from "node:path";
+import path2 from "node:path";
 import { describePackage } from "@openfn/describe-package";
 import { getNameAndVersion as getNameAndVersion2 } from "@openfn/runtime";
 var RETRY_DURATION = 500;
 var RETRY_COUNT = 20;
 var TIMEOUT_MS = 1e3 * 60;
 var actualDocGen = (specifier) => describePackage(specifier, {});
-var ensurePath = (filePath) => mkdirSync(path.dirname(filePath), { recursive: true });
-var generatePlaceholder = (path5) => {
-  writeFileSync(path5, `{ "loading": true, "timestamp": ${Date.now()}}`);
+var ensurePath = (filePath) => mkdirSync(path2.dirname(filePath), { recursive: true });
+var generatePlaceholder = (path6) => {
+  writeFileSync(path6, `{ "loading": true, "timestamp": ${Date.now()}}`);
 };
 var finish = (logger, resultPath) => {
   logger.success("Done! Docs can be found at:\n");
-  logger.print(`  ${path.resolve(resultPath)}`);
+  logger.print(`  ${path2.resolve(resultPath)}`);
 };
-var generateDocs = async (specifier, path5, docgen, logger) => {
+var generateDocs = async (specifier, path6, docgen, logger) => {
   const result = await docgen(specifier);
-  await writeFile3(path5, JSON.stringify(result, null, 2));
-  finish(logger, path5);
-  return path5;
+  await writeFile3(path6, JSON.stringify(result, null, 2));
+  finish(logger, path6);
+  return path6;
 };
-var waitForDocs = async (docs, path5, logger, retryDuration = RETRY_DURATION) => {
+var waitForDocs = async (docs, path6, logger, retryDuration = RETRY_DURATION) => {
   try {
     if (docs.hasOwnProperty("loading")) {
       logger.info("Docs are being loaded by another process. Waiting.");
@@ -392,19 +645,19 @@ var waitForDocs = async (docs, path5, logger, retryDuration = RETRY_DURATION) =>
             clearInterval(i);
             reject(new Error("Timed out waiting for docs to load"));
           }
-          const updated = JSON.parse(readFileSync(path5, "utf8"));
+          const updated = JSON.parse(readFileSync(path6, "utf8"));
           if (!updated.hasOwnProperty("loading")) {
             logger.info("Docs found!");
             clearInterval(i);
-            resolve(path5);
+            resolve(path6);
           }
           count++;
         }, retryDuration);
       });
     } else {
-      logger.info(`Docs already written to cache at ${path5}`);
-      finish(logger, path5);
-      return path5;
+      logger.info(`Docs already written to cache at ${path6}`);
+      finish(logger, path6);
+      return path6;
     }
   } catch (e) {
     logger.error("Existing doc JSON corrupt. Aborting");
@@ -421,28 +674,28 @@ var docgenHandler = (options, logger, docgen = actualDocGen, retryDuration = RET
     process.exit(9);
   }
   logger.success(`Generating docs for ${specifier}`);
-  const path5 = `${repoDir}/docs/${specifier}.json`;
-  ensurePath(path5);
+  const path6 = `${repoDir}/docs/${specifier}.json`;
+  ensurePath(path6);
   const handleError = () => {
     logger.info("Removing placeholder");
-    rmSync(path5);
+    rmSync(path6);
   };
   try {
-    const existing = readFileSync(path5, "utf8");
+    const existing = readFileSync(path6, "utf8");
     const json = JSON.parse(existing);
     if (json && json.timeout && Date.now() - json.timeout >= TIMEOUT_MS) {
       logger.info(`Expired placeholder found. Removing.`);
-      rmSync(path5);
+      rmSync(path6);
       throw new Error("TIMEOUT");
     }
-    return waitForDocs(json, path5, logger, retryDuration);
+    return waitForDocs(json, path6, logger, retryDuration);
   } catch (e) {
     if (e.message !== "TIMEOUT") {
-      logger.info(`Docs JSON not found at ${path5}`);
+      logger.info(`Docs JSON not found at ${path6}`);
     }
     logger.debug("Generating placeholder");
-    generatePlaceholder(path5);
-    return generateDocs(specifier, path5, docgen, logger).catch((e2) => {
+    generatePlaceholder(path6);
+    return generateDocs(specifier, path6, docgen, logger).catch((e2) => {
       logger.error("Error generating documentation");
       logger.error(e2);
       handleError();
@@ -452,7 +705,7 @@ var docgenHandler = (options, logger, docgen = actualDocGen, retryDuration = RET
 var handler_default4 = docgenHandler;
 
 // src/docs/handler.ts
-import { readFile as readFile2 } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { getNameAndVersion as getNameAndVersion3, getLatestVersion } from "@openfn/runtime";
 var describeFn = (adaptorName, fn) => `## ${fn.name}(${fn.parameters.map(({ name }) => name).join(",")})
 
@@ -481,7 +734,8 @@ ${data.functions.map((fn) => `  ${fn.name}(${fn.parameters.map((p) => p.name).jo
 `;
 var docsHandler = async (options, logger) => {
   const { adaptor, operation, repoDir } = options;
-  const [adaptorName] = expand_adaptors_default([adaptor], logger);
+  const { adaptors } = expand_adaptors_default({ adaptors: [adaptor] });
+  const [adaptorName] = adaptors;
   let { name, version } = getNameAndVersion3(adaptorName);
   if (!version) {
     logger.info("No version number provided, looking for latest...");
@@ -490,29 +744,38 @@ var docsHandler = async (options, logger) => {
     logger.success(`Showing docs for ${adaptorName} v${version}`);
   }
   logger.info("Generating/loading documentation...");
-  const path5 = await handler_default4(
+  const path6 = await handler_default4(
     {
       specifier: `${name}@${version}`,
       repoDir
     },
     createNullLogger()
   );
-  if (path5) {
-    const source = await readFile2(path5, "utf8");
+  let didError = false;
+  if (path6) {
+    const source = await readFile(path6, "utf8");
     const data = JSON.parse(source);
     let desc;
     if (operation) {
       const fn = data.functions.find(({ name: name2 }) => name2 === operation);
-      logger.debug("Operation schema:", fn);
-      logger.success(`Documentation for ${name}.${operation} v${version}:
+      if (fn) {
+        logger.debug("Operation schema:", fn);
+        logger.success(`Documentation for ${name}.${operation} v${version}:
 `);
-      desc = describeFn(name, fn);
+        desc = describeFn(name, fn);
+      } else {
+        logger.error(`Failed to find ${operation} in ${name}`);
+      }
     } else {
       logger.debug("No operation provided, listing available operations");
       desc = describeLib(name, data);
     }
     logger.print(desc);
-    logger.success("Done!");
+    if (didError) {
+      logger.error("Error");
+    } else {
+      logger.success("Done!");
+    }
   } else {
     logger.error("Not found");
   }
@@ -522,13 +785,29 @@ var handler_default5 = docsHandler;
 // src/metadata/cache.ts
 import { createHash } from "node:crypto";
 import { readFileSync as readFileSync2 } from "node:fs";
-import path2 from "node:path";
+import path3 from "node:path";
 import { writeFile as writeFile4, mkdir } from "node:fs/promises";
 var getPath = (repoDir, key) => `${repoDir}/meta/${key}.json`;
-var generateKey = (config) => createHash("sha256").update(JSON.stringify(config)).digest("hex");
+var sortKeys = (obj) => {
+  const newObj = {};
+  Object.keys(obj).sort().forEach((k) => {
+    const v = obj[k];
+    if (!v || typeof v == "string" || !isNaN(v) || Array.isArray(v)) {
+      newObj[k] = v;
+    } else {
+      newObj[k] = sortKeys(v);
+    }
+  });
+  return newObj;
+};
+var generateKey = (config, adaptor) => {
+  const sorted = sortKeys(config);
+  const key = `${JSON.stringify(sorted)}-${adaptor}}`;
+  return createHash("sha256").update(key).digest("hex");
+};
 var get = (repoPath, key) => {
   try {
-    const data = readFileSync2(getPath(repoPath, key));
+    const data = readFileSync2(getPath(repoPath, key), "utf8");
     const json = JSON.parse(data);
     return json;
   } catch (e) {
@@ -537,10 +816,10 @@ var get = (repoPath, key) => {
 };
 var set = async (repoPath, key, data) => {
   const fullPath = getPath(repoPath, key);
-  await mkdir(path2.dirname(fullPath), { recursive: true });
+  await mkdir(path3.dirname(fullPath), { recursive: true });
   await writeFile4(fullPath, JSON.stringify(data));
 };
-var cache_default = { get, set, generateKey, getPath };
+var cache_default = { get, set, generateKey, getPath, sortKeys };
 
 // src/metadata/handler.ts
 import { getModuleEntryPoint } from "@openfn/runtime";
@@ -580,8 +859,8 @@ var metadataHandler = async (options, logger) => {
   const adaptor = adaptors[0];
   const state = await load_state_default(options, logger);
   logger.success(`Generating metadata`);
+  logger.info("config:", state);
   const config = state.configuration;
-  logger.info("config:", config);
   if (!config || Object.keys(config).length === 0) {
     logger.error("ERROR: Invalid configuration passed");
     process.exit(1);
@@ -590,7 +869,7 @@ var metadataHandler = async (options, logger) => {
     logger.success("Done!");
     logger.print(cache_default.getPath(repoDir, id));
   };
-  const id = cache_default.generateKey(config);
+  const id = cache_default.generateKey(config, adaptor);
   if (!options.force) {
     logger.debug("config hash: ", id);
     const cached = await cache_default.get(repoDir, id);
@@ -621,13 +900,13 @@ var metadataHandler = async (options, logger) => {
 var handler_default6 = metadataHandler;
 
 // src/util/use-adaptors-repo.ts
-import { readFile as readFile3 } from "node:fs/promises";
-import path3 from "node:path";
+import { readFile as readFile2 } from "node:fs/promises";
+import path4 from "node:path";
 import assert from "node:assert";
-import { getNameAndVersion as getNameAndVersion4 } from "@openfn/runtime";
+import { getNameAndVersion as getNameAndVersion5 } from "@openfn/runtime";
 var validateMonoRepo = async (repoPath, log) => {
   try {
-    const raw = await readFile3(`${repoPath}/package.json`, "utf8");
+    const raw = await readFile2(`${repoPath}/package.json`, "utf8");
     const pkg = JSON.parse(raw);
     assert(pkg.name === "adaptors");
   } catch (e) {
@@ -639,14 +918,14 @@ var updatePath = (adaptor, repoPath, log) => {
   if (adaptor.match("=")) {
     return adaptor;
   }
-  const { name, version } = getNameAndVersion4(adaptor);
+  const { name, version } = getNameAndVersion5(adaptor);
   if (version) {
     log.warn(
       `Warning: Ignoring version specifier on ${adaptor} as loading from the adaptors monorepo`
     );
   }
   const shortName = name.replace("@openfn/language-", "");
-  const abspath = path3.resolve(repoPath, "packages", shortName);
+  const abspath = path4.resolve(repoPath, "packages", shortName);
   return `${name}=${abspath}`;
 };
 var useAdaptorsRepo = async (adaptors, repoPath, log) => {
@@ -663,8 +942,8 @@ var use_adaptors_repo_default = useAdaptorsRepo;
 
 // src/util/print-versions.ts
 import { readFileSync as readFileSync3 } from "node:fs";
-import path4 from "node:path";
-import { getNameAndVersion as getNameAndVersion5 } from "@openfn/runtime";
+import path5 from "node:path";
+import { getNameAndVersion as getNameAndVersion6 } from "@openfn/runtime";
 import { mainSymbols } from "figures";
 var NODE = "node.js";
 var CLI2 = "cli";
@@ -673,7 +952,7 @@ var COMPILER2 = "compiler";
 var { triangleRightSmall: t } = mainSymbols;
 var loadVersionFromPath = (adaptorPath) => {
   try {
-    const pkg = JSON.parse(readFileSync3(path4.resolve(adaptorPath, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync3(path5.resolve(adaptorPath, "package.json"), "utf8"));
     return pkg.version;
   } catch (e) {
     return "unknown";
@@ -691,9 +970,9 @@ var printVersions = async (logger, options = {}) => {
     if (adaptor.match("=")) {
       const [namePart, pathPart] = adaptor.split("=");
       adaptorVersion = loadVersionFromPath(pathPart);
-      adaptorName = getNameAndVersion5(namePart).name;
+      adaptorName = getNameAndVersion6(namePart).name;
     } else {
-      const { name, version: version2 } = getNameAndVersion5(adaptor);
+      const { name, version: version2 } = getNameAndVersion6(adaptor);
       adaptorName = name;
       adaptorVersion = version2 || "latest";
     }
@@ -750,7 +1029,7 @@ var handlers = {
   ["repo-list"]: list,
   version: async (opts, logger) => print_versions_default(logger, opts)
 };
-var maybeEnsureOpts = (basePath, options) => /^(execute|compile)$/.test(options.command) ? ensureLogOpts(options) : ensureOpts(basePath, options);
+var maybeEnsureOpts = (basePath, options) => /^(execute|compile|test)$/.test(options.command) ? ensureLogOpts(options) : ensureOpts(basePath, options);
 var parse = async (basePath, options, log) => {
   const opts = maybeEnsureOpts(basePath, options);
   const logger = log || logger_default(CLI, opts);
@@ -771,9 +1050,9 @@ var parse = async (basePath, options, log) => {
       logger
     );
   } else if (opts.adaptors && opts.expandAdaptors) {
-    opts.adaptors = expand_adaptors_default(opts.adaptors);
+    expand_adaptors_default(opts);
   }
-  if (/^(test|version)$/.test(opts.command) && !opts.repoDir) {
+  if (!/^(test|version)$/.test(opts.command) && !opts.repoDir) {
     logger.warn(
       "WARNING: no repo module dir found! Using the default (/tmp/repo)"
     );
@@ -796,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;