feat: implement queryPermission method in NodeFileSystemHandle using fs.access

Co-authored-by: streamich <[email protected]>

Author: Copilot

src/fsa-to-node/FsaNodeFs.ts

@@ -404,34 +404,25 @@ export class FsaNodeFs extends FsaNodeCore implements FsCallbackApi, FsSynchrono
     const [folder, name] = pathToLocation(filename);
     (async () => {
       const node = folder.length || name ? await this.getFileOrDir(folder, name, 'access') : await this.root;
+      
+      // Check execute permission - not supported by FSA
       const checkIfCanExecute = mode & AMODE.X_OK;
       if (checkIfCanExecute) throw util.createError('EACCESS', 'access', filename);
+      
+      // Use queryPermission to check read/write access
+      const checkIfCanRead = mode & AMODE.R_OK;
       const checkIfCanWrite = mode & AMODE.W_OK;
-      switch (node.kind) {
-        case 'file': {
-          if (checkIfCanWrite) {
-            try {
-              const file = node as fsa.IFileSystemFileHandle;
-              const writable = await file.createWritable();
-              await writable.close();
-            } catch {
-              throw util.createError('EACCESS', 'access', filename);
-            }
-          }
-          break;
-        }
-        case 'directory': {
-          if (checkIfCanWrite) {
-            const dir = node as fsa.IFileSystemDirectoryHandle;
-            const canWrite = await testDirectoryIsWritable(dir);
-            if (!canWrite) throw util.createError('EACCESS', 'access', filename);
-          }
-          break;
-        }
-        default: {
+      
+      if (checkIfCanRead || checkIfCanWrite) {
+        const permissionMode = checkIfCanWrite ? 'readwrite' : 'read';
+        const permission = node.queryPermission({ mode: permissionMode });
+        
+        if (permission.state === 'denied') {
           throw util.createError('EACCESS', 'access', filename);
         }
       }
+      
+      // If only F_OK is requested, we already verified the file exists by getting the node
     })().then(
       () => callback(null),
       error => callback(error),

src/node-to-fsa/NodeFileSystemHandle.ts

@@ -1,5 +1,7 @@
 import { NodePermissionStatus } from './NodePermissionStatus';
+import { AMODE } from '../consts/AMODE';
 import type { IFileSystemHandle, FileSystemHandlePermissionDescriptor } from '../fsa/types';
+import type { NodeFsaFs } from './types';
 
 /**
  * Represents a File System Access API file handle `FileSystemHandle` object,
@@ -8,6 +10,9 @@ import type { IFileSystemHandle, FileSystemHandlePermissionDescriptor } from '..
  * @see [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/FileSystemHandle)
  */
 export abstract class NodeFileSystemHandle implements IFileSystemHandle {
+  protected abstract readonly fs: NodeFsaFs;
+  protected abstract readonly __path: string;
+
   constructor(
     public readonly kind: 'file' | 'directory',
     public readonly name: string,
@@ -30,7 +35,26 @@ export abstract class NodeFileSystemHandle implements IFileSystemHandle {
   public queryPermission(
     fileSystemHandlePermissionDescriptor: FileSystemHandlePermissionDescriptor,
   ): NodePermissionStatus {
-    throw new Error('Not implemented');
+    const { mode } = fileSystemHandlePermissionDescriptor;
+    
+    try {
+      // Use Node.js fs.access() to check permissions synchronously
+      let accessMode = AMODE.F_OK;
+      
+      if (mode === 'read') {
+        accessMode = AMODE.R_OK;
+      } else if (mode === 'readwrite') {
+        accessMode = AMODE.R_OK | AMODE.W_OK;
+      }
+      
+      // Use synchronous access check
+      this.fs.accessSync(this.__path, accessMode);
+      
+      return new NodePermissionStatus(mode, 'granted');
+    } catch (error) {
+      // If access check fails, permission is denied
+      return new NodePermissionStatus(mode, 'denied');
+    }
   }
 
   /**

src/node-to-fsa/__tests__/NodeFileSystemHandle.test.ts

@@ -40,4 +40,48 @@ onlyOnNode20('NodeFileSystemHandle', () => {
       expect(dir.isSameEntry(file)).toBe(false);
     });
   });
+
+  describe('.queryPermission()', () => {
+    test('grants read permission for existing files', async () => {
+      const { dir } = setup({
+        'test.txt': 'content',
+      });
+      const file = await dir.getFileHandle('test.txt');
+      const permission = file.queryPermission({ mode: 'read' });
+      expect(permission.state).toBe('granted');
+      expect(permission.name).toBe('read');
+    });
+
+    test('grants readwrite permission for files when context allows', async () => {
+      const { dir } = setup({
+        'test.txt': 'content',
+      });
+      const file = await dir.getFileHandle('test.txt');
+      const permission = file.queryPermission({ mode: 'readwrite' });
+      expect(permission.state).toBe('granted');
+      expect(permission.name).toBe('readwrite');
+    });
+
+    test('grants read permission for existing directories', async () => {
+      const { dir } = setup({
+        subdir: null,
+      });
+      const subdir = await dir.getDirectoryHandle('subdir');
+      const permission = subdir.queryPermission({ mode: 'read' });
+      expect(permission.state).toBe('granted');
+      expect(permission.name).toBe('read');
+    });
+
+    test('denies permission for non-existent paths', async () => {
+      const { fs } = setup();
+      const nonExistentFile = new (await import('../NodeFileSystemFileHandle')).NodeFileSystemFileHandle(
+        fs as any,
+        '/nonexistent.txt',
+        { mode: 'readwrite' }
+      );
+      const permission = nonExistentFile.queryPermission({ mode: 'read' });
+      expect(permission.state).toBe('denied');
+      expect(permission.name).toBe('read');
+    });
+  });
 });

src/node-to-fsa/types.ts

@@ -6,7 +6,7 @@ import type { FsCommonObjects } from '../node/types/FsCommonObjects';
  */
 export type NodeFsaFs = Pick<FsCommonObjects, 'constants'> & { promises: FsPromisesApi } & Pick<
     FsSynchronousApi,
-    'openSync' | 'fsyncSync' | 'statSync' | 'closeSync' | 'readSync' | 'truncateSync' | 'writeSync'
+    'openSync' | 'fsyncSync' | 'statSync' | 'closeSync' | 'readSync' | 'truncateSync' | 'writeSync' | 'accessSync'
   >;
 
 export interface NodeFsaContext {