Class NodeFileDataStore

packages/foam-cli/src/support/filesystem.ts:36–92

};

export class NodeFileDataStore implements IDataStore {
  constructor(
    private readonly rootDir: string,
    private readonly excludedPaths: string[],
    private readonly matcher: IMatcher
  ) {}

  async list(pattern?: string) {
    const files: string[] = [];
    await collectFiles(this.rootDir, files, this.excludedPaths);
    let uris = files.map(file => URI.file(file));
    if (pattern) {
      const absoluteGlob = path.posix.join(this.rootDir, pattern);
      const matched = micromatch(uris.map(u => u.toFsPath()), [absoluteGlob]);
      const matchedSet = new Set(matched);
      uris = uris.filter(u => matchedSet.has(u.toFsPath()));
    }
    return uris.filter(uri => this.matcher.isMatch(uri));
  }

  async read(uri: URI) {
    try {
      return await fs.readFile(uri.toFsPath(), 'utf8');
    } catch {
      return null;
    }
  }

  async write(uri: URI, content: string): Promise<void> {
    const fsPath = uri.toFsPath();
    await fs.mkdir(path.dirname(fsPath), { recursive: true });
    await fs.writeFile(fsPath, content, 'utf8');
  }

  async delete(uri: URI): Promise<void> {
    try {
      await fs.unlink(uri.toFsPath());
    } catch (err: any) {
      if (err.code !== 'ENOENT') throw err;
    }
  }

  async move(from: URI, to: URI): Promise<void> {
    const toFs = to.toFsPath();
    await fs.mkdir(path.dirname(toFs), { recursive: true });
    await fs.rename(from.toFsPath(), toFs);
  }

  async exists(uri: URI): Promise<boolean> {
    try {
      await fs.access(uri.toFsPath());
      return true;
    } catch {
      return false;
    }
  }
}