redux-paginator-immutable 17.0.4 → 17.0.18

package/src/__tests__/selectors.spec.js

@@ -5,93 +5,92 @@ import chaiImmutable from "chai-immutable";
 
 chai.use(chaiImmutable);
 
-import selectors from "../selectors";
-
-const {
-  getCurrentTotalResultsCount,
-  getAllResults,
-  getResultsUpToPage,
-  isPageFetched,
-  isPageFetching,
-  getCurrentView,
-} = selectors;
-
 import * as Immutable from "immutable";
+import selectors from "../selectors";
 
-const paginator = Immutable.Map({
-  "foo=bar": Immutable.Map({
-    page  : 3,
-    token : "foo=bar",
-    ids   : Immutable.List([
-      1,
-      2,
-      3,
-      7,
-      8,
-      9,
-    ]),
-    total    : 42,
-    view     : 2,
-    fetching : false,
-    fetched  : true,
-  }),
-  "foo=baz": Immutable.Map({
-    page  : 1,
-    token : "foo=baz",
-    ids   : Immutable.List([
-      1,
-      4,
-      6,
-    ]),
-    fetching : false,
-    fetched  : true,
-    total    : 17,
-    view     : 1,
+const
+  {
+    getCurrentTotalResultsCount,
+    getAllResults,
+    getResultsUpToPage,
+    isPageFetched,
+    isPageFetching,
+    getCurrentView,
+  } = selectors,
+  paginator = Immutable.Map({
+    "foo=bar": Immutable.Map({
+      page  : 3,
+      token : "foo=bar",
+      ids   : Immutable.List([
+        1,
+        2,
+        3,
+        7,
+        8,
+        9,
+      ]),
+      total    : 42,
+      view     : 2,
+      fetching : false,
+      fetched  : true,
+    }),
+    "foo=baz": Immutable.Map({
+      page  : 1,
+      token : "foo=baz",
+      ids   : Immutable.List([
+        1,
+        4,
+        6,
+      ]),
+      fetching : false,
+      fetched  : true,
+      total    : 17,
+      view     : 1,
+    }),
   }),
-});
 
-const items = Immutable.Map({
-  "1": Immutable.Map({
-    data : "foo1",
-    id   : 1,
-  }),
-  "2": Immutable.Map({
-    data : "foo2",
-    id   : 2,
-  }),
-  "3": Immutable.Map({
-    data : "foo3",
-    id   : 3,
-  }),
-  "4": Immutable.Map({
-    data : "foo4",
-    id   : 4,
-  }),
-  "5": Immutable.Map({
-    data : "foo5",
-    id   : 5,
-  }),
-  "6": Immutable.Map({
-    data : "foo6",
-    id   : 6,
-  }),
-  "7": Immutable.Map({
-    data : "foo7",
-    id   : 7,
-  }),
-  "8": Immutable.Map({
-    data : "foo8",
-    id   : 8,
-  }),
-  "9": Immutable.Map({
-    data : "foo9",
-    id   : 9,
-  }),
-});
+  items = Immutable.Map({
+    "1": Immutable.Map({
+      data : "foo1",
+      id   : 1,
+    }),
+    "2": Immutable.Map({
+      data : "foo2",
+      id   : 2,
+    }),
+    "3": Immutable.Map({
+      data : "foo3",
+      id   : 3,
+    }),
+    "4": Immutable.Map({
+      data : "foo4",
+      id   : 4,
+    }),
+    "5": Immutable.Map({
+      data : "foo5",
+      id   : 5,
+    }),
+    "6": Immutable.Map({
+      data : "foo6",
+      id   : 6,
+    }),
+    "7": Immutable.Map({
+      data : "foo7",
+      id   : 7,
+    }),
+    "8": Immutable.Map({
+      data : "foo8",
+      id   : 8,
+    }),
+    "9": Immutable.Map({
+      data : "foo9",
+      id   : 9,
+    }),
+  });
 
 describe("selectors", () => {
 
-  it("getAllResults shoud select all the items ids for pages with same params than the current page", () => {
+  it("getAllResults should select all the items ids for pages with same params than the current page", () => {
     expect(getAllResults(paginator, "foo=bar", items)).
       to.equal(Immutable.List([
         Immutable.Map({
@@ -121,7 +120,7 @@ describe("selectors", () => {
       ]));
   });
 
-  it("getResultsUpToPage shoud select all the items ids for pages with same params than the current page", () => {
+  it("getResultsUpToPage should select all the items ids for pages with same params than the current page", () => {
     expect(getResultsUpToPage(paginator, "foo=bar", items, 2, 2)).
       to.equal(Immutable.List([
         Immutable.Map({

package/src/{actionTypes.js → actionTypes.ts}

@@ -1,13 +1,9 @@
-// @flow
-
 export const REQUEST_PAGE = "@@redux-paginator-immutable/REQUEST_PAGE";
 export const RECEIVE_PAGE = "@@redux-paginator-immutable/RECEIVE_PAGE";
 export const RESET_VIEW = "@@redux-paginator-immutable/RESET_VIEW";
 export const CHANGE_VIEW = "@@redux-paginator-immutable/CHANGE_VIEW";
 export const CLEAR_DATA = "@@redux-paginator-immutable/CLEAR_DATA";
-
 export const FETCH_ITEM_DATA_PENDING = "@@redux-paginator-immutable/FETCH_ITEM_DATA_PENDING";
 export const FETCH_ITEM_DATA_REJECTED = "@@redux-paginator-immutable/FETCH_ITEM_DATA_REJECTED";
 export const FETCH_ITEM_DATA_FULFILLED = "@@redux-paginator-immutable/FETCH_ITEM_DATA_FULFILLED";
-
 export const FETCH_CURRENT_COMPANY_INFO_PENDING = "FETCH_CURRENT_COMPANY_INFO_PENDING";

package/src/actions.ts

@@ -0,0 +1,157 @@
+
+import agent from "superagent";
+
+import type { Action, EndPointCb } from "./types";
+
+type RequestPageArgsTypes = {
+  endpoint: string;
+  endpointCb: EndPointCb;
+  manageEntity: any;
+  resultsKey: string;
+  totalKey: string;
+  pageArgName: string;
+  idKey: string;
+  page: number;
+  token: string;
+};
+
+type ReceivePageArgsTypes = {
+  endpoint: string;
+  endpointCb: EndPointCb;
+  manageEntity: any;
+  pageArgName: string;
+  idKey: string;
+  page: number;
+  token: string;
+  items: Array<any>;
+  total: number;
+  error: boolean;
+};
+
+const requestPage = ({
+    endpoint,
+    endpointCb,
+    manageEntity,
+    resultsKey,
+    totalKey,
+    pageArgName,
+    idKey,
+    page,
+    token,
+  }: RequestPageArgsTypes): Action => ({
+    type : "@@redux-paginator-immutable/REQUEST_PAGE",
+    meta : {
+      endpoint,
+      endpointCb,
+      manageEntity,
+      resultsKey,
+      totalKey,
+      pageArgName,
+      idKey,
+    },
+    payload: {
+      page,
+      token,
+    },
+  }),
+
+  receivePage = ({
+    endpoint,
+    endpointCb,
+    manageEntity,
+    pageArgName,
+    idKey,
+    page,
+    token,
+    items,
+    error,
+    total,
+  }: ReceivePageArgsTypes): Action => ({
+    type : "@@redux-paginator-immutable/RECEIVE_PAGE",
+    meta : {
+      endpoint,
+      endpointCb,
+      manageEntity,
+      pageArgName,
+      idKey,
+    },
+    payload: {
+      page,
+      token,
+      items,
+      error,
+      total,
+    },
+  }),
+
+  resetView = (endpoint: string, token: string): Action => ({
+    type : "@@redux-paginator-immutable/RESET_VIEW",
+    meta : {
+      endpoint,
+    },
+    payload: {
+      token,
+    },
+  }),
+
+  changeView = (endpoint: string, {
+    token,
+    view,
+  }: {
+  token: string;
+  view: number;
+}): Action => ({
+    type : "@@redux-paginator-immutable/CHANGE_VIEW",
+    meta : {
+      endpoint,
+    },
+    payload: {
+      token,
+      view,
+    },
+  }),
+
+  clearData = (endpoint: string): Action => ({
+    type : "@@redux-paginator-immutable/CLEAR_DATA",
+    meta : {
+      endpoint,
+    },
+  });
+
+// data info
+type FetchDataItem = {
+  dataItemURL: string;
+  endpoint: string;
+  normalizeDataItem: any;
+  id: string;
+};
+
+const fetchDataItemRequest = ({
+  dataItemURL,
+  normalizeDataItem,
+  id,
+}: FetchDataItem): Promise<any> => (
+  new Promise((resolve, reject) => (
+    agent.
+      get(`${dataItemURL}/${id}`).
+      set("Accept", "application/json").
+      end(normalizeDataItem(resolve, reject))
+  )) as Promise<any>
+);
+
+export const fetchItem = (things: FetchDataItem): any => ({
+  type    : "@@redux-paginator-immutable/FETCH_ITEM_DATA",
+  payload : fetchDataItemRequest(things),
+  meta    : {
+    id       : things.id,
+    endpoint : things.endpoint,
+  },
+});
+
+export default {
+  clearData,
+  requestPage,
+  receivePage,
+  resetView,
+  changeView,
+};

package/src/agent.ts

@@ -0,0 +1,62 @@
+/* eslint-disable no-bitwise*/
+
+type FetchPageArgs = {
+  endpoint: string;
+  pageArgName: string;
+  page: number;
+  token: string;
+};
+
+import agent from "superagent";
+import qs from "query-string";
+
+export const
+  buildSuffix = (pageArgName: string, page: number, params: string) => {
+    const parsedParams = qs.parse(params);
+    let finalParsedParams = {},
+      startString = "";
+
+    for (const key of Object.keys(parsedParams)) {
+      if (parsedParams[key] === null) {
+        startString += key;
+      } else {
+        finalParsedParams = { ...finalParsedParams,
+          [key]: parsedParams[key],
+        };
+      }
+    }
+
+    startString = startString === "" ? "?" : `${startString}?`;
+
+    if (Object.keys(finalParsedParams).length > 0 && qs.extract(params) !== "") {
+      startString = params.replace(qs.extract(params), "");
+    }
+
+    return startString + qs.stringify({ ...finalParsedParams,
+      [pageArgName]: page,
+    }, {
+      encode: false,
+    }).replace(startString, "");
+  },
+  fetchPage = ({
+    endpoint,
+    pageArgName,
+    page,
+    token,
+  }: FetchPageArgs) => {
+    const suffix = buildSuffix(pageArgName, page, token),
+      url = endpoint + suffix,
+      promise: any = new Promise(
+        (resolve: any, reject: any) => (
+          agent.
+            get(url).
+            end((err: any, res: any) => err ? reject(err) : resolve(res))
+        ),
+      );
+
+    return promise.then((res: {
+    body: any;
+  }) => ({
+      response: res.body,
+    }));
+  };

package/src/createDataReducer.ts

@@ -0,0 +1,98 @@
+/* eslint-disable max-lines-per-function,  */
+import { createSelector } from "reselect";
+import * as Immutable from "immutable";
+import type { PaginatorSettings } from "./types";
+
+/*
+  Use to create a complex list where you need more information about
+  the item. For instance, if you DO need to fetch more data or to
+  manipulate it
+*/
+const
+  createDataReducer = ({ key }: PaginatorSettings) => {
+    const
+      getItems = (state: any) : any => (
+        state.getIn(["entities", key])
+      ),
+      getItem = createSelector(
+        getItems,
+        (_state : any, id : string) => id,
+        (data : any, id : string) : any => data.get(id) || Immutable.Map(),
+      ),
+      getItemsList = createSelector(
+        getItems,
+        (data : any) => data.map((current : any) => current.get("Data")).toList(),
+      ),
+      getItemData = createSelector(
+        getItems,
+        (_state : any, id : string) => id,
+        (data : any, id : string) : any => {
+          if (typeof data === "undefined") {
+            return Immutable.Map();
+          }
+
+          return data.getIn([id, "Data"]);
+        },
+      ),
+      getItemHasError = createSelector(
+        getItem,
+        (data : any) : boolean => {
+          if (typeof data === "undefined") {
+            return false;
+          }
+
+          return data.get("error") === true;
+        },
+      ),
+      getIsFetchingItemInfo = createSelector(
+        getItem,
+        (data : any) : boolean => {
+          if (typeof data === "undefined") {
+            return false;
+          }
+
+          return data.get("fetching");
+        },
+      ),
+      getItemIsFetched = createSelector(
+        getItem,
+        (data : any) : boolean => {
+          if (typeof data === "undefined") {
+            return false;
+          }
+
+          return data.get("fetched");
+        },
+      ),
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      getShouldFetchItemInfo = createSelector(
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        getIsFetchingItemInfo,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        getItemIsFetched,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        getItemHasError,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        (isFetching : boolean, isFetched : boolean, hasError : boolean) : boolean => (
+          !isFetched && !isFetching && !hasError
+        ),
+      );
+
+    return {
+      getItems,
+      getItem,
+      getItemsList,
+      getItemData,
+      getItemHasError,
+      getIsFetchingItemInfo,
+      getItemIsFetched,
+      getShouldFetchItemInfo,
+    };
+  };
+
+export default createDataReducer;

package/src/{createItemReducer.js → createItemReducer.ts}

@@ -1,28 +1,22 @@
-// @flow
-
-import type { PaginatorSettings } from "./types";
-
 import { createSelector } from "reselect";
+import type { PaginatorSettings } from "./types";
 
 /*
   Use to create a simple list where you do not need more information about
   the item. For instance, if you do NOT need to fetch more data or
   manipulate it
 */
-const createReducer = ({ key } : PaginatorSettings) => {
+const createReducer = ({ key }: PaginatorSettings) => {
   const
-    getItems = (state : any) => state.getIn([
-      "entities",
-      key,
-    ]),
+    getItems = (state: any) => state.getIn(["entities", key]),
     getItem = createSelector(
       getItems,
-      (state, id) => id,
-      (data, id) => data.get(id)
+      (_state : any, id : any) => id,
+      (data : any, id : any) => data.get(id),
     ),
     getItemsList = createSelector(
       getItems,
-      (data) => data.toList()
+      (data) => data.toList(),
     );
 
   return {

package/src/createPaginator.ts

@@ -0,0 +1,107 @@
+/* eslint-disable max-lines-per-function,  */
+
+import { rowsPerLoad as defaultRowsPerLoad } from "x25/utility/others";
+import * as Immutable from "immutable";
+import { pages as pagesReducer, items as itemsReducer, dataItems as dataItemsReducer } from "./reducers";
+import actions from "./actions";
+
+import type { PaginatorSettings } from "./types";
+
+type EndpointData = {
+  path: string;
+  cb: () => string;
+};
+
+type Endpoint = EndpointData | string;
+type CreatePaginator = (endpoint: Endpoint, info: PaginatorSettings) => any;
+type OnlyForEndpoint = (endpoint: string, reducer: any) => (state: any, action: {
+  meta: {
+    endpoint: string;
+  };
+}) => any;
+
+
+const getEndpoint = (data: Endpoint) => {
+  if (typeof data === "object") {
+    return {
+      path : data.path,
+      cb   : data.cb,
+    };
+  }
+
+  return {
+    path : data,
+    cb   : null,
+  };
+};
+
+export const
+  onlyForEndpoint: OnlyForEndpoint = (endpoint, reducer) => (state = Immutable.Map(), action) => {
+    if (typeof action.meta === "undefined" || action.meta.endpoint !== endpoint) {
+      return state;
+    }
+
+    return reducer(state, action);
+  },
+  createPaginator: CreatePaginator = (endpointData: Endpoint, settings: PaginatorSettings) => {
+    const
+      {
+        path: endpoint,
+        cb: endpointCb,
+      } = getEndpoint(endpointData),
+      {
+        key,
+        normalizeDataItem,
+        dataItemURL,
+        manageEntity,
+        resultsKey,
+        totalKey = "Total",
+        pageArgName = "page",
+        idKey = "ID",
+        rowsPerLoad = defaultRowsPerLoad,
+        manipulateItems = (items) => items,
+      } = settings,
+      endpointedActions = {
+        requestPage: (page: number, token: string) => actions.requestPage({
+          endpoint,
+          endpointCb,
+          manageEntity,
+          resultsKey,
+          totalKey,
+          pageArgName,
+          idKey,
+          page,
+          token,
+        }),
+
+        resetView (token : any) {
+          return actions.resetView(endpoint, token);
+        },
+
+        changeView ({ view, token }: { view: number; token: string; }) {
+          return actions.changeView(endpoint, {
+            view,
+            token,
+          });
+        },
+
+        clearData () {
+          return actions.clearData(endpoint);
+        },
+      };
+
+    return {
+      key,
+      normalizeDataItem,
+      dataItemURL,
+      manipulateItems,
+      rowsPerLoad,
+      manageEntity,
+      resultsKey,
+      endpoint,
+      pagesReducer     : onlyForEndpoint(endpoint, pagesReducer),
+      itemsReducer     : onlyForEndpoint(endpoint, itemsReducer),
+      dataItemsReducer : onlyForEndpoint(endpoint, dataItemsReducer),
+      ...endpointedActions,
+    };
+  };

package/src/{index.js → index.ts}

@@ -1,17 +1,11 @@
-// @flow
-
 import { createPaginator } from "./createPaginator";
 import paginatorMiddleware from "./paginatorMiddleware";
-
 import paginatorSelectors from "./selectors";
-
 import { manageDataEntity, manipulateDataItems, manipulateItems, manageEntity } from "./util";
-
 import Info from "./Info";
 import LoadingButton from "./LoadingButton";
 import LoadPaginator from "./LoadPaginator";
 import LoadDataItem from "./LoadDataItem";
-
 import createDataReducer from "./createDataReducer";
 import createItemReducer from "./createItemReducer";
 
@@ -20,19 +14,12 @@ export {
   LoadingButton,
   LoadPaginator,
   LoadDataItem,
-
   createPaginator,
-
   paginatorMiddleware,
-
   paginatorSelectors,
-
-  // util
   createDataReducer,
-
   manageDataEntity,
   manipulateDataItems,
-
   createItemReducer,
   manipulateItems,
   manageEntity,