@workflow/next 5.0.0-beta.36 → 5.0.0-beta.38

package/dist/watch-ignore.js

@@ -0,0 +1,264 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WATCH_IGNORED_PATHS_ENV = exports.BUILTIN_IGNORED_PATH_FRAGMENTS = void 0;
+exports.parseIgnoredPathsEnv = parseIgnoredPathsEnv;
+exports.createWatchIgnorePredicate = createWatchIgnorePredicate;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const ignore_1 = __importDefault(require("ignore"));
+/**
+ * Directory-name fragments that are always excluded from the dev watcher,
+ * regardless of `.gitignore`. Matched as POSIX substrings of the absolute
+ * path (e.g. `/node_modules/` matches any path containing that segment).
+ */
+exports.BUILTIN_IGNORED_PATH_FRAGMENTS = [
+    '/.git/',
+    '/node_modules/',
+    '/.next/',
+    '/.turbo/',
+    '/.vercel/',
+    '/dist/',
+    '/build/',
+    '/out/',
+    '/.cache/',
+    '/.yarn/',
+    '/.pnpm-store/',
+    '/.parcel-cache/',
+    '/.well-known/workflow/',
+];
+/**
+ * Environment variable that lets a project add extra path fragments to the
+ * dev watcher ignore list. Comma-separated; each entry is matched as a POSIX
+ * substring of the absolute path, exactly like {@link BUILTIN_IGNORED_PATH_FRAGMENTS}.
+ * Additive to `.gitignore` and the built-in list. Dev-mode only.
+ */
+exports.WATCH_IGNORED_PATHS_ENV = 'WORKFLOW_DEV_WATCH_IGNORED_PATHS';
+const toPosix = (pathname) => pathname.replace(/\\/g, '/');
+/**
+ * Parse the comma-separated {@link WATCH_IGNORED_PATHS_ENV} value into a list
+ * of POSIX path fragments. Whitespace is trimmed and empty entries dropped.
+ */
+function parseIgnoredPathsEnv(value) {
+    if (!value) {
+        return [];
+    }
+    return value
+        .split(',')
+        .map((entry) => toPosix(entry.trim()))
+        .filter((entry) => entry.length > 0);
+}
+/**
+ * Rebuild a matcher with `dropped` pattern lines removed. Used when a rule
+ * excluded a directory that a deeper `.gitignore` re-included: that rule must
+ * stop applying to the subtree, while every *other* rule in the same file
+ * (e.g. a `*.secret` that still matches a file inside) keeps applying.
+ */
+function matcherWithout(entry, dropped) {
+    if (dropped.size === 0) {
+        return entry.matcher;
+    }
+    const key = [...dropped].sort().join('\n');
+    const cached = entry.filtered.get(key);
+    if (cached) {
+        return cached;
+    }
+    const rebuilt = (0, ignore_1.default)().add(entry.lines.filter((line) => !dropped.has(line.trim())));
+    entry.filtered.set(key, rebuilt);
+    return rebuilt;
+}
+/**
+ * Load `.gitignore` matchers for `workingDir` up to and including
+ * `projectRoot`. In a monorepo the largest ignored trees are typically listed
+ * at the workspace root, and app-level `.gitignore` files are covered too.
+ *
+ * Returned outermost-first (workspace root → app), which is the order git
+ * applies them: a rule in a deeper `.gitignore` overrides a conflicting rule
+ * from a shallower one.
+ *
+ * Nested `.gitignore` files *below* `workingDir` are intentionally not read —
+ * the {@link WATCH_IGNORED_PATHS_ENV} env var backstops anything they'd cover.
+ */
+function loadGitignoreMatchers(workingDir, projectRoot) {
+    const matchers = [];
+    const stopAt = toPosix(projectRoot);
+    let current = toPosix(workingDir);
+    while (true) {
+        let content;
+        try {
+            content = (0, node_fs_1.readFileSync)(node_path_1.posix.join(current, '.gitignore'), 'utf-8');
+        }
+        catch {
+            content = undefined;
+        }
+        if (content) {
+            const lines = content.split('\n');
+            matchers.push({
+                dir: current,
+                matcher: (0, ignore_1.default)().add(content),
+                lines,
+                hasNegation: lines.some((line) => line.trim().startsWith('!')),
+                filtered: new Map(),
+            });
+        }
+        if (current === stopAt) {
+            break;
+        }
+        const parent = (0, node_path_1.dirname)(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    // Collected innermost-first while walking up; git precedence is
+    // outermost-first, with deeper files winning.
+    return matchers.reverse();
+}
+/**
+ * Build the dev-watcher ignore predicate. The returned function receives a
+ * POSIX-normalized absolute path and returns `true` when that path should be
+ * pruned from both the initial directory walk and the chokidar watch set.
+ *
+ * A path is ignored when it matches any of:
+ * - a built-in fragment ({@link BUILTIN_IGNORED_PATH_FRAGMENTS}) or caller
+ *   `extraFragments` (POSIX substring match),
+ * - a {@link WATCH_IGNORED_PATHS_ENV} fragment (POSIX substring match),
+ * - a `.gitignore` rule from `workingDir` up to `projectRoot`.
+ *
+ * Matchers are built once here; the returned predicate is hot (called per path
+ * during traversal and per chokidar event) and does no I/O.
+ */
+function createWatchIgnorePredicate(options) {
+    const projectRoot = options.projectRoot ?? options.workingDir;
+    const envIgnoredPaths = options.envIgnoredPaths ?? process.env[exports.WATCH_IGNORED_PATHS_ENV];
+    const fragments = [
+        ...exports.BUILTIN_IGNORED_PATH_FRAGMENTS,
+        ...(options.extraFragments ?? []).map(toPosix),
+        ...parseIgnoredPathsEnv(envIgnoredPaths),
+    ];
+    const gitignoreMatchers = loadGitignoreMatchers(options.workingDir, projectRoot);
+    // Re-inclusion is only possible when some file has a `!` rule. Without one,
+    // the cheap flat scan below is equivalent to the full per-directory walk.
+    const anyNegation = gitignoreMatchers.some((entry) => entry.hasNegation);
+    const outermostDir = gitignoreMatchers[0]?.dir;
+    /** Test one path against one matcher, as both a file and a directory node. */
+    const testEntry = (entry, rel, dropped) => {
+        const matcher = dropped ? matcherWithout(entry, dropped) : entry.matcher;
+        // Test the trailing-slash form too so a directory node itself matches a
+        // `dir/` gitignore rule (not just its children) — this lets the walk and
+        // chokidar prune the directory instead of descending into it.
+        const asFile = matcher.test(rel);
+        const asDir = matcher.test(`${rel}/`);
+        if (asFile.ignored) {
+            return { ignored: true, pattern: asFile.rule?.pattern };
+        }
+        if (asDir.ignored) {
+            return { ignored: true, pattern: asDir.rule?.pattern };
+        }
+        if (asFile.unignored || asDir.unignored) {
+            return { ignored: false, pattern: undefined };
+        }
+        return undefined;
+    };
+    /**
+     * Resolve one path level against every applicable `.gitignore`, deepest file
+     * last so it wins. Returns the level's verdict plus the rules that voted to
+     * exclude it, which the caller neutralizes if the level is re-included.
+     */
+    const decideLevel = (prefix, neutralized) => {
+        let decision;
+        let excludedBy = [];
+        for (let index = 0; index < gitignoreMatchers.length; index++) {
+            const entry = gitignoreMatchers[index];
+            const rel = node_path_1.posix.relative(entry.dir, prefix);
+            // Empty means the path *is* the gitignore dir; a `..` prefix means it is
+            // outside. `ignore` only accepts relative, in-tree paths.
+            if (rel === '' || rel === '..' || rel.startsWith('../')) {
+                continue;
+            }
+            const result = testEntry(entry, rel, neutralized.get(index));
+            if (!result) {
+                continue;
+            }
+            if (!result.ignored) {
+                decision = false;
+                continue;
+            }
+            if (decision !== true) {
+                excludedBy = [];
+            }
+            decision = true;
+            if (result.pattern) {
+                excludedBy.push({ index, pattern: result.pattern });
+            }
+        }
+        return { decision, excludedBy };
+    };
+    /**
+     * Walk the path one directory segment at a time, the way git does. At each
+     * level the deepest `.gitignore` with an opinion wins; if that verdict is
+     * "ignored" git stops descending, so we can return immediately.
+     *
+     * When a level is re-included after a shallower file excluded it, the rule
+     * that did the excluding is neutralized for the rest of the walk. That is
+     * what lets root `generated/` + app `!generated/` watch `app/generated/x.ts`
+     * while a sibling root rule such as `*.secret` still excludes
+     * `app/generated/a.secret`.
+     */
+    const walkGitignore = (normalizedPath) => {
+        if (!outermostDir) {
+            return false;
+        }
+        const relToBase = node_path_1.posix.relative(outermostDir, normalizedPath);
+        if (relToBase === '' || relToBase === '..' || relToBase.startsWith('../')) {
+            return false;
+        }
+        const neutralized = new Map();
+        let prefix = outermostDir;
+        for (const segment of relToBase.split('/')) {
+            prefix = `${prefix}/${segment}`;
+            const { decision, excludedBy } = decideLevel(prefix, neutralized);
+            if (decision === true) {
+                // Git does not descend into an excluded directory.
+                return true;
+            }
+            if (decision === false) {
+                // This level was re-included; the rules that excluded it must not
+                // resurrect for anything beneath it.
+                for (const { index, pattern } of excludedBy) {
+                    const dropped = neutralized.get(index) ?? new Set();
+                    dropped.add(pattern);
+                    neutralized.set(index, dropped);
+                }
+            }
+        }
+        return false;
+    };
+    return (normalizedPath) => {
+        // Built-in and env-var fragments are hard excludes: they are deliberately
+        // not subject to gitignore negation, so a stray `!` rule cannot drag
+        // `node_modules` or the generated directory back into the watch set.
+        for (const fragment of fragments) {
+            if (normalizedPath.includes(fragment)) {
+                return true;
+            }
+        }
+        if (!anyNegation) {
+            // Fast path: no re-inclusion anywhere, so the first match decides.
+            for (const entry of gitignoreMatchers) {
+                const rel = node_path_1.posix.relative(entry.dir, normalizedPath);
+                if (rel === '' || rel === '..' || rel.startsWith('../')) {
+                    continue;
+                }
+                if (entry.matcher.ignores(rel) || entry.matcher.ignores(`${rel}/`)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        return walkGitignore(normalizedPath);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"watch-ignore.js","sourceRoot":"","sources":["../src/watch-ignore.ts"],"names":[],"mappings":"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","sourcesContent":["import { readFileSync } from 'node:fs';\nimport { dirname, posix } from 'node:path';\nimport ignore, { type Ignore } from 'ignore';\n\n/**\n * Directory-name fragments that are always excluded from the dev watcher,\n * regardless of `.gitignore`. Matched as POSIX substrings of the absolute\n * path (e.g. `/node_modules/` matches any path containing that segment).\n */\nexport const BUILTIN_IGNORED_PATH_FRAGMENTS: readonly string[] = [\n  '/.git/',\n  '/node_modules/',\n  '/.next/',\n  '/.turbo/',\n  '/.vercel/',\n  '/dist/',\n  '/build/',\n  '/out/',\n  '/.cache/',\n  '/.yarn/',\n  '/.pnpm-store/',\n  '/.parcel-cache/',\n  '/.well-known/workflow/',\n];\n\n/**\n * Environment variable that lets a project add extra path fragments to the\n * dev watcher ignore list. Comma-separated; each entry is matched as a POSIX\n * substring of the absolute path, exactly like {@link BUILTIN_IGNORED_PATH_FRAGMENTS}.\n * Additive to `.gitignore` and the built-in list. Dev-mode only.\n */\nexport const WATCH_IGNORED_PATHS_ENV = 'WORKFLOW_DEV_WATCH_IGNORED_PATHS';\n\nconst toPosix = (pathname: string) => pathname.replace(/\\\\/g, '/');\n\n/**\n * Parse the comma-separated {@link WATCH_IGNORED_PATHS_ENV} value into a list\n * of POSIX path fragments. Whitespace is trimmed and empty entries dropped.\n */\nexport function parseIgnoredPathsEnv(value: string | undefined): string[] {\n  if (!value) {\n    return [];\n  }\n  return value\n    .split(',')\n    .map((entry) => toPosix(entry.trim()))\n    .filter((entry) => entry.length > 0);\n}\n\ninterface GitignoreMatcher {\n  /** POSIX absolute directory the `.gitignore` lives in (no trailing slash). */\n  dir: string;\n  matcher: Ignore;\n  /** Raw pattern lines, used to rebuild the matcher without a neutralized rule. */\n  lines: string[];\n  /** Whether this file contains any `!` re-inclusion rule. */\n  hasNegation: boolean;\n  /** Matchers rebuilt with some rules dropped, keyed by the dropped set. */\n  filtered: Map<string, Ignore>;\n}\n\n/**\n * Rebuild a matcher with `dropped` pattern lines removed. Used when a rule\n * excluded a directory that a deeper `.gitignore` re-included: that rule must\n * stop applying to the subtree, while every *other* rule in the same file\n * (e.g. a `*.secret` that still matches a file inside) keeps applying.\n */\nfunction matcherWithout(entry: GitignoreMatcher, dropped: Set<string>): Ignore {\n  if (dropped.size === 0) {\n    return entry.matcher;\n  }\n  const key = [...dropped].sort().join('\\n');\n  const cached = entry.filtered.get(key);\n  if (cached) {\n    return cached;\n  }\n  const rebuilt = ignore().add(\n    entry.lines.filter((line) => !dropped.has(line.trim()))\n  );\n  entry.filtered.set(key, rebuilt);\n  return rebuilt;\n}\n\n/**\n * Load `.gitignore` matchers for `workingDir` up to and including\n * `projectRoot`. In a monorepo the largest ignored trees are typically listed\n * at the workspace root, and app-level `.gitignore` files are covered too.\n *\n * Returned outermost-first (workspace root → app), which is the order git\n * applies them: a rule in a deeper `.gitignore` overrides a conflicting rule\n * from a shallower one.\n *\n * Nested `.gitignore` files *below* `workingDir` are intentionally not read —\n * the {@link WATCH_IGNORED_PATHS_ENV} env var backstops anything they'd cover.\n */\nfunction loadGitignoreMatchers(\n  workingDir: string,\n  projectRoot: string\n): GitignoreMatcher[] {\n  const matchers: GitignoreMatcher[] = [];\n  const stopAt = toPosix(projectRoot);\n\n  let current = toPosix(workingDir);\n  while (true) {\n    let content: string | undefined;\n    try {\n      content = readFileSync(posix.join(current, '.gitignore'), 'utf-8');\n    } catch {\n      content = undefined;\n    }\n    if (content) {\n      const lines = content.split('\\n');\n      matchers.push({\n        dir: current,\n        matcher: ignore().add(content),\n        lines,\n        hasNegation: lines.some((line) => line.trim().startsWith('!')),\n        filtered: new Map(),\n      });\n    }\n\n    if (current === stopAt) {\n      break;\n    }\n    const parent = dirname(current);\n    if (parent === current) {\n      break;\n    }\n    current = parent;\n  }\n\n  // Collected innermost-first while walking up; git precedence is\n  // outermost-first, with deeper files winning.\n  return matchers.reverse();\n}\n\nexport interface WatchIgnoreOptions {\n  /** Absolute path of the app directory being built. */\n  workingDir: string;\n  /** Absolute path of the workspace/project root. Defaults to `workingDir`. */\n  projectRoot?: string;\n  /**\n   * Extra POSIX substring fragments to ignore, in addition to the built-in\n   * list and the {@link WATCH_IGNORED_PATHS_ENV} env var. Used by the caller\n   * for build-time paths such as the generated workflow directory.\n   */\n  extraFragments?: string[];\n  /**\n   * Override for the {@link WATCH_IGNORED_PATHS_ENV} env var. Primarily for\n   * testing; defaults to `process.env[WATCH_IGNORED_PATHS_ENV]`.\n   */\n  envIgnoredPaths?: string;\n}\n\n/**\n * Build the dev-watcher ignore predicate. The returned function receives a\n * POSIX-normalized absolute path and returns `true` when that path should be\n * pruned from both the initial directory walk and the chokidar watch set.\n *\n * A path is ignored when it matches any of:\n * - a built-in fragment ({@link BUILTIN_IGNORED_PATH_FRAGMENTS}) or caller\n *   `extraFragments` (POSIX substring match),\n * - a {@link WATCH_IGNORED_PATHS_ENV} fragment (POSIX substring match),\n * - a `.gitignore` rule from `workingDir` up to `projectRoot`.\n *\n * Matchers are built once here; the returned predicate is hot (called per path\n * during traversal and per chokidar event) and does no I/O.\n */\nexport function createWatchIgnorePredicate(\n  options: WatchIgnoreOptions\n): (normalizedPath: string) => boolean {\n  const projectRoot = options.projectRoot ?? options.workingDir;\n  const envIgnoredPaths =\n    options.envIgnoredPaths ?? process.env[WATCH_IGNORED_PATHS_ENV];\n\n  const fragments = [\n    ...BUILTIN_IGNORED_PATH_FRAGMENTS,\n    ...(options.extraFragments ?? []).map(toPosix),\n    ...parseIgnoredPathsEnv(envIgnoredPaths),\n  ];\n\n  const gitignoreMatchers = loadGitignoreMatchers(\n    options.workingDir,\n    projectRoot\n  );\n  // Re-inclusion is only possible when some file has a `!` rule. Without one,\n  // the cheap flat scan below is equivalent to the full per-directory walk.\n  const anyNegation = gitignoreMatchers.some((entry) => entry.hasNegation);\n  const outermostDir = gitignoreMatchers[0]?.dir;\n\n  /** Test one path against one matcher, as both a file and a directory node. */\n  const testEntry = (\n    entry: GitignoreMatcher,\n    rel: string,\n    dropped: Set<string> | undefined\n  ) => {\n    const matcher = dropped ? matcherWithout(entry, dropped) : entry.matcher;\n    // Test the trailing-slash form too so a directory node itself matches a\n    // `dir/` gitignore rule (not just its children) — this lets the walk and\n    // chokidar prune the directory instead of descending into it.\n    const asFile = matcher.test(rel);\n    const asDir = matcher.test(`${rel}/`);\n    if (asFile.ignored) {\n      return { ignored: true, pattern: asFile.rule?.pattern };\n    }\n    if (asDir.ignored) {\n      return { ignored: true, pattern: asDir.rule?.pattern };\n    }\n    if (asFile.unignored || asDir.unignored) {\n      return { ignored: false, pattern: undefined };\n    }\n    return undefined;\n  };\n\n  /**\n   * Resolve one path level against every applicable `.gitignore`, deepest file\n   * last so it wins. Returns the level's verdict plus the rules that voted to\n   * exclude it, which the caller neutralizes if the level is re-included.\n   */\n  const decideLevel = (\n    prefix: string,\n    neutralized: Map<number, Set<string>>\n  ) => {\n    let decision: boolean | undefined;\n    let excludedBy: Array<{ index: number; pattern: string }> = [];\n\n    for (let index = 0; index < gitignoreMatchers.length; index++) {\n      const entry = gitignoreMatchers[index];\n      const rel = posix.relative(entry.dir, prefix);\n      // Empty means the path *is* the gitignore dir; a `..` prefix means it is\n      // outside. `ignore` only accepts relative, in-tree paths.\n      if (rel === '' || rel === '..' || rel.startsWith('../')) {\n        continue;\n      }\n      const result = testEntry(entry, rel, neutralized.get(index));\n      if (!result) {\n        continue;\n      }\n      if (!result.ignored) {\n        decision = false;\n        continue;\n      }\n      if (decision !== true) {\n        excludedBy = [];\n      }\n      decision = true;\n      if (result.pattern) {\n        excludedBy.push({ index, pattern: result.pattern });\n      }\n    }\n\n    return { decision, excludedBy };\n  };\n\n  /**\n   * Walk the path one directory segment at a time, the way git does. At each\n   * level the deepest `.gitignore` with an opinion wins; if that verdict is\n   * \"ignored\" git stops descending, so we can return immediately.\n   *\n   * When a level is re-included after a shallower file excluded it, the rule\n   * that did the excluding is neutralized for the rest of the walk. That is\n   * what lets root `generated/` + app `!generated/` watch `app/generated/x.ts`\n   * while a sibling root rule such as `*.secret` still excludes\n   * `app/generated/a.secret`.\n   */\n  const walkGitignore = (normalizedPath: string): boolean => {\n    if (!outermostDir) {\n      return false;\n    }\n    const relToBase = posix.relative(outermostDir, normalizedPath);\n    if (relToBase === '' || relToBase === '..' || relToBase.startsWith('../')) {\n      return false;\n    }\n\n    const neutralized = new Map<number, Set<string>>();\n    let prefix = outermostDir;\n\n    for (const segment of relToBase.split('/')) {\n      prefix = `${prefix}/${segment}`;\n      const { decision, excludedBy } = decideLevel(prefix, neutralized);\n\n      if (decision === true) {\n        // Git does not descend into an excluded directory.\n        return true;\n      }\n      if (decision === false) {\n        // This level was re-included; the rules that excluded it must not\n        // resurrect for anything beneath it.\n        for (const { index, pattern } of excludedBy) {\n          const dropped = neutralized.get(index) ?? new Set<string>();\n          dropped.add(pattern);\n          neutralized.set(index, dropped);\n        }\n      }\n    }\n\n    return false;\n  };\n\n  return (normalizedPath: string): boolean => {\n    // Built-in and env-var fragments are hard excludes: they are deliberately\n    // not subject to gitignore negation, so a stray `!` rule cannot drag\n    // `node_modules` or the generated directory back into the watch set.\n    for (const fragment of fragments) {\n      if (normalizedPath.includes(fragment)) {\n        return true;\n      }\n    }\n\n    if (!anyNegation) {\n      // Fast path: no re-inclusion anywhere, so the first match decides.\n      for (const entry of gitignoreMatchers) {\n        const rel = posix.relative(entry.dir, normalizedPath);\n        if (rel === '' || rel === '..' || rel.startsWith('../')) {\n          continue;\n        }\n        if (entry.matcher.ignores(rel) || entry.matcher.ignores(`${rel}/`)) {\n          return true;\n        }\n      }\n      return false;\n    }\n\n    return walkGitignore(normalizedPath);\n  };\n}\n"]}

package/docs/next.mdx

@@ -192,7 +192,7 @@ async function sendOnboardingEmail(user: { id: string; email: string}) {
 
 Taking a look at this code:
 
-* Business logic lives inside **steps**. When a step is invoked inside a **workflow**, it gets enqueued to run on a separate request while the workflow is suspended, just like `sleep`.
+* Business logic lives inside **steps**. When a workflow invokes a step, the workflow suspends while the step runs with full Node.js access. The combined handler may execute it inline; queued retries and continuations return through the same flow route.
 * If a step throws an error, like in `sendWelcomeEmail`, the step will automatically be retried until it succeeds (or hits the step's max retry count).
 * Steps can throw a `FatalError` if an error is intentional and should not be retried.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow/next",
-  "version": "5.0.0-beta.36",
+  "version": "5.0.0-beta.38",
   "description": "Next.js integration for Workflow SDK",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -28,15 +28,16 @@
   "dependencies": {
     "@swc/core": "1.15.3",
     "chokidar": "4.0.3",
+    "ignore": "7.0.5",
     "semver": "7.7.4",
-    "@workflow/builders": "5.0.0-beta.36",
-    "@workflow/core": "5.0.0-beta.36",
+    "@workflow/builders": "5.0.0-beta.38",
+    "@workflow/core": "5.0.0-beta.38",
     "@workflow/swc-plugin": "5.0.0-beta.5"
   },
   "devDependencies": {
     "@types/node": "22.19.0",
     "@types/semver": "7.7.1",
-    "next": "16.2.10",
+    "next": "16.2.11",
     "typescript": "^6.0.3",
     "vitest": "^4.1.10",
     "@workflow/tsconfig": "5.0.0-beta.0"