fix: used async API from fs

Author: Sayan751

src/cli/configuration.ts

@@ -1,7 +1,8 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { existsSync, mkdirSync, statSync } from 'fs';
+import { promises as fs } from 'fs';
 import { isAbsolute, resolve } from 'path';
 import { EndpointConfiguration, Logger } from './shared.js';
+import { exists as exists } from './file-system-helper.js';
 
 export class Configuration {
 
@@ -33,11 +34,11 @@ export class Configuration {
             throw new Error('When providing a configuration file, the --config needs to be the first CLI argument.');
           }
           const configPath = resolve(process.cwd(), args[i + 1]);
-          if (!existsSync(configPath) || !statSync(configPath).isFile()) {
+          if (!await exists(configPath) || !(await fs.stat(configPath)).isFile()) {
             throw new Error(`The config file "${configPath}" does not exist.`);
           }
           // eslint-disable-next-line @typescript-eslint/no-var-requires
-          instance.applyConfiguration(await require(configPath) as ConfigSchema);
+          await instance.applyConfiguration(await require(configPath) as ConfigSchema);
           break;
         }
         case 'endpoint':
@@ -47,7 +48,7 @@ export class Configuration {
           instance.setEndpoints(JSON.parse(args[i + 1]) as string | EndpointConfiguration[]);
           break;
         case 'outputDir': {
-          instance.setOutputDir(args[i + 1], true);
+          await instance.setOutputDir(args[i + 1], true);
           break;
         }
         case 'quoteStyle':
@@ -78,8 +79,8 @@ export class Configuration {
 
   private constructor() { /* noop */ }
 
-  private applyConfiguration(config: ConfigSchema) {
-    this.setOutputDir(config.outputDir, false);
+  private async applyConfiguration(config: ConfigSchema) {
+    await this.setOutputDir(config.outputDir, false);
     this.setEndpointsFromConfig(config);
     this.setQuote(config.quoteStyle);
     this.setIndentation(config.indentSize);
@@ -110,12 +111,12 @@ export class Configuration {
     this.adjustOutputPaths();
   }
 
-  private setOutputDir(outputDir: string | undefined, throwError: boolean) {
+  private async setOutputDir(outputDir: string | undefined, throwError: boolean) {
     if (!outputDir) { return; }
     const absolutePath: string = resolve(process.cwd(), outputDir);
-    if (!existsSync(absolutePath)) {
-      mkdirSync(absolutePath, { recursive: true });
-    } else if (throwError && !statSync(absolutePath).isDirectory()) {
+    if (!await exists(absolutePath)) {
+      await fs.mkdir(absolutePath, { recursive: true });
+    } else if (throwError && !(await fs.stat(absolutePath)).isDirectory()) {
       throw new Error(`The output path "${absolutePath}" is not a directory.`);
     }
     this.outputDir = absolutePath;

src/cli/file-system-helper.ts

@@ -0,0 +1,15 @@
+import { promises } from 'fs';
+
+/**
+ * Checks if a file or directory exists.
+ * @param path
+ * @returns `true` if the file or directory exists, `false` otherwise.
+ */
+export async function exists(path: string): Promise<boolean> {
+  try {
+    await promises.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}

src/cli/generator.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { existsSync, writeFileSync, mkdirSync } from 'fs';
+import { promises as fs } from 'fs';
 import { EOL } from 'os';
 import { dirname } from 'path';
 // eslint-disable-next-line @typescript-eslint/no-shadow
@@ -18,6 +18,7 @@ import {
   ComplexTypeInfoSet,
 } from './shared.js';
 import { EdmTemplate, EndpointTemplate } from './templates.js';
+import { exists } from './file-system-helper.js';
 
 // interface ImportInfo { ns: string; type: string; }
 
@@ -94,7 +95,7 @@ export class $Generator {
   private readonly endpointTemplate = new EndpointTemplate();
   private readonly edmTemplate = new EdmTemplate();
 
-  public generateEdm(metadata: string, endpoints: Endpoint[], configuration: EndpointConfiguration): void {
+  public async generateEdm(metadata: string, endpoints: Endpoint[], configuration: EndpointConfiguration): Promise<void> {
     const parsed = new DOMParser()
       .parseFromString(metadata, 'application/xml')
       .documentElement;
@@ -104,17 +105,17 @@ export class $Generator {
     }
     const edmInfo = this.generateCodeContent(parsed, endpoints, configuration);
     if (edmInfo !== null) {
-      this.generateEdmFile(edmInfo);
+      await this.generateEdmFile(edmInfo);
     }
   }
 
-  public generateEndpointsFile(endpoints: Endpoint[], configuration: EndpointConfiguration): void {
+  public async generateEndpointsFile(endpoints: Endpoint[], configuration: EndpointConfiguration): Promise<void> {
     const path = getEndpointsPath(configuration);
     const dirName = dirname(path);
-    if (!existsSync(dirName)) {
-      mkdirSync(dirName, { recursive: true });
+    if (!await exists(dirName)) {
+      await fs.mkdir(dirName, { recursive: true });
     }
-    writeFileSync(path, this.endpointTemplate.render(endpoints));
+    await fs.writeFile(path, this.endpointTemplate.render(endpoints));
   }
 
   private generateStringEnum(acc: EnumInfo[], enumType: Element, ignored: string[]): EnumInfo[] {
@@ -177,17 +178,17 @@ export class $Generator {
     return new EdmInfo(schema.getAttribute('Namespace')!, /* imports, */ entities, $complexTypes, enums, configuration);
   }
 
-  private generateEdmFile(edmInfo: EdmInfo) {
+  private async generateEdmFile(edmInfo: EdmInfo) {
     const filePath = edmInfo.filePath;
 
     const dirName = dirname(filePath);
-    if (!existsSync(dirName)) {
-      mkdirSync(dirName, { recursive: true });
+    if (!await exists(dirName)) {
+      await fs.mkdir(dirName, { recursive: true });
     }
 
     const template = this.edmTemplate;
     const content = template.render(edmInfo);
-    writeFileSync(filePath, content);
+    await fs.writeFile(filePath, content);
   }
 
   private generateEntityInfo(

src/cli/index.ts

@@ -51,10 +51,10 @@ Options:
       const baseEndpoint = ep.url;
       const { value: endpoints } = JSON.parse(await getData(baseEndpoint)) as { value: Endpoint[] };
 
-      generator.generateEndpointsFile(endpoints, ep);
+      await generator.generateEndpointsFile(endpoints, ep);
       Logger.info(`generated endpoints for ${baseEndpoint}.`);
 
-      generator.generateEdm(await getData(`${baseEndpoint}/$metadata`), endpoints, ep);
+      await generator.generateEdm(await getData(`${baseEndpoint}/$metadata`), endpoints, ep);
       Logger.info(`generated EDM for ${baseEndpoint}.`);
     }
   } finally {

tests/data/double-quote/input/config.js tests/data/double-quote/input/config.cjs

@@ -4,32 +4,32 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 import { assert } from 'chai';
-import { red, green, gray } from 'colorette';
+import { gray, green, red } from 'colorette';
 import { diffLines } from 'diff';
-import { existsSync, readdirSync, readFileSync } from 'fs';
+import { Dirent, promises as fs } from 'fs';
 import mockFs from 'mock-fs';
 import type { DirectoryItems } from 'mock-fs/lib/filesystem';
 import { join } from 'path';
-// eslint-disable-next-line @typescript-eslint/no-shadow
-import { URL } from 'url';
+import { URL } from 'node:url';
 import { v4 as uuid } from 'uuid';
 import { Configuration } from '../src/cli/configuration.js';
 import { $Generator } from '../src/cli/generator.js';
 import { Endpoint, EndpointConfiguration } from '../src/cli/shared.js';
+import { exists } from '../src/cli/file-system-helper.js';
 
 const __dirname = process.cwd();
 
 describe('generator', function () {
 
-  function readAllContent(path: string): Map<string, string> {
+  async function readAllContent(path: string): Promise<Map<string, string>> {
     const result = new Map<string, string>();
-    for (const dirent of readdirSync(path, { encoding: 'utf8', withFileTypes: true })) {
+    for (const dirent of await fs.readdir(path, { encoding: 'utf8', withFileTypes: true })) {
       const entryName = dirent.name;
       const completePath = join(path, entryName);
       if (dirent.isFile()) {
-        result.set(entryName, readFileSync(completePath, 'utf8'));
+        result.set(entryName, await fs.readFile(completePath, 'utf8'));
       } else {
-        const content = readAllContent(completePath);
+        const content = await readAllContent(completePath);
         for (const [key, value] of content) {
           result.set(join(entryName, key), value);
         }
@@ -65,12 +65,14 @@ describe('generator', function () {
   }
 
   const dataPath = join(__dirname, 'tests', 'data');
-  for (const dirent of
-    readdirSync(dataPath, { encoding: 'utf8', withFileTypes: true })
-      .filter((x) => x.isDirectory())
-  ) {
+  let directoryEntries: Dirent[] = [];
+  before(async function () {
+    directoryEntries = (await fs.readdir(dataPath, { encoding: 'utf8', withFileTypes: true }))
+    .filter((x) => x.isDirectory());
+  });
+  for (const dirent of directoryEntries) {
     const dirName = dirent.name;
-    it(`works for ${dirName}`, async function () {
+    it.only(`works for ${dirName}`, async function () {
       let generator: $Generator | null = null;
       try {
         // arrange
@@ -84,36 +86,36 @@ describe('generator', function () {
         let configuredEndpoints: EndpointConfiguration[] | undefined = undefined;
         let hasConfiguredEndpoints = false;
         const args = ['--outputDir', baseOutputPath];
-        if (existsSync(configFilePath)) {
+        if (await exists(configFilePath)) {
           args.unshift('--config', configFilePath);
           mockFsConfig[configFilePath] = mockFs.load(configFilePath);
-          // eslint-disable-next-line @typescript-eslint/no-var-requires
-          configuredEndpoints = (await import(configFilePath)).endpoints;
+          configuredEndpoints = (await import(`file:///${configFilePath}`)).endpoints;
           hasConfiguredEndpoints = Array.isArray(configuredEndpoints) && configuredEndpoints.length > 0;
         }
         if (!hasConfiguredEndpoints) {
           args.push('--endpoint', 'https://api.example.com');
         }
-        const expected = readAllContent(join(caseDir, 'expected'));
+        const expected = await readAllContent(join(caseDir, 'expected'));
         mockFs(mockFsConfig, { createCwd: true });
         const configuration = await Configuration.createFromCLIArgs(args);
         generator = new $Generator();
 
         for (const ep of configuration.endpoints) {
           let epInput = join(inputDir, new URL(ep.url).hostname);
-          epInput = mockFs.bypass(() => existsSync(epInput)) ? epInput : inputDir;
+          epInput = await exists(epInput) ? epInput : inputDir;
 
-          const edmxXml = mockFs.bypass(() => readFileSync(join(epInput, 'metadata.xml'), 'utf8'));
+          const edmxXml = await fs.readFile(join(epInput, 'metadata.xml'), 'utf8');
+          console.log('[test] edmxXml', edmxXml);
           // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-          const endpoints: Endpoint[] = mockFs.bypass(() => JSON.parse(readFileSync(join(epInput, 'endpoints.json'), 'utf8')).value);
+          const endpoints: Endpoint[] = JSON.parse(await fs.readFile(join(epInput, 'endpoints.json'), 'utf8')).value;
 
           // act
-          generator.generateEndpointsFile(endpoints, ep);
-          generator.generateEdm(edmxXml, endpoints, ep);
+          await generator.generateEndpointsFile(endpoints, ep);
+          await generator.generateEdm(edmxXml, endpoints, ep);
         }
 
         // assert
-        const actual = readAllContent(baseOutputPath);
+        const actual = await readAllContent(baseOutputPath);
         assertContent(actual, expected);
       } catch (e) {
         assert.fail((e as Error).message);