Merge pull request #19 from tilde-lab/#12

Close #12

Author: blokhin

.eslintrc

@@ -0,0 +1,17 @@
+{
+    "extends": [
+        "eslint:recommended",
+        "plugin:@typescript-eslint/recommended"
+    ],
+    "plugins": [
+        "@typescript-eslint"
+    ],
+    "parser": "@typescript-eslint/parser",
+    "root": true,
+    "env": {
+        "node": true
+    },
+    "rules": {
+        "@typescript-eslint/no-explicit-any": "off"
+    }
+}

package-lock.json

@@ -7,31 +7,37 @@
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "npm run lint && rollup --config",
-    "lint": "tslint -c tslint.json \"src/**/*.ts\"",
-    "lint:fix": "tslint --fix -c tslint.json \"src/**/*.ts\"",
+    "lint": "eslint './src/**/*.ts'",
+    "lint:fix": "eslint --fix './src/**/*.ts'",
     "prepublishOnly": "npm run build && npm run prefetch",
     "test": "echo \"Error: no test specified\" && exit 1",
     "prefetch": "node prefetch.js"
   },
   "author": "Pavel Malyshev",
   "license": "MIT",
   "devDependencies": {
+    "@types/eslint": "^8.4.2",
+    "@typescript-eslint/eslint-plugin": "^5.25.0",
+    "@typescript-eslint/parser": "^5.25.0",
+    "@rollup/plugin-json": "^4.1.0",
     "@types/jest": "^26.0.15",
     "jest": "^26.6.0",
     "rollup": "^2.47.0",
     "rollup-plugin-typescript2": "^0.28.0",
     "ts-jest": "^26.4.1",
-    "tslint": "^6.1.3",
-    "tslint-eslint-rules": "^5.4.0",
+    "eslint": "^8.16.0",
     "typescript": "^4.0.3"
   },
   "dependencies": {
     "isomorphic-unfetch": "^3.1.0",
     "node-abort-controller": "^3.0.1"
   },
-  "keywords": ["optimade", "materials"],
+  "keywords": [
+    "optimade",
+    "materials"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/tilde-lab/optimade-client"
-   }
-}
+  }
+}

package.json

@@ -1,4 +1,7 @@
+/* jshint esversion: 6 */
+
 import typescript from 'rollup-plugin-typescript2';
+import json from '@rollup/plugin-json';
 
 import pkg from './package.json';
 
@@ -14,5 +17,6 @@ export default {
     ],
     plugins: [
         typescript(),
+        json(),
     ],
 };

rollup.config.js

@@ -1,11 +1,12 @@
 import { allSettled, fetchWithTimeout } from './utils';
+import { version } from '../package.json'
 
 import type * as Types from './types';
 export { Types };
 
 export class Optimade {
-    private providersUrl: string = '';
-    private corsProxyUrl: string = '';
+    private providersUrl = '';
+    private corsProxyUrl = '';
     providers: Types.ProvidersMap | null = null;
     apis: Types.ApisMap = {};
     private reqStack: string[] = [];
@@ -16,7 +17,7 @@ export class Optimade {
     }
 
     async addProvider(provider: Types.Provider) {
-        if (!this.apis[provider.id]) this.apis[provider.id] = [];
+        if (!this.apis[provider.id]) { this.apis[provider.id] = []; }
 
         try {
             const ver = provider.attributes
@@ -28,7 +29,7 @@ export class Optimade {
                 this.apis[provider.id].push(api);
             }
 
-        } catch (ignore) { }
+        } catch (ignore) { console.log(ignore) }
 
         if (!provider.attributes.query_limits) {
             const formula = `chemical_formula_anonymous="A2B"`;
@@ -37,7 +38,7 @@ export class Optimade {
             try {
                 const res = await fetch(url).then(res => res.json());
                 const version = res.meta && res.meta.api_version || this.apis[provider.id][0].attributes.api_version;
-                const detail = (errors: { detail: any; }[]) => {
+                const detail = (errors) => {
                     return errors
                         ? errors.length
                             ? errors[0].detail
@@ -71,18 +72,18 @@ export class Optimade {
             Optimade.getJSON(this.providersUrl).catch(() => null)
         );
 
-        if (!providers) return null;
-        if (!this.providers) this.providers = {};
+        if (!providers) { return null; }
+        if (!this.providers) { this.providers = {}; }
 
         const data = providers.data.filter(Optimade.isProviderValid);
         const ver = providers.meta && providers.meta.api_version ?
             providers.meta.api_version.charAt(0) : '';
 
         for (const provider of data) {
-            if (!this.apis[provider.id]) this.apis[provider.id] = [];
+            if (!this.apis[provider.id]) { this.apis[provider.id] = []; }
             try {
                 const api = await this.getApis(provider, ver ? `v${ver}` : '');
-                if (!api) continue;
+                if (!api) { continue; }
 
                 if (api.attributes.available_endpoints.includes('structures')) {
                     this.apis[provider.id].push(api);
@@ -92,36 +93,36 @@ export class Optimade {
                 } else {
                     await this.getProviders(api);
                 }
-            } catch (ignore) { }
+            } catch (ignore) { console.log(ignore) }
         }
 
         return this.providers;
     }
 
-    async getApis(provider: Types.Provider | string, version: string = ''): Promise<Types.Api | null> {
+    async getApis(provider: Types.Provider | string, version = ''): Promise<Types.Api | null> {
         if (typeof provider === 'string') {
             provider = this.providers[provider];
         }
 
-        if (!provider) throw new Error('No provider found');
+        if (!provider) { throw new Error('No provider found'); }
 
         const url: string = this.wrapUrl(`${provider.attributes.base_url}/${version}`, '/info');
 
-        if (this.isDuplicatedReq(url)) return null;
+        if (this.isDuplicatedReq(url)) { return null; }
 
         const apis: Types.InfoResponse = await Optimade.getJSON(url);
         return Optimade.apiVersion(apis);
     }
 
-    async getStructures(providerId: string, filter: string = '', page: number = 1, limit: number): Promise<Types.StructuresResponse[] | Types.ResponseError> {
+    async getStructures(providerId: string, filter = '', page = 1, limit: number): Promise<Types.StructuresResponse[] | Types.ResponseError> {
 
-        if (!this.apis[providerId]) return null;
+        if (!this.apis[providerId]) { return null; }
 
         const apis = this.apis[providerId].filter(api => api.attributes.available_endpoints.includes('structures'));
         const provider = this.providers[providerId];
 
         const structures: Types.StructuresResponse[] = await allSettled(apis.map(async (api: Types.Api) => {
-            if (page <= 0) page = 1;
+            if (page <= 0) { page = 1; }
             const pageLimit = limit ? `&page_limit=${limit}` : '';
             const pageNumber = page ? `&page_number=${page - 1}` : '';
             const pageOffset = limit && page ? `&page_offset=${limit * (page - 1)}` : '';
@@ -148,7 +149,7 @@ export class Optimade {
         }, []);
     }
 
-    getStructuresAll(providerIds: string[], filter: string = '', page: number = 1, limit: number, batch: boolean = true): Promise<Promise<Types.StructuresResult>[]> | Promise<Types.StructuresResult>[] {
+    getStructuresAll(providerIds: string[], filter = '', page = 1, limit: number, batch = true): Promise<Promise<Types.StructuresResult>[]> | Promise<Types.StructuresResult>[] {
 
         const results = providerIds.reduce((structures: Promise<any>[], providerId: string) => {
             const provider = this.providers[providerId];
@@ -165,7 +166,7 @@ export class Optimade {
     }
 
     private async followLinks(api: Types.Api): Promise<Types.LinksResponse | null> {
-        if (!api.attributes.available_endpoints.includes('links')) return null;
+        if (!api.attributes.available_endpoints.includes('links')) { return null; }
 
         const url = this.wrapUrl(Optimade.apiVersionUrl(api), '/links');
 
@@ -181,7 +182,7 @@ export class Optimade {
         return this.reqStack.includes(url) || !this.reqStack.unshift(url);
     }
 
-    static async getJSON(uri: string, params: {} = null, headers: {} = {}) {
+    static async getJSON(uri: string, params = null, headers = {}) {
 
         const url = new URL(uri);
         const timeout = 10000;
@@ -190,6 +191,8 @@ export class Optimade {
             Object.entries(params).forEach((param: [string, any]) => url.searchParams.append(...param));
         }
 
+        Object.assign(headers, { 'User-Agent': `tilde-lab-optimade-client/${version}` })
+
         const res = await fetchWithTimeout(url.toString(), { headers }, timeout);
 
         if (!res.ok) {

src/index.ts

@@ -46,7 +46,7 @@ export interface Api {
         api_version: string;
         available_api_versions: ApiVer | ApiVer[];
         available_endpoints: string[];
-        entry_types_by_format: {};
+        entry_types_by_format: Record<string, unknown>;
         formats: string[];
     };
 }

src/types.ts

@@ -11,6 +11,7 @@
         "noImplicitReturns": true,
         "noUnusedLocals": true,
         "noUnusedParameters": true,
+        "resolveJsonModule": true,
         "removeComments": true,
         "noLib": false,
         "moduleResolution": "node",