@api-client/core 0.3.3 → 0.3.6

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/headers/Headers.ts

@@ -0,0 +1,219 @@
+import http from 'http';
+
+/* eslint-disable no-unused-vars */
+interface RawValue {
+  name: string;
+  value: string;
+}
+
+/**
+ * Normalizes name of a header.
+ * 
+ * @param name
+ * @return Normalized name
+ */
+function normalizeName(name: string): string {
+  if (typeof name !== 'string') {
+    name = String(name);
+  }
+  return name.toLowerCase();
+}
+
+/**
+ * Normalizes value of a header.
+ * @param value
+ * @return Normalized name
+ */
+function normalizeValue(value: string): string {
+  if (typeof value !== 'string') {
+    value = String(value);
+  }
+  return value;
+}
+
+/**
+ * A generator for list of headers from a string.
+ *
+ * ```javascript
+ * for (let [name, value] of headersStringToList('a:b')) {
+ *  ...
+ * }
+ * ```
+ * @param string Headers string to parse
+ */
+function* headersStringToList(string: string): Generator<string[]> {
+  if (!string || string.trim() === '') {
+    return [];
+  }
+  const headers = string.split(/\n(?=[^ \t]+)/gim);
+  for (let i = 0, len = headers.length; i < len; i++) {
+    const line = headers[i].trim();
+    if (line === '') {
+      continue;
+    }
+    const sepPosition = line.indexOf(':');
+    if (sepPosition === -1) {
+      yield [line, ''];
+    } else {
+      const name = line.substr(0, sepPosition);
+      const value = line.substr(sepPosition + 1).trim();
+      yield [name, value];
+    }
+  }
+}
+
+/**
+ * The same interface as Web platform's Headers but without 
+ * CORS restrictions.
+ */
+export class Headers {
+  /**
+   * The keys are canonical keys and the values are the input values.
+   */
+  map: Record<string, RawValue> = {};
+  /**
+   * @param headers The headers to parse.
+   */
+  constructor(headers?: string | Record<string, string> | Headers | http.IncomingHttpHeaders) {
+    if (headers instanceof Headers) {
+      headers.forEach((value, name) => this.append(name, value));
+    } else if (typeof headers === 'string') {
+      const iterator = headersStringToList(headers);
+      let result = iterator.next();
+      while (!result.done) {
+        this.append(result.value[0], result.value[1]);
+        result = iterator.next();
+      }
+    } else if (headers) {
+      Object.keys(headers).forEach((name) => this.append(name, headers[name]));
+    }
+  }
+
+  /**
+   * Adds value to existing header or creates new header
+   */
+  append(name: string, value: string | string[] | undefined): void {
+    if (Array.isArray(value)) {
+      value.forEach(v => this.append(name, v));
+      return;
+    }
+    const normalizedName = normalizeName(name);
+    value = value ? normalizeValue(value) : '';
+    let item = this.map[normalizedName];
+    if (item) {
+      const oldValue = item.value;
+      item.value = oldValue ? `${oldValue},${value}` : value;
+    } else {
+      item = {
+        name,
+        value,
+      };
+    }
+    this.map[normalizedName] = item;
+  }
+
+  /**
+   * Removes a header from the list of headers.
+   * @param name The header name
+   */
+  delete(name: string): void {
+    delete this.map[normalizeName(name)];
+  }
+
+  /**
+   * Returns the current value of the header
+   * @param name Header name
+   */
+  get(name: string): string | undefined {
+    name = normalizeName(name);
+    return this.has(name) ? this.map[name].value : undefined;
+  }
+
+  /**
+   * Checks if the header exists.
+   */
+  has(name: string): boolean {
+    return Object.prototype.hasOwnProperty.call(this.map, normalizeName(name));
+  }
+
+  /**
+   * Creates a new header. If the header exist it replaces the value.
+   */
+  set(name: string, value: string): void {
+    const normalizedName = normalizeName(name);
+    this.map[normalizedName] = {
+      value: normalizeValue(value),
+      name,
+    };
+  }
+
+  /**
+   * Iterates over each header.
+   */
+  forEach(callback: (value: string, name: string, headers: Headers) => void, thisArg?: unknown): void {
+    for (const name in this.map) {
+      if (Object.prototype.hasOwnProperty.call(this.map, name)) {
+        callback.call(thisArg, this.map[name].value, this.map[name].name, this);
+      }
+    }
+  }
+
+  /**
+   * @return The headers HTTP string
+   */
+  toString(): string {
+    const result: string[] = [];
+    this.forEach((value, name) => {
+      let tmp = `${name}: `;
+      if (value) {
+        tmp += value;
+      }
+      result.push(tmp);
+    });
+    return result.join('\n');
+  }
+
+  /**
+   * Iterates over keys.
+   */
+  *keys(): IterableIterator<string> {
+    for (const name in this.map) {
+      if (Object.prototype.hasOwnProperty.call(this.map, name)) {
+        yield this.map[name].name;
+      }
+    }
+  }
+
+  /**
+   * Iterates over values.
+   */
+  *values(): IterableIterator<string> {
+    for (const name in this.map) {
+      if (Object.prototype.hasOwnProperty.call(this.map, name)) {
+        yield this.map[name].value;
+      }
+    }
+  }
+
+  /**
+   * Iterates over headers.
+   */
+  *entries(): IterableIterator<string[]> {
+    for (const name in this.map) {
+      if (Object.prototype.hasOwnProperty.call(this.map, name)) {
+        yield [this.map[name].name, this.map[name].value];
+      }
+    }
+  }
+
+  /**
+   * Iterates over headers.
+   */
+  *[Symbol.iterator](): IterableIterator<string[]> {
+    for (const name in this.map) {
+      if (Object.prototype.hasOwnProperty.call(this.map, name)) {
+        yield [this.map[name].name, this.map[name].value];
+      }
+    }
+  }
+}

package/src/lib/logging/DefaultLogger.ts

@@ -0,0 +1,19 @@
+import { Logger } from './Logger.js';
+
+export class DefaultLogger extends Logger {
+  warn(...args: unknown[]): void {
+    console.warn(...args);
+  }
+  info(...args: unknown[]): void {
+    console.info(...args);
+  }
+  error(...args: unknown[]): void {
+    console.error(...args);
+  }
+  log(...args: unknown[]): void {
+    console.log(...args);
+  }
+  debug(...args: unknown[]): void {
+    console.debug(...args);
+  }
+}

package/src/lib/logging/DummyLogger.ts

@@ -0,0 +1,21 @@
+/* eslint-disable no-unused-vars */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Logger } from './Logger.js';
+
+export class DummyLogger extends Logger {
+  warn(...args: unknown[]): void {
+    // ...
+  }
+  info(...args: unknown[]): void {
+    // ...
+  }
+  error(...args: unknown[]): void {
+    // ...
+  }
+  log(...args: unknown[]): void {
+    // ...
+  }
+  debug(...args: unknown[]): void {
+    // ...
+  }
+}

package/src/lib/logging/Logger.ts

@@ -0,0 +1,16 @@
+/* eslint-disable no-unused-vars */
+export interface ILogger {
+  warn: (...args: unknown[]) => void;
+  info: (...args: unknown[]) => void;
+  error: (...args: unknown[]) => void;
+  log: (...args: unknown[]) => void;
+  debug: (...args: unknown[]) => void;
+}
+
+export abstract class Logger {
+  abstract warn(...args: unknown[]): void;
+  abstract info(...args: unknown[]): void;
+  abstract error(...args: unknown[]): void;
+  abstract log(...args: unknown[]): void;
+  abstract debug(...args: unknown[]): void;
+}

package/src/lib/timers/Timers.ts

@@ -0,0 +1,9 @@
+/**
+ * Awaits the set number of milliseconds before resolving the promise.
+ * @param timeout The number of milliseconds to wait.
+ */
+export function sleep(timeout = 0): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve(), timeout);
+  });
+}