@openfn/cli 0.0.28 → 0.0.30

package/README.md

@@ -46,7 +46,7 @@ openfn path/to/job.js -ia adaptor-name
 
 You MUST specify which adaptor to use. Pass the `-i` flag to auto-install that adaptor (it's safe to do this redundantly).
 
-If output.json and state.json are not passed, the CLI will look for them next to the job.js file. You can pass a path to state by adding `-s path/to/state.json`, and output by passing `-o path/to/output.json`. You can use `-S` and `-O` to pass state through stdin and return the output through stdout.
+If output.json is not passed, the CLI will create an `output.json` next to the job file. You can pass a path to state by adding `-s path/to/state.json`, and output by passing `-o path/to/output.json`. You can use `-S` and `-O` to pass state through stdin and return the output through stdout.
 
 The CLI can auto-install language adaptors to its own privately maintained repo. 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.
 

package/dist/process/runner.js

@@ -94,6 +94,7 @@ function ensureOpts(basePath = ".", opts) {
     specifier: opts.specifier,
     stateStdin: opts.stateStdin,
     strictOutput: opts.strictOutput ?? true,
+    statePath: opts.statePath,
     timeout: opts.timeout
   };
   const set = (key, value) => {
@@ -109,7 +110,6 @@ function ensureOpts(basePath = ".", opts) {
   } else {
     set("jobPath", `${baseDir}/job.js`);
   }
-  set("statePath", `${baseDir}/state.json`);
   if (!opts.outputStdout) {
     set(
       "outputPath",
@@ -123,31 +123,34 @@ function ensureOpts(basePath = ".", opts) {
 // 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 (opts.stateStdin) {
+  if (stateStdin) {
     try {
-      const json = JSON.parse(opts.stateStdin);
+      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(opts.stateStdin);
+      log.error(stateStdin);
       log.error(e);
       process.exit(1);
     }
   }
-  try {
-    const str = await fs.readFile(opts.statePath, "utf8");
-    const json = JSON.parse(str);
-    log.success(`Loaded state from ${opts.statePath}`);
-    log.debug("state:", json);
-    return json;
-  } catch (e) {
-    log.warn(`Error loading state from ${opts.statePath}`);
-    log.warn(e);
+  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.warn("Using default state { data: {}, configuration: {}");
+  log.info("No state provided - using default state { data: {}, configuration: {}");
   return {
     data: {},
     configuration: {}
@@ -171,11 +174,11 @@ var execute_default = (code, state, opts) => {
 function parseAdaptors(opts) {
   const adaptors = {};
   opts.adaptors.reduce((obj, exp) => {
-    const [module, path4] = exp.split("=");
+    const [module, path5] = exp.split("=");
     const { name, version } = getNameAndVersion(module);
     const info = {};
-    if (path4) {
-      info.path = path4;
+    if (path5) {
+      info.path = path5;
     }
     if (version) {
       info.version = version;
@@ -200,7 +203,7 @@ var compile_default = async (opts, log) => {
   } else {
     const complilerOptions = await loadTransformOptions(opts, log);
     complilerOptions.logger = logger_default(COMPILER, opts);
-    job = compile(opts.jobPath, complilerOptions);
+    job = compile(opts.jobSource || opts.jobPath, complilerOptions);
     if (opts.jobPath) {
       log.success(`Compiled job from ${opts.jobPath}`);
     } else {
@@ -217,10 +220,10 @@ var stripVersionSpecifier = (specifier) => {
   return specifier;
 };
 var resolveSpecifierPath = async (pattern, repoDir, log) => {
-  const [specifier, path4] = pattern.split("=");
-  if (path4) {
-    log.debug(`Resolved ${specifier} to path: ${path4}`);
-    return path4;
+  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) {
@@ -237,15 +240,15 @@ var loadTransformOptions = async (opts, log) => {
     const [pattern] = opts.adaptors;
     const [specifier] = pattern.split("=");
     log.debug(`Attempting to preload typedefs for ${specifier}`);
-    const path4 = await resolveSpecifierPath(pattern, opts.repoDir, log);
-    if (path4) {
+    const path5 = await resolveSpecifierPath(pattern, opts.repoDir, log);
+    if (path5) {
       try {
-        exports = await preloadAdaptorExports(path4);
+        exports = await preloadAdaptorExports(path5);
         if (exports) {
           log.info(`Loaded typedefs for ${specifier}`);
         }
       } catch (e) {
-        log.error(`Failed to load adaptor typedefs from path ${path4}`);
+        log.error(`Failed to load adaptor typedefs from path ${path5}`);
         log.error(e);
       }
     }
@@ -448,20 +451,18 @@ var compileHandler = async (options, logger) => {
 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.jobPath = `const fn = () => state => state * 2; fn()`;
+  options.jobSource = `const fn = () => state => { console.log('${sillyMessage}'); return state * 2; } ; fn()`;
+  delete options.jobPath;
   if (!options.stateStdin) {
-    logger.warn("No state detected: pass -S <number> to provide some state");
+    logger.debug("No state provided: try -S <number> to provide some state");
     options.stateStdin = "21";
   }
   const silentLogger = createNullLogger();
   const state = await load_state_default(options, silentLogger);
   const code = await compile_default(options, logger);
-  logger.break();
-  logger.info("Compiled job:", "\n", code);
-  logger.break();
-  logger.info("Running job...");
   const result = await execute_default(code, state, options);
   logger.success(`Result: ${result}`);
   return result;
@@ -479,20 +480,20 @@ var RETRY_COUNT = 20;
 var TIMEOUT_MS = 1e3 * 60;
 var actualDocGen = (specifier) => describePackage(specifier, {});
 var ensurePath = (filePath) => mkdirSync(path2.dirname(filePath), { recursive: true });
-var generatePlaceholder = (path4) => {
-  writeFileSync(path4, `{ "loading": true, "timestamp": ${Date.now()}}`);
+var generatePlaceholder = (path5) => {
+  writeFileSync(path5, `{ "loading": true, "timestamp": ${Date.now()}}`);
 };
 var finish = (logger, resultPath) => {
   logger.success("Done! Docs can be found at:\n");
   logger.print(`  ${path2.resolve(resultPath)}`);
 };
-var generateDocs = async (specifier, path4, docgen, logger) => {
+var generateDocs = async (specifier, path5, docgen, logger) => {
   const result = await docgen(specifier);
-  await writeFile3(path4, JSON.stringify(result, null, 2));
-  finish(logger, path4);
-  return path4;
+  await writeFile3(path5, JSON.stringify(result, null, 2));
+  finish(logger, path5);
+  return path5;
 };
-var waitForDocs = async (docs, path4, logger, retryDuration = RETRY_DURATION) => {
+var waitForDocs = async (docs, path5, logger, retryDuration = RETRY_DURATION) => {
   try {
     if (docs.hasOwnProperty("loading")) {
       logger.info("Docs are being loaded by another process. Waiting.");
@@ -504,19 +505,19 @@ var waitForDocs = async (docs, path4, logger, retryDuration = RETRY_DURATION) =>
             clearInterval(i);
             reject(new Error("Timed out waiting for docs to load"));
           }
-          const updated = JSON.parse(readFileSync(path4, "utf8"));
+          const updated = JSON.parse(readFileSync(path5, "utf8"));
           if (!updated.hasOwnProperty("loading")) {
             logger.info("Docs found!");
             clearInterval(i);
-            resolve(path4);
+            resolve(path5);
           }
           count++;
         }, retryDuration);
       });
     } else {
-      logger.info(`Docs already written to cache at ${path4}`);
-      finish(logger, path4);
-      return path4;
+      logger.info(`Docs already written to cache at ${path5}`);
+      finish(logger, path5);
+      return path5;
     }
   } catch (e) {
     logger.error("Existing doc JSON corrupt. Aborting");
@@ -533,28 +534,28 @@ var docgenHandler = (options, logger, docgen = actualDocGen, retryDuration = RET
     process.exit(9);
   }
   logger.success(`Generating docs for ${specifier}`);
-  const path4 = `${repoDir}/docs/${specifier}.json`;
-  ensurePath(path4);
+  const path5 = `${repoDir}/docs/${specifier}.json`;
+  ensurePath(path5);
   const handleError = () => {
     logger.info("Removing placeholder");
-    rmSync(path4);
+    rmSync(path5);
   };
   try {
-    const existing = readFileSync(path4, "utf8");
+    const existing = readFileSync(path5, "utf8");
     const json = JSON.parse(existing);
     if (json && json.timeout && Date.now() - json.timeout >= TIMEOUT_MS) {
       logger.info(`Expired placeholder found. Removing.`);
-      rmSync(path4);
+      rmSync(path5);
       throw new Error("TIMEOUT");
     }
-    return waitForDocs(json, path4, logger, retryDuration);
+    return waitForDocs(json, path5, logger, retryDuration);
   } catch (e) {
     if (e.message !== "TIMEOUT") {
-      logger.info(`Docs JSON not found at ${path4}`);
+      logger.info(`Docs JSON not found at ${path5}`);
     }
     logger.debug("Generating placeholder");
-    generatePlaceholder(path4);
-    return generateDocs(specifier, path4, docgen, logger).catch((e2) => {
+    generatePlaceholder(path5);
+    return generateDocs(specifier, path5, docgen, logger).catch((e2) => {
       logger.error("Error generating documentation");
       logger.error(e2);
       handleError();
@@ -602,15 +603,15 @@ var docsHandler = async (options, logger) => {
     logger.success(`Showing docs for ${adaptorName} v${version}`);
   }
   logger.info("Generating/loading documentation...");
-  const path4 = await handler_default4(
+  const path5 = await handler_default4(
     {
       specifier: `${name}@${version}`,
       repoDir
     },
     createNullLogger()
   );
-  if (path4) {
-    const source = await readFile(path4, "utf8");
+  if (path5) {
+    const source = await readFile(path5, "utf8");
     const data = JSON.parse(source);
     let desc;
     if (operation) {
@@ -673,25 +674,56 @@ var useAdaptorsRepo = async (adaptors, repoPath, log) => {
 var use_adaptors_repo_default = useAdaptorsRepo;
 
 // src/util/print-versions.ts
-import { mainSymbols } from "figures";
+import { readFileSync as readFileSync2 } from "node:fs";
+import path4 from "node:path";
 import { getNameAndVersion as getNameAndVersion5 } from "@openfn/runtime";
+import { mainSymbols } from "figures";
+var NODE = "node.js";
+var CLI2 = "cli";
+var RUNTIME2 = "runtime";
+var COMPILER2 = "compiler";
 var { triangleRightSmall: t } = mainSymbols;
+var loadVersionFromPath = (adaptorPath) => {
+  try {
+    const pkg = JSON.parse(readFileSync2(path4.resolve(adaptorPath, "package.json"), "utf8"));
+    return pkg.version;
+  } catch (e) {
+    return "unknown";
+  }
+};
 var printVersions = async (logger, options = {}) => {
-  const prefix = (str) => `         ${t} ${str.padEnd(options.adaptors ? 16 : 8, " ")}`;
+  const { adaptors, logJson } = options;
+  let adaptor = "";
+  if (adaptors && adaptors.length) {
+    adaptor = adaptors[0];
+  }
+  let adaptorVersion;
+  let adaptorName = "";
+  if (adaptor) {
+    if (adaptor.match("=")) {
+      const [namePart, pathPart] = adaptor.split("=");
+      adaptorVersion = loadVersionFromPath(pathPart);
+      adaptorName = getNameAndVersion5(namePart).name;
+    } else {
+      const { name, version: version2 } = getNameAndVersion5(adaptor);
+      adaptorName = name;
+      adaptorVersion = version2 || "latest";
+    }
+  }
+  const longest = Math.max(...[
+    NODE,
+    CLI2,
+    RUNTIME2,
+    COMPILER2,
+    adaptorName
+  ].map((s) => s.length));
+  const prefix = (str) => `         ${t} ${str.padEnd(longest + 4, " ")}`;
   const pkg = await import("../../package.json", { assert: { type: "json" } });
   const { version, dependencies } = pkg.default;
   const compilerVersion = dependencies["@openfn/compiler"];
   const runtimeVersion = dependencies["@openfn/runtime"];
-  const { adaptors } = options;
-  let adaptorName, adaptorVersion;
-  if (adaptors && adaptors.length === 1) {
-    const [a] = adaptors;
-    const { name, version: version2 } = getNameAndVersion5(a);
-    adaptorName = name.replace(/^@openfn\/language-/, "");
-    adaptorVersion = version2 || "latest";
-  }
   let output;
-  if (options.logJson) {
+  if (logJson) {
     output = {
       versions: {
         "node.js": process.version.substring(1),
@@ -701,19 +733,16 @@ var printVersions = async (logger, options = {}) => {
       }
     };
     if (adaptorName) {
-      output.versions.adaptor = {
-        name: adaptorName,
-        version: adaptorVersion
-      };
+      output.versions[adaptorName] = adaptorVersion;
     }
   } else {
     const adaptorVersionString = adaptorName ? `
-${prefix("adaptor " + adaptorName)}${adaptorVersion}` : "";
+${prefix(adaptorName)}${adaptorVersion}` : "";
     output = `Versions:
-${prefix("node.js")}${process.version.substring(1)}
-${prefix("cli")}${version}
-${prefix("runtime")}${runtimeVersion}
-${prefix("compiler")}${compilerVersion}${adaptorVersionString}`;
+${prefix(NODE)}${process.version.substring(1)}
+${prefix(CLI2)}${version}
+${prefix(RUNTIME2)}${runtimeVersion}
+${prefix(COMPILER2)}${compilerVersion}${adaptorVersionString}`;
   }
   logger.info(output);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfn/cli",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "CLI devtools for the openfn toolchain.",
   "engines": {
     "node": ">=18",
@@ -36,15 +36,15 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@openfn/compiler": "0.0.24",
-    "@openfn/describe-package": "0.0.14",
-    "@openfn/logger": "0.0.9",
-    "@openfn/runtime": "0.0.18",
     "fast-safe-stringify": "^2.1.1",
     "figures": "^5.0.0",
     "rimraf": "^3.0.2",
     "treeify": "^1.1.0",
-    "yargs": "^17.5.1"
+    "yargs": "^17.5.1",
+    "@openfn/compiler": "0.0.25",
+    "@openfn/describe-package": "0.0.14",
+    "@openfn/runtime": "0.0.19",
+    "@openfn/logger": "0.0.10"
   },
   "files": [
     "dist",