zorb 0.0.1-alpha.0 → 0.0.3

package/dist/runners/run.cjs

@@ -0,0 +1,59 @@
+/**
+ * This file should not be bundled into Deno - it's a Javascript wrapper to load a file & run a function
+ */
+// deno-lint-ignore-file no-process-global
+const { resolve } = require("node:path");
+
+async function main() {
+  // node run.cjs <modulePath> <symbol> <inputsJson>
+  const [, , modulePath, symbol, inputsJson = "{}"] = process.argv;
+
+  if (!modulePath || !symbol) {
+    console.error(
+      "Usage: node run.cjs <modulePath> <symbol> <inputsJson> <ctxJson>",
+    );
+    process.exit(2);
+  }
+
+  let inputs;
+
+  try {
+    inputs = JSON.parse(inputsJson);
+  } catch {
+    console.error("Invalid inputs JSON");
+    process.exit(2);
+  }
+
+  // Resolve to absolute path so require() is deterministic
+  const absPath = resolve(modulePath);
+
+  let mod;
+  try {
+    mod = require(absPath);
+  } catch (err) {
+    console.error(`Failed to import ${absPath}`);
+    console.error(err);
+    process.exit(3);
+  }
+
+  const fn = mod[symbol];
+  if (typeof fn !== "function") {
+    console.error(`Export "${symbol}" is not a function in ${absPath}`);
+    process.exit(4);
+  }
+
+  try {
+    const result = fn(inputs);
+    if (result && typeof result.then === "function") {
+      await result;
+    }
+
+    process.exit(0);
+  } catch (err) {
+    console.error(`Error running ${symbol} from ${absPath}`);
+    console.error(err);
+    process.exit(1);
+  }
+}
+
+main();

package/dist/runners/run.mjs

@@ -0,0 +1,61 @@
+/**
+ * This file should not be bundled into Deno - it's a Javascript wrapper to load a file & run a function
+ */
+// deno-lint-ignore-file no-process-global
+import { pathToFileURL } from "node:url";
+import { resolve } from "node:path";
+
+async function main() {
+  // node run.mjs <modulePath> <symbol> <inputsJson>
+  const [, , modulePath, symbol, inputsJson = "{}"] = process.argv;
+
+  if (!modulePath || !symbol) {
+    console.error(
+      "Usage: node run.mjs <modulePath> <symbol> <inputsJson> <ctxJson>",
+    );
+    process.exit(2);
+  }
+
+  let inputs;
+
+  try {
+    inputs = JSON.parse(inputsJson);
+  } catch {
+    console.error("Invalid inputs JSON");
+    process.exit(2);
+  }
+
+  // Resolve to absolute path so import() is deterministic
+  const absPath = resolve(modulePath);
+  const { href: moduleUrl } = pathToFileURL(absPath);
+
+  let mod;
+  try {
+    mod = await import(moduleUrl);
+  } catch (err) {
+    console.error(`Failed to import ${absPath}`);
+    console.error(err);
+    process.exit(3);
+  }
+
+  const fn = mod[symbol];
+  if (typeof fn !== "function") {
+    console.error(`Export "${symbol}" is not a function in ${absPath}`);
+    process.exit(4);
+  }
+
+  try {
+    const result = fn(inputs);
+    if (result && typeof result.then === "function") {
+      await result;
+    }
+
+    process.exit(0);
+  } catch (err) {
+    console.error(`Error running ${symbol} from ${absPath}`);
+    console.error(err);
+    process.exit(1);
+  }
+}
+
+main();

package/dist/runners/run.py

@@ -0,0 +1,31 @@
+# Usage: python run.py <modulePath> <symbol> <inputsJson>
+import importlib.util, json, sys, traceback
+
+if len(sys.argv) < 3:
+  print("Usage: run.py <modulePath> <symbol> <inputsJson>", file=sys.stderr)
+  sys.exit(2)
+
+module_path = sys.argv[1]
+symbol = sys.argv[2]
+inputs = json.loads(sys.argv[3]) if len(sys.argv) > 3 else {}
+
+spec = importlib.util.spec_from_file_location("zorb_user_module", module_path)
+if spec is None or spec.loader is None:
+  print(f"Failed to load module from {module_path}", file=sys.stderr)
+  sys.exit(3)
+
+mod = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(mod)
+
+fn = getattr(mod, symbol, None)
+if not callable(fn):
+  print(f'Symbol "{symbol}" is not callable in {module_path}', file=sys.stderr)
+  sys.exit(4)
+
+try:
+  res = fn(inputs)
+  # If you want async python support, you can detect coroutine and run it.
+  sys.exit(0)
+except Exception:
+  traceback.print_exc()
+  sys.exit(1)

package/dist/runners/run.ts

@@ -0,0 +1,60 @@
+/**
+ * This file should not be bundled into Deno - it's a Typescript wrapper to load a file & run a function
+ */
+// deno-lint-ignore-file no-process-global
+import { pathToFileURL } from 'node:url';
+import { resolve } from 'node:path';
+
+async function main() {
+  // tsx run.ts <modulePath> <symbol> <inputsJson>
+  const [, , modulePath, symbol, inputsJson = '{}'] = process.argv;
+
+  if (!modulePath || !symbol) {
+    console.error('Usage: tsx run.ts <modulePath> <symbol> <inputsJson> <ctxJson>');
+    process.exit(2);
+  }
+
+  let inputs: unknown;
+
+  try {
+    inputs = JSON.parse(inputsJson);
+  } catch {
+    console.error('Invalid inputs JSON');
+    process.exit(2);
+  }
+
+  // Resolve to absolute path so import() is deterministic
+  const absPath = resolve(modulePath);
+  const { href: moduleUrl } = pathToFileURL(absPath);
+
+  let mod: Record<string, unknown>;
+  try {
+    mod = await import(moduleUrl);
+  } catch (err) {
+    console.error(`Failed to import ${absPath}`);
+    console.error(err);
+    process.exit(3);
+  }
+
+  const fn = mod![symbol];
+  if (typeof fn !== 'function') {
+    console.error(`Export "${symbol}" is not a function in ${absPath}`);
+    process.exit(4);
+  }
+
+  try {
+    // deno-lint-ignore no-explicit-any
+    const result = (fn as any)(inputs);
+    if (result && typeof result.then === 'function') {
+      await result;
+    }
+
+    process.exit(0);
+  } catch (err) {
+    console.error(`Error running ${symbol} from ${absPath}`);
+    console.error(err);
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -1,30 +1,19 @@
 {
   "name": "zorb",
-  "description": "Structure data workflow runner",
-  "version": "0.0.1-alpha.0",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "version": "0.0.3",
+  "description": "Standalone workflow runner",
+  "bin": {
+    "zorb": "dist/zorb"
   },
-  "main": "./index.js",
-  "types": "./types.d.ts",
-  "bin": "./bin.js",
-  "author": "James D <james@jdrydn.com> (https://jdrydn.com)",
+  "author": "jdrydn <james@jdrydn.com> (https://jdrydn.com)",
   "license": "MIT",
-  "homepage": "https://github.com/someimportantcompany/zorb",
-  "bugs": "https://github.com/someimportantcompany/zorb/issues",
-  "repository": "https://github.com/someimportantcompany/zorb.git",
-  "dependencies": {
-    "@someimportantcompany/utils": "^1.3.1",
-    "http-assert-plus": "^2.0.1",
-    "yaml": "^2.3.4",
-    "yargs": "^17.7.2",
-    "yup": "^1.3.3"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jdrydn/zorb.git"
   },
-  "devDependencies": {
-    "@types/yargs": "^17.0.29"
-  },
-  "engines": {
-    "node": ">16",
-    "npm": ">7"
-  }
+  "bugs": "https://github.com/jdrydn/zorb/issues",
+  "homepage": "https://github.com/jdrydn/zorb",
+  "files": [
+    "./dist"
+  ]
 }

package/.editorconfig

@@ -1,9 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-indent_style = space
-indent_size = 2
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true

package/README.md

@@ -1,3 +0,0 @@
-# zorb
-
-Structure data workflow runner.

package/bin.js

@@ -1,74 +0,0 @@
-const yargs = require('yargs');
-const { hideBin } = require('yargs/helpers');
-
-const { runWorkflow } = require('./lib/runner');
-const { validateSchemaFile } = require('./lib/schemas');
-
-const { loadFile } = require('./lib/files');
-const { createLogger } = require('./lib/logger');
-
-const parser = yargs(hideBin(process.argv))
-  .count('verbose')
-  .alias('v', 'verbose')
-  .option('cwd', {
-    type: 'string',
-    default: process.env.PWD ?? '/',
-  })
-  .command('run <script>', 'run the specific script', args => args
-    .option('file', {
-      type: 'string',
-      default: 'zorb.yml',
-      alias: 'f',
-    })
-    .option('with', {
-      type: 'array',
-      coerce: args => Object.fromEntries(args.map(a => a.split('='))),
-    })
-    .positional('script', {}))
-  .command('use <package>', 'run the specific package', args => args
-    .option('with', {
-      type: 'array',
-      coerce: args => Object.fromEntries(args.map(a => a.split('='))),
-    })
-    .positional('package', {}))
-  .demandCommand(1);
-
-(async () => {
-  try {
-    const args = await parser.parseAsync();
-    const log = (args.verbose > 0) ? createLogger(args.verbose) : undefined;
-    log?.debug({ args });
-
-    switch (args._.shift()) {
-      case 'run':
-        const file = await loadFile(args.cwd, args.file);
-        const config = validateSchemaFile(file);
-        log?.debug({ config });
-        // @TODO Resolve variables within the config script
-        await runWorkflow({ cwd: args.cwd, log }, config, args.script, args.with);
-        break;
-
-      case 'use':
-        // @TODO Resolve variables within the config script
-        await runWorkflow({
-          cwd: args.cwd,
-          log,
-        }, {
-          scripts: {
-            '0': {
-              steps: [
-                { uses: args.package, with: args.with ? args.with : undefined },
-              ],
-            },
-          },
-        }, '0');
-        break;
-    }
-
-    log?.debug('Finished');
-    process.exit(0);
-  } catch (err) {
-    console.error(err);
-    process.exit(1);
-  }
-})();

package/index.js

@@ -1,11 +0,0 @@
-const { runWorkflow } = require('./lib/runner');
-const { validateSchemaFile } = require('./lib/schemas');
-
-module.exports = function zorb(input, { log }) {
-  const config = validateSchemaFile(input);
-
-  return Object.keys(config.scripts).reduce((fns, key) => ({
-    ...fns,
-    [key]: () => runWorkflow({ cwd: args.cwd, log }, config, args.script),
-  }), {});
-};

package/lib/context.js

@@ -1,35 +0,0 @@
-/**
- * @param {Partial<import('../types').ZorbContext>} ctx
- * @param {Nullable<import('../types').ZorbContext['cwd']>} ctx.cwd
- * @param {Nullable<import('../types').ZorbContext['env']>} ctx.env
- * @param {Nullable<import('../types').ZorbContext['log']>} ctx.log
- * @returns {import('../types').ZorbContext}
- */
-function createContext({ cwd, env, log }) {
-  return Object.create({}, {
-    cwd: {
-      enumerable: true,
-      value: cwd ?? process.env.PWD,
-    },
-    env: {
-      enumerable: true,
-      value: { ...env },
-    },
-    log: {
-      enumerable: true,
-      get: () => log,
-    },
-    output: {
-      enumerable: true,
-      value: {},
-    },
-    // state: {
-    //   enumerable: true,
-    //   value: {},
-    // },
-  });
-}
-
-module.exports = {
-  createContext,
-};

package/lib/files.js

@@ -1,50 +0,0 @@
-const assert = require('http-assert-plus');
-const fs = require('fs/promises');
-const path = require('path');
-const yaml = require('yaml');
-
-const { tryCatch } = require('./utils');
-
-/**
- * @param {string} dirname
- * @param {string} filename
- * @returns {Promise<Record<string, any>>}
- */
-async function loadFile(dirname, filename) {
-  assert(typeof dirname === 'string', new TypeError('Expected dirname to be a string'));
-  assert(typeof filename === 'string', new TypeError('Expected filename to be a string'));
-
-  const contents = await fs.readFile(path.resolve(dirname, filename), 'utf8').catch(err => {
-    let prefix = `Failed to read file at ${path.resolve(dirname, filename)}`;
-    // @TODO Change prefix based on fs err code
-    err.message = `${prefix}: ${err.message}`;
-    throw err;
-  });
-
-  // let parsed;
-
-  switch (path.extname(filename)) {
-    case '.json': {
-      return tryCatch(() => JSON.parse(contents), err => {
-        // @TODO Change prefix based on JSON.parse err code
-        err.message = `Failed to parse JSON file: ${err.message}`;
-        throw err;
-      });
-    }
-
-    case '.yaml': case '.yml': {
-      return tryCatch(() => yaml.parse(contents), err => {
-        // @TODO Change prefix based on yaml.parse err code
-        err.message = `Failed to parse YAML file: ${err.message}`;
-        throw err;
-      });
-    }
-
-    default:
-      throw new Error(`Unknown file extension: ${filename}`);
-  }
-}
-
-module.exports = {
-  loadFile,
-};

package/lib/logger.js

@@ -1,27 +0,0 @@
-function createLogLevel(prefix) {
-  return function (first, ...rest) {
-    if (typeof first === 'string') {
-      console.log(prefix, (new Date()).toISOString(), first, ...rest);
-    } else {
-      console.log(prefix, (new Date()).toISOString(), first);
-      if (rest.length) {
-        console.log(prefix, (new Date()).toISOString(), first, ...rest);
-      }
-    }
-  }
-}
-
-const noop = () => {};
-
-function createLogger(verbose) {
-  return {
-    error: createLogLevel('[ERROR]'),
-    warn: createLogLevel('[WARN] '),
-    info: verbose >= 1 ? createLogLevel('[INFO] ') : noop,
-    debug: verbose > 1 ? createLogLevel('[DEBUG]') : noop,
-  };
-}
-
-module.exports = {
-  createLogger,
-};

package/lib/runner.js

@@ -1,50 +0,0 @@
-const assert = require('http-assert-plus');
-
-const { createContext } = require('./context');
-
-const { runShellStep } = require('../steps/run');
-const { runActionStep, loadActionSteps } = require('../steps/use');
-
-// Given a valid runner file
-// And some instruction
-// Complete the steps at hand
-
-async function runWorkflow({ cwd, log }, config, handle) {
-  assert(config.scripts?.[handle], 'Script not found', {
-    code: 'SCRIPT_NOT_FOUND',
-    meta: { handle },
-  });
-
-  const { [handle]: script } = config.scripts;
-
-  assert(Array.isArray(script.steps), 'No steps found for script', {
-    code: 'SCRIPT_STEPS_NOT_FOUND',
-    meta: { handle },
-  });
-
-  const ctx = createContext({
-    cwd: typeof script.defaults?.run?.cwd === 'string'
-      ? script.defaults.run.cwd
-      : process.env.PWD,
-    env: { ...config.env, ...script.defaults?.run?.env, ...script.env },
-    log
-  });
-
-  loadActionSteps({ cwd, log }, script.steps
-    .filter(step => typeof step.uses === 'string')
-    .map(step => step.uses));
-
-  for (const step of script.steps) {
-    log?.info({ step }, '@zorb/run step');
-
-    if (typeof step.uses === 'string') {
-      await runActionStep(ctx, step, script);
-    } else if (typeof step.run === 'string') {
-      await runShellStep(ctx, step, script);
-    }
-  }
-}
-
-module.exports = {
-  runWorkflow,
-};

package/lib/schemas.js

@@ -1,56 +0,0 @@
-const yup = require('yup');
-
-function dynamicObject(value) {
-  return yup.lazy(map => yup.object((map ? Object.keys(map) : [])
-    .reduce((newMap, key) => ({...newMap, [key]: value}), {})));
-}
-
-const runnerActionStep = module.exports.runnerActionStep = yup.object().noUnknown(true).shape({
-  uses: yup.string().required(),
-  with: yup.object(),
-});
-
-// const runnerCodeStep = module.exports.runnerCodeStep = yup.object().noUnknown(true).shape({
-//   code: yup.string().required(),
-//   with: yup.object(),
-// });
-
-const runnerShellStep = module.exports.runnerShellStep = yup.object().noUnknown(true).shape({
-  run: yup.string().required(),
-  cwd: yup.string(),
-  env: dynamicObject(yup.string()),
-  shell: yup.string(),
-});
-
-const runnerScriptSchema = module.exports.runnerScriptSchema = yup.object().noUnknown(true).shape({
-  env: dynamicObject(yup.string()),
-  defaults: yup.object(),
-  steps: yup.array().required().min(1).of(yup.lazy(o => {
-    if (o && typeof o.uses === 'string') {
-      return runnerActionStep.clone();
-    } else {
-      return runnerShellStep.clone();
-    }
-  })),
-});
-
-const runnerFileSchema = module.exports.runnerFileSchema = yup.object().required().shape({
-  version: yup.string().oneOf(['1']),
-  env: dynamicObject(yup.string()),
-  params: yup.object(),
-  scripts: dynamicObject(runnerScriptSchema),
-});
-
-/**
- * @param {Record<string, any>} input
- * @returns {NonNullable<ReturnType<typeof runnerFileSchema.cast>>}
- */
-function validateSchemaFile(input) {
-  return runnerFileSchema.validateSync(input, {
-    abortEarly: false,
-  });
-}
-
-module.exports = {
-  validateSchemaFile,
-};

package/lib/utils.js

@@ -1,66 +0,0 @@
-const { assert } = require('@someimportantcompany/utils');
-
-/**
- * @param {string} str
- * @param {string|number} split
- * @param {boolean} first
- * @returns {[string, string | undefined]}
- */
-function splitOnIndex(str, split, first = true) {
-  assert(typeof str === 'string', new TypeError('Expected first argument to be a string'));
-  assert(['string', 'number'].includes(typeof split), new TypeError('Expected second argument to be a string or number'));
-  assert(typeof first === 'boolean', new TypeError('Expected third argument to be a boolean'));
-
-  if (typeof split === 'string') {
-    split = first ? str.indexOf(split) : str.lastIndexOf(split);
-  }
-
-  return split >= 0 ? [str.slice(0, split), str.slice(split + 1)] : [str, undefined];
-}
-
-/**
- * @template T
- * @param {() => T} fn
- * @param {*} [err]
- * @returns {T}
-
- * @template T
- * @param {() => Promise<T>} fn
- * @param {*} [err]
- * @returns {Promise<T>}
-
- * @template T
- * @param {(() => T) | (() => Promise<T>)} fn
- * @param {*} [err]
- * @returns {T | Promise<T>}
- */
-function tryCatch(fn, err) {
-  try {
-    const r = fn();
-    // If the function return a Promise-like result
-    if (r instanceof Promise) {
-      // Then wrap the promise to protect against errors
-      return r.catch((e) => {
-        if (typeof err === 'function') {
-          return err(e);
-        } else {
-          throw e;
-        }
-      });
-    } else {
-      // Otherwise, return the raw value returned from the function
-      return r;
-    }
-  } catch (e) {
-    if (typeof err === 'function') {
-      return err(e);
-    } else {
-      throw e;
-    }
-  }
-}
-
-module.exports = {
-  splitOnIndex,
-  tryCatch,
-};

package/steps/run.js

@@ -1,43 +0,0 @@
-const assert = require('http-assert-plus');
-const childProcess = require('child_process');
-const path = require('path');
-
-/**
- * @param {import('../types').ZorbContext} ctx
- * @param {Object} step
- * @param {string} step.run
- * @param {Object} script
- * @returns {number|undefined}
- */
-function runShellStep(ctx, step, script) {
-  assert(typeof step.run === 'string', new TypeError('Expected $.run to be a string'));
-
-  const cwd = typeof step.cwd === 'string' ? path.resolve(ctx.cwd, step.cwd) : ctx.cwd;
-
-  const env = {
-    ...script.env,
-    ...script.defaults?.run?.env,
-    ...step.env,
-  };
-
-  const shell = step.shell ?? script.defaults?.run?.shell ?? undefined;
-
-  return new Promise((resolve, reject) => {
-    ctx.log?.debug({ run: step.run, opts: { cwd, env, shell } });
-
-    const child = childProcess.exec(step.run, { cwd, env, shell });
-
-    child.stdout.setEncoding('utf8');
-    child.stdout.on('data', data => process.stdout.write(data));
-
-    child.stderr.setEncoding('utf8');
-    child.stderr.on('data', data => process.stderr.write(data));
-
-    child.on('close', code => resolve(code ?? undefined));
-    child.on('err', err => reject(err));
-  });
-}
-
-module.exports = {
-  runShellStep,
-};

package/steps/use.js

@@ -1,38 +0,0 @@
-const path = require('path');
-const { assert } = require('@someimportantcompany/utils');
-
-const { tryCatch } = require('../lib/utils');
-
-const actions = new Map();
-
-function loadActionSteps(ctx, usesList) {
-  for (const useName of usesList) {
-    const functionName = path.extname(useName);
-    const fileName = functionName ? useName.substring(0, useName.length - functionName.length) : useName;
-
-    const requireName = tryCatch(() => require.resolve(fileName), () => null)
-      ?? tryCatch(() => require.resolve(path.resolve(ctx.cwd, fileName)), () => null)
-      ?? fileName;
-
-    const mod = require(requireName);
-    const handler = functionName ? mod[functionName] : mod;
-    assert(typeof handler === 'function', new TypeError('Expected handler to be a function'));
-    actions.set(useName, {
-      handler,
-    });
-  }
-
-  ctx.log?.debug({ name: '@zorb/core', use: Array.from(actions.keys()) }, 'Loaded actions');
-}
-
-async function runActionStep(ctx, step) {
-  assert(typeof step.uses === 'string', new TypeError('Expected $.uses to be a string'));
-  const { handler } = actions.get(step.uses) || {};
-  assert(typeof handler === 'function', new Error('Expected use handler to be a function'));
-  return handler(ctx, step.with ?? undefined);
-}
-
-module.exports = {
-  loadActionSteps,
-  runActionStep,
-};

package/types.d.ts

@@ -1,13 +0,0 @@
-export interface ZorbContext {
-  cwd: string,
-  env: Record<string, string | undefined>,
-  log?: Record<'debug' | 'info' | 'warn' | 'error',
-    ((msg: string) => void) |
-    ((args: Record<string, any>, msg: string) => void)>,
-  output: Record<string, any>,
-  // state: Record<string, any>,
-}
-
-export interface ZorbAction {
-  (ctx: ZorbContext, args: Record<string, any>): void | Promise<void>
-}

package/zorb.yml

@@ -1,16 +0,0 @@
-scripts:
-  test:
-    steps:
-      - run: echo "Hello, world!"
-      - uses: '@zorb/aws/s3-sync'
-        with:
-          bucket: mybucket
-          folder: dist/
-      - uses: './test/action/scenario1'
-        with:
-          bucket: mybucket
-          folder: dist/
-          a:
-            b:
-              c:
-                d: true