Merge branch 'master' into fsa-observable

Author: streamich

CHANGELOG.md

@@ -1,3 +1,36 @@
+## [4.38.3](https://github.com/streamich/memfs/compare/v4.38.2...v4.38.3) (2025-09-09)
+
+
+### Bug Fixes
+
+* prevent readFile from updating ctime when only accessing files ([f5f3066](https://github.com/streamich/memfs/commit/f5f3066cd6d2d7e2d8bec7414e9eda064afd7868))
+
+## [4.38.2](https://github.com/streamich/memfs/compare/v4.38.1...v4.38.2) (2025-08-26)
+
+
+### Bug Fixes
+
+* correct permission check logic for readonly files in copyFile operations ([a06bb4d](https://github.com/streamich/memfs/commit/a06bb4d13b3ed4bad28921f5e06a7a87f2c089b7))
+
+## [4.38.1](https://github.com/streamich/memfs/compare/v4.38.0...v4.38.1) (2025-08-24)
+
+
+### Bug Fixes
+
+* 🐛 use glob-to-regex library ([8962374](https://github.com/streamich/memfs/commit/89623740b78cbcf58a5b1b32d67b2e4ecd183469))
+
+# [4.38.0](https://github.com/streamich/memfs/compare/v4.37.1...v4.38.0) (2025-08-24)
+
+
+### Bug Fixes
+
+* handle chmod 0 permissions in existsSync and access methods ([3452bcf](https://github.com/streamich/memfs/commit/3452bcf24cd44f476687b693a1a1b6685d7353c9))
+
+
+### Features
+
+* revert exists implementation ([bf209cd](https://github.com/streamich/memfs/commit/bf209cd05ed41787be8afb425077fbcdb93fb3fa))
+
 ## [4.37.1](https://github.com/streamich/memfs/compare/v4.37.0...v4.37.1) (2025-08-22)
 
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "memfs",
-  "version": "4.37.1",
+  "version": "4.38.3",
   "description": "In-memory file-system with Node's fs API.",
   "keywords": [
     "fs",
@@ -126,6 +126,7 @@
   "dependencies": {
     "@jsonjoy.com/json-pack": "^1.11.0",
     "@jsonjoy.com/util": "^1.9.0",
+    "glob-to-regex.js": "^1.0.1",
     "thingies": "^2.5.0",
     "tree-dump": "^1.0.3",
     "tslib": "^2.0.0"

src/__tests__/node.test.ts

@@ -60,15 +60,15 @@ describe('node.ts', () => {
         node.read(buf, 0, 1, 1);
         expect(buf.equals(Buffer.from([2]))).toBe(true);
       });
-      it('updates the atime and ctime', () => {
+      it('updates the atime but not ctime', () => {
         const node = new Node(1);
         const oldAtime = node.atime;
         const oldCtime = node.ctime;
         node.read(Buffer.alloc(0));
         const newAtime = node.atime;
         const newCtime = node.ctime;
         expect(newAtime).not.toBe(oldAtime);
-        expect(newCtime).not.toBe(oldCtime);
+        expect(newCtime).toBe(oldCtime);
       });
     });
     describe('.chmod(perm)', () => {
@@ -79,7 +79,7 @@ describe('node.ts', () => {
       expect(node.perm).toBe(0o600);
       expect(node.isFile()).toBe(true);
     });
-    describe.each(['uid', 'gid', 'atime', 'mtime', 'perm', 'nlink'])('when %s changes', field => {
+    describe.each(['uid', 'gid', 'mtime', 'perm', 'nlink'])('when %s changes', field => {
       it('updates the property and the ctime', () => {
         const node = new Node(1);
         const oldCtime = node.ctime;
@@ -89,28 +89,38 @@ describe('node.ts', () => {
         expect(node[field]).toBe(1);
       });
     });
+    describe('when atime changes', () => {
+      it('updates the property but NOT the ctime', () => {
+        const node = new Node(1);
+        const oldCtime = node.ctime;
+        node.atime = new Date(1);
+        const newCtime = node.ctime;
+        expect(newCtime).toBe(oldCtime);
+        expect(node.atime).toEqual(new Date(1));
+      });
+    });
     describe('.getString(encoding?)', () => {
-      it('updates the atime and ctime', () => {
+      it('updates the atime but not ctime', () => {
         const node = new Node(1);
         const oldAtime = node.atime;
         const oldCtime = node.ctime;
         node.getString();
         const newAtime = node.atime;
         const newCtime = node.ctime;
         expect(newAtime).not.toBe(oldAtime);
-        expect(newCtime).not.toBe(oldCtime);
+        expect(newCtime).toBe(oldCtime);
       });
     });
     describe('.getBuffer()', () => {
-      it('updates the atime and ctime', () => {
+      it('updates the atime but not ctime', () => {
         const node = new Node(1);
         const oldAtime = node.atime;
         const oldCtime = node.ctime;
         node.getBuffer();
         const newAtime = node.atime;
         const newCtime = node.ctime;
         expect(newAtime).not.toBe(oldAtime);
-        expect(newCtime).not.toBe(oldCtime);
+        expect(newCtime).toBe(oldCtime);
       });
     });
   });

src/core/Node.ts

@@ -75,7 +75,6 @@ export class Node {
 
   public set atime(atime: Date) {
     this._atime = atime;
-    this.ctime = new Date();
   }
 
   public get atime(): Date {
@@ -122,7 +121,7 @@ export class Node {
 
   getBuffer(): Buffer {
     this.atime = new Date();
-    if (!this.buf) this.setBuffer(bufferAllocUnsafe(0));
+    if (!this.buf) this.buf = bufferAllocUnsafe(0);
     return bufferFrom(this.buf); // Return a copy.
   }
 

src/core/Superblock.ts

@@ -444,12 +444,14 @@ export class Superblock {
     }
 
     // Check node permissions
-    if (!(flagsNum & O_WRONLY)) {
+    // For read access: check if flags are O_RDONLY or O_RDWR (i.e., not only O_WRONLY)
+    if ((flagsNum & (O_RDONLY | O_RDWR | O_WRONLY)) !== O_WRONLY) {
       if (!node.canRead()) {
         throw createError(ERROR_CODE.EACCES, 'open', link.getPath());
       }
     }
-    if (!(flagsNum & O_RDONLY)) {
+    // For write access: check if flags are O_WRONLY or O_RDWR
+    if (flagsNum & (O_WRONLY | O_RDWR)) {
       if (!node.canWrite()) {
         throw createError(ERROR_CODE.EACCES, 'open', link.getPath());
       }

src/node/__tests__/volume/chmod-permission-issue.test.ts

@@ -0,0 +1,83 @@
+import { create } from '../../../__tests__/util';
+import { AMODE } from '../../../consts/AMODE';
+
+describe('chmod 0 permission issue reproduction', () => {
+  describe('existsSync()', () => {
+    test('chmod on file and existsSync', () => {
+      // Arrange
+      const vol = create({ '/path/to/file.txt': 'some text' });
+      vol.chmodSync('/path/to/file.txt', 0o0000);
+
+      // Act
+      const exists = vol.existsSync('/path/to/file.txt');
+      const exists2 = vol.existsSync('/path/to/file2.txt');
+      const exists3 = vol.existsSync('/path/to3/file3.txt');
+
+      // Assert
+      expect(exists).toBe(true);
+      expect(exists2).toBe(false);
+      expect(exists3).toBe(false);
+    });
+
+    test('chmod on directory and existsSync', () => {
+      // Arrange
+      const vol = create({ '/path/to/file.txt': 'some text' });
+      vol.chmodSync('/path/to/', 0o0000);
+
+      // Act
+      const exists = vol.existsSync('/path/to/file.txt');
+
+      // Assert
+      expect(exists).toBe(false);
+    });
+  });
+
+  test.each([AMODE.R_OK, AMODE.W_OK])('chmod on file and access mode %d', mode => {
+    // Arrange
+    const vol = create({ '/path/to/file.txt': 'some text' });
+    vol.accessSync('/path/to/file.txt', mode);
+    vol.chmodSync('/path/to/file.txt', 0o0000);
+
+    // Act & Assert
+    expect(() => {
+      vol.accessSync('/path/to/file.txt', mode);
+    }).toThrow();
+  });
+
+  test.each([AMODE.R_OK, AMODE.W_OK])('chmod on directory and access mode %d', mode => {
+    // Arrange
+    const vol = create({ '/path/to/file.txt': 'some text' });
+    vol.accessSync('/path/to/file.txt', mode);
+    vol.chmodSync('/path/to/', 0o0000);
+
+    // Act & Assert
+    expect(() => {
+      vol.accessSync('/path/to/file.txt', mode);
+    }).toThrow();
+  });
+
+  test('chmod on file and access F_OK should not throw', () => {
+    const vol = create({ '/path/to/file.txt': 'some text' });
+    vol.accessSync('/path/to/file.txt', AMODE.F_OK);
+    vol.chmodSync('/path/to/file.txt', 0o0000);
+    vol.accessSync('/path/to/file.txt', AMODE.F_OK);
+  });
+
+  // Test the exact scenario from the issue (https://github.com/streamich/memfs/issues/1172)
+  test('chmod on file and promises access with fs.constants', async () => {
+    const vol = create({ '/path/to/file.txt': 'some text' });
+
+    await vol.promises.chmod('/path/to/file.txt', 0o0000);
+
+    // Should throw for R_OK and W_OK
+    await expect(vol.promises.access('/path/to/file.txt', AMODE.R_OK)).rejects.toThrow();
+    await expect(vol.promises.access('/path/to/file.txt', AMODE.R_OK | AMODE.F_OK)).rejects.toThrow();
+    await expect(vol.promises.access('/path/to/file.txt', AMODE.W_OK)).rejects.toThrow();
+    await expect(vol.promises.access('/path/to/file.txt', AMODE.W_OK | AMODE.F_OK)).rejects.toThrow();
+    await expect(vol.promises.access('/path/to/file.txt', AMODE.W_OK | AMODE.R_OK)).rejects.toThrow();
+    await expect(vol.promises.access('/path/to/file.txt', AMODE.W_OK | AMODE.R_OK | AMODE.F_OK)).rejects.toThrow();
+
+    // F_OK should NOT throw - it just checks existence, which it does exist
+    await expect(vol.promises.access('/path/to/file.txt', AMODE.F_OK)).resolves.toBeUndefined();
+  });
+});

src/node/__tests__/volume/copyFile.test.ts

@@ -99,6 +99,23 @@ describe('copyFile(src, dest[, flags], callback)', () => {
     });
   });
 
+  it('copying readonly source file should succeed', done => {
+    const vol = create({ '/foo': 'hello world' });
+    vol.chmodSync('/foo', 0o400); // read-only for owner
+
+    // This should not throw - we can read the file even though it's read-only
+    vol.copyFile('/foo', '/bar', err => {
+      try {
+        expect(err).toBeNull();
+        expect(vol.readFileSync('/foo', 'utf8')).toBe('hello world');
+        expect(vol.readFileSync('/bar', 'utf8')).toBe('hello world');
+        done();
+      } catch (failure) {
+        done(failure);
+      }
+    });
+  });
+
   it('copying gives EACCES with insufficient permissions on an intermediate directory', done => {
     const vol = create({ '/foo/test': 'test' });
     vol.mkdirSync('/bar');

src/node/__tests__/volume/copyFileSync.test.ts

@@ -125,6 +125,18 @@ describe('copyFileSync(src, dest[, flags])', () => {
         }).toThrowError(/EACCES/);
       });
     });
+
+    it('copying readonly source file should succeed', () => {
+      const vol = create({ '/foo': 'hello world' });
+      vol.chmodSync('/foo', 0o400); // read-only for owner
+
+      // This should not throw - we can read the file even though it's read-only
+      vol.copyFileSync('/foo', '/bar');
+
+      expect(vol.readFileSync('/foo', 'utf8')).toBe('hello world');
+      expect(vol.readFileSync('/bar', 'utf8')).toBe('hello world');
+    });
+
     it('copying throws EACCES with insufficient permissions an intermediate directory', () => {
       const vol = create({ '/foo/test': 'test' });
       vol.mkdirSync('/bar');

src/node/__tests__/volume/readFile-ctime.test.ts

@@ -0,0 +1,78 @@
+import { memfs } from '../../..';
+
+describe('readFile ctime issue', () => {
+  it('should NOT change ctime when readFile is called', async () => {
+    const { fs } = memfs();
+
+    const file = '/test-readfile-ctime.txt';
+
+    // Create the file
+    await fs.promises.writeFile(file, 'test content');
+
+    // Get initial ctime
+    const initialStat = await fs.promises.stat(file);
+    const initialCtime = initialStat.ctimeMs;
+
+    // Wait a bit to ensure any ctime change would be detectable
+    await new Promise(resolve => setTimeout(resolve, 10));
+
+    // Read the file (this should only update atime, not ctime)
+    await fs.promises.readFile(file);
+
+    // Check ctime again
+    const afterReadStat = await fs.promises.stat(file);
+    const afterReadCtime = afterReadStat.ctimeMs;
+
+    // ctime should be unchanged after read
+    expect(afterReadCtime).toBe(initialCtime);
+  });
+
+  it('should change atime when readFile is called', async () => {
+    const { fs } = memfs();
+
+    const file = '/test-readfile-atime.txt';
+
+    // Create the file
+    await fs.promises.writeFile(file, 'test content');
+
+    // Get initial atime
+    const initialStat = await fs.promises.stat(file);
+    const initialAtime = initialStat.atimeMs;
+
+    // Wait a bit to ensure any atime change would be detectable
+    await new Promise(resolve => setTimeout(resolve, 10));
+
+    // Read the file (this should update atime)
+    await fs.promises.readFile(file);
+
+    // Check atime again
+    const afterReadStat = await fs.promises.stat(file);
+    const afterReadAtime = afterReadStat.atimeMs;
+
+    // atime should be updated after read
+    expect(afterReadAtime).toBeGreaterThan(initialAtime);
+  });
+
+  it('should NOT change ctime when readFileSync is called', () => {
+    const { fs } = memfs();
+
+    const file = '/test-readfilesync-ctime.txt';
+
+    // Create the file
+    fs.writeFileSync(file, 'test content');
+
+    // Get initial ctime
+    const initialStat = fs.statSync(file);
+    const initialCtime = initialStat.ctimeMs;
+
+    // Read the file (this should only update atime, not ctime)
+    fs.readFileSync(file);
+
+    // Check ctime again
+    const afterReadStat = fs.statSync(file);
+    const afterReadCtime = afterReadStat.ctimeMs;
+
+    // ctime should be unchanged after read
+    expect(afterReadCtime).toBe(initialCtime);
+  });
+});