switched to tslint:recommended

Author: daimor

api/index.ts

@@ -1,34 +1,34 @@
-import * as vscode from "vscode";
 import * as httpModule from "http";
 import * as httpsModule from "https";
-import { outputConsole, currentWorkspaceFolder } from "../utils";
-const Cache = require("vscode-cache");
+import * as request from "request-promise";
+import * as url from "url";
+import * as vscode from "vscode";
+import * as Cache from "vscode-cache";
 import {
   config,
   extensionContext,
+  FILESYSTEM_SCHEMA,
   workspaceState,
-  FILESYSTEM_SCHEMA
 } from "../extension";
-import * as url from "url";
-import * as request from "request-promise";
+import { currentWorkspaceFolder, outputConsole } from "../utils";
 
 const DEFAULT_API_VERSION: number = 1;
 // require("request-promise").debug = true;
 
 export class AtelierAPI {
-  private _config: any;
-  private _namespace: string;
-  private _cache;
-  private _workspaceFolder;
+  private config: any;
+  private namespace: string;
+  private cache;
+  private workspaceFolder;
 
   public get ns(): string {
-    return this._namespace || this._config.ns;
+    return this.namespace || this.config.ns;
   }
 
   private get apiVersion(): number {
     return workspaceState.get(
-      this._workspaceFolder + ":apiVersion",
-      DEFAULT_API_VERSION
+      this.workspaceFolder + ":apiVersion",
+      DEFAULT_API_VERSION,
     );
   }
 
@@ -38,11 +38,11 @@ export class AtelierAPI {
       if (wsOrFile instanceof vscode.Uri) {
         if (wsOrFile.scheme === FILESYSTEM_SCHEMA) {
           workspaceFolderName = wsOrFile.authority;
-          let query = url.parse(decodeURIComponent(wsOrFile.toString()), true)
+          const query = url.parse(decodeURIComponent(wsOrFile.toString()), true)
             .query;
           if (query) {
             if (query.ns && query.ns !== "") {
-              let namespace = query.ns.toString();
+              const namespace = query.ns.toString();
               this.setNamespace(namespace);
             }
           }
@@ -54,65 +54,65 @@ export class AtelierAPI {
     this.setConnection(workspaceFolderName || currentWorkspaceFolder());
   }
 
-  setNamespace(namespace: string) {
-    this._namespace = namespace;
+  public setNamespace(namespace: string) {
+    this.namespace = namespace;
   }
 
   get cookies(): string[] {
-    return this._cache.get("cookies", []);
+    return this.cache.get("cookies", []);
   }
 
-  updateCookies(newCookies: string[]): Promise<any> {
-    let cookies = this._cache.get("cookies", []);
-    newCookies.forEach(cookie => {
-      let [cookieName] = cookie.split("=");
-      let index = cookies.findIndex(el => el.startsWith(cookieName));
+  public updateCookies(newCookies: string[]): Promise<any> {
+    const cookies = this.cache.get("cookies", []);
+    newCookies.forEach((cookie) => {
+      const [cookieName] = cookie.split("=");
+      const index = cookies.findIndex((el) => el.startsWith(cookieName));
       if (index >= 0) {
         cookies[index] = cookie;
       } else {
         cookies.push(cookie);
       }
     });
-    return this._cache.put("cookies", cookies);
+    return this.cache.put("cookies", cookies);
   }
 
-  setConnection(workspaceFolderName: string) {
-    this._workspaceFolder = workspaceFolderName;
-    let conn = config("conn", workspaceFolderName);
-    this._config = conn;
-    const { name, host, port } = this._config;
-    this._cache = new Cache(extensionContext, `API:${name}:${host}:${port}`);
+  public setConnection(workspaceFolderName: string) {
+    this.workspaceFolder = workspaceFolderName;
+    const conn = config("conn", workspaceFolderName);
+    this.config = conn;
+    const { name, host, port } = this.config;
+    this.cache = new Cache(extensionContext, `API:${name}:${host}:${port}`);
   }
 
-  async request(
+  public async request(
     minVersion: number,
     method: string,
     path?: string,
     body?: any,
     params?: any,
-    headers?: any
+    headers?: any,
   ): Promise<any> {
     if (minVersion > this.apiVersion) {
       return Promise.reject(
-        `${path} not supported by API version ${this.apiVersion}`
+        `${path} not supported by API version ${this.apiVersion}`,
       );
     }
     if (minVersion && minVersion > 0) {
       path = `v${this.apiVersion}/${path}`;
     }
-    if (!this._config.active) {
+    if (!this.config.active) {
       return Promise.reject();
     }
     headers = {
       ...headers,
-      Accept: "application/json"
+      Accept: "application/json",
     };
     const buildParams = (): string => {
       if (!params) {
         return "";
       }
-      let result = [];
-      Object.keys(params).forEach(key => {
+      const result = [];
+      Object.keys(params).forEach((key) => {
         let value = params[key];
         if (value && value !== "") {
           if (typeof value === "boolean") {
@@ -129,54 +129,46 @@ export class AtelierAPI {
     }
     headers["Cache-Control"] = "no-cache";
 
-    const { host, port, username, password, https } = this._config;
-    const proto = this._config.https ? "https" : "http";
-    const http: any = this._config.https ? httpsModule : httpModule;
+    const { host, port, username, password, https } = this.config;
+    const proto = this.config.https ? "https" : "http";
+    const http: any = this.config.https ? httpsModule : httpModule;
     const agent = new http.Agent({
       keepAlive: true,
       maxSockets: 10,
-      rejectUnauthorized: https && config("http.proxyStrictSSL")
+      rejectUnauthorized: https && config("http.proxyStrictSSL"),
     });
     path = encodeURI(`/api/atelier/${path || ""}${buildParams()}`);
 
-    // if (headers["Content-Type"] && headers["Content-Type"].includes("json")) {
-    //   body = JSON.stringify(body);
-    // }
-
-    // console.log(`APIRequest: ${method} ${proto}://${host}:${port}${path}`)
-
-    let cookies = this.cookies;
+    const cookies = this.cookies;
     let auth;
-    if (cookies.length || method === 'HEAD') {
+    if (cookies.length || method === "HEAD") {
       auth = Promise.resolve(cookies);
     } else if (!cookies.length) {
-      auth = this.request(0, 'HEAD')
+      auth = this.request(0, "HEAD");
     }
-    return auth.then((cookies) => {
-      // console.log('cookies', cookies);
+    return auth.then((cookie) => {
       return request({
-        // jar: cookieJar,
-        uri: `${proto}://${host}:${port}${path}`,
-        method,
         agent,
         auth: { username, password, sendImmediately: false },
+        body: ["PUT", "POST"].includes(method) ? body : null,
         headers: {
           ...headers,
-          Cookie: cookies
+          Cookie: cookie,
         },
-        body: ["PUT", "POST"].includes(method) ? body : null,
         json: true,
+        method,
         resolveWithFullResponse: true,
-        simple: true
+        simple: true,
+        uri: `${proto}://${host}:${port}${path}`,
       })
         // .catch(error => error.error)
-        .then(response => this.updateCookies(response.headers["set-cookie"]).then(() => response))
-        .then(response => {
+        .then((response) => this.updateCookies(response.headers["set-cookie"]).then(() => response))
+        .then((response) => {
           // console.log(`APIResponse: ${method} ${proto}://${host}:${port}${path}`)
-          if (method === 'HEAD') {
-            return this.cookies
+          if (method === "HEAD") {
+            return this.cookies;
           }
-          let data = response.body;
+          const data = response.body;
           if (data.console) {
             outputConsole(data.console);
           }
@@ -185,27 +177,27 @@ export class AtelierAPI {
           } else if (data.result.status) {
             throw new Error(data.result.status);
           } else {
-            return data
+            return data;
           }
-        })
+        });
     });
   }
 
-  serverInfo(): Promise<any> {
+  public serverInfo(): Promise<any> {
     return this.request(0, "GET")
-      .then(info => {
+      .then((info) => {
         if (
           info &&
           info.result &&
           info.result.content &&
           info.result.content.api > 0
         ) {
-          let data = info.result.content;
-          let apiVersion = data.api;
+          const data = info.result.content;
+          const apiVersion = data.api;
           if (!data.namespaces.includes(this.ns)) {
             throw {
               code: "WrongNamespace",
-              message: "This server does not have specified namespace."
+              message: "This server does not have specified namespace.",
             };
           }
           return workspaceState
@@ -215,11 +207,11 @@ export class AtelierAPI {
       });
   }
   // api v1+
-  getDocNames({
+  public getDocNames({
     generated = false,
     category = "*",
     type = "*",
-    filter = ""
+    filter = "",
   }: {
     generated?: boolean;
     category?: string;
@@ -233,39 +225,39 @@ export class AtelierAPI {
       null,
       {
         filter,
-        generated
-      }
+        generated,
+      },
     );
   }
   // api v1+
-  getDoc(name: string, format?: string): Promise<any> {
+  public getDoc(name: string, format?: string): Promise<any> {
     let params = {};
     if (format) {
       params = {
-        format
+        format,
       };
     }
     return this.request(1, "GET", `${this.ns}/doc/${name}`, params);
   }
   // api v1+
-  deleteDoc(name: string): Promise<any> {
+  public deleteDoc(name: string): Promise<any> {
     return this.request(1, "DELETE", `${this.ns}/doc/${name}`);
   }
   // v1+
-  putDoc(
+  public putDoc(
     name: string,
     data: { enc: boolean; content: string[] },
-    ignoreConflict?: boolean
+    ignoreConflict?: boolean,
   ): Promise<any> {
-    let params = { ignoreConflict };
+    const params = { ignoreConflict };
     return this.request(1, "PUT", `${this.ns}/doc/${name}`, data, params);
   }
   // v1+
-  actionIndex(docs: string[]): Promise<any> {
+  public actionIndex(docs: string[]): Promise<any> {
     return this.request(1, "POST", `${this.ns}/action/index`, docs);
   }
   // v2+
-  actionSearch(params: {
+  public actionSearch(params: {
     query: string;
     files?: string;
     sys?: boolean;
@@ -275,53 +267,53 @@ export class AtelierAPI {
     return this.request(2, "GET", `${this.ns}/action/search`, null, params);
   }
   // v1+
-  actionQuery(query: string, parameters: string[]): Promise<any> {
+  public actionQuery(query: string, parameters: string[]): Promise<any> {
     // outputChannel.appendLine('SQL: ' + query);
     // outputChannel.appendLine('SQLPARAMS: ' + JSON.stringify(parameters));
     return this.request(1, "POST", `${this.ns}/action/query`, {
+      parameters,
       query,
-      parameters
     });
   }
   // v1+
-  actionCompile(docs: string[], flags?: string, source = false): Promise<any> {
+  public actionCompile(docs: string[], flags?: string, source = false): Promise<any> {
     return this.request(1, "POST", `${this.ns}/action/compile`, docs, {
       flags,
-      source
+      source,
     });
   }
 
-  cvtXmlUdl(source: string): Promise<any> {
+  public cvtXmlUdl(source: string): Promise<any> {
     return this.request(
       1,
       "POST",
       `${this.ns}/`,
       source,
       {},
-      { "Content-Type": "application/xml" }
+      { "Content-Type": "application/xml" },
     );
   }
   // v2+
-  getmacrodefinition(docname: string, macroname: string, includes: string[]) {
+  public getmacrodefinition(docname: string, macroname: string, includes: string[]) {
     return this.request(2, "POST", `${this.ns}/action/getmacrodefinition`, {
       docname,
+      includes,
       macroname,
-      includes
     });
   }
   // v2+
-  getmacrolocation(docname: string, macroname: string, includes: string[]) {
+  public getmacrolocation(docname: string, macroname: string, includes: string[]) {
     return this.request(2, "POST", `${this.ns}/action/getmacrolocation`, {
       docname,
+      includes,
       macroname,
-      includes
     });
   }
   // v2+
-  getmacrollist(docname: string, includes: string[]) {
+  public getmacrollist(docname: string, includes: string[]) {
     return this.request(2, "POST", `${this.ns}/action/getmacrolist`, {
       docname,
-      includes
+      includes,
     });
   }
 }