@workflow/builders 5.0.0-beta.42 → 5.0.0-beta.44

package/dist/write-if-changed.test.js

@@ -0,0 +1,186 @@
+import { chmodSync, mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { BaseBuilder } from './base-builder.js';
+import { hasSameContent, writeFileIfChanged } from './write-if-changed.js';
+// Resolve symlinks in tmpdir to avoid macOS /var -> /private/var issues
+const realTmpdir = realpathSync(tmpdir());
+/** Minimal subclass exposing the protected `writeGeneratedFile()`. */
+class TestBuilder extends BaseBuilder {
+    async build() {
+        // no-op
+    }
+    writeGeneratedFile(targetPath, content) {
+        return super.writeGeneratedFile(targetPath, content);
+    }
+}
+/**
+ * Stands in for a target whose consumers use the mtime of a generated file as
+ * a change signal, such as the Nitro dev handler.
+ */
+class OptedOutBuilder extends TestBuilder {
+    get skipsUnchangedGeneratedWrites() {
+        return false;
+    }
+}
+function makeConfig(workingDir) {
+    return {
+        buildTarget: 'standalone',
+        workingDir,
+        dirs: [workingDir],
+        stepsBundlePath: join(workingDir, 'steps.js'),
+        workflowsBundlePath: join(workingDir, 'workflows.js'),
+        webhookBundlePath: join(workingDir, 'webhook.js'),
+    };
+}
+function createBuilder(workingDir) {
+    return new TestBuilder(makeConfig(workingDir));
+}
+function createOptedOutBuilder(workingDir) {
+    return new OptedOutBuilder(makeConfig(workingDir));
+}
+/**
+ * mtime resolution varies by filesystem, so compare the full stat identity
+ * (mtime in ns plus inode) rather than trusting a millisecond timestamp.
+ * `writeGeneratedFile` renames over the target, which changes the inode even
+ * when the mtime happens to land in the same tick.
+ */
+function fileIdentity(path) {
+    const s = statSync(path, { bigint: true });
+    return `${s.mtimeNs}:${s.ino}`;
+}
+let testRoot;
+beforeEach(() => {
+    testRoot = mkdtempSync(join(realTmpdir, 'write-if-changed-'));
+});
+afterEach(() => {
+    rmSync(testRoot, { recursive: true, force: true });
+});
+describe('hasSameContent', () => {
+    it('is false when the file does not exist', async () => {
+        await expect(hasSameContent(join(testRoot, 'missing.js'), 'hello')).resolves.toBe(false);
+    });
+    it('is true for byte-identical content', async () => {
+        const target = join(testRoot, 'a.js');
+        writeFileSync(target, 'export const a = 1;\n');
+        await expect(hasSameContent(target, 'export const a = 1;\n')).resolves.toBe(true);
+    });
+    it('is false when content differs at the same byte length', async () => {
+        const target = join(testRoot, 'a.js');
+        writeFileSync(target, 'aaaa');
+        await expect(hasSameContent(target, 'aaab')).resolves.toBe(false);
+    });
+    it('is false when only the length differs', async () => {
+        const target = join(testRoot, 'a.js');
+        writeFileSync(target, 'aaaa');
+        await expect(hasSameContent(target, 'aaaaa')).resolves.toBe(false);
+    });
+    it('compares utf-8 byte length, not code units', async () => {
+        const target = join(testRoot, 'a.js');
+        writeFileSync(target, '// é\u{1f600}\n', 'utf-8');
+        await expect(hasSameContent(target, '// é\u{1f600}\n')).resolves.toBe(true);
+    });
+    it('is false for byte-different content that decodes to the same string', async () => {
+        // An unpaired surrogate and U+FFFD both decode to the replacement
+        // character, so a utf-8 string comparison would call these equal.
+        const target = join(testRoot, 'a.js');
+        writeFileSync(target, Buffer.from([0x61, 0xf0, 0x90, 0x80]));
+        await expect(hasSameContent(target, Buffer.from([0x61, 0xef, 0xbf, 0xbd]).toString())).resolves.toBe(false);
+    });
+    it('is false when the path is a directory', async () => {
+        // Match the directory's own reported size so the check cannot pass by
+        // short-circuiting on length before it ever tries to read.
+        const sameSizeAsDir = 'x'.repeat(statSync(testRoot).size);
+        await expect(hasSameContent(testRoot, sameSizeAsDir)).resolves.toBe(false);
+    });
+    it('is false when the file cannot be read', async () => {
+        const target = join(testRoot, 'locked.js');
+        writeFileSync(target, 'secret');
+        chmodSync(target, 0o000);
+        try {
+            // Root ignores the mode bits, so only assert when the read really fails.
+            let readable = true;
+            try {
+                readFileSync(target, 'utf8');
+            }
+            catch {
+                readable = false;
+            }
+            if (readable) {
+                return;
+            }
+            await expect(hasSameContent(target, 'secret')).resolves.toBe(false);
+        }
+        finally {
+            chmodSync(target, 0o600);
+        }
+    });
+});
+describe('writeFileIfChanged', () => {
+    it('creates the file when it does not exist', async () => {
+        const target = join(testRoot, 'a.js');
+        await expect(writeFileIfChanged(target, 'hello')).resolves.toBe(true);
+        expect(readFileSync(target, 'utf8')).toBe('hello');
+    });
+    it('does not touch the file when content is unchanged', async () => {
+        const target = join(testRoot, 'a.js');
+        await writeFileIfChanged(target, 'hello');
+        const before = fileIdentity(target);
+        await expect(writeFileIfChanged(target, 'hello')).resolves.toBe(false);
+        expect(fileIdentity(target)).toBe(before);
+    });
+    it('rewrites the file when content changes', async () => {
+        const target = join(testRoot, 'a.js');
+        await writeFileIfChanged(target, 'hello');
+        await expect(writeFileIfChanged(target, 'goodbye')).resolves.toBe(true);
+        expect(readFileSync(target, 'utf8')).toBe('goodbye');
+    });
+});
+describe('writeGeneratedFile', () => {
+    // Regression test for the dev watcher thrash: the generated routes live
+    // inside the app directory the dev server watches, so a rewrite with
+    // identical bytes still invalidates the bundler and forces a recompile.
+    it('leaves the file untouched when the generated output is unchanged', async () => {
+        const builder = createBuilder(testRoot);
+        const target = join(testRoot, 'route.js');
+        await builder.writeGeneratedFile(target, 'export const GET = () => {};');
+        const before = fileIdentity(target);
+        await builder.writeGeneratedFile(target, 'export const GET = () => {};');
+        expect(fileIdentity(target)).toBe(before);
+    });
+    it('leaves no temp files behind when the write is skipped', async () => {
+        const builder = createBuilder(testRoot);
+        const target = join(testRoot, 'route.js');
+        await builder.writeGeneratedFile(target, 'same');
+        await builder.writeGeneratedFile(target, 'same');
+        expect(readdirSync(testRoot).filter((f) => f.endsWith('.tmp'))).toEqual([]);
+    });
+    it('still writes when the generated output changes', async () => {
+        const builder = createBuilder(testRoot);
+        const target = join(testRoot, 'route.js');
+        await builder.writeGeneratedFile(target, 'v1');
+        await builder.writeGeneratedFile(target, 'v2');
+        expect(readFileSync(target, 'utf8')).toBe('v2');
+    });
+    it('creates the file on first write', async () => {
+        const builder = createBuilder(testRoot);
+        const target = join(testRoot, 'route.js');
+        await builder.writeGeneratedFile(target, 'first');
+        expect(readFileSync(target, 'utf8')).toBe('first');
+    });
+    // The Nitro dev handler cache-busts its import of `steps.mjs` off the mtime
+    // of `workflows.mjs`, so that target opts out: skipping the redundant write
+    // would freeze the version key and serve stale step code. See
+    // `packages/nitro/src/builders.ts`.
+    it('still rewrites unchanged output when the target opts out', async () => {
+        const builder = createOptedOutBuilder(testRoot);
+        const target = join(testRoot, 'workflows.mjs');
+        await builder.writeGeneratedFile(target, 'export const a = 1;');
+        const before = fileIdentity(target);
+        await builder.writeGeneratedFile(target, 'export const a = 1;');
+        expect(fileIdentity(target)).not.toBe(before);
+        expect(readFileSync(target, 'utf8')).toBe('export const a = 1;');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"write-if-changed.test.js","sourceRoot":"","sources":["../src/write-if-changed.test.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  chmodSync,\n  mkdtempSync,\n  readdirSync,\n  readFileSync,\n  realpathSync,\n  rmSync,\n  statSync,\n  writeFileSync,\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport { afterEach, beforeEach, describe, expect, it } from 'vitest';\nimport { BaseBuilder } from './base-builder.js';\nimport type { StandaloneConfig } from './types.js';\nimport { hasSameContent, writeFileIfChanged } from './write-if-changed.js';\n\n// Resolve symlinks in tmpdir to avoid macOS /var -> /private/var issues\nconst realTmpdir = realpathSync(tmpdir());\n\n/** Minimal subclass exposing the protected `writeGeneratedFile()`. */\nclass TestBuilder extends BaseBuilder {\n  async build(): Promise<void> {\n    // no-op\n  }\n\n  public writeGeneratedFile(\n    targetPath: string,\n    content: string\n  ): Promise<void> {\n    return super.writeGeneratedFile(targetPath, content);\n  }\n}\n\n/**\n * Stands in for a target whose consumers use the mtime of a generated file as\n * a change signal, such as the Nitro dev handler.\n */\nclass OptedOutBuilder extends TestBuilder {\n  protected override get skipsUnchangedGeneratedWrites(): boolean {\n    return false;\n  }\n}\n\nfunction makeConfig(workingDir: string): StandaloneConfig {\n  return {\n    buildTarget: 'standalone',\n    workingDir,\n    dirs: [workingDir],\n    stepsBundlePath: join(workingDir, 'steps.js'),\n    workflowsBundlePath: join(workingDir, 'workflows.js'),\n    webhookBundlePath: join(workingDir, 'webhook.js'),\n  };\n}\n\nfunction createBuilder(workingDir: string): TestBuilder {\n  return new TestBuilder(makeConfig(workingDir));\n}\n\nfunction createOptedOutBuilder(workingDir: string): OptedOutBuilder {\n  return new OptedOutBuilder(makeConfig(workingDir));\n}\n\n/**\n * mtime resolution varies by filesystem, so compare the full stat identity\n * (mtime in ns plus inode) rather than trusting a millisecond timestamp.\n * `writeGeneratedFile` renames over the target, which changes the inode even\n * when the mtime happens to land in the same tick.\n */\nfunction fileIdentity(path: string): string {\n  const s = statSync(path, { bigint: true });\n  return `${s.mtimeNs}:${s.ino}`;\n}\n\nlet testRoot: string;\n\nbeforeEach(() => {\n  testRoot = mkdtempSync(join(realTmpdir, 'write-if-changed-'));\n});\n\nafterEach(() => {\n  rmSync(testRoot, { recursive: true, force: true });\n});\n\ndescribe('hasSameContent', () => {\n  it('is false when the file does not exist', async () => {\n    await expect(\n      hasSameContent(join(testRoot, 'missing.js'), 'hello')\n    ).resolves.toBe(false);\n  });\n\n  it('is true for byte-identical content', async () => {\n    const target = join(testRoot, 'a.js');\n    writeFileSync(target, 'export const a = 1;\\n');\n\n    await expect(hasSameContent(target, 'export const a = 1;\\n')).resolves.toBe(\n      true\n    );\n  });\n\n  it('is false when content differs at the same byte length', async () => {\n    const target = join(testRoot, 'a.js');\n    writeFileSync(target, 'aaaa');\n\n    await expect(hasSameContent(target, 'aaab')).resolves.toBe(false);\n  });\n\n  it('is false when only the length differs', async () => {\n    const target = join(testRoot, 'a.js');\n    writeFileSync(target, 'aaaa');\n\n    await expect(hasSameContent(target, 'aaaaa')).resolves.toBe(false);\n  });\n\n  it('compares utf-8 byte length, not code units', async () => {\n    const target = join(testRoot, 'a.js');\n    writeFileSync(target, '// é\\u{1f600}\\n', 'utf-8');\n\n    await expect(hasSameContent(target, '// é\\u{1f600}\\n')).resolves.toBe(true);\n  });\n\n  it('is false for byte-different content that decodes to the same string', async () => {\n    // An unpaired surrogate and U+FFFD both decode to the replacement\n    // character, so a utf-8 string comparison would call these equal.\n    const target = join(testRoot, 'a.js');\n    writeFileSync(target, Buffer.from([0x61, 0xf0, 0x90, 0x80]));\n\n    await expect(\n      hasSameContent(target, Buffer.from([0x61, 0xef, 0xbf, 0xbd]).toString())\n    ).resolves.toBe(false);\n  });\n\n  it('is false when the path is a directory', async () => {\n    // Match the directory's own reported size so the check cannot pass by\n    // short-circuiting on length before it ever tries to read.\n    const sameSizeAsDir = 'x'.repeat(statSync(testRoot).size);\n\n    await expect(hasSameContent(testRoot, sameSizeAsDir)).resolves.toBe(false);\n  });\n\n  it('is false when the file cannot be read', async () => {\n    const target = join(testRoot, 'locked.js');\n    writeFileSync(target, 'secret');\n    chmodSync(target, 0o000);\n\n    try {\n      // Root ignores the mode bits, so only assert when the read really fails.\n      let readable = true;\n      try {\n        readFileSync(target, 'utf8');\n      } catch {\n        readable = false;\n      }\n      if (readable) {\n        return;\n      }\n      await expect(hasSameContent(target, 'secret')).resolves.toBe(false);\n    } finally {\n      chmodSync(target, 0o600);\n    }\n  });\n});\n\ndescribe('writeFileIfChanged', () => {\n  it('creates the file when it does not exist', async () => {\n    const target = join(testRoot, 'a.js');\n\n    await expect(writeFileIfChanged(target, 'hello')).resolves.toBe(true);\n    expect(readFileSync(target, 'utf8')).toBe('hello');\n  });\n\n  it('does not touch the file when content is unchanged', async () => {\n    const target = join(testRoot, 'a.js');\n    await writeFileIfChanged(target, 'hello');\n    const before = fileIdentity(target);\n\n    await expect(writeFileIfChanged(target, 'hello')).resolves.toBe(false);\n\n    expect(fileIdentity(target)).toBe(before);\n  });\n\n  it('rewrites the file when content changes', async () => {\n    const target = join(testRoot, 'a.js');\n    await writeFileIfChanged(target, 'hello');\n\n    await expect(writeFileIfChanged(target, 'goodbye')).resolves.toBe(true);\n    expect(readFileSync(target, 'utf8')).toBe('goodbye');\n  });\n});\n\ndescribe('writeGeneratedFile', () => {\n  // Regression test for the dev watcher thrash: the generated routes live\n  // inside the app directory the dev server watches, so a rewrite with\n  // identical bytes still invalidates the bundler and forces a recompile.\n  it('leaves the file untouched when the generated output is unchanged', async () => {\n    const builder = createBuilder(testRoot);\n    const target = join(testRoot, 'route.js');\n\n    await builder.writeGeneratedFile(target, 'export const GET = () => {};');\n    const before = fileIdentity(target);\n\n    await builder.writeGeneratedFile(target, 'export const GET = () => {};');\n\n    expect(fileIdentity(target)).toBe(before);\n  });\n\n  it('leaves no temp files behind when the write is skipped', async () => {\n    const builder = createBuilder(testRoot);\n    const target = join(testRoot, 'route.js');\n\n    await builder.writeGeneratedFile(target, 'same');\n    await builder.writeGeneratedFile(target, 'same');\n\n    expect(readdirSync(testRoot).filter((f) => f.endsWith('.tmp'))).toEqual([]);\n  });\n\n  it('still writes when the generated output changes', async () => {\n    const builder = createBuilder(testRoot);\n    const target = join(testRoot, 'route.js');\n\n    await builder.writeGeneratedFile(target, 'v1');\n    await builder.writeGeneratedFile(target, 'v2');\n\n    expect(readFileSync(target, 'utf8')).toBe('v2');\n  });\n\n  it('creates the file on first write', async () => {\n    const builder = createBuilder(testRoot);\n    const target = join(testRoot, 'route.js');\n\n    await builder.writeGeneratedFile(target, 'first');\n\n    expect(readFileSync(target, 'utf8')).toBe('first');\n  });\n\n  // The Nitro dev handler cache-busts its import of `steps.mjs` off the mtime\n  // of `workflows.mjs`, so that target opts out: skipping the redundant write\n  // would freeze the version key and serve stale step code. See\n  // `packages/nitro/src/builders.ts`.\n  it('still rewrites unchanged output when the target opts out', async () => {\n    const builder = createOptedOutBuilder(testRoot);\n    const target = join(testRoot, 'workflows.mjs');\n\n    await builder.writeGeneratedFile(target, 'export const a = 1;');\n    const before = fileIdentity(target);\n\n    await builder.writeGeneratedFile(target, 'export const a = 1;');\n\n    expect(fileIdentity(target)).not.toBe(before);\n    expect(readFileSync(target, 'utf8')).toBe('export const a = 1;');\n  });\n});\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow/builders",
-  "version": "5.0.0-beta.42",
+  "version": "5.0.0-beta.44",
   "description": "Shared builder infrastructure for Workflow SDK",
   "type": "module",
   "main": "./dist/index.js",
@@ -41,9 +41,9 @@
     "find-up": "7.0.0",
     "json5": "2.2.3",
     "tinyglobby": "0.2.17",
-    "@workflow/core": "5.0.0-beta.42",
-    "@workflow/errors": "5.0.0-beta.17",
-    "@workflow/utils": "5.0.0-beta.8",
+    "@workflow/core": "5.0.0-beta.44",
+    "@workflow/errors": "5.0.0-beta.18",
+    "@workflow/utils": "5.0.0-beta.9",
     "@workflow/swc-plugin": "5.0.0-beta.5"
   },
   "scripts": {