rest-hooks - npm Package Compare versions

Comparing version 0.3.1 to 0.4.0

lib/index.d.ts

 import Resource, { SelectShape as ImportedSelectShape } from './resource/Resource';
 import { RestProvider, hooks } from './react-rest';
 import * as selectors from './state/selectors';
-export declare type SelectShape<T extends typeof Resource, S> = ImportedSelectShape<T, S>;
+export declare type SelectShape<Param extends object, Payload extends object | void> = ImportedSelectShape<Param, Payload>;
 export { Resource, RestProvider, hooks, selectors };

lib/index.js

@@ -6,2 +6,2 @@ import Resource from './resource/Resource';
 export { Resource, RestProvider, hooks, selectors };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6WyJSZXNvdXJjZSIsIlJlc3RQcm92aWRlciIsImhvb2tzIiwic2VsZWN0b3JzIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPQSxRQUFQLE1BQTZELHFCQUE3RDtBQUNBLFNBQVNDLFlBQVQsRUFBdUJDLEtBQXZCLFFBQW9DLGNBQXBDO0FBQ0EsT0FBTyxLQUFLQyxTQUFaLE1BQTJCLG1CQUEzQixDLENBRUE7O0FBRUEsU0FBU0gsUUFBVCxFQUFtQkMsWUFBbkIsRUFBaUNDLEtBQWpDLEVBQXdDQyxTQUF4QyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBSZXNvdXJjZSwgeyBTZWxlY3RTaGFwZSBhcyBJbXBvcnRlZFNlbGVjdFNoYXBlIH0gZnJvbSAnLi9yZXNvdXJjZS9SZXNvdXJjZSc7XG5pbXBvcnQgeyBSZXN0UHJvdmlkZXIsIGhvb2tzIH0gZnJvbSAnLi9yZWFjdC1yZXN0JztcbmltcG9ydCAqIGFzIHNlbGVjdG9ycyBmcm9tICcuL3N0YXRlL3NlbGVjdG9ycyc7XG5cbi8vIHRoaXMgaXMgcmVxdWlyZWQgc28gYmFiZWwgZG9lc24ndCBwdXQgdGhlIGV4cG9ydCBpbiB0aGUgSlMgY29kZVxuZXhwb3J0IHR5cGUgU2VsZWN0U2hhcGU8VCBleHRlbmRzIHR5cGVvZiBSZXNvdXJjZSwgUz4gPSBJbXBvcnRlZFNlbGVjdFNoYXBlPFQsIFM+O1xuZXhwb3J0IHsgUmVzb3VyY2UsIFJlc3RQcm92aWRlciwgaG9va3MsIHNlbGVjdG9ycyB9O1xuIl19
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6WyJSZXNvdXJjZSIsIlJlc3RQcm92aWRlciIsImhvb2tzIiwic2VsZWN0b3JzIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPQSxRQUFQLE1BRU8scUJBRlA7QUFHQSxTQUFTQyxZQUFULEVBQXVCQyxLQUF2QixRQUFvQyxjQUFwQztBQUNBLE9BQU8sS0FBS0MsU0FBWixNQUEyQixtQkFBM0IsQyxDQUVBOztBQUtBLFNBQVNILFFBQVQsRUFBbUJDLFlBQW5CLEVBQWlDQyxLQUFqQyxFQUF3Q0MsU0FBeEMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgUmVzb3VyY2UsIHtcbiAgU2VsZWN0U2hhcGUgYXMgSW1wb3J0ZWRTZWxlY3RTaGFwZSxcbn0gZnJvbSAnLi9yZXNvdXJjZS9SZXNvdXJjZSc7XG5pbXBvcnQgeyBSZXN0UHJvdmlkZXIsIGhvb2tzIH0gZnJvbSAnLi9yZWFjdC1yZXN0JztcbmltcG9ydCAqIGFzIHNlbGVjdG9ycyBmcm9tICcuL3N0YXRlL3NlbGVjdG9ycyc7XG5cbi8vIHRoaXMgaXMgcmVxdWlyZWQgc28gYmFiZWwgZG9lc24ndCBwdXQgdGhlIGV4cG9ydCBpbiB0aGUgSlMgY29kZVxuZXhwb3J0IHR5cGUgU2VsZWN0U2hhcGU8XG4gIFBhcmFtIGV4dGVuZHMgb2JqZWN0LFxuICBQYXlsb2FkIGV4dGVuZHMgb2JqZWN0IHwgdm9pZFxuPiA9IEltcG9ydGVkU2VsZWN0U2hhcGU8UGFyYW0sIFBheWxvYWQ+O1xuZXhwb3J0IHsgUmVzb3VyY2UsIFJlc3RQcm92aWRlciwgaG9va3MsIHNlbGVjdG9ycyB9O1xuIl19

lib/react-rest/context.d.ts

 import React from 'react';
-import Resource, { SelectShape } from '../resource/Resource';
+import { SelectShape, ParamArg, PayloadArg } from '../resource/Resource';
 export declare const StateContext: React.Context<{
@@ -9,3 +9,3 @@ entities: {};
 export declare const DispatchContext: React.Context<{
-    fetch: <T extends typeof Resource, S>(selectDefinition: SelectShape<T, S>, params: object) => void | Promise<any>;
+    fetch: <S extends SelectShape<P1, P2>, P1 extends object, P2 extends void | object>(selectDefinition: S, params: ParamArg<S>, body: PayloadArg<S>) => void | Promise<any>;
 }>;

lib/react-rest/context.js

@@ -8,4 +8,4 @@ import React from 'react';
 export var DispatchContext = React.createContext({
-  fetch: function fetch(selectDefinition, params) {}
+  fetch: function fetch(selectDefinition, params, body) {}
 });
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9yZWFjdC1yZXN0L2NvbnRleHQudHMiXSwibmFtZXMiOlsiUmVhY3QiLCJTdGF0ZUNvbnRleHQiLCJjcmVhdGVDb250ZXh0IiwiZW50aXRpZXMiLCJyZXN1bHRzIiwibWV0YSIsIkRpc3BhdGNoQ29udGV4dCIsImZldGNoIiwic2VsZWN0RGVmaW5pdGlvbiIsInBhcmFtcyJdLCJtYXBwaW5ncyI6IkFBQUEsT0FBT0EsS0FBUCxNQUFrQixPQUFsQjtBQUdBLE9BQU8sSUFBTUMsWUFBWSxHQUFHRCxLQUFLLENBQUNFLGFBQU4sQ0FBb0I7QUFBRUMsRUFBQUEsUUFBUSxFQUFFLEVBQVo7QUFBZ0JDLEVBQUFBLE9BQU8sRUFBRSxFQUF6QjtBQUE2QkMsRUFBQUEsSUFBSSxFQUFFO0FBQW5DLENBQXBCLENBQXJCO0FBQ1AsT0FBTyxJQUFNQyxlQUFlLEdBQUdOLEtBQUssQ0FBQ0UsYUFBTixDQUFvQjtBQUNqREssRUFBQUEsS0FBSyxFQUFHLGVBQ05DLGdCQURNLEVBRU5DLE1BRk0sRUFHa0IsQ0FBRTtBQUpxQixDQUFwQixDQUF4QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBSZWFjdCBmcm9tICdyZWFjdCc7XG5pbXBvcnQgUmVzb3VyY2UsIHsgU2VsZWN0U2hhcGUgfSBmcm9tICcuLi9yZXNvdXJjZS9SZXNvdXJjZSc7XG5cbmV4cG9ydCBjb25zdCBTdGF0ZUNvbnRleHQgPSBSZWFjdC5jcmVhdGVDb250ZXh0KHsgZW50aXRpZXM6IHt9LCByZXN1bHRzOiB7fSwgbWV0YToge30gfSk7XG5leHBvcnQgY29uc3QgRGlzcGF0Y2hDb250ZXh0ID0gUmVhY3QuY3JlYXRlQ29udGV4dCh7XG4gIGZldGNoOiA8VCBleHRlbmRzIHR5cGVvZiBSZXNvdXJjZSwgUz4oXG4gICAgc2VsZWN0RGVmaW5pdGlvbjogU2VsZWN0U2hhcGU8VCwgUz4sXG4gICAgcGFyYW1zOiBvYmplY3QsXG4gICk6IFByb21pc2U8YW55PiB8IHZvaWQgPT4ge30sXG59KTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9yZWFjdC1yZXN0L2NvbnRleHQudHMiXSwibmFtZXMiOlsiUmVhY3QiLCJTdGF0ZUNvbnRleHQiLCJjcmVhdGVDb250ZXh0IiwiZW50aXRpZXMiLCJyZXN1bHRzIiwibWV0YSIsIkRpc3BhdGNoQ29udGV4dCIsImZldGNoIiwic2VsZWN0RGVmaW5pdGlvbiIsInBhcmFtcyIsImJvZHkiXSwibWFwcGluZ3MiOiJBQUFBLE9BQU9BLEtBQVAsTUFBa0IsT0FBbEI7QUFHQSxPQUFPLElBQU1DLFlBQVksR0FBR0QsS0FBSyxDQUFDRSxhQUFOLENBQW9CO0FBQzlDQyxFQUFBQSxRQUFRLEVBQUUsRUFEb0M7QUFFOUNDLEVBQUFBLE9BQU8sRUFBRSxFQUZxQztBQUc5Q0MsRUFBQUEsSUFBSSxFQUFFO0FBSHdDLENBQXBCLENBQXJCO0FBS1AsT0FBTyxJQUFNQyxlQUFlLEdBQUdOLEtBQUssQ0FBQ0UsYUFBTixDQUFvQjtBQUNqREssRUFBQUEsS0FBSyxFQUFHLGVBQ05DLGdCQURNLEVBRU5DLE1BRk0sRUFHTkMsSUFITSxFQUlrQixDQUFFO0FBTHFCLENBQXBCLENBQXhCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0JztcbmltcG9ydCBSZXNvdXJjZSwgeyBTZWxlY3RTaGFwZSwgUGFyYW1BcmcsIFBheWxvYWRBcmcgfSBmcm9tICcuLi9yZXNvdXJjZS9SZXNvdXJjZSc7XG5cbmV4cG9ydCBjb25zdCBTdGF0ZUNvbnRleHQgPSBSZWFjdC5jcmVhdGVDb250ZXh0KHtcbiAgZW50aXRpZXM6IHt9LFxuICByZXN1bHRzOiB7fSxcbiAgbWV0YToge30sXG59KTtcbmV4cG9ydCBjb25zdCBEaXNwYXRjaENvbnRleHQgPSBSZWFjdC5jcmVhdGVDb250ZXh0KHtcbiAgZmV0Y2g6IDxTIGV4dGVuZHMgU2VsZWN0U2hhcGU8UDEsIFAyPiwgUDEgZXh0ZW5kcyBvYmplY3QsIFAyIGV4dGVuZHMgb2JqZWN0IHwgdm9pZD4oXG4gICAgc2VsZWN0RGVmaW5pdGlvbjogUyxcbiAgICBwYXJhbXM6IFBhcmFtQXJnPFM+LFxuICAgIGJvZHk6IFBheWxvYWRBcmc8Uz4sXG4gICk6IFByb21pc2U8YW55PiB8IHZvaWQgPT4ge30sXG59KTtcbiJdfQ==

lib/react-rest/hooks.d.ts

@@ -1,6 +0,9 @@
-import Resource, { SelectShape } from '../resource/Resource';
-export declare function selectResource<T extends typeof Resource, S>({ select }: SelectShape<T, S>, params: {} | null): S | null;
-export declare function fetchResource<T extends typeof Resource, S>(selectShape: SelectShape<T, S>, params: {} | null): void | Promise<any>;
-declare type ResourceArgs<T extends typeof Resource, S> = [SelectShape<T, S>, {} | null];
-export declare function useResource<T extends typeof Resource, S, A>(...args: ResourceArgs<T, S> | ResourceArgs<T, S>[]): A extends ResourceArgs<T, S>[] ? S[] : S;
-export {};
+import { SelectShape, SelectReturn, AlwaysSelect, ParamArg, PayloadArg } from '../resource/Resource';
+export declare function selectResource<S extends SelectShape<P1, P2>, P1 extends object, P2 extends object>({ select }: S, params: ParamArg<S> | null): SelectReturn<S>;
+export declare function fetchResource<S extends SelectShape<P1, P2>, P1 extends object, P2 extends object>(selectShape: S, params: ParamArg<S> | null, body?: PayloadArg<S>): void | Promise<any>;
+export declare function useResource<S extends SelectShape<P1, P2>, P1 extends object, P2 extends object>(selectShape: S, params: ParamArg<S> | null): AlwaysSelect<S>;
+export declare function useResource<S1 extends SelectShape<X, Y>, X extends object, Y extends object>(v1: [S1, ParamArg<S1> | null]): [AlwaysSelect<S1>];
+export declare function useResource<S1 extends SelectShape<X1, Y1>, X1 extends object, Y1 extends object, S2 extends SelectShape<X2, Y2>, X2 extends object, Y2 extends object>(v1: [S1, ParamArg<S1> | null], v2: [S2, ParamArg<S2> | null]): [AlwaysSelect<S1>, AlwaysSelect<S2>];
+export declare function useResource<S1 extends SelectShape<X1, Y1>, X1 extends object, Y1 extends object, S2 extends SelectShape<X2, Y2>, X2 extends object, Y2 extends object, S3 extends SelectShape<X3, Y3>, X3 extends object, Y3 extends object>(v1: [S1, ParamArg<S1> | null], v2: [S2, ParamArg<S2> | null], v3: [S3, ParamArg<S3> | null]): [AlwaysSelect<S1>, AlwaysSelect<S2>, AlwaysSelect<S3>];
+export declare function useResource<S1 extends SelectShape<X1, Y1>, X1 extends object, Y1 extends object, S2 extends SelectShape<X2, Y2>, X2 extends object, Y2 extends object, S3 extends SelectShape<X3, Y3>, X3 extends object, Y3 extends object, S4 extends SelectShape<X4, Y4>, X4 extends object, Y4 extends object>(v1: [S1, ParamArg<S1> | null], v2: [S2, ParamArg<S2> | null], v3: [S3, ParamArg<S3> | null], v4: [S4, ParamArg<S4> | null]): [AlwaysSelect<S1>, AlwaysSelect<S2>, AlwaysSelect<S3>, AlwaysSelect<S4>];
+export declare function useResource<S1 extends SelectShape<X1, Y1>, X1 extends object, Y1 extends object, S2 extends SelectShape<X2, Y2>, X2 extends object, Y2 extends object, S3 extends SelectShape<X3, Y3>, X3 extends object, Y3 extends object, S4 extends SelectShape<X4, Y4>, X4 extends object, Y4 extends object, S5 extends SelectShape<X5, Y5>, X5 extends object, Y5 extends object>(v1: [S1, ParamArg<S1> | null], v2: [S2, ParamArg<S2> | null], v3: [S3, ParamArg<S3> | null], v4: [S4, ParamArg<S4> | null], v5: [S5, ParamArg<S5> | null]): [AlwaysSelect<S1>, AlwaysSelect<S2>, AlwaysSelect<S3>, AlwaysSelect<S4>, AlwaysSelect<S5>];

lib/react-rest/hooks.js

@@ -6,2 +6,3 @@ import "core-js/modules/es6.array.from";
 import "core-js/modules/es6.symbol";
+import "core-js/modules/es6.array.is-array";
 import "core-js/modules/es6.promise";
@@ -13,4 +14,11 @@ import "core-js/modules/web.dom.iterable";
 import "core-js/modules/es6.array.filter";
-import "core-js/modules/es6.array.is-array";
 
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+
+function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
@@ -24,10 +32,2 @@
 
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
-
-function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
-
 import { useContext, useMemo } from 'react';
@@ -51,36 +51,19 @@ import { StateContext, DispatchContext } from './context';
 
-export function fetchResource(selectShape, params) {
+export function fetchResource(selectShape, params, body) {
   var _useContext = useContext(DispatchContext),
       fetch = _useContext.fetch;
 
-  if (!params) return;
+  if (!params) return; // TODO: figure out how to express that body is optional in SelectShape as we don't need to cast here
+
   return useMemo(function () {
-    return fetch(selectShape, params);
+    return fetch(selectShape, params, body);
   }, [params && selectShape.getUrl(params)]);
 }
-/*
-const user = useResource(
-  UserResource.singleSelect(),
-  { id },
-);
-*/
 
-export function useResource() {
-  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-    args[_key] = arguments[_key];
-  }
-
-  if (Array.isArray(args[0])) {
-    // TODO: provide type guard function to detect this
-    return useManyResources.apply(void 0, _toConsumableArray(args));
-  } // TODO: make return types match up with the branching logic we put in here.
-
-
-  return useOneResource(args[0], args[1]);
-} // single form resource
-
+// single form resource
 function useOneResource(selectShape, params) {
   var maybePromise = fetchResource(selectShape, params);
   if (maybePromise && typeof maybePromise.then === 'function') throw maybePromise;
-  var resource = selectResource(selectShape, params); // fetch "guarantees" it will be in cache by this point
+  var resource = selectResource(selectShape, params);
+  if (!resource) throw Error("Resource not found when it should be ".concat(params)); // fetch "guarantees" it will be in cache by this point
   // TODO: technically the data could be messed up even with an entry in the results table
@@ -93,4 +76,4 @@
 function useManyResources() {
-  for (var _len2 = arguments.length, resourceList = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-    resourceList[_key2] = arguments[_key2];
+  for (var _len = arguments.length, resourceList = new Array(_len), _key = 0; _key < _len; _key++) {
+    resourceList[_key] = arguments[_key];
   }
@@ -121,4 +104,30 @@
 /*
+const user = useResource(
+  UserResource.singleSelect(),
+  { id },
+);
+const [user, posts] = useResource(
+  [UserResource.singleSelect(), { id }],
+  [PostResource.listSelect(), { id: postid }]
+);
+*/
+
+
+export function useResource() {
+  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    args[_key2] = arguments[_key2];
+  }
+
+  if (Array.isArray(args[0])) {
+    // TODO: provide type guard function to detect this
+    return useManyResources.apply(void 0, _toConsumableArray(args));
+  }
+
+  args = args; // TODO: make return types match up with the branching logic we put in here.
+
+  return useOneResource(args[0], args[1]);
+}
+/*
 function UserForm() {
-  const { create } = useMutate(UserResource);
+  const create = useDispatch(UserResource.createSelect());
   return <form onSubmit={(data) => create(data)}></form>
@@ -128,6 +137,6 @@ }
 
-/*export function useMutate(model: Resource): MutateDispatchers {
+/*export function useDispatch(selectShape: SelectShape<T, Body>) {
 
 }
 */
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/react-rest/hooks.ts"],"names":["useContext","useMemo","StateContext","DispatchContext","selectResource","params","select","state","resource","fetchResource","selectShape","body","fetch","getUrl","useOneResource","maybePromise","then","Error","useManyResources","resourceList","promises","map","filter","p","length","Promise","all","useResource","args","Array","isArray"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAASA,UAAT,EAAqBC,OAArB,QAAoC,OAApC;AASA,SAASC,YAAT,EAAuBC,eAAvB,QAA8C,WAA9C;AAEA;;;;AAGA,OAAO,SAASC,cAAT,OAIUC,MAJV,EAIuD;AAAA,MAA1DC,MAA0D,QAA1DA,MAA0D;AAC5D,MAAMC,KAAK,GAAGP,UAAU,CAACE,YAAD,CAAxB;AACA,MAAMM,QAAQ,GAAGP,OAAO,CAAC;AAAA,WAAMI,MAAM,IAAIC,MAAM,CAACC,KAAD,EAAQF,MAAR,CAAtB;AAAA,GAAD,EAAwC,CAC9DE,KAD8D,EAE9DF,MAF8D,CAAxC,CAAxB;AAIA,SAAOG,QAAP;AACD;AAED;;;;AAGA,OAAO,SAASC,aAAT,CAILC,WAJK,EAIWL,MAJX,EAIuCM,IAJvC,EAI6D;AAAA,oBAC9BX,UAAU,CAACG,eAAD,CADoB;AAAA,MAC1DS,KAD0D,eAC1DA,KAD0D;;AAElE,MAAI,CAACP,MAAL,EAAa,OAFqD,CAIlE;;AACA,SAAOJ,OAAO,CAAC;AAAA,WAAMW,KAAK,CAACF,WAAD,EAAcL,MAAd,EAAsBM,IAAtB,CAAX;AAAA,GAAD,EAA0D,CACtEN,MAAM,IAAIK,WAAW,CAACG,MAAZ,CAAmBR,MAAnB,CAD4D,CAA1D,CAAd;AAGD;;AAQD;AACA,SAASS,cAAT,CAIEJ,WAJF,EAIkBL,MAJlB,EAI8C;AAC5C,MAAIU,YAAY,GAAGN,aAAa,CAACC,WAAD,EAAcL,MAAd,CAAhC;AACA,MAAIU,YAAY,IAAI,OAAOA,YAAY,CAACC,IAApB,KAA6B,UAAjD,EACE,MAAMD,YAAN;AACF,MAAMP,QAAQ,GAAGJ,cAAc,CAACM,WAAD,EAAcL,MAAd,CAA/B;AACA,MAAI,CAACG,QAAL,EAAe,MAAMS,KAAK,gDAAyCZ,MAAzC,EAAX,CAL6B,CAM5C;AACA;;AACA,SAAQG,QAAR;AACD,C,CAED;;;AACA,SAASU,gBAAT,GAEE;AAAA,oCADGC,YACH;AADGA,IAAAA,YACH;AAAA;;AACA,MAAMC,QAAQ,GAAGD,YAAY,CAC1BE,GADc,CACV;AAAA;AAAA,QAAEf,MAAF;AAAA,QAAUD,MAAV;;AAAA,WAAsBI,aAAa,CAACH,MAAD,EAASD,MAAT,CAAnC;AAAA,GADU,EAEdiB,MAFc,CAEP,UAAAC,CAAC;AAAA,WAAIA,CAAJ;AAAA,GAFM,CAAjB;;AAGA,MAAIH,QAAQ,CAACI,MAAb,EAAqB;AACnB,UAAMC,OAAO,CAACC,GAAR,CAAYN,QAAZ,CAAN;AACD;;AACD,SAAOD,YAAY,CAACE,GAAb,CACJ;AAAA;AAAA,QACCf,MADD;AAAA,QAECD,MAFD;;AAAA,WAG8BD,cAAc,CAACE,MAAD,EAASD,MAAT,CAH5C;AAAA,GADI,CAAP;AAMD;AAED;;;;;;;;;;;;AA8FA,OAAO,SAASsB,WAAT,GAIyD;AAAA,qCAA3DC,IAA2D;AAA3DA,IAAAA,IAA2D;AAAA;;AAC9D,MAAIC,KAAK,CAACC,OAAN,CAAcF,IAAI,CAAC,CAAD,CAAlB,CAAJ,EAA4B;AAC1B;AACA,WAAOV,gBAAgB,MAAhB,4BAAqBU,IAArB,EAAP;AACD;;AACDA,EAAAA,IAAI,GAAGA,IAAP,CAL8D,CAM9D;;AACA,SAAOd,cAAc,CAACc,IAAI,CAAC,CAAD,CAAL,EAAUA,IAAI,CAAC,CAAD,CAAd,CAArB;AACD;AAED;;;;;;;AAMA","sourcesContent":["import { useContext, useMemo } from 'react';\n\nimport Resource, {\n  SelectShape,\n  SelectReturn,\n  AlwaysSelect,\n  ParamArg,\n  PayloadArg,\n} from '../resource/Resource';\nimport { StateContext, DispatchContext } from './context';\n\n/*\nconst user = selectResource(User.singleSelect(), { id });\n*/\nexport function selectResource<\n  S extends SelectShape<P1, P2>,\n  P1 extends object,\n  P2 extends object\n>({ select }: S, params: ParamArg<S> | null): SelectReturn<S> {\n  const state = useContext(StateContext);\n  const resource = useMemo(() => params && select(state, params), [\n    state,\n    params,\n  ]);\n  return resource;\n}\n\n/*\nfetchResource(UserResource.listSelect(), { id });\n*/\nexport function fetchResource<\n  S extends SelectShape<P1, P2>,\n  P1 extends object,\n  P2 extends object\n>(selectShape: S, params: ParamArg<S> | null, body?: PayloadArg<S>) {\n  const { fetch /*, unsubscribe*/ } = useContext(DispatchContext);\n  if (!params) return;\n\n  // TODO: figure out how to express that body is optional in SelectShape as we don't need to cast here\n  return useMemo(() => fetch(selectShape, params, body as PayloadArg<S>), [\n    params && selectShape.getUrl(params),\n  ]);\n}\n\ntype ResourceArgs<\n  S extends SelectShape<P1, P2>,\n  P1 extends object,\n  P2 extends object\n> = [S, ParamArg<S> | null];\n\n// single form resource\nfunction useOneResource<\n  S extends SelectShape<P1, P2>,\n  P1 extends object,\n  P2 extends object\n>(selectShape: S, params: ParamArg<S> | null) {\n  let maybePromise = fetchResource(selectShape, params);\n  if (maybePromise && typeof maybePromise.then === 'function')\n    throw maybePromise;\n  const resource = selectResource(selectShape, params);\n  if (!resource) throw Error(`Resource not found when it should be ${params}`);\n  // fetch \"guarantees\" it will be in cache by this point\n  // TODO: technically the data could be messed up even with an entry in the results table\n  return (resource as unknown) as AlwaysSelect<S>;\n}\n\n// many form resource\nfunction useManyResources<A extends ResourceArgs<any, any, any>[]>(\n  ...resourceList: A\n) {\n  const promises = resourceList\n    .map(([select, params]) => fetchResource(select, params))\n    .filter(p => p);\n  if (promises.length) {\n    throw Promise.all(promises);\n  }\n  return resourceList.map(\n    <S extends SelectShape<P1, P2>, P1 extends object, P2 extends object>([\n      select,\n      params,\n    ]: ResourceArgs<S, P1, P2>) => selectResource(select, params),\n  );\n}\n\n/*\nconst user = useResource(\n  UserResource.singleSelect(),\n  { id },\n);\nconst [user, posts] = useResource(\n  [UserResource.singleSelect(), { id }],\n  [PostResource.listSelect(), { id: postid }]\n);\n*/\nexport function useResource<\n  S extends SelectShape<P1, P2>,\n  P1 extends object,\n  P2 extends object\n>(selectShape: S, params: ParamArg<S> | null): AlwaysSelect<S>;\nexport function useResource<\n  S1 extends SelectShape<X, Y>,\n  X extends object,\n  Y extends object\n>(v1: [S1, ParamArg<S1> | null]): [AlwaysSelect<S1>];\nexport function useResource<\n  S1 extends SelectShape<X1, Y1>,\n  X1 extends object,\n  Y1 extends object,\n  S2 extends SelectShape<X2, Y2>,\n  X2 extends object,\n  Y2 extends object\n>(\n  v1: [S1, ParamArg<S1> | null],\n  v2: [S2, ParamArg<S2> | null],\n): [AlwaysSelect<S1>, AlwaysSelect<S2>];\nexport function useResource<\n  S1 extends SelectShape<X1, Y1>,\n  X1 extends object,\n  Y1 extends object,\n  S2 extends SelectShape<X2, Y2>,\n  X2 extends object,\n  Y2 extends object,\n  S3 extends SelectShape<X3, Y3>,\n  X3 extends object,\n  Y3 extends object\n>(\n  v1: [S1, ParamArg<S1> | null],\n  v2: [S2, ParamArg<S2> | null],\n  v3: [S3, ParamArg<S3> | null],\n): [AlwaysSelect<S1>, AlwaysSelect<S2>, AlwaysSelect<S3>];\nexport function useResource<\n  S1 extends SelectShape<X1, Y1>,\n  X1 extends object,\n  Y1 extends object,\n  S2 extends SelectShape<X2, Y2>,\n  X2 extends object,\n  Y2 extends object,\n  S3 extends SelectShape<X3, Y3>,\n  X3 extends object,\n  Y3 extends object,\n  S4 extends SelectShape<X4, Y4>,\n  X4 extends object,\n  Y4 extends object\n>(\n  v1: [S1, ParamArg<S1> | null],\n  v2: [S2, ParamArg<S2> | null],\n  v3: [S3, ParamArg<S3> | null],\n  v4: [S4, ParamArg<S4> | null],\n): [AlwaysSelect<S1>, AlwaysSelect<S2>, AlwaysSelect<S3>, AlwaysSelect<S4>];\nexport function useResource<\n  S1 extends SelectShape<X1, Y1>,\n  X1 extends object,\n  Y1 extends object,\n  S2 extends SelectShape<X2, Y2>,\n  X2 extends object,\n  Y2 extends object,\n  S3 extends SelectShape<X3, Y3>,\n  X3 extends object,\n  Y3 extends object,\n  S4 extends SelectShape<X4, Y4>,\n  X4 extends object,\n  Y4 extends object,\n  S5 extends SelectShape<X5, Y5>,\n  X5 extends object,\n  Y5 extends object\n>(\n  v1: [S1, ParamArg<S1> | null],\n  v2: [S2, ParamArg<S2> | null],\n  v3: [S3, ParamArg<S3> | null],\n  v4: [S4, ParamArg<S4> | null],\n  v5: [S5, ParamArg<S5> | null],\n): [\n  AlwaysSelect<S1>,\n  AlwaysSelect<S2>,\n  AlwaysSelect<S3>,\n  AlwaysSelect<S4>,\n  AlwaysSelect<S5>\n];\nexport function useResource<\n  S extends SelectShape<P1, P2>,\n  P1 extends object,\n  P2 extends object\n>(...args: ResourceArgs<S, P1, P2> | ResourceArgs<S, P1, P2>[]) {\n  if (Array.isArray(args[0])) {\n    // TODO: provide type guard function to detect this\n    return useManyResources(...(args as ResourceArgs<S, P1, P2>[]));\n  }\n  args = args as ResourceArgs<S, P1, P2>;\n  // TODO: make return types match up with the branching logic we put in here.\n  return useOneResource(args[0], args[1]);\n}\n\n/*\nfunction UserForm() {\n  const create = useDispatch(UserResource.createSelect());\n  return <form onSubmit={(data) => create(data)}></form>\n}\n*/\n/*export function useDispatch(selectShape: SelectShape<T, Body>) {\n\n}\n*/\n"]}

lib/react-rest/provider.js

@@ -32,3 +32,6 @@ import "core-js/modules/es7.symbol.async-iterator";
     window.requestIdleCallback(function () {
-      resolvers[action.meta.url](action.payload);
+      resolvers[action.meta.url](action.payload); // since we're resolved we no longer need to keep track of this promise
+
+      delete resolvers[action.meta.url];
+      delete fetched[action.meta.url];
     }, {
@@ -52,3 +55,3 @@ timeout: 500
   var dispatchers = {
-    fetch: useCallback(function (_ref2, params) {
+    fetch: useCallback(function (_ref2, params, body) {
       var fetch = _ref2.fetch,
@@ -68,3 +71,3 @@ schema = _ref2.schema,
 
-      fetch('get', url).then(function (data) {
+      fetch(url, body).then(function (data) {
         dispatch({
@@ -92,2 +95,2 @@ type: 'receive',
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

lib/resource/Resource.d.ts

 import request from 'superagent';
 import { schema, Schema } from 'normalizr';
-import { AbstractInstanceType, State, Method } from '../types';
+import { AbstractInstanceType, State } from '../types';
 export default abstract class Resource {
@@ -23,3 +23,3 @@ static readonly urlRoot: string;
         getUrl(params: object): string;
-        fetch(method: "get" | "post" | "put" | "patch" | "delete" | undefined, url: string, body?: Partial<AbstractInstanceType<T>> | undefined): Promise<any>;
+        fetch(url: string, body?: object | undefined): Promise<any>;
     };
@@ -30,10 +30,44 @@ static listSelect<T extends typeof Resource>(this: T): {
         getUrl(params: object): string;
-        fetch(method: "get" | "post" | "put" | "patch" | "delete" | undefined, url: string, body?: Partial<AbstractInstanceType<T>> | undefined): Promise<any>;
+        fetch(url: string, body?: object | undefined): Promise<any>;
     };
+    static createSelect<T extends typeof Resource>(this: T): {
+        select: (state: State<Resource>, urlParams: Partial<AbstractInstanceType<T>>) => AbstractInstanceType<T> | null;
+        schema: schema.Entity;
+        getUrl(): string;
+        fetch(url: string, body: Partial<AbstractInstanceType<T>>): Promise<any>;
+    };
+    static updateSelect<T extends typeof Resource>(this: T): {
+        select: (state: State<Resource>, urlParams: Partial<AbstractInstanceType<T>>) => AbstractInstanceType<T> | null;
+        schema: schema.Entity;
+        getUrl(params: object): string;
+        fetch(url: string, body: Partial<AbstractInstanceType<T>>): Promise<any>;
+    };
+    static partialUpdateSelect<T extends typeof Resource>(this: T): {
+        select: (state: State<Resource>, urlParams: Partial<AbstractInstanceType<T>>) => AbstractInstanceType<T> | null;
+        schema: schema.Entity;
+        getUrl(params: object): string;
+        fetch(url: string, body: Partial<AbstractInstanceType<T>>): Promise<any>;
+    };
+    static deleteSelect<T extends typeof Resource>(this: T): {
+        select: () => null;
+        schema: {};
+        getUrl(params: object): string;
+        fetch(url: string): Promise<any>;
+    };
 }
-export interface SelectShape<T extends typeof Resource, S extends any> {
-    select(state: State<Resource>, params: object): S;
-    getUrl(params: object): string;
+export interface SelectShape<Param extends object, Payload extends object | void> {
+    select(state: State<Resource>, params: Param): any;
+    getUrl(params: Param): string;
     schema: Schema;
-    fetch(method: Method, url: string, body?: Partial<AbstractInstanceType<T>>): Promise<any>;
+    fetch(url: string, body: Payload): Promise<any>;
 }
+export declare type SelectReturn<T> = T extends {
+    select: (...args: any[]) => infer U;
+} ? U : never;
+export declare type AlwaysSelect<T> = Exclude<SelectReturn<T>, null>;
+export declare type ParamArg<T> = T extends {
+    select: (a: any, b: infer U) => any;
+} ? U : never;
+export declare type PayloadArg<T> = T extends {
+    fetch: (a: any, c: infer U) => any;
+} ? U : never;

lib/resource/Resource.js

@@ -168,7 +168,4 @@ import "core-js/modules/es6.promise";
         },
-        fetch: function fetch() {
-          var method = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'get';
-          var url = arguments.length > 1 ? arguments[1] : undefined;
-          var body = arguments.length > 2 ? arguments[2] : undefined;
-          return self.fetch(method, url, body);
+        fetch: function fetch(url, body) {
+          return self.fetch('get', url, body);
         }
@@ -187,10 +184,70 @@ };
         },
-        fetch: function fetch() {
-          var method = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'get';
-          var url = arguments.length > 1 ? arguments[1] : undefined;
-          var body = arguments.length > 2 ? arguments[2] : undefined;
-          return self.fetch(method, url, body);
+        fetch: function fetch(url, body) {
+          return self.fetch('get', url, body);
         }
       };
     }
+  }, {
+    key: "createSelect",
+    value: function createSelect() {
+      var self = this;
+      return {
+        select: makeSingle(self),
+        schema: self.getSchema(),
+        getUrl: function getUrl() {
+          return self.listUrl();
+        },
+        fetch: function fetch(url, body) {
+          return self.fetch('post', url, body);
+        }
+      };
+    }
+  }, {
+    key: "updateSelect",
+    value: function updateSelect() {
+      var self = this;
+      return {
+        select: makeSingle(self),
+        schema: self.getSchema(),
+        getUrl: function getUrl(params) {
+          return self.url(params);
+        },
+        fetch: function fetch(url, body) {
+          return self.fetch('put', url, body);
+        }
+      };
+    }
+  }, {
+    key: "partialUpdateSelect",
+    value: function partialUpdateSelect() {
+      var self = this;
+      return {
+        select: makeSingle(self),
+        schema: self.getSchema(),
+        //TODO: change merge strategy in case we want to handle partial returns
+        getUrl: function getUrl(params) {
+          return self.url(params);
+        },
+        fetch: function fetch(url, body) {
+          return self.fetch('patch', url, body);
+        }
+      };
+    }
+  }, {
+    key: "deleteSelect",
+    value: function deleteSelect() {
+      var self = this;
+      return {
+        select: function select() {
+          return null;
+        },
+        schema: {},
+        getUrl: function getUrl(params) {
+          return self.url(params);
+        },
+        fetch: function fetch(url) {
+          return self.fetch('delete', url);
+        }
+      };
+    }
   }]);
@@ -208,2 +265,2 @@
 export { Resource as default };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/resource/Resource.ts"],"names":["request","schema","qs","makeSingle","makeList","getSchema","M","Entity","urlRoot","idAttribute","value","parent","key","pk","toString","processStrategy","fromJS","mergeStrategy","a","b","Resource","S","constructor","url","props","Error","instance","Object","assign","Symbol","params","prototype","call","urlParams","hasOwnProperty","searchParams","queryString","stringify","indices","sort","strictNullHandling","method","body","req","fetchPlugin","use","send","json","self","select","getUrl","fetch","getListSchema","listUrl"],"mappings":"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","sourcesContent":["import request from 'superagent';\nimport { schema, Schema } from 'normalizr';\nimport { memoize, identity, isEmpty } from 'lodash';\nimport qs from 'qs';\nimport { AbstractInstanceType, State, Method } from '../types';\nimport { makeSingle, makeList } from '../state/selectors';\n\nconst getSchema: <T extends typeof Resource>(\n  M: T,\n) => schema.Entity = memoize(<T extends typeof Resource>(M: T) => {\n  return new schema.Entity(\n    M.urlRoot,\n    {},\n    {\n      idAttribute: (value, parent, key) => {\n        return (M.pk(value) || key).toString();\n      },\n      processStrategy: value => {\n        return M.fromJS(value);\n      },\n      mergeStrategy: (a, b) => b,\n    },\n  );\n});\n\nexport default abstract class Resource {\n  // typescript todo: require subclasses to implement\n  static readonly urlRoot: string;\n  static readonly poll?: number;\n  static fetchPlugin?: request.Plugin;\n  abstract pk(): string | number | null;\n\n  static fromJS<T extends typeof Resource>(\n    this: T,\n    props: Partial<AbstractInstanceType<T>>,\n  ) {\n    if (this === Resource)\n      throw new Error('cannot construct on abstract types');\n    // we type guarded abstract case above, so ok to force typescript to allow constructor call\n    const instance = new (this as any)(props) as AbstractInstanceType<T>;\n    Object.assign(instance, props);\n    return instance;\n  }\n\n  static toString<T extends typeof Resource>(this: T) {\n    return `this.name::${this.urlRoot}`;\n  }\n  static getKey<T extends typeof Resource>(this: T) {\n    return Symbol(this.toString());\n  }\n  static pk<T extends typeof Resource>(\n    this: T,\n    params: Partial<AbstractInstanceType<T>>,\n  ): string | number | null {\n    return this.prototype.pk.call(params);\n  }\n\n  get url(): string {\n    // typescript thinks constructor is just a function\n    const S = this.constructor as typeof Resource;\n    return S.url(this);\n  }\n\n  static url<T extends typeof Resource>(\n    this: T,\n    urlParams?: Partial<AbstractInstanceType<T>>,\n  ): string {\n    if (urlParams) {\n      if (\n        urlParams.hasOwnProperty('url') &&\n        urlParams.url &&\n        typeof urlParams.url === 'string'\n      ) {\n        return urlParams.url;\n      }\n      if (this.pk(urlParams)) {\n        return `${this.urlRoot}${this.pk(urlParams)}`;\n      }\n    }\n    return this.urlRoot;\n  }\n\n  static listUrl<T extends typeof Resource>(\n    this: T,\n    searchParams?: object,\n  ): string {\n    const queryString =\n      searchParams && !isEmpty(searchParams)\n        ? `?${qs.stringify(searchParams, {\n            indices: false,\n            sort: identity,\n            strictNullHandling: true,\n          })}`\n        : '';\n    return `${this.urlRoot}${queryString}`;\n  }\n\n  static async fetch<T extends typeof Resource>(\n    this: T,\n    method: Method = 'get',\n    url: string,\n    body?: Partial<AbstractInstanceType<T>>,\n  ) {\n    let req = request[method](url);\n    if (this.fetchPlugin) req = req.use(this.fetchPlugin);\n    if (body) req = req.send(body);\n    const json = (await req).body;\n    return json;\n  }\n\n  static getSchema<T extends typeof Resource>(this: T) {\n    return getSchema(this);\n  }\n  static getListSchema<T extends typeof Resource>(this: T): Schema {\n    return [this.getSchema()];\n  }\n\n  static singleSelect<T extends typeof Resource>(this: T) {\n    const self = this;\n    return {\n      select: makeSingle(self),\n      schema: self.getSchema(),\n      getUrl(params: object) {\n        return self.url(params);\n      },\n      fetch(\n        method: Method = 'get',\n        url: string,\n        body?: Partial<AbstractInstanceType<T>>,\n      ) {\n        return self.fetch(method, url, body);\n      },\n    };\n  }\n\n  static listSelect<T extends typeof Resource>(this: T) {\n    const self = this;\n    return {\n      select: makeList(self),\n      schema: self.getListSchema(),\n      getUrl(params: object) {\n        return self.listUrl(params);\n      },\n      fetch(\n        method: Method = 'get',\n        url: string,\n        body?: Partial<AbstractInstanceType<T>>,\n      ) {\n        return self.fetch(method, url, body);\n      },\n    };\n  }\n}\n\n\nexport interface SelectShape<T extends typeof Resource, S extends any> {\n  select(state: State<Resource>, params: object): S;\n  getUrl(params: object): string;\n  schema: Schema;\n  fetch(\n    method: Method,\n    url: string,\n    body?: Partial<AbstractInstanceType<T>>,\n  ): Promise<any>;\n}\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/resource/Resource.ts"],"names":["request","schema","qs","makeSingle","makeList","getSchema","M","Entity","urlRoot","idAttribute","value","parent","key","pk","toString","processStrategy","fromJS","mergeStrategy","a","b","Resource","S","constructor","url","props","Error","instance","Object","assign","Symbol","params","prototype","call","urlParams","hasOwnProperty","searchParams","queryString","stringify","indices","sort","strictNullHandling","method","body","req","fetchPlugin","use","send","json","self","select","getUrl","fetch","getListSchema","listUrl"],"mappings":"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","sourcesContent":["import request from 'superagent';\nimport { schema, Schema } from 'normalizr';\nimport { memoize, identity, isEmpty } from 'lodash';\nimport qs from 'qs';\nimport { AbstractInstanceType, State, Method } from '../types';\nimport { makeSingle, makeList } from '../state/selectors';\n\nconst getSchema: <T extends typeof Resource>(M: T) => schema.Entity = memoize(\n  <T extends typeof Resource>(M: T) => {\n    return new schema.Entity(\n      M.urlRoot,\n      {},\n      {\n        idAttribute: (value, parent, key) => {\n          return (M.pk(value) || key).toString();\n        },\n        processStrategy: value => {\n          return M.fromJS(value);\n        },\n        mergeStrategy: (a, b) => b,\n      },\n    );\n  },\n);\n\nexport default abstract class Resource {\n  // typescript todo: require subclasses to implement\n  static readonly urlRoot: string;\n  static readonly poll?: number;\n  static fetchPlugin?: request.Plugin;\n  abstract pk(): string | number | null;\n\n  static fromJS<T extends typeof Resource>(\n    this: T,\n    props: Partial<AbstractInstanceType<T>>,\n  ) {\n    if (this === Resource)\n      throw new Error('cannot construct on abstract types');\n    // we type guarded abstract case above, so ok to force typescript to allow constructor call\n    const instance = new (this as any)(props) as AbstractInstanceType<T>;\n    Object.assign(instance, props);\n    return instance;\n  }\n\n  static toString<T extends typeof Resource>(this: T) {\n    return `this.name::${this.urlRoot}`;\n  }\n  static getKey<T extends typeof Resource>(this: T) {\n    return Symbol(this.toString());\n  }\n  static pk<T extends typeof Resource>(\n    this: T,\n    params: Partial<AbstractInstanceType<T>>,\n  ): string | number | null {\n    return this.prototype.pk.call(params);\n  }\n\n  get url(): string {\n    // typescript thinks constructor is just a function\n    const S = this.constructor as typeof Resource;\n    return S.url(this);\n  }\n\n  static url<T extends typeof Resource>(\n    this: T,\n    urlParams?: Partial<AbstractInstanceType<T>>,\n  ): string {\n    if (urlParams) {\n      if (\n        urlParams.hasOwnProperty('url') &&\n        urlParams.url &&\n        typeof urlParams.url === 'string'\n      ) {\n        return urlParams.url;\n      }\n      if (this.pk(urlParams)) {\n        return `${this.urlRoot}${this.pk(urlParams)}`;\n      }\n    }\n    return this.urlRoot;\n  }\n\n  static listUrl<T extends typeof Resource>(\n    this: T,\n    searchParams?: object,\n  ): string {\n    const queryString =\n      searchParams && !isEmpty(searchParams)\n        ? `?${qs.stringify(searchParams, {\n            indices: false,\n            sort: identity,\n            strictNullHandling: true,\n          })}`\n        : '';\n    return `${this.urlRoot}${queryString}`;\n  }\n\n  static async fetch<T extends typeof Resource>(\n    this: T,\n    method: Method = 'get',\n    url: string,\n    body?: Partial<AbstractInstanceType<T>>,\n  ) {\n    let req = request[method](url);\n    if (this.fetchPlugin) req = req.use(this.fetchPlugin);\n    if (body) req = req.send(body);\n    const json = (await req).body;\n    return json;\n  }\n\n  static getSchema<T extends typeof Resource>(this: T) {\n    return getSchema(this);\n  }\n  static getListSchema<T extends typeof Resource>(this: T): Schema {\n    return [this.getSchema()];\n  }\n\n  static singleSelect<T extends typeof Resource>(this: T) {\n    const self = this;\n    return {\n      select: makeSingle(self),\n      schema: self.getSchema(),\n      getUrl(params: object) {\n        return self.url(params);\n      },\n      fetch(url: string, body?: object) {\n        return self.fetch('get', url, body);\n      },\n    };\n  }\n\n  static listSelect<T extends typeof Resource>(this: T) {\n    const self = this;\n    return {\n      select: makeList(self),\n      schema: self.getListSchema(),\n      getUrl(params: object) {\n        return self.listUrl(params);\n      },\n      fetch(url: string, body?: object) {\n        return self.fetch('get', url, body);\n      },\n    };\n  }\n  static createSelect<T extends typeof Resource>(this: T) {\n    const self = this;\n    return {\n      select: makeSingle(self),\n      schema: self.getSchema(),\n      getUrl() {\n        return self.listUrl();\n      },\n      fetch(url: string, body: Partial<AbstractInstanceType<T>>) {\n        return self.fetch('post', url, body);\n      },\n    };\n  }\n  static updateSelect<T extends typeof Resource>(this: T) {\n    const self = this;\n    return {\n      select: makeSingle(self),\n      schema: self.getSchema(),\n      getUrl(params: object) {\n        return self.url(params);\n      },\n      fetch(url: string, body: Partial<AbstractInstanceType<T>>) {\n        return self.fetch('put', url, body);\n      },\n    };\n  }\n  static partialUpdateSelect<T extends typeof Resource>(this: T) {\n    const self = this;\n    return {\n      select: makeSingle(self),\n      schema: self.getSchema(), //TODO: change merge strategy in case we want to handle partial returns\n      getUrl(params: object) {\n        return self.url(params);\n      },\n      fetch(url: string, body: Partial<AbstractInstanceType<T>>) {\n        return self.fetch('patch', url, body);\n      },\n    };\n  }\n  static deleteSelect<T extends typeof Resource>(this: T) {\n    const self = this;\n    return {\n      select: () => null,\n      schema: {},\n      getUrl(params: object) {\n        return self.url(params);\n      },\n      fetch(url: string) {\n        return self.fetch('delete', url);\n      },\n    };\n  }\n}\n\nexport interface SelectShape<Param extends object, Payload extends object | void> {\n  select(state: State<Resource>, params: Param): any;\n  getUrl(params: Param): string;\n  schema: Schema;\n  fetch(url: string, body: Payload): Promise<any>;\n}\nexport type SelectReturn<T> = T extends { select: (...args: any[]) => infer U }\n  ? U\n  : never;\nexport type AlwaysSelect<T> = Exclude<SelectReturn<T>, null>;\nexport type ParamArg<T> = T extends {\n  select: (a: any, b: infer U) => any;\n}\n  ? U\n  : never;\nexport type PayloadArg<T> = T extends {\n  fetch: (a: any, c: infer U) => any;\n}\n  ? U\n  : never;\n"]}

lib/state/reducer.js

@@ -24,9 +24,2 @@ import "core-js/modules/es6.array.for-each";
 
-    case 'fetch':
-      return _objectSpread({}, state, {
-        meta: _objectSpread({}, state.meta, _defineProperty({}, action.payload, _objectSpread({}, action.meta, {
-          status: 'fetching'
-        })))
-      });
-
     default:
@@ -38,2 +31,2 @@ // A reducer must always return a valid state.
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdGF0ZS9yZWR1Y2VyLnRzIl0sIm5hbWVzIjpbIm5vcm1hbGl6ZSIsInJlZHVjZXIiLCJzdGF0ZSIsImFjdGlvbiIsInR5cGUiLCJub3JtYWxpemVkIiwicGF5bG9hZCIsIm1ldGEiLCJzY2hlbWEiLCJlbnRpdGllcyIsInJlc3VsdHMiLCJ1cmwiLCJyZXN1bHQiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7OztBQUFBLFNBQVNBLFNBQVQsUUFBMEIsV0FBMUI7QUFLQSxlQUFlLFNBQVNDLE9BQVQsQ0FBaUJDLEtBQWpCLEVBQXlDQyxNQUF6QyxFQUE4RDtBQUMzRSxVQUFRQSxNQUFNLENBQUNDLElBQWY7QUFDRSxTQUFLLFNBQUw7QUFDRSxVQUFNQyxVQUFVLEdBQUdMLFNBQVMsQ0FBQ0csTUFBTSxDQUFDRyxPQUFSLEVBQWlCSCxNQUFNLENBQUNJLElBQVAsQ0FBWUMsTUFBN0IsQ0FBNUI7QUFDQSxhQUFPO0FBQ0xDLFFBQUFBLFFBQVEsRUFBRSx5QkFBV1AsS0FBSyxDQUFDTyxRQUFqQixHQUE2QkosVUFBVSxDQUFDSSxRQUF4QyxDQURMO0FBRUxDLFFBQUFBLE9BQU8sb0JBQ0ZSLEtBQUssQ0FBQ1EsT0FESixzQkFFSlAsTUFBTSxDQUFDSSxJQUFQLENBQVlJLEdBRlIsRUFFY04sVUFBVSxDQUFDTyxNQUZ6QixFQUZGO0FBTUxMLFFBQUFBLElBQUksRUFBRUwsS0FBSyxDQUFDSztBQU5QLE9BQVA7O0FBUUY7QUFDRTtBQUNBO0FBQ0EsYUFBT0wsS0FBUDtBQWRKO0FBZ0JEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgbm9ybWFsaXplIH0gZnJvbSAnbm9ybWFsaXpyJztcbmltcG9ydCB7IG1lcmdlIH0gZnJvbSAnbG9kYXNoJztcbmltcG9ydCB7IFJlc291cmNlIH0gZnJvbSAnLi4vcmVzb3VyY2UnO1xuaW1wb3J0IHsgQWN0aW9uVHlwZXMsIFN0YXRlIH0gZnJvbSAnLi4vdHlwZXMnO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiByZWR1Y2VyKHN0YXRlOiBTdGF0ZTxSZXNvdXJjZT4sIGFjdGlvbjogQWN0aW9uVHlwZXMpIHtcbiAgc3dpdGNoIChhY3Rpb24udHlwZSkge1xuICAgIGNhc2UgJ3JlY2VpdmUnOlxuICAgICAgY29uc3Qgbm9ybWFsaXplZCA9IG5vcm1hbGl6ZShhY3Rpb24ucGF5bG9hZCwgYWN0aW9uLm1ldGEuc2NoZW1hKTtcbiAgICAgIHJldHVybiB7XG4gICAgICAgIGVudGl0aWVzOiBtZXJnZSh7IC4uLnN0YXRlLmVudGl0aWVzIH0sIG5vcm1hbGl6ZWQuZW50aXRpZXMpLFxuICAgICAgICByZXN1bHRzOiB7XG4gICAgICAgICAgLi4uc3RhdGUucmVzdWx0cyxcbiAgICAgICAgICBbYWN0aW9uLm1ldGEudXJsXTogbm9ybWFsaXplZC5yZXN1bHQsXG4gICAgICAgIH0sXG4gICAgICAgIG1ldGE6IHN0YXRlLm1ldGEsXG4gICAgICB9O1xuICAgIGRlZmF1bHQ6XG4gICAgICAvLyBBIHJlZHVjZXIgbXVzdCBhbHdheXMgcmV0dXJuIGEgdmFsaWQgc3RhdGUuXG4gICAgICAvLyBBbHRlcm5hdGl2ZWx5IHlvdSBjYW4gdGhyb3cgYW4gZXJyb3IgaWYgYW4gaW52YWxpZCBhY3Rpb24gaXMgZGlzcGF0Y2hlZC5cbiAgICAgIHJldHVybiBzdGF0ZTtcbiAgfVxufVxuIl19

package.json

 {
   "name": "rest-hooks",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Easy react hooks for REST apis",
@@ -30,3 +30,5 @@ "sideEffects": false,
     "networking",
-    "suspense"
+    "suspense",
+    "fetch",
+    "data fetching"
   ],
@@ -57,3 +59,3 @@ "author": "Nathaniel Tucker",
   "devDependencies": {
-    "@anansi/babel-preset": "0.11.1",
+    "@anansi/babel-preset": "0.11.3",
     "@anansi/eslint-config": "^0.5.2",
@@ -64,3 +66,3 @@ "@babel/cli": "^7.2.3",
     "@types/lodash": "^4.14.120",
-    "@types/nock": "^9.3.0",
+    "@types/nock": "^9.3.1",
     "@types/qs": "^6.5.1",
@@ -89,3 +91,3 @@ "babel-core": "^7.0.0-bridge.0",
   "dependencies": {
-    "@types/react": "^16.7.20",
+    "@types/react": "^16.8.1",
     "@types/superagent": "^3.8.6",
@@ -92,0 +94,0 @@ "core-js": "^2.6.3",

README.md

@@ -37,2 +37,2 @@ # Rest hooks: Data fetching and binding hooks
   * Optimistic query update on create
-  * Cross-resource multi-update RPC
+  * Cross-resource multi-update RPC (dealing with side-effects)

No alert changes

Improved metrics

Total package byte prevSize

93383

increased by16.66%

Lines of code

747

increased by15.63%

Dependency changes

• Updated@types/react@^16.8.1