@api-client/core 0.3.5 → 0.3.8

package/src/lib/fs/Fs.ts

@@ -0,0 +1,258 @@
+import { writeFile, mkdir, rm, readdir, stat, access, readFile, copyFile as fsCopyFile } from 'fs/promises';
+import { constants } from 'fs';
+import { join, dirname } from 'path';
+
+export interface JsonReadOptions {
+  /**
+   * Whether it should throw an error when a reading error occurs.
+   */
+  throws?: boolean;
+}
+
+// function statPromise(filePath: string): Promise<fsSync.Stats> {
+//   return new Promise((resolve, reject) => {
+//     fsSync.stat(filePath, (err, stats) => {
+//       if (err) {
+//         reject(err);
+//       } else {
+//         resolve(stats);
+//       }
+//     });
+//   });
+// }
+
+/**
+ * Checks whether a file exists in the location.
+ */
+export async function pathExists(filePath: string): Promise<boolean> {
+  // return new Promise((resolve) => {
+  //   fsSync.stat(filePath, (err, stats) => {
+  //     if (err) {
+  //       resolve(false);
+  //     } else {
+  //       resolve(true);
+  //     }
+  //   });
+  // });
+  try {
+    await stat(filePath);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Tests a user's permissions for the file or directory specified by filePath.
+ * @param filePath The path to test
+ * @returns True when the path can be read by the current user.  
+ */
+export async function canRead(filePath: string): Promise<boolean> {
+  const exists = await pathExists(filePath);
+  if (!exists) {
+    return false;
+  }
+  
+  // return new Promise((resolve) => {
+  //   fsSync.access(filePath, constants.R_OK, (err) => {
+  //     if (err) {
+  //       resolve(false);
+  //     } else {
+  //       resolve(true);
+  //     }
+  //   });
+  // });
+  try {
+    await access(filePath, constants.R_OK);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Tests a user's permissions for the file or directory specified by filePath.
+ * @param filePath The path to test
+ * @returns True when the path can be written to by the current user.  
+ */
+export async function canWrite(filePath: string): Promise<boolean> {
+  const exists = await pathExists(filePath);
+  if (!exists) {
+    return false;
+  }
+  // return new Promise((resolve) => {
+  //   fsSync.access(filePath, constants.W_OK, (err) => {
+  //     if (err) {
+  //       resolve(false);
+  //     } else {
+  //       resolve(true);
+  //     }
+  //   });
+  // });
+  try {
+    await access(filePath, constants.W_OK);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Reads the contents of a JSON file.
+ * 
+ * @param filePath The path to the JSON file to read.
+ * @returns The contents of the file. When `throws` options is not set and error occurs then it returns an empty file.
+ */
+export async function readJson(filePath: string, opts: JsonReadOptions={}): Promise<unknown> {
+  const readable = await canRead(filePath);
+  if (!readable) {
+    if (opts.throws) {
+      throw new Error(`Unable to read file: ${filePath}. Access is denied.`);
+    }
+    return {};
+  }
+  // return new Promise((resolve, reject) => {
+  //   fsSync.readFile(filePath, 'utf8', (err, contents) => {
+  //     if (err) {
+  //       reject(err);
+  //     } else {
+  //       let data = {};
+  //       try {
+  //         data = JSON.parse(contents);
+  //       } catch (e) {
+  //         if (opts.throws) {
+  //           const err = new Error(`Invalid JSON contents for file: ${filePath}.`);
+  //           reject(err);
+  //           return;
+  //         }
+  //       }
+  //       resolve(data);
+  //     }
+  //   });
+  // });
+  const contents = await readFile(filePath, 'utf8');
+  let data = {};
+  try {
+    data = JSON.parse(contents);
+  } catch (e) {
+    if (opts.throws) {
+      throw new Error(`Invalid JSON contents for file: ${filePath}.`);
+    }
+  }
+  return data;
+}
+
+/**
+ * Writes the contents to the file.
+ * 
+ * @param filePath The file to write to. It replaces the contents.
+ * @param contents The contents to write.
+ */
+export async function writeJson(filePath: string, contents: string|any): Promise<void> {
+  const destParent = dirname(filePath);
+  await ensureDir(destParent);
+  const parentWritable = await canWrite(destParent);
+  if (!parentWritable) {
+    throw new Error(`Unable to write to location: ${parentWritable}. Access is denied.`);
+  }
+  const data = typeof contents === 'string' ? contents : JSON.stringify(contents);
+  await writeFile(filePath, data);
+}
+
+/**
+ * Ensures the directory exists.
+ */
+export async function ensureDir(dirPath: string): Promise<void> {
+  const readable = await canRead(dirPath);
+  if (readable) {
+    return;
+  }
+  await mkdir(dirPath, { recursive: true });
+}
+
+/**
+ * Removes contents of the directory, leaving the directory in the filesystem.
+ */
+export async function emptyDir(dirPath: string): Promise<void> {
+  const exists = await pathExists(dirPath);
+  if (!exists) {
+    return;
+  }
+  const writeable = await canWrite(dirPath);
+  if (!writeable) {
+    throw new Error(`Unable to clear directory: ${dirPath}. Access is denied.`);
+  }
+  const items = await readdir(dirPath, 'utf8');
+  for (const item of items) {
+    const file = join(dirPath, item);
+    await rm(file, { recursive: true });
+  }
+}
+
+/**
+ * Copies a file
+ */
+async function copyFile(source: string, dest: string): Promise<void> {
+  const destParent = dirname(dest);
+  await ensureDir(destParent);
+  await fsCopyFile(source, dest);
+}
+
+// /**
+//  * Copies a file
+//  * @param {string} source 
+//  * @param {string} dest 
+//  * @returns {Promise<void>}
+//  */
+// async function copyFile(source, dest) {
+//   const destParent = dirname(dest);
+//   await ensureDir(destParent);
+//   return new Promise((resolve, reject) => {
+//     fsSync.copyFile(source, dest, (err) => {
+//       if (err) {
+//         reject(err);
+//       } else {
+//         resolve();
+//       }
+//     });
+//   });
+// }
+
+/**
+ * Copies a directory and its contents.
+ */
+async function copyDirectory(source: string, dest: string): Promise<void> {
+  await ensureDir(dest);
+  // const entries = fsSync.readdirSync(source, { withFileTypes: true, encoding: 'utf8' });
+  const entries = await readdir(source, { withFileTypes: true, encoding: 'utf8' });
+  for (const entry of entries) {
+    const srcFile = join(source, entry.name);
+    const destFile = join(dest, entry.name);
+    const srcStat = await stat(srcFile);
+    if (srcStat.isDirectory()) {
+      await copyDirectory(srcFile, destFile);
+    } else {
+      await copyFile(srcFile, destFile);
+    }
+  }
+}
+
+/**
+ * Copies a file or a directory to the destination location.
+ * It creates the destination folder when missing.
+ * 
+ * @param source The source file or folder.
+ * @param dest The destination file or folder.
+ */
+export async function copy(source: string, dest: string): Promise<void> {
+  const existing = await pathExists(source);
+  if (!existing) {
+    throw new Error(`Specified path does not exist: ${source}`);
+  }
+  const srcStat = await stat(source);
+  if (srcStat.isDirectory()) {
+    await copyDirectory(source, dest);
+  } else {
+    await copyFile(source, dest);
+  }
+}

package/src/lib/parsers/UrlEncoder.ts

@@ -0,0 +1,74 @@
+export class UrlEncoder {
+  /**
+   * Returns a string where all characters that are not valid for a URL
+   * component have been escaped. The escaping of a character is done by
+   * converting it into its UTF-8 encoding and then encoding each of the
+   * resulting bytes as a %xx hexadecimal escape sequence.
+   * <p>
+   * Note: this method will convert any the space character into its escape
+   * short form, '+' rather than %20. It should therefore only be used for
+   * query-string parts.
+   *
+   * <p>
+   * The following character sets are <em>not</em> escaped by this method:
+   * <ul>
+   * <li>ASCII digits or letters</li>
+   * <li>ASCII punctuation characters:
+   *
+   * <pre>- _ . ! ~ * ' ( )</pre>
+   * </li>
+   * </ul>
+   * </p>
+   *
+   * <p>
+   * Notice that this method <em>does</em> encode the URL component delimiter
+   * characters:<blockquote>
+   *
+   * <pre>
+   * ; / ? : &amp; = + $ , #
+   * </pre>
+   *
+   * </blockquote>
+   * </p>
+   *
+   * @param str A string containing invalid URL characters
+   * @param replacePlus When set it replaces `%20` with `+`.
+   * @returns a string with all invalid URL characters escaped
+   */
+  static encodeQueryString(str: string, replacePlus?: boolean): string {
+    if (!str) {
+      return str;
+    }
+    // normalize
+    let result = str.toString().replace(/\r?\n/g, "\r\n");
+    // encode
+    result = encodeURIComponent(result);
+    if (replacePlus) {
+      // replace "%20" with "+" when needed
+      result = result.replace(/%20/g, "+");
+    }
+    return result;
+  }
+
+  /**
+   * Returns a string where all URL component escape sequences have been
+   * converted back to their original character representations.
+   *
+   * Note: this method will convert the space character escape short form, '+',
+   * into a space. It should therefore only be used for query-string parts.
+   *
+   * @param str A string containing encoded URL component sequences
+   * @param replacePlus When set it replaces `+` with `%20`.
+   * @returns string with no encoded URL component encoded sequences
+   */
+  static decodeQueryString(str: string, replacePlus?: boolean): string {
+    if (!str) {
+      return str;
+    }
+    let result = str;
+    if (replacePlus) {
+      result = str.replace(/\+/g, "%20");
+    }
+    return decodeURIComponent(result);
+  }
+}

package/src/lib/parsers/UrlParser.ts

@@ -0,0 +1,201 @@
+import { UrlValueParser, IUrlValueParserOptions } from './UrlValueParser.js';
+
+/**
+ * A class to parse URL string.
+ */
+export class UrlParser extends UrlValueParser {
+  /**
+   * @param value The URL value
+   */
+  constructor(value: string, opts?: IUrlValueParserOptions) {
+    super(opts);
+    this.value = value;
+  }
+
+  /**
+   * Returns protocol value in format `protocol` + ':'
+   *
+   * @return The value of the protocol or `undefined` if the value is not set
+   */
+  get protocol(): string | undefined {
+    return this.__data.protocol;
+  }
+
+  /**
+   * Sets value of the `protocol`
+   *
+   * @param value Protocol value.
+   */
+  set protocol(value: string | undefined) {
+    this.__data.protocol = value;
+  }
+
+  /**
+   * It reads the authority part of the URL value. It doesn't parses it
+   * to host, port and credentials parts.
+   *
+   * @return The value of the host or `undefined` if the value is not set
+   */
+  get host(): string | undefined {
+    return this.__data.host;
+  }
+
+  /**
+   * Sets value of the `host`
+   *
+   * @param value Host value.
+   */
+  set host(value: string | undefined) {
+    this.__data.host = value;
+  }
+
+  /**
+   * Returns path part of the URL.
+   *
+   * @returns The value of the path or `undefined` if the value not set
+   */
+  get path(): string | undefined {
+    return this.__data.path || '/';
+  }
+
+  /**
+   * Sets value of the `path`
+   *
+   * @param value Path value.
+   */
+  set path(value: string | undefined) {
+    this.__data.path = value;
+  }
+
+  /**
+   * Returns anchor part of the URL.
+   *
+   * @returns The value of the anchor or `undefined` if the value not set
+   */
+  get anchor(): string | undefined {
+    return this.__data.anchor;
+  }
+
+  /**
+   * Sets value of the `anchor`
+   *
+   * @param value The anchor value.
+   */
+  set anchor(value: string | undefined) {
+    this.__data.anchor = value;
+  }
+
+  /**
+   * Returns search part of the URL.
+   *
+   * @returns the value of the search or `undefined` if the value not set
+   */
+  get search(): string | undefined {
+    return this.__data.search;
+  }
+
+  /**
+   * Sets value of the `search`
+   *
+   * @param value Search value.
+   */
+  set search(value: string | undefined) {
+    this.__data.search = value;
+  }
+
+  /**
+   * The URL value. It is the same as calling `toString()`.
+   *
+   * @return The URL value for current configuration.
+   */
+  get value(): string {
+    return this.toString();
+  }
+
+  /**
+   * Sets value of the URL.
+   * It parses the url and sets properties.
+   *
+   * @param value The URL value.
+   */
+  set value(value: string) {
+    this.protocol = this._parseProtocol(value);
+    this.host = this._parseHost(value);
+    this.path = this._parsePath(value);
+    this.anchor = this._parseAnchor(value);
+    this.search = this._parseSearch(value);
+  }
+
+  /**
+   * Returns an array of search params.
+   *
+   * @returns The list of search params. Each item contains an
+   * array where the first item is the name of the parameter and the second item is the
+   * value.
+   */
+  get searchParams(): string[][] {
+    return this._parseSearchParams(this.search);
+  }
+
+  /**
+   * Sets the value of `search` and `searchParams`.
+   *
+   * @param value Search params list.
+   */
+  set searchParams(value: string[][]) {
+    if (!value || !value.length) {
+      this.search = undefined;
+      return;
+    }
+    this.search = value.map((item) => {
+      let itemValue = item[1];
+      if (!item[0] && !itemValue) {
+        return '';
+      }
+      if (itemValue === undefined) {
+        itemValue = '';
+      } else if (typeof itemValue !== 'string') {
+        itemValue = String(itemValue);
+      }
+      return `${item[0]}=${itemValue}`;
+    })
+    .join(this.opts.queryDelimiter);
+  }
+
+  /**
+   * Returns the URL for current settings.
+   *
+   * @return The URL value.
+   */
+  toString(): string {
+    let result = '';
+    if (this.protocol) {
+      result += this.protocol;
+      result += '//';
+    }
+    if (this.host) {
+      result += this.host;
+    }
+    if (this.path) {
+      if (this.path === '/' && !this.host && !this.search && !this.anchor) {
+        // ???
+      } else {
+        if (this.path[0] !== '/') {
+          result += '/';
+        }
+        result += this.path;
+      }
+    } else if (this.search || this.anchor) {
+        result += '/';
+      }
+    if (this.search) {
+      const p = this.searchParams;
+      this.searchParams = p;
+      result += `?${this.search}`;
+    }
+    if (this.anchor) {
+      result += `#${this.anchor}`;
+    }
+    return result;
+  }
+}