curl_transcode/src/config.ts

Transcode cURL query to various programming languages

import assert from "assert";
import * as path from "path";
import * as fs from "fs";
import json5 from "json5";
import Ajv from "ajv";
import { ConfigError } from "./error.ts";

const DEFAULT_RAW_CONFIG = {
  replace: []
};

class InternalError extends Error {
  constructor(message: string) {
    super(message);
    this.name = InternalError.name;
  }
}

export class Config {
  private static ajv = new Ajv();
  private static validate = Config.ajv.compile({
    type: "object",
    additionalProperties: false,
    properties: {
      replace: {
        type: "array",
        items: {
          type: "string"
        }
      }
    }
  });

  replace: Array<string>;

  constructor(replace: Array<string> = []) {
    this.replace = replace;
  }

  static fromDefaultFile(): Config {
    let filePath = path.join(".", ".curl_transcode.json");
    if (!fs.existsSync(filePath)) {
      return new Config();
    }
    try {
      let rawString = Config.readConfigurationFile(filePath);
      let rawConfig = Config.parseConfigJson(rawString);
      if (!this.validate(rawConfig)) {
        throw new InternalError(Config.getAjvErrorMessage());
      }
      rawConfig = Object.assign(DEFAULT_RAW_CONFIG, rawConfig);
      return new Config((rawConfig as any).replace);
    } catch (error) {
      if (error instanceof InternalError) {
        throw new ConfigError(filePath, error.message);
      }
      throw error;
    }
  }

  private static readConfigurationFile(filePath: string): string {
    try {
      return fs.readFileSync(filePath, "utf-8");
    } catch {
      throw new InternalError("can not read");
    }
  }

  private static parseConfigJson(text: string): any {
    try {
      return json5.parse(text);
    } catch {
      throw new InternalError("invalid JSON format");
    }
  }

  private static getAjvErrorMessage(): string {
    if (!Config.validate.errors || Config.validate.errors.length === 0) {
      throw new Error("no errors from Ajv");
    }
    let { instancePath, message } = Config.validate.errors[0];
    assert(message, "no error message from Ajv");
    if (instancePath) {
      return `property ${instancePath}: ${message}`;
    } else {
      return message;
    }
  }
}