eth-graph-query 0.1.3

package/src/normal-query.ts

@@ -0,0 +1,34 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import axios, { AxiosRequestConfig, AxiosResponse } from 'axios';
+
+export const defaultHeader = { Accept: 'application/json', 'Content-Type': 'application/json' };
+
+function responseBody<T>(res: AxiosResponse<T>) {
+  return res.data;
+}
+
+export default class NormalQuery {
+  root: string;
+  config: AxiosRequestConfig;
+
+  constructor(rootUrl: string, config?: AxiosRequestConfig) {
+    this.root = rootUrl;
+    this.config = config ? { ...config, ...{ headers: defaultHeader } } : { headers: defaultHeader };
+  }
+
+  protected async get<T = any>(url: string, config?: AxiosRequestConfig) {
+    return await axios.get(`${this.root}${url}`, { ...config, ...this.config }).then<T>(responseBody);
+  }
+
+  protected async post<B = any, T = any>(url: string, data?: B, config?: AxiosRequestConfig) {
+    return await axios.post(`${this.root}${url}`, data, { ...config, ...this.config }).then<T>(responseBody);
+  }
+
+  protected async put<B = any, T = any>(url: string, data?: B, config?: AxiosRequestConfig) {
+    return await axios.put(`${this.root}${url}`, data, { ...config, ...this.config }).then<T>(responseBody);
+  }
+
+  protected async del<T = any>(url: string, config?: AxiosRequestConfig) {
+    return await axios.delete(`${this.root}${url}`, { ...config, ...this.config }).then<T>(responseBody);
+  }
+}

package/src/query-builder.ts

@@ -0,0 +1,89 @@
+import { ElementType, GraphParams, OptionKeys, OptionsKey, QueryJson, WhereOptions } from './type';
+
+export default class QueryBuilder {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static isWhereOptions(data: any) {
+    const keys = Object.keys(data);
+    if (keys.length == 0) return true;
+    for (const key of keys) {
+      if (!OptionKeys.includes(key)) return false;
+    }
+    return true;
+  }
+
+  static buildJsonQuery(query: QueryJson): string {
+    const whereList = [];
+    for (const key in query) {
+      if (query[key] != undefined) {
+        if (Array.isArray(query[key])) {
+          const queryArray = query[key] as Array<string>;
+          whereList.push(`${key}: [${queryArray.map((item) => `"${item}"`).join(', ')}]`);
+        } else if (this.isWhereOptions(query[key])) {
+          const realJson: QueryJson = {};
+          const options = query[key] as WhereOptions;
+          for (const option in options) {
+            const value = options[option as OptionsKey];
+            if (value) realJson[`${key}_${option}`] = value;
+          }
+          whereList.push(`${this.buildJsonQuery(realJson as QueryJson)}`);
+        } else if (typeof query[key] == 'object')
+          whereList.push(`${key}: {${this.buildJsonQuery(query[key] as QueryJson)}}`);
+        else if (typeof query[key] == 'string') whereList.push(`${key}: "${query[key]}"`);
+        else whereList.push(`${key}: ${query[key]}`);
+      }
+    }
+    return whereList.join(', ');
+  }
+
+  static buildElements(elements: Array<ElementType>): Array<string> {
+    const elementList = [];
+    for (const element of elements) {
+      if (typeof element == 'string') elementList.push(element);
+      else {
+        const object = element as { collection: string; params: GraphParams };
+        elementList.push(this.buildQuery(object.collection, object.params));
+      }
+    }
+    return elementList;
+  }
+
+  static buildQuery(collection: string, params?: GraphParams) {
+    const filters: Array<string> = [];
+    if (params?.id != undefined) filters.push(`id: ${params.id}`);
+    if (params?.orderBy) filters.push(`orderBy: ${params.orderBy}`);
+    if (params?.orderDirection) filters.push(`orderDirection: ${params.orderDirection}`);
+    if (params?.first != undefined) {
+      if (params.first < 0) params.first = 0;
+      else if (params.first > 1000) params.first = 1000;
+      filters.push(`first: ${params.first}`);
+    }
+    if (params?.skip != undefined) {
+      if (params.skip < 0) params.skip = 0;
+      else if (params.skip > 5000) params.skip = 5000;
+      filters.push(`skip: ${params.skip}`);
+    }
+    if (params?.where) {
+      const sWhere = this.buildJsonQuery(params.where);
+      if (sWhere.length > 0) filters.push(`where: {${sWhere}}`);
+    }
+    if (params?.block) {
+      const sBlock = this.buildJsonQuery(params.block);
+      if (sBlock.length > 0) filters.push(`block: {${sBlock}}`);
+    }
+    const filterString = filters.join(', ');
+    let elements: Array<string> = ['id'];
+    if (params?.elements) if (params.elements.length > 0) elements = this.buildElements(params.elements);
+    if (filterString.length > 0) return `${collection}(${filterString}) {${elements.join(' ')}}`;
+    else return `${collection} {${elements.join(' ')}}`;
+  }
+
+  static mergeQuery(data: Array<{ collection: string; params?: GraphParams }>) {
+    const queries: Array<string> = [];
+    for (const item of data) queries.push(this.buildQuery(item.collection, item.params));
+    return queries.join(' ');
+  }
+
+  static makeFullQuery(query: string) {
+    return `query MyQuery {${query}}`;
+  }
+}

package/src/type.ts

@@ -0,0 +1,86 @@
+type BaseQueryType = Array<string> | string | number | boolean | undefined;
+
+export const OptionKeys = [
+  'contains',
+  'contains_nocase',
+  'ends_with',
+  'end_with_nocase',
+  'starts_with',
+  'starts_with_nocase',
+  'not_contains',
+  'not_contains_nocase',
+  'not_ends_with',
+  'not_ends_with_nocase',
+  'not_starts_with',
+  'not_starts_with_nocase',
+  'gt',
+  'gte',
+  'lt',
+  'lts',
+  'not',
+  'in',
+  'not_in',
+];
+export type OptionsKey =
+  | 'contains'
+  | 'contains_nocase'
+  | 'ends_with'
+  | 'end_with_nocase'
+  | 'starts_with'
+  | 'starts_with_nocase'
+  | 'not_contains'
+  | 'not_contains_nocase'
+  | 'not_ends_with'
+  | 'not_ends_with_nocase'
+  | 'not_starts_with'
+  | 'not_starts_with_nocase'
+  | 'gt'
+  | 'gte'
+  | 'lt'
+  | 'lte'
+  | 'not'
+  | 'in'
+  | 'not_in';
+
+export type TextWhereOptions = {
+  contains?: BaseQueryType;
+  contains_nocase?: BaseQueryType;
+  ends_with?: BaseQueryType;
+  end_with_nocase?: BaseQueryType;
+  starts_with?: BaseQueryType;
+  starts_with_nocase?: BaseQueryType;
+  not_contains?: BaseQueryType;
+  not_contains_nocase?: BaseQueryType;
+  not_ends_with?: BaseQueryType;
+  not_ends_with_nocase?: BaseQueryType;
+  not_starts_with?: BaseQueryType;
+  not_starts_with_nocase?: BaseQueryType;
+};
+
+export type CommonWhereOptions = {
+  gt?: BaseQueryType;
+  gte?: BaseQueryType;
+  lt?: BaseQueryType;
+  lte?: BaseQueryType;
+  not?: BaseQueryType;
+  in?: BaseQueryType;
+  not_in?: BaseQueryType;
+};
+
+export type WhereOptions = TextWhereOptions & CommonWhereOptions;
+
+export type QueryJson = { [key: string]: QueryJson | WhereOptions | BaseQueryType };
+export type BlockQuery = { hash?: string; number?: number; number_gte?: number };
+export type ElementType = string | { collection: string; params?: GraphParams };
+
+export interface GraphParams {
+  elements?: Array<ElementType>;
+  where?: QueryJson;
+  id?: string;
+  first?: number;
+  orderBy?: string;
+  orderDirection?: 'asc' | 'desc';
+  skip?: number;
+  subgraphError?: 'allow' | 'deny';
+  block?: BlockQuery;
+}