@schwabyio/gta 0.13.0 → 0.14.0

package/dist/chunks/chunk-KVO46B7X.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+import { createRequire as __gtaCreateRequire } from 'node:module';
+const require = __gtaCreateRequire(import.meta.url);
+import {
+  failureDetails,
+  findCollection,
+  idOf,
+  isDirectory,
+  loadProject,
+  paint,
+  tallyOf
+} from "./chunk-Q3VRXFS5.js";
+import {
+  COLLECTIONS_DIR,
+  canonical,
+  redact,
+  resolveRequestSet,
+  runJob,
+  runSuite,
+  secretValues,
+  stepLabel,
+  stepLines
+} from "./chunk-ZDHGCHIV.js";
+
+// src/library/project.ts
+import path from "node:path";
+var OPTION_OF = { environmentType: "environment" };
+var USE_FILE = ".gta-use.yml";
+var openProject = async (folder, options = {}) => {
+  const root = await canonical(path.resolve(folder));
+  if (!await isDirectory(path.join(root, COLLECTIONS_DIR))) {
+    throw new Error(`${root} is not a Gravity project: it has no ${COLLECTIONS_DIR}/ folder.`);
+  }
+  const project = await loadProject({
+    root,
+    env: process.env,
+    overrides: overridesOf(options),
+    overrideLabel: (key) => `the ${OPTION_OF[key] ?? key} option`,
+    flagValues: options.flags ?? {},
+    optionalSettings: true
+  });
+  return projectOf(project);
+};
+function overridesOf(options) {
+  return {
+    ...options.environment !== void 0 ? { environmentType: options.environment } : {},
+    ...options.bail !== void 0 ? { bail: String(options.bail) } : {},
+    ...options.timeoutCollection !== void 0 ? { timeoutCollection: String(options.timeoutCollection) } : {}
+  };
+}
+function projectOf(project) {
+  const { root, settings } = project;
+  const environment = settings.environmentType;
+  const flags = project.flags.values;
+  return {
+    root,
+    name: project.name,
+    environment,
+    environments: project.environments,
+    flags,
+    collections: project.collections.map(idOf),
+    warnings: project.warnings,
+    async run(name, options = {}) {
+      const collection = findCollection(project.collections, name);
+      if (!collection) throw new Error(noSuchCollection(name, project));
+      checkValues(options.vars, "vars");
+      const steps = options.steps && collection.problems.length === 0 ? pickSteps(collection, options.steps) : null;
+      const { onResult } = options;
+      const file = collection.path;
+      const run = deadline(options.signal, settings.timeoutCollection);
+      const produced = /* @__PURE__ */ new Map();
+      const started = performance.now();
+      const outcome = await runJob(
+        {
+          file,
+          projectRoot: root,
+          environment,
+          steps,
+          bail: options.bail ?? settings.bail,
+          flags,
+          ...options.vars ? { vars: options.vars } : {}
+        },
+        {
+          signal: run.signal,
+          produced,
+          ...onResult ? { onResult: (result, ref) => onResult(result, { file, ...ref }) } : {}
+        }
+      );
+      return outcomeOf({
+        id: idOf(collection),
+        file,
+        stepCount: steps?.length ?? collection.doc.steps.length,
+        outcome,
+        steps: outcome.ok ? outcome.steps.map((ref) => ({ file, ...ref })) : [],
+        produced,
+        stopped: run.stopped(),
+        durationMs: performance.now() - started
+      });
+    },
+    async use(set, params = {}, options = {}) {
+      checkValues(params, "params");
+      checkValues(options.vars, "vars");
+      const found = await resolveRequestSet(root, project.global, set);
+      const collectionPath = path.join(root, COLLECTIONS_DIR, USE_FILE);
+      const collection = { steps: [{ use: set, with: params }] };
+      const context = {
+        collectionPath,
+        environmentName: environment,
+        flags,
+        dataRow: null,
+        collectionVars: null
+      };
+      const secrets = await secretValues(context);
+      const lines = (await stepLines(found.path)).steps;
+      const shown = (result) => {
+        const hidden = redact(result, secrets);
+        return { ...hidden, item: { ...hidden.item, path: found.path } };
+      };
+      const steps = [];
+      const run = deadline(options.signal, settings.timeoutCollection);
+      const produced = /* @__PURE__ */ new Map();
+      const started = performance.now();
+      let outcome;
+      try {
+        const summary = await runSuite({
+          collection,
+          collectionPath,
+          context,
+          bail: options.bail ?? settings.bail,
+          signal: run.signal,
+          produced,
+          ...options.vars ? { vars: options.vars } : {},
+          onResult: (_index, result) => {
+            const child = result.use?.child ?? 0;
+            const ref = { file: found.path, line: lines[child] ?? null, index: child };
+            steps.push(ref);
+            options.onResult?.(shown(result), ref);
+          }
+        });
+        outcome = {
+          ok: true,
+          summary: { ...summary, results: summary.results.map(shown) },
+          steps,
+          data: null
+        };
+      } catch (cause) {
+        outcome = { ok: false, message: cause instanceof Error ? cause.message : String(cause) };
+      }
+      return outcomeOf({
+        id: set,
+        file: found.path,
+        stepCount: found.doc.steps.length,
+        outcome,
+        steps,
+        produced,
+        stopped: run.stopped(),
+        durationMs: performance.now() - started
+      });
+    }
+  };
+}
+function deadline(signal, timeoutMs) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  return {
+    signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+    /** Why the run stopped before it finished, or null when nothing stopped it. */
+    stopped: () => timeout.aborted ? `Timed out after ${timeoutMs} ms (timeoutCollection)` : signal?.aborted ? "The run was cancelled" : null
+  };
+}
+function outcomeOf(run) {
+  const { outcome } = run;
+  const counted = tallyOf(run.id, run.stepCount, outcome, run.durationMs);
+  const tally = run.stopped && outcome.ok ? { ...counted, passed: false, error: run.stopped } : counted;
+  return {
+    passed: tally.passed,
+    id: run.id,
+    file: run.file,
+    error: tally.error,
+    summary: outcome.ok ? outcome.summary : {
+      total: run.stepCount,
+      passed: 0,
+      failed: 0,
+      errored: 0,
+      skipped: run.stepCount,
+      durationMs: run.durationMs,
+      results: []
+    },
+    steps: run.steps,
+    values: Object.fromEntries(run.produced),
+    failures: tally.passed ? "" : failureDetails([tally], paint(false)).join("\n").trimEnd()
+  };
+}
+function pickSteps(collection, selectors) {
+  const id = idOf(collection);
+  const { steps } = collection.doc;
+  if (selectors.length === 0) {
+    throw new Error(`steps is empty: name a step of ${id}, or leave steps out to run them all`);
+  }
+  const picked = /* @__PURE__ */ new Set();
+  for (const selector of selectors) {
+    if (typeof selector === "number") {
+      if (!Number.isInteger(selector) || selector < 1 || selector > steps.length) {
+        throw new Error(`${id} has no step ${selector}: its steps are 1 to ${steps.length}`);
+      }
+      picked.add(selector - 1);
+      continue;
+    }
+    const matching = steps.flatMap((step, index) => stepLabel(step) === selector ? [index] : []);
+    if (matching.length === 0) {
+      const names = steps.map((step) => `"${stepLabel(step)}"`).join(", ");
+      throw new Error(`${id} has no step called "${selector}". Its steps: ${names}`);
+    }
+    for (const index of matching) picked.add(index);
+  }
+  return [...picked].sort((a, b) => a - b);
+}
+function noSuchCollection(name, project) {
+  const ids = project.collections.map(idOf);
+  const folder = project.collections.some((c) => c.directory === name.replace(/\/+$/, ""));
+  const shown = ids.length > 30 ? `${ids.slice(0, 30).join(", ")}, \u2026` : ids.join(", ");
+  return (folder ? `"${name}" is a folder: run its collections one at a time.` : `No collection is called "${name}".`) + (ids.length > 0 ? ` This project has: ${shown}` : ` This project has no collections.`);
+}
+function checkValues(values, what) {
+  for (const [name, value] of Object.entries(values ?? {})) {
+    const kind = typeof value;
+    if (value !== null && kind !== "string" && kind !== "number" && kind !== "boolean") {
+      throw new TypeError(`${what}.${name} must be a string, number, boolean or null`);
+    }
+  }
+}
+
+export {
+  openProject
+};