@panagos/jojoscript 0.7.1 → 0.9.0

package/src/runtime/retry.js

@@ -0,0 +1,67 @@
+import { NonRetryableError } from './errors.js'
+
+/*
+ * Wraps `fn` so calling the returned function retries on failure, up to
+ * `options.attempts` total tries, with an optional fixed or exponential
+ * delay between attempts. Errors marked non-retryable (`NonRetryableError`,
+ * or any error with `error.retryable === false`) are never retried and
+ * propagate immediately.
+ *
+ * Used two ways by compiled pipelines:
+ *  - fused into a preceding `map`/`mapAsync`/`filterAsync`/`tap` stage, so
+ *    each *item* is retried independently: `map(items, retry(fetch, opts))`.
+ *  - standalone, wrapping the whole pipeline expression built so far as a
+ *    zero-argument thunk: `retry(() => (expr), opts)()`.
+ */
+export function retry(fn, options = {}, meta = {}) {
+  const attempts = options.attempts ?? 1
+  const backoff = options.backoff ?? 'fixed'
+  const delayMs = options.delay ?? 0
+
+  return async function retried(...args) {
+    let attempt = 1
+
+    while (true) {
+      try {
+        return await fn(...args)
+      } catch (error) {
+        if (error instanceof NonRetryableError || error?.retryable === false) {
+          annotate(error, meta, attempt)
+          throw error
+        }
+        if (attempt >= attempts) {
+          annotate(error, meta, attempt)
+          throw error
+        }
+
+        const wait = backoff === 'exponential'
+          ? delayMs * 2 ** (attempt - 1)
+          : delayMs
+
+        if (wait > 0) await sleep(wait)
+        attempt++
+      }
+    }
+  }
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+/*
+ * Attaches structured failure context (§16: pipelineId, nodeId, retryCount)
+ * to the error without changing its type/instanceof behavior, so the CLI
+ * (or user code) can report exactly which pipeline node exhausted retries.
+ */
+function annotate(error, meta, retryCount) {
+  if (error && typeof error === 'object') {
+    error.jojo = {
+      pipelineId: meta.pipelineId ?? null,
+      nodeId: meta.id ?? null,
+      operation: 'retry',
+      retryCount,
+      timestamp: new Date().toISOString()
+    }
+  }
+}

package/src/runtime/trace.js

@@ -0,0 +1,66 @@
+import { getCurrentContext, getDefaultContext } from './execution-context.js'
+
+/*
+ * Generic per-node instrumentation used only by `jojo profile` (the
+ * compiler wraps every stage's output with a call to this function when
+ * compiled with `{ profile: true }`). It must be transparent to *type*,
+ * not just to values: eager results (arrays, Maps, Sets, scalars) are
+ * counted and returned completely unchanged, while lazy
+ * generator/async-generator results are wrapped in an equivalent
+ * generator that counts items as they're pulled through — never
+ * materializing anything itself.
+ */
+export function traceNode(value, meta = {}) {
+  const ctx = getCurrentContext() ?? getDefaultContext()
+  const start = process.hrtime.bigint()
+
+  function finish(count) {
+    const durationMs = Number(process.hrtime.bigint() - start) / 1e6
+    ctx.metrics.record(meta.id, meta.type, count, durationMs)
+  }
+
+  const isAsyncGenerator = value != null &&
+    typeof value.next === 'function' &&
+    typeof value[Symbol.asyncIterator] === 'function'
+
+  const isSyncGenerator = !isAsyncGenerator && value != null &&
+    typeof value.next === 'function' &&
+    typeof value[Symbol.iterator] === 'function'
+
+  if (isAsyncGenerator) {
+    return (async function* () {
+      let count = 0
+      try {
+        for await (const item of value) {
+          count++
+          yield item
+        }
+      } finally {
+        finish(count)
+      }
+    })()
+  }
+
+  if (isSyncGenerator) {
+    return (function* () {
+      let count = 0
+      try {
+        for (const item of value) {
+          count++
+          yield item
+        }
+      } finally {
+        finish(count)
+      }
+    })()
+  }
+
+  const count = Array.isArray(value)
+    ? value.length
+    : value instanceof Map || value instanceof Set
+      ? value.size
+      : 1
+
+  finish(count)
+  return value
+}