# fs

### `access`

```typescript
function(path: PathLike, mode?: number): Observable<void>
```

Tests a user's permissions for the file or directory specified by `path`. The `mode` argument is an optional integer that specifies the accessibility checks to be performed. Check [File access constants](https://nodejs.org/docs/latest-v12.x/api/fs.html#fs_file_access_constants) for possible values of `mode`. It is possible to create a mask consisting of the bitwise OR of two or more values (e.g. `fs.constants.W_OK | fs.constants.R_OK`).

The following examples check if `package.json` exists and if it is readable or writable.

```typescript
import { access } from '@rxnode/fs';

const file = 'package.json';

// Check if the file exists in the current directory.
access(file, fs.constants.F_OK).subscribe({
  next() {
    console.log(`${file} exists`);
  },
  error(err) {
    console.log(`${file} does not exist`);
  },
});

// Check if the file is readable.
access(file, fs.constants.R_OK).subscribe({
  next() {
    console.log(`${file} is readable`);
  },
  error(err) {
    console.log(`${file} is not readable`);
  },
});

// Check if the file is writable.
access(file, fs.constants.W_OK).subscribe({
  next() {
    console.log(`${file} is writable`);
  },
  error(err) {
    console.log(`${file} is not writable`);
  },
});

// Check if the file exists in the current directory, and if it is writable.
access(file, fs.constants.F_OK | fs.constants.W_OK).subscribe({
  next() {
    console.log(`${file} exists, and it is writable`);
  },
  error(err) {
    console.error(
      `${file} ${err.code === 'ENOENT' ? 'does not exist' : 'is read-only'}`
    );
  },
});
```

Do not use `access()` to check for the accessibility of a file before calling `open()`, `readFile()` or `writeFile()`. Doing so introduces a race condition since other processes may change the file's state between the two calls. Instead, user code should open/read/write the file directly and handle the error raised if it is not accessible.

**write (NOT RECOMMENDED)**

```typescript
import { access, open } from '@rxnode/fs';

access('myfile').subscribe({
  next() {
    console.error('myfile already exists');
  },
  error() {
    open('myfile', 'wx').subscribe((fd) => {
      writeMyData(fd);
    });
  },
});
```

**write (RECOMMENDED)**

```typescript
import { open } from '@rxnode/fs';

open('myfile', 'wx').subscribe((fd) => writeMyData(fd));
```

**read (NOT RECOMMENDED)**

```typescript
import { access, open } from '@rxnode/fs';

access('myfile').subscribe(() => {
  open('myfile', 'r').subscribe((fb) => readMyData(fd));
});
```

**read (RECOMMENDED)**

```typescript
import { open } from '@rxnode/fs';

open('myfile', 'r').subscribe((fd) => {
  readMyData(fd);
});
```

The "not recommended" examples above check for accessibility and then use the file; the "recommended" examples are better because they use the file directly and handle the error if any.

In general, check for the accessibility of a file only if the file will not be used directly, for example when its accessibility is a signal from another process.

On Windows, access-control policies (ACLs) on a directory may limit access to a file or directory. The `fs.access()` function, however, does not check the ACL and therefore may report that a path is accessible even if the ACL restricts the user from reading or writing to it.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://rxnode.gitbook.io/docs/libs/fs.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.