eth-graph-query 0.1.3

package/README.md

@@ -0,0 +1,76 @@
+<h1>
+eth-graph-query
+</h1>
+
+Simple package for create query command to [the GraphQL](https://thegraph.com/).
+
+---
+
+### Installation
+
+```shell
+npm install eth-graph-query
+
+```
+
+---
+
+### Usage
+
+- The first thing you have to do is creating a query instance
+
+```js
+const query = new EthGraphQuery(root);
+```
+
+- This package has two query options. To create simple query
+
+```js
+const result = await query.query('collection1', { elements: ['element1', 'element2'] });
+```
+
+- To create a multiple query
+
+```js
+const result = await query.mergeQuery([
+  { collection: 'collection1', params: { elements: ['element11', 'element12'] } },
+  { collection: 'collection2', params: { elements: ['element21', 'element22'] } },
+]);
+```
+
+- You can create a complex query
+
+```js
+const result1 = await query.mergeQuery([
+  { collection: 'collection1', params: { elements: ['element11', 'element12'], where: { element11: 'abc' } } },
+  {
+    collection: 'collection2',
+    params: {
+      elements: [
+        'element21',
+        {
+          collection: 'collection3',
+          params: { elements: ['element31'], where: { id: { in: ['123'] }, element31: 'element31' }, first: 50 },
+        },
+      ],
+      where: { element21: '123', collection3: { element31: '123' } },
+    },
+  },
+]);
+```
+
+---
+
+### For develop
+
+- To test package, you can run below command
+
+```shell
+npm run test
+```
+
+- Before running above command, you must create `.env` file
+
+```shell
+cp .env.example .env
+```

package/dist/cjs/core/index.d.ts

@@ -0,0 +1,12 @@
+import { AxiosRequestConfig } from 'axios';
+import NormalQuery from './normal-query';
+import { GraphParams } from '../type';
+export default class CoreGraphQuery extends NormalQuery {
+    constructor(rootUrl: string, config?: AxiosRequestConfig);
+    protected _fetch(query: string): Promise<any>;
+    query(collection: string, params?: GraphParams): Promise<any>;
+    mergeQuery(data: Array<{
+        collection: string;
+        params?: GraphParams;
+    }>): Promise<any>;
+}

package/dist/cjs/core/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const normal_query_1 = require("./normal-query");
+const query_builder_1 = require("./query-builder");
+class CoreGraphQuery extends normal_query_1.default {
+    constructor(rootUrl, config) {
+        super(rootUrl, config);
+    }
+    async _fetch(query) {
+        return await this.post('', { query: query });
+    }
+    async query(collection, params) {
+        const sQuery = query_builder_1.default.buildQuery(collection, params);
+        return await this._fetch(query_builder_1.default.makeFullQuery(sQuery));
+    }
+    async mergeQuery(data) {
+        const sQuery = query_builder_1.default.mergeQuery(data);
+        return await this._fetch(query_builder_1.default.makeFullQuery(sQuery));
+    }
+}
+exports.default = CoreGraphQuery;

package/dist/cjs/core/normal-query.d.ts

@@ -0,0 +1,14 @@
+import { AxiosRequestConfig } from 'axios';
+export declare const defaultHeader: {
+    Accept: string;
+    'Content-Type': string;
+};
+export default class NormalQuery {
+    root: string;
+    config: AxiosRequestConfig;
+    constructor(rootUrl: string, config?: AxiosRequestConfig);
+    protected get<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    protected post<B = any, T = any>(url: string, data?: B, config?: AxiosRequestConfig): Promise<T>;
+    protected put<B = any, T = any>(url: string, data?: B, config?: AxiosRequestConfig): Promise<T>;
+    protected del<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+}

package/dist/cjs/core/normal-query.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultHeader = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const axios_1 = require("axios");
+exports.defaultHeader = { Accept: 'application/json', 'Content-Type': 'application/json' };
+function responseBody(res) {
+    return res.data;
+}
+class NormalQuery {
+    constructor(rootUrl, config) {
+        this.root = rootUrl;
+        this.config = config ? { ...config, ...{ headers: exports.defaultHeader } } : { headers: exports.defaultHeader };
+    }
+    async get(url, config) {
+        return await axios_1.default.get(`${this.root}${url}`, { ...config, ...this.config }).then(responseBody);
+    }
+    async post(url, data, config) {
+        return await axios_1.default.post(`${this.root}${url}`, data, { ...config, ...this.config }).then(responseBody);
+    }
+    async put(url, data, config) {
+        return await axios_1.default.put(`${this.root}${url}`, data, { ...config, ...this.config }).then(responseBody);
+    }
+    async del(url, config) {
+        return await axios_1.default.delete(`${this.root}${url}`, { ...config, ...this.config }).then(responseBody);
+    }
+}
+exports.default = NormalQuery;

package/dist/cjs/core/query-builder.d.ts

@@ -0,0 +1,10 @@
+import { GraphParams, QueryJson } from '../type';
+export default class QueryBuilder {
+    static buildJsonQuery(query: QueryJson): string;
+    static buildQuery(collection: string, params?: GraphParams): string;
+    static mergeQuery(data: Array<{
+        collection: string;
+        params?: GraphParams;
+    }>): string;
+    static makeFullQuery(query: string): string;
+}

package/dist/cjs/core/query-builder.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class QueryBuilder {
+    static buildJsonQuery(query) {
+        const whereList = [];
+        for (const key in query) {
+            if (query[key] != undefined) {
+                if (Array.isArray(query[key])) {
+                    const queryArray = query[key];
+                    whereList.push(`${key}: [${queryArray.map((item) => `"${item}"`).join(', ')}]`);
+                }
+                else if (typeof query[key] == 'object')
+                    whereList.push(`${key}: {${this.buildJsonQuery(query[key])}}`);
+                else if (typeof query[key] == 'string')
+                    whereList.push(`${key}: "${query[key]}"`);
+                else
+                    whereList.push(`${key}: ${query[key]}`);
+            }
+        }
+        return whereList.join(', ');
+    }
+    static buildQuery(collection, params) {
+        const filters = [];
+        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 = ['id'];
+        if (params?.elements)
+            if (params.elements.length > 0)
+                elements = params.elements;
+        if (filterString.length > 0)
+            return `${collection}(${filterString}) {${elements.join(' ')}}`;
+        else
+            return `${collection} {${elements.join(' ')}}`;
+    }
+    static mergeQuery(data) {
+        const queries = [];
+        for (const item of data)
+            queries.push(this.buildQuery(item.collection, item.params));
+        return queries.join(' ');
+    }
+    static makeFullQuery(query) {
+        return `query MyQuery {${query}}`;
+    }
+}
+exports.default = QueryBuilder;

package/dist/cjs/data-set.d.ts

@@ -0,0 +1,5 @@
+import { BaseQueryPattern } from './type';
+export default class DataSet<T extends BaseQueryPattern> {
+    collection: string;
+    constructor(collection: string);
+}

package/dist/cjs/data-set.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DataSet {
+    constructor(collection) {
+        this.collection = collection;
+    }
+}
+exports.default = DataSet;

package/dist/cjs/index.d.ts

@@ -0,0 +1,12 @@
+import { AxiosRequestConfig } from 'axios';
+import NormalQuery from './normal-query';
+import { GraphParams } from './type';
+export default class CoreGraphQuery extends NormalQuery {
+    constructor(rootUrl: string, config?: AxiosRequestConfig);
+    protected _fetch(query: string): Promise<any>;
+    query(collection: string, params?: GraphParams): Promise<any>;
+    mergeQuery(data: Array<{
+        collection: string;
+        params?: GraphParams;
+    }>): Promise<any>;
+}

package/dist/cjs/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const normal_query_1 = require("./normal-query");
+const query_builder_1 = require("./query-builder");
+class CoreGraphQuery extends normal_query_1.default {
+    constructor(rootUrl, config) {
+        super(rootUrl, config);
+    }
+    async _fetch(query) {
+        return await this.post('', { query: query });
+    }
+    async query(collection, params) {
+        const sQuery = query_builder_1.default.buildQuery(collection, params);
+        return await this._fetch(query_builder_1.default.makeFullQuery(sQuery));
+    }
+    async mergeQuery(data) {
+        const sQuery = query_builder_1.default.mergeQuery(data);
+        return await this._fetch(query_builder_1.default.makeFullQuery(sQuery));
+    }
+}
+exports.default = CoreGraphQuery;

package/dist/cjs/normal-query.d.ts

@@ -0,0 +1,14 @@
+import { AxiosRequestConfig } from 'axios';
+export declare const defaultHeader: {
+    Accept: string;
+    'Content-Type': string;
+};
+export default class NormalQuery {
+    root: string;
+    config: AxiosRequestConfig;
+    constructor(rootUrl: string, config?: AxiosRequestConfig);
+    protected get<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    protected post<B = any, T = any>(url: string, data?: B, config?: AxiosRequestConfig): Promise<T>;
+    protected put<B = any, T = any>(url: string, data?: B, config?: AxiosRequestConfig): Promise<T>;
+    protected del<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+}

package/dist/cjs/normal-query.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultHeader = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const axios_1 = require("axios");
+exports.defaultHeader = { Accept: 'application/json', 'Content-Type': 'application/json' };
+function responseBody(res) {
+    return res.data;
+}
+class NormalQuery {
+    constructor(rootUrl, config) {
+        this.root = rootUrl;
+        this.config = config ? { ...config, ...{ headers: exports.defaultHeader } } : { headers: exports.defaultHeader };
+    }
+    async get(url, config) {
+        return await axios_1.default.get(`${this.root}${url}`, { ...config, ...this.config }).then(responseBody);
+    }
+    async post(url, data, config) {
+        return await axios_1.default.post(`${this.root}${url}`, data, { ...config, ...this.config }).then(responseBody);
+    }
+    async put(url, data, config) {
+        return await axios_1.default.put(`${this.root}${url}`, data, { ...config, ...this.config }).then(responseBody);
+    }
+    async del(url, config) {
+        return await axios_1.default.delete(`${this.root}${url}`, { ...config, ...this.config }).then(responseBody);
+    }
+}
+exports.default = NormalQuery;

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

package/dist/cjs/query-builder.d.ts

@@ -0,0 +1,12 @@
+import { ElementType, GraphParams, QueryJson } from './type';
+export default class QueryBuilder {
+    static isWhereOptions(data: any): boolean;
+    static buildJsonQuery(query: QueryJson): string;
+    static buildElements(elements: Array<ElementType>): Array<string>;
+    static buildQuery(collection: string, params?: GraphParams): string;
+    static mergeQuery(data: Array<{
+        collection: string;
+        params?: GraphParams;
+    }>): string;
+    static makeFullQuery(query: string): string;
+}

package/dist/cjs/query-builder.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const type_1 = require("./type");
+class QueryBuilder {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static isWhereOptions(data) {
+        const keys = Object.keys(data);
+        if (keys.length == 0)
+            return true;
+        for (const key of keys) {
+            if (!type_1.OptionKeys.includes(key))
+                return false;
+        }
+        return true;
+    }
+    static buildJsonQuery(query) {
+        const whereList = [];
+        for (const key in query) {
+            if (query[key] != undefined) {
+                if (Array.isArray(query[key])) {
+                    const queryArray = query[key];
+                    whereList.push(`${key}: [${queryArray.map((item) => `"${item}"`).join(', ')}]`);
+                }
+                else if (this.isWhereOptions(query[key])) {
+                    const realJson = {};
+                    const options = query[key];
+                    for (const option in options) {
+                        const value = options[option];
+                        if (value)
+                            realJson[`${key}_${option}`] = value;
+                    }
+                    whereList.push(`${this.buildJsonQuery(realJson)}`);
+                }
+                else if (typeof query[key] == 'object')
+                    whereList.push(`${key}: {${this.buildJsonQuery(query[key])}}`);
+                else if (typeof query[key] == 'string')
+                    whereList.push(`${key}: "${query[key]}"`);
+                else
+                    whereList.push(`${key}: ${query[key]}`);
+            }
+        }
+        return whereList.join(', ');
+    }
+    static buildElements(elements) {
+        const elementList = [];
+        for (const element of elements) {
+            if (typeof element == 'string')
+                elementList.push(element);
+            else {
+                const object = element;
+                elementList.push(this.buildQuery(object.collection, object.params));
+            }
+        }
+        return elementList;
+    }
+    static buildQuery(collection, params) {
+        const filters = [];
+        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 = ['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) {
+        const queries = [];
+        for (const item of data)
+            queries.push(this.buildQuery(item.collection, item.params));
+        return queries.join(' ');
+    }
+    static makeFullQuery(query) {
+        return `query MyQuery {${query}}`;
+    }
+}
+exports.default = QueryBuilder;

package/dist/cjs/type.d.ts

@@ -0,0 +1,51 @@
+type BaseQueryType = Array<string> | string | number | boolean | undefined;
+export declare const OptionKeys: string[];
+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;
+}
+export {};

package/dist/cjs/type.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionKeys = void 0;
+exports.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',
+];

package/dist/esm/core/index.d.ts

@@ -0,0 +1,12 @@
+import { AxiosRequestConfig } from 'axios';
+import NormalQuery from './normal-query';
+import { GraphParams } from '../type';
+export default class CoreGraphQuery extends NormalQuery {
+    constructor(rootUrl: string, config?: AxiosRequestConfig);
+    protected _fetch(query: string): Promise<any>;
+    query(collection: string, params?: GraphParams): Promise<any>;
+    mergeQuery(data: Array<{
+        collection: string;
+        params?: GraphParams;
+    }>): Promise<any>;
+}

package/dist/esm/core/index.js

@@ -0,0 +1,18 @@
+import NormalQuery from './normal-query';
+import QueryBuilder from './query-builder';
+export default class CoreGraphQuery extends NormalQuery {
+    constructor(rootUrl, config) {
+        super(rootUrl, config);
+    }
+    async _fetch(query) {
+        return await this.post('', { query: query });
+    }
+    async query(collection, params) {
+        const sQuery = QueryBuilder.buildQuery(collection, params);
+        return await this._fetch(QueryBuilder.makeFullQuery(sQuery));
+    }
+    async mergeQuery(data) {
+        const sQuery = QueryBuilder.mergeQuery(data);
+        return await this._fetch(QueryBuilder.makeFullQuery(sQuery));
+    }
+}

package/dist/esm/core/normal-query.d.ts

@@ -0,0 +1,14 @@
+import { AxiosRequestConfig } from 'axios';
+export declare const defaultHeader: {
+    Accept: string;
+    'Content-Type': string;
+};
+export default class NormalQuery {
+    root: string;
+    config: AxiosRequestConfig;
+    constructor(rootUrl: string, config?: AxiosRequestConfig);
+    protected get<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    protected post<B = any, T = any>(url: string, data?: B, config?: AxiosRequestConfig): Promise<T>;
+    protected put<B = any, T = any>(url: string, data?: B, config?: AxiosRequestConfig): Promise<T>;
+    protected del<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+}

package/dist/esm/core/normal-query.js

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

package/dist/esm/core/query-builder.d.ts

@@ -0,0 +1,10 @@
+import { GraphParams, QueryJson } from '../type';
+export default class QueryBuilder {
+    static buildJsonQuery(query: QueryJson): string;
+    static buildQuery(collection: string, params?: GraphParams): string;
+    static mergeQuery(data: Array<{
+        collection: string;
+        params?: GraphParams;
+    }>): string;
+    static makeFullQuery(query: string): string;
+}