resolve jql to gql11

src/gql/gqlAuth.js

@@ -0,0 +1,53 @@
+import {gql} from "../utills";
+import {actionAuthLogin} from '../reducers';
+
+
+export const actionLogin = (login, password) => {
+    const upsertQuery = `query login($login:String, $password:String){
+                        login(login:$login, password:$password)
+                }`;
+
+    return gql(upsertQuery, { login: login, password: password });
+}
+
+export const actionFullLogin = (login, password) => {
+    return async (dispatch) => {
+        try {
+            delete localStorage.authToken;
+            //dispatch возвращает то, что вернул thunk, возвращаемый actionLogin, а там промис, 
+            //так как actionPromise возвращает асинхронную функцию
+            let promiseResult = actionLogin(login, password);
+            let res = await promiseResult;
+            if (res && res.data) {
+                let token = Object.values(res.data)[0];
+                if (token && typeof token == 'string')
+                    return dispatch(actionAuthLogin(token));
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}
+////////////////////////////////////////
+export const actionAuthUpsert = (login, password) => {
+    const loginQuery = `mutation UserRegistration($login: String, $password: String) {
+                            UserUpsert(user: {login: $login, password: $password}) {
+                                _id createdAt
+                            }
+                        }`;
+
+    return gql(loginQuery, { login: login, password: password });////////  
+}
+/*export const actionFullAuthUpsert = (login, password) => {
+    return gqlFullAuthUpsert = async (dispatch) => {
+        //dispatch возвращает то, что вернул thunk, возвращаемый actionLogin, а там промис, 
+        //так как actionPromise возвращает асинхронную функцию
+        delete localStorage.authToken;
+        let promiseResult = actionAuthUpsert(login, password);
+        let res = await promiseResult;
+        dispatch(actionFullLogin(login, password));
+        console.log(res)
+        //проверьте что token - строка и отдайте его в actionAuthLogin
+    }
+}*/

src/gql/gqlCategories.js

@@ -0,0 +1,23 @@
+import { gql } from "../utills/gql";
+import { actionPromise } from "../reducers";
+
+export const gqlRootCats = () => {
+    const catQuery = `query roots {
+        CategoryFind(query: "[{\\"parent\\": null }]") {
+                                _id name
+                            }}`;
+    return gql(catQuery);
+}
+export const gqlCategoryFindOne = (id) => {
+    const catQuery = `query CategoryFindOne($q: String) {
+            CategoryFindOne(query: $q) {
+                _id name
+                parent { _id name }
+                subCategories { _id name }
+                goods { _id name price description 
+                    images { url }
+                }
+            }
+        }`;
+    return gql(catQuery, { q: `[{\"_id\": \"${id}\"}]` });
+}

src/gql/gqlGoods.js

@@ -0,0 +1,37 @@
+import { gql } from "../utills/gql";
+import { createFullQuery } from "./gqlUtils";
+export const gqlGoodFindOne = (id) => {
+    let params = createFullQuery({ searchStr: id, searchFieldNames: ["_id"] });
+    const gqlQuery = `
+                query GoodFindOne($q: String) {
+                    GoodFindOne(query: $q) {
+                        _id name  price description
+                        images { url }
+                    }
+                }
+                `;
+    return gql(gqlQuery, params);
+}
+
+export const gqlGoodFind = (fromPage, pageSize, searchStr = '', queryExt = {}) => {
+    let params = createFullQuery(getGoodsSearchParams(searchStr, queryExt), { fromPage, pageSize });
+    const gqlQuery = `
+                query GoodFind($q: String) {
+                    GoodFind(query: $q) {
+                        _id name  price description
+                        images { url }
+                    }
+                }
+                `;
+    return gql(gqlQuery, params);
+}
+export const gqlGoodsCount = (query = '', queryExt = {}) => {
+    let params = createFullQuery(getGoodsSearchParams(query, queryExt));
+    const gqlQuery = `query GoodsCount($q: String) { GoodCount(query: $q) }`;
+    return gql(gqlQuery, params);
+}
+const getGoodsSearchParams = (searchStr, queryExt) => (
+    {
+        searchStr: searchStr, searchFieldNames: ["name", "description"],
+        queryExt
+    });

src/gql/gqlOrders.js

@@ -0,0 +1,103 @@
+import { gql } from "../utills/gql";
+import { actionPromise } from "../reducers";
+import { actionCartClear } from '../reducers';
+import { createFullQuery } from "./gqlUtils";
+
+const orderUpsert = (order, id = null) => {
+    const orderUpsertQuery = `mutation OrderUpsert($order: OrderInput) {
+                            OrderUpsert(order: $order) {
+                                _id
+                            }
+                        }`;
+    return gql(orderUpsertQuery, { order: { "_id": id, "orderGoods": order } });
+}
+export const actionOrderUpsert = (order, id) =>
+    actionPromise('orderUpsert', orderUpsert(order, id));
+
+const orderFullUpsert = (then) => {
+    return async (dispatch, getState) => {
+        let state = getState();
+        let order = [];
+        for (let cartItem of Object.values(state.cartReducer)) {
+            //{count: 3, good: {_id: "xxxx" }}
+            order.push({ good: { _id: cartItem.good._id }, count: cartItem.count });
+        }
+        if (order.length > 0) {
+            //dispatch возвращает то, что вернул thunk, возвращаемый actionLogin, а там промис, 
+            //так как actionPromise возвращает асинхронную функцию
+            let promiseResult = orderUpsert(order);
+            let res = await promiseResult;
+            if (res && res.errors && res.errors.length > 0) {
+                throw res.errors[0];
+            }
+            dispatch(actionCartClear());
+        }
+        if (then)
+            then();
+        //проверьте что token - строка и отдайте его в actionAuthLogin
+    }
+}
+export const actionOrderFullUpsert = (then) =>
+    actionPromise('orderUpsert', orderFullUpsert(then));
+
+
+const getOrderSearchParams = query => ({ searchStr: query, searchFieldNames: ["_id"] });
+
+export const gqlOrderFindOne = (_id) => {
+    let params = createFullQuery({ queryExt: { _id } });
+    const gqlQuery = `query OrderFindOne($q: String) {
+        OrderFindOne(query: $q) {
+            _id total createdAt
+            orderGoods {
+                _id price count total createdAt
+                good {
+                    _id
+                    name 
+                    images { url }
+                }
+            }
+        }
+        }`;
+    return gql(gqlQuery, params);
+}
+
+export const gqlFindOrders = (fromPage, pageSize, query = '') => {
+    let params = createFullQuery(getOrderSearchParams(query), { fromPage, pageSize });
+    const gqlQuery = `query OrderFind($q: String) {
+                            OrderFind(query: $q) {
+                                _id total
+                                orderGoods {
+                                    _id price count total createdAt
+                                    good {
+                                        name 
+                                        images { url }
+                                    }
+                                }
+                            }
+                            }`;
+    return gql(gqlQuery, params);
+}
+
+export const gqlOrdersCount = (query = '') => {
+    let params = createFullQuery(getOrderSearchParams(query));
+    const catQuery = `query OrdersCount($q: String) { OrderCount(query: $q) }`;
+    return gql(catQuery, params);
+}
+
+/*
+    const gqlFindOrders = (fromPage, pageSize) => {
+        const findOrdersQuery = `query OrderFind {
+                                OrderFind(query: "[{}]") {
+                                    _id total
+                                    orderGoods {
+                                        _id price count total createdAt
+                                        good {
+                                            name 
+                                            images { url }
+                                        }
+                                    }
+                                }
+                                }`;
+        return gql(findOrdersQuery);
+    }
+*/

src/gql/gqlUtils.js

@@ -0,0 +1,29 @@
+const createQuery = (searchStr, searchFieldNames) => {
+    let result = [];
+    if (searchStr) {
+        for (let searchFieldName of searchFieldNames) {
+            //result[searchFieldName] = searchFieldName === '_id' ? searchStr : `/${searchStr}/`;
+            result.push({ [searchFieldName]: searchFieldName === '_id' ? searchStr : `/${searchStr}/` });
+        }
+    }
+    return result.length == 0 ? {} :  { $or: result };
+}
+
+const createQueryExt = (searchQuery = {}, queryExt = {}) => {
+    if (!queryExt)
+        return searchQuery;
+    return { $and: [searchQuery, queryExt] };
+}
+
+const createQueryPaging = (fromPage, pageSize) => {
+    let result = {};
+    if (fromPage !== undefined && pageSize !== undefined) {
+        result["skip"] = [fromPage * pageSize];
+        result["limit"] = [pageSize];
+    }
+    return result;
+}
+
+export const createFullQuery = ({ searchStr, searchFieldNames, queryExt = {} }, { fromPage, pageSize } = {}) => {
+    return { q: JSON.stringify([createQueryExt(createQuery(searchStr, searchFieldNames), queryExt), createQueryPaging(fromPage, pageSize)]) };
+}

src/gql/index.js

@@ -0,0 +1,4 @@
+export { actionAuthUpsert, actionLogin, actionFullLogin } from './gqlAuth';
+export { gqlGoodFind, gqlGoodFindOne } from './gqlGoods';
+export { actionOrderFullUpsert, actionOrderUpsert , gqlOrderFindOne, gqlFindOrders, gqlOrdersCount } from './gqlOrders';
+export {createFullQuery} from './gqlUtils';