@openfn/cli 0.0.25 → 0.0.27

package/README.md

@@ -68,6 +68,30 @@ If no command is specified, execute will run.
 
 To get more information about a command, including usage examples, run `openfn <command> help`, ie, `openfn compile help`.
 
+## Logging 
+
+The CLI is actually a collection of packages, each of which will log with slightly different rules. To help understand where logs are coming from, each package prints a namespace or prefix at the start of its log.
+
+* [CLI] - the CLI itself, responsible for parsing and validating user input, reading and writing to disk, and executing the correct functionality.
+* [CMP] - the Compiler will parse openfn jobs into executable Javascript, changing your code
+* [R/T] - the Runtime executes your job code in a secure sandboxed environment, one operation at a time
+* [JOB] - the actual job code that your wrote. Any console.log statements in your job will appear under this namespace.
+
+The CLI will log information at three different levels of verbosity: `default`, `info` and `debug` (`none` is also supported).
+
+To set the log level, pass `--log info` into your command. You can configure this for individual packages, ie `--log cmp=debug` will run the compiler with debug logging but leave everything else at default.
+
+Note that, unless explicitly overriden, jobs will always report at debug verbosity (meaning job logging will always be shown).
+
+If something unexpected happens during a command, your first step should be to re-run with info-level logging.
+
+`default` logging is designed to give high-level feedback about what you absolutely need to know. It will show any errors or warnings, as well as high-level reporting about what the command has actually done.
+
+`info` level logging is suitable for most developers. It is more verbose than default but still aims to provide high-level information about a command. It includes version numbers, key paths, and simple reporting about how the compiler changes your code (see below).
+
+`debug` level logging is highly verbose and aims to tell you everything that's going on under-the hood. This is aimed mostly at CLI/runtime developers and can be very useful for debugging problems.
+
+
 ## Compilation
 
 The CLI will attempt to compile your job code into normalized Javascript. It will do a number of things to make your code robust and portable:

package/dist/index.js

@@ -105,6 +105,9 @@ var executeCommand = {
     }).option("state-stdin", {
       alias: "S",
       description: "Read state from stdin (instead of a file)"
+    }).option("skip-adaptor-validation", {
+      boolean: true,
+      description: "Skip adaptor validation warnings"
     }).option("timeout", {
       alias: "-t",
       description: "Set the timeout duration in MS"

package/dist/process/runner.js

@@ -89,6 +89,7 @@ function ensureOpts(basePath = ".", opts) {
     timeout: opts.timeout,
     specifier: opts.specifier,
     strictOutput: opts.strictOutput ?? true,
+    skipAdaptorValidation: opts.skipAdaptorValidation ?? false,
     immutable: opts.immutable || false
   };
   const set = (key, value) => {
@@ -299,7 +300,7 @@ var expand_adaptors_default = (names, log = nullLogger) => names?.map((name) =>
     return name;
   }
   const expanded = `@openfn/language-${name}`;
-  log.info(`Expanded adaptor ${name} to ${expanded}`);
+  log.debug(`Expanded adaptor ${name} to ${expanded}`);
   return expanded;
 });
 
@@ -370,6 +371,23 @@ var list = async (options, logger) => {
   logger.success("Installed packages:\n\n" + treeify.asTree(output));
 };
 
+// src/util/validate-adaptors.ts
+var validateAdaptors = async (options, logger) => {
+  if (options.skipAdaptorValidation) {
+    return;
+  }
+  if (!options.adaptors || options.adaptors.length === 0) {
+    logger.warn("WARNING: No adaptor provided!");
+    logger.warn(
+      "This job will probably fail. Pass an adaptor with the -a flag, eg:"
+    );
+    logger.break();
+    logger.print("          openfn job.js -a common");
+    logger.break();
+  }
+};
+var validate_adaptors_default = validateAdaptors;
+
 // src/execute/handler.ts
 var getAutoinstallTargets = (options) => {
   if (options.autoinstall && options.adaptors) {
@@ -379,6 +397,7 @@ var getAutoinstallTargets = (options) => {
 };
 var executeHandler = async (options, logger) => {
   const start = new Date().getTime();
+  await validate_adaptors_default(options, logger);
   const autoInstallTargets = getAutoinstallTargets(options);
   if (autoInstallTargets.length) {
     const { repoDir } = options;
@@ -601,17 +620,29 @@ var handler_default5 = docsHandler;
 
 // src/util/print-versions.ts
 import { mainSymbols } from "figures";
+import { getNameAndVersion as getNameAndVersion4 } from "@openfn/runtime";
 var { triangleRightSmall: t } = mainSymbols;
-var printVersions = async (logger) => {
+var printVersions = async (logger, options = {}) => {
+  const prefix = (str) => `         ${t} ${str.padEnd(options.adaptors ? 16 : 8, " ")}`;
   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 adaptorVersionString = "";
+  if (adaptors && adaptors.length === 1) {
+    const [a] = adaptors;
+    const { name, version: version2 } = getNameAndVersion4(a);
+    adaptorVersionString = `
+${prefix(
+      "adaptor " + name.replace(/^@openfn\/language-/, "")
+    )}${version2 || "latest"}`;
+  }
   logger.info(`Versions:
-        ${t} Node.js   ${process.version.substring(1)}
-        ${t} cli       ${version}
-        ${t} runtime   ${runtimeVersion}
-        ${t} compiler  ${compilerVersion}`);
+${prefix("node.js")}${process.version.substring(1)}
+${prefix("cli")}${version}
+${prefix("runtime")}${runtimeVersion}
+${prefix("compiler")}${compilerVersion}${adaptorVersionString}`);
 };
 var print_versions_default = printVersions;
 
@@ -632,7 +663,7 @@ var parse = async (basePath, options, log) => {
   const opts = ensureOpts(basePath, options);
   const logger = log || logger_default(CLI, opts);
   if (opts.command === "execute" || opts.command === "test") {
-    await print_versions_default(logger);
+    await print_versions_default(logger, opts);
   }
   if (opts.adaptors && opts.expand) {
     opts.adaptors = expand_adaptors_default(opts.adaptors, logger);
@@ -653,7 +684,17 @@ var parse = async (basePath, options, log) => {
     logger.error(`Unrecognise command: ${options.command}`);
     process.exit(1);
   }
-  return handler(opts, logger);
+  try {
+    const result = await handler(opts, logger);
+    return result;
+  } catch (e) {
+    if (!process.exitCode) {
+      process.exitCode = e.exitCode || 1;
+    }
+    logger.break();
+    logger.error("Command failed!");
+    logger.error(e);
+  }
 };
 var commands_default = parse;
 var assertPath = (basePath) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfn/cli",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "description": "CLI devtools for the openfn toolchain.",
   "engines": {
     "node": ">=18",
@@ -36,15 +36,15 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@openfn/compiler": "0.0.22",
-    "@openfn/describe-package": "0.0.14",
-    "@openfn/logger": "0.0.8",
-    "@openfn/runtime": "0.0.15",
     "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.23",
+    "@openfn/describe-package": "0.0.14",
+    "@openfn/logger": "0.0.8",
+    "@openfn/runtime": "0.0.17"
   },
   "files": [
     "dist",