@data-client/rest 0.1.0

package/legacy/next/RestEndpoint.js

@@ -0,0 +1,225 @@
+import _objectDestructuringEmpty from "@babel/runtime/helpers/objectDestructuringEmpty";
+import _classPrivateFieldLooseBase from "@babel/runtime/helpers/classPrivateFieldLooseBase";
+import _classPrivateFieldLooseKey from "@babel/runtime/helpers/classPrivateFieldLooseKey";
+import { Endpoint } from '@data-client/endpoint';
+import { pathToRegexp } from 'path-to-regexp';
+import extractCollection from '../extractCollection.js';
+import mapCollection from '../mapCollection.js';
+import NetworkError from '../NetworkError.js';
+import { paginatedMerge, paginatedFilter } from '../paginatedCollections.js';
+import paginationUpdate from '../paginationUpdate.js';
+import paramsToString from '../paramsToString.js';
+import { getUrlBase, getUrlTokens, isPojo } from '../RestHelpers.js';
+
+/** Simplifies endpoint definitions that follow REST patterns
+ *
+ * @see https://resthooks.io/rest/api/RestEndpoint
+ */
+var _hasBody = /*#__PURE__*/_classPrivateFieldLooseKey("hasBody");
+export default class RestEndpoint extends Endpoint {
+  constructor(options) {
+    var _options$fetch;
+    super((_options$fetch = options.fetch) != null ? _options$fetch : async function (...args) {
+      const urlParams = _classPrivateFieldLooseBase(this, _hasBody)[_hasBody] && args.length < 2 ? {} : args[0] || {};
+      const body = _classPrivateFieldLooseBase(this, _hasBody)[_hasBody] ? args[args.length - 1] : undefined;
+      return this.fetchResponse(this.url(urlParams), await this.getRequestInit(body)).then(response => this.parseResponse(response)).then(res => this.process(res, ...args));
+    }, options);
+    // we want to use the prototype chain here
+    Object.defineProperty(this, _hasBody, {
+      writable: true,
+      value: void 0
+    });
+    if (!('sideEffect' in this) || 'method' in options && !('sideEffect' in options)) {
+      this.sideEffect = options.method === 'GET' || options.method === undefined ? undefined : true;
+    }
+    if (this.method === undefined) {
+      this.method = this.sideEffect ? 'POST' : 'GET';
+    }
+    if (this.urlPrefix === undefined) {
+      this.urlPrefix = '';
+    }
+    _classPrivateFieldLooseBase(this, _hasBody)[_hasBody] = (!('body' in this) || this.body !== undefined) && !['GET', 'DELETE'].includes(this.method);
+    Object.defineProperty(this, 'name', {
+      get() {
+        // using 'in' to ensure inheritance lookup
+        if ('__name' in this) return this.__name;
+        return this.urlPrefix + this.path;
+      }
+    });
+  }
+  key(...args) {
+    return `${this.method} ${this.url(_classPrivateFieldLooseBase(this, _hasBody)[_hasBody] && args.length < 2 ? {} : args[0] || {})}`;
+  }
+
+  /** Get the url */
+  url(urlParams = {}) {
+    const urlBase = getUrlBase(this.path)(urlParams);
+    const tokens = getUrlTokens(this.path);
+    const searchParams = {};
+    Object.keys(urlParams).forEach(k => {
+      if (!tokens.has(k)) {
+        searchParams[k] = urlParams[k];
+      }
+    });
+    if (Object.keys(searchParams).length) {
+      return `${this.urlPrefix}${urlBase}?${paramsToString(searchParams)}`;
+    }
+    return `${this.urlPrefix}${urlBase}`;
+  }
+  getHeaders(headers) {
+    return headers;
+  }
+
+  /** Init options for fetch - run at fetch */
+  async getRequestInit(body) {
+    const bodyIsPojo = isPojo(body);
+    if (bodyIsPojo) {
+      body = JSON.stringify(body);
+    }
+    const init = Object.assign({}, this.requestInit, {
+      method: this.method,
+      signal: this.signal,
+      body
+    });
+    if (!body || bodyIsPojo) {
+      init.headers = Object.assign({
+        // default to application/json but allow user explicit overrides
+        'Content-Type': 'application/json'
+      }, init.headers);
+    }
+    init.headers = await this.getHeaders(init.headers);
+    return init;
+  }
+
+  /** Perform network request and resolve with HTTP Response */
+  fetchResponse(input, init) {
+    return fetch(input, init).then(response => {
+      if (!response.ok) {
+        throw new NetworkError(response);
+      }
+      return response;
+    }).catch(error => {
+      // ensure CORS, network down, and parse errors are still caught by NetworkErrorBoundary
+      if (error instanceof TypeError) {
+        error.status = 500;
+      }
+      throw error;
+    });
+  }
+  parseResponse(response) {
+    var _response$headers$get;
+    // this should not have any content to read
+    if (response.status === 204) return Promise.resolve(null);
+    if (!((_response$headers$get = response.headers.get('content-type')) != null && _response$headers$get.includes('json'))) {
+      return response.text().then(text => {
+        // string or 'not set' schema, are valid
+        // when overriding process they might handle other cases, so we don't want to block on our logic
+        if (['string', 'undefined'].includes(typeof this.schema) || this.schema === null || this.process !== RestEndpoint.prototype.process) return text;
+        const error = new NetworkError(response);
+        error.status = 404;
+        error.message = `Unexpected text response for schema ${this.schema}`;
+        // custom dev-only messages for more detailed cause
+        /* istanbul ignore else */
+        if (process.env.NODE_ENV !== 'production') {
+          var _response$headers$get2;
+          if (!((_response$headers$get2 = response.headers.get('content-type')) != null && _response$headers$get2.includes('html') || text.startsWith('<!doctype html>'))) {
+            if (tryParse(text) !== undefined) {
+              error.message = `"content-type" header does not include "json", but JSON response found.
+See https://www.rfc-editor.org/rfc/rfc4627 for information on JSON responses
+
+Using parsed JSON.
+If text content was expected see https://resthooks.io/rest/api/RestEndpoint#parseResponse`;
+            }
+          } else {
+            error.message = `Unexpected html response for schema ${this.schema}
+This likely means no API endpoint was configured for this request, resulting in an HTML fallback.
+
+Response (first 300 characters): ${text.substring(0, 300)}`;
+          }
+        }
+        throw error;
+      });
+    }
+    return response.json().catch(error => {
+      error.status = 400;
+      throw error;
+    });
+  }
+  process(value) {
+    return value;
+  }
+  errorPolicy(error) {
+    return error.status >= 500 ? 'soft' : undefined;
+  }
+  get pathRegex() {
+    return pathToRegexp(this.path);
+  }
+  testKey(key) {
+    const prefix = this.method + ' ' + this.urlPrefix;
+    if (!key.startsWith(prefix)) return false;
+    let lastQuestion = key.lastIndexOf('?');
+    if (lastQuestion === -1) lastQuestion = undefined;
+    return this.pathRegex.test(key.substring(prefix.length, lastQuestion));
+  }
+  extend(options) {
+    // make a constructor/prototype based off this
+    // extend from it and init with options sent
+    class E extends this.constructor {}
+    Object.assign(E.prototype, this);
+    const instance = new E( //  fetch get overridden by function prototype, so we must set it explicitly every time
+    Object.assign({
+      fetch: this.fetch
+    }, options));
+    return instance;
+  }
+  paginated(removeCursor) {
+    if (typeof removeCursor === 'string') {
+      const fieldName = removeCursor;
+      removeCursor = _ref => {
+        let params = Object.assign({}, (_objectDestructuringEmpty(_ref), _ref));
+        delete params[fieldName];
+        return [params];
+      };
+    }
+    let found = false;
+    const createPaginatedSchema = collection => {
+      found = true;
+      return collection.addWith(paginatedMerge, paginatedFilter(removeCursor));
+    };
+    const newSchema = mapCollection(this.schema, createPaginatedSchema);
+    if (found) {
+      return this.extend({
+        schema: newSchema
+      });
+    }
+    return this.extend({
+      update: paginationUpdate(this, removeCursor)
+    });
+  }
+  get push() {
+    return this.extend({
+      method: 'POST',
+      schema: extractCollection(this.schema, s => s.push)
+    });
+  }
+  get unshift() {
+    return this.extend({
+      method: 'POST',
+      schema: extractCollection(this.schema, s => s.unshift)
+    });
+  }
+  get assign() {
+    return this.extend({
+      method: 'POST',
+      schema: extractCollection(this.schema, s => s.assign)
+    });
+  }
+}
+const tryParse = input => {
+  try {
+    return JSON.parse(input);
+  } catch (e) {
+    return undefined;
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Endpoint","pathToRegexp","extractCollection","mapCollection","NetworkError","paginatedMerge","paginatedFilter","paginationUpdate","paramsToString","getUrlBase","getUrlTokens","isPojo","_hasBody","_classPrivateFieldLooseKey","RestEndpoint","constructor","options","_options$fetch","fetch","args","urlParams","_classPrivateFieldLooseBase","length","body","undefined","fetchResponse","url","getRequestInit","then","response","parseResponse","res","process","Object","defineProperty","writable","value","sideEffect","method","urlPrefix","includes","get","__name","path","key","urlBase","tokens","searchParams","keys","forEach","k","has","getHeaders","headers","bodyIsPojo","JSON","stringify","init","assign","requestInit","signal","input","ok","catch","error","TypeError","status","_response$headers$get","Promise","resolve","text","schema","prototype","message","env","NODE_ENV","_response$headers$get2","startsWith","tryParse","substring","json","errorPolicy","pathRegex","testKey","prefix","lastQuestion","lastIndexOf","test","extend","E","instance","paginated","removeCursor","fieldName","_ref","params","_objectDestructuringEmpty","found","createPaginatedSchema","collection","addWith","newSchema","update","push","s","unshift","parse","e"],"sources":["../../src/next/RestEndpoint.js"],"sourcesContent":["import { Endpoint } from '@data-client/endpoint';\nimport { pathToRegexp } from 'path-to-regexp';\n\nimport extractCollection from '../extractCollection.js';\nimport mapCollection from '../mapCollection.js';\nimport NetworkError from '../NetworkError.js';\nimport { paginatedMerge, paginatedFilter } from '../paginatedCollections.js';\nimport paginationUpdate from '../paginationUpdate.js';\nimport paramsToString from '../paramsToString.js';\nimport { getUrlBase, getUrlTokens, isPojo } from '../RestHelpers.js';\n\n/** Simplifies endpoint definitions that follow REST patterns\n *\n * @see https://resthooks.io/rest/api/RestEndpoint\n */\nexport default class RestEndpoint extends Endpoint {\n  #hasBody;\n  constructor(options) {\n    super(\n      options.fetch ??\n        async function (...args) {\n          const urlParams =\n            this.#hasBody && args.length < 2 ? {} : args[0] || {};\n          const body = this.#hasBody ? args[args.length - 1] : undefined;\n          return this.fetchResponse(\n            this.url(urlParams),\n            await this.getRequestInit(body),\n          )\n            .then(response => this.parseResponse(response))\n            .then(res => this.process(res, ...args));\n        },\n      options,\n    );\n    // we want to use the prototype chain here\n    if (\n      !('sideEffect' in this) ||\n      ('method' in options && !('sideEffect' in options))\n    ) {\n      this.sideEffect =\n        options.method === 'GET' || options.method === undefined\n          ? undefined\n          : true;\n    }\n    if (this.method === undefined) {\n      this.method = this.sideEffect ? 'POST' : 'GET';\n    }\n    if (this.urlPrefix === undefined) {\n      this.urlPrefix = '';\n    }\n    this.#hasBody =\n      (!('body' in this) || this.body !== undefined) &&\n      !['GET', 'DELETE'].includes(this.method);\n\n    Object.defineProperty(this, 'name', {\n      get() {\n        // using 'in' to ensure inheritance lookup\n        if ('__name' in this) return this.__name;\n        return this.urlPrefix + this.path;\n      },\n    });\n  }\n\n  key(...args) {\n    return `${this.method} ${this.url(\n      this.#hasBody && args.length < 2 ? {} : args[0] || {},\n    )}`;\n  }\n\n  /** Get the url */\n  url(urlParams = {}) {\n    const urlBase = getUrlBase(this.path)(urlParams);\n    const tokens = getUrlTokens(this.path);\n    const searchParams = {};\n    Object.keys(urlParams).forEach(k => {\n      if (!tokens.has(k)) {\n        searchParams[k] = urlParams[k];\n      }\n    });\n    if (Object.keys(searchParams).length) {\n      return `${this.urlPrefix}${urlBase}?${paramsToString(searchParams)}`;\n    }\n    return `${this.urlPrefix}${urlBase}`;\n  }\n\n  getHeaders(headers) {\n    return headers;\n  }\n\n  /** Init options for fetch - run at fetch */\n  async getRequestInit(body) {\n    const bodyIsPojo = isPojo(body);\n    if (bodyIsPojo) {\n      body = JSON.stringify(body);\n    }\n    const init = {\n      ...this.requestInit,\n      method: this.method,\n      signal: this.signal,\n      body,\n    };\n    if (!body || bodyIsPojo) {\n      init.headers = {\n        // default to application/json but allow user explicit overrides\n        'Content-Type': 'application/json',\n        ...init.headers,\n      };\n    }\n    init.headers = await this.getHeaders(init.headers);\n    return init;\n  }\n\n  /** Perform network request and resolve with HTTP Response */\n  fetchResponse(input, init) {\n    return fetch(input, init)\n      .then(response => {\n        if (!response.ok) {\n          throw new NetworkError(response);\n        }\n        return response;\n      })\n      .catch(error => {\n        // ensure CORS, network down, and parse errors are still caught by NetworkErrorBoundary\n        if (error instanceof TypeError) {\n          error.status = 500;\n        }\n        throw error;\n      });\n  }\n\n  parseResponse(response) {\n    // this should not have any content to read\n    if (response.status === 204) return Promise.resolve(null);\n    if (!response.headers.get('content-type')?.includes('json')) {\n      return response.text().then(text => {\n        // string or 'not set' schema, are valid\n        // when overriding process they might handle other cases, so we don't want to block on our logic\n        if (\n          ['string', 'undefined'].includes(typeof this.schema) ||\n          this.schema === null ||\n          this.process !== RestEndpoint.prototype.process\n        )\n          return text;\n\n        const error = new NetworkError(response);\n        error.status = 404;\n        error.message = `Unexpected text response for schema ${this.schema}`;\n        // custom dev-only messages for more detailed cause\n        /* istanbul ignore else */\n        if (process.env.NODE_ENV !== 'production') {\n          if (\n            !(\n              response.headers.get('content-type')?.includes('html') ||\n              text.startsWith('<!doctype html>')\n            )\n          ) {\n            if (tryParse(text) !== undefined) {\n              error.message = `\"content-type\" header does not include \"json\", but JSON response found.\nSee https://www.rfc-editor.org/rfc/rfc4627 for information on JSON responses\n\nUsing parsed JSON.\nIf text content was expected see https://resthooks.io/rest/api/RestEndpoint#parseResponse`;\n            }\n          } else {\n            error.message = `Unexpected html response for schema ${this.schema}\nThis likely means no API endpoint was configured for this request, resulting in an HTML fallback.\n\nResponse (first 300 characters): ${text.substring(0, 300)}`;\n          }\n        }\n        throw error;\n      });\n    }\n    return response.json().catch(error => {\n      error.status = 400;\n      throw error;\n    });\n  }\n\n  process(value) {\n    return value;\n  }\n\n  errorPolicy(error) {\n    return error.status >= 500 ? 'soft' : undefined;\n  }\n\n  get pathRegex() {\n    return pathToRegexp(this.path);\n  }\n\n  testKey(key) {\n    const prefix = this.method + ' ' + this.urlPrefix;\n    if (!key.startsWith(prefix)) return false;\n    let lastQuestion = key.lastIndexOf('?');\n    if (lastQuestion === -1) lastQuestion = undefined;\n    return this.pathRegex.test(key.substring(prefix.length, lastQuestion));\n  }\n\n  extend(options) {\n    // make a constructor/prototype based off this\n    // extend from it and init with options sent\n    class E extends this.constructor {}\n\n    Object.assign(E.prototype, this);\n    const instance = new E(\n      //  fetch get overridden by function prototype, so we must set it explicitly every time\n      { fetch: this.fetch, ...options },\n    );\n\n    return instance;\n  }\n\n  paginated(removeCursor) {\n    if (typeof removeCursor === 'string') {\n      const fieldName = removeCursor;\n      removeCursor = ({ ...params }) => {\n        delete params[fieldName];\n        return [params];\n      };\n    }\n    let found = false;\n    const createPaginatedSchema = collection => {\n      found = true;\n      return collection.addWith(paginatedMerge, paginatedFilter(removeCursor));\n    };\n    const newSchema = mapCollection(this.schema, createPaginatedSchema);\n    if (found) {\n      return this.extend({ schema: newSchema });\n    }\n\n    return this.extend({ update: paginationUpdate(this, removeCursor) });\n  }\n\n  get push() {\n    return this.extend({\n      method: 'POST',\n      schema: extractCollection(this.schema, s => s.push),\n    });\n  }\n\n  get unshift() {\n    return this.extend({\n      method: 'POST',\n      schema: extractCollection(this.schema, s => s.unshift),\n    });\n  }\n\n  get assign() {\n    return this.extend({\n      method: 'POST',\n      schema: extractCollection(this.schema, s => s.assign),\n    });\n  }\n}\n\nconst tryParse = input => {\n  try {\n    return JSON.parse(input);\n  } catch (e) {\n    return undefined;\n  }\n};\n"],"mappings":"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"}

package/legacy/next/createResource.js

@@ -0,0 +1,86 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+const _excluded = ["path", "schema", "Endpoint", "optimistic"];
+import { AbortOptimistic, schema } from '@data-client/endpoint';
+import RestEndpoint from './RestEndpoint.js';
+import { shortenPath } from '../RestHelpers.js';
+const {
+  Invalidate,
+  Collection
+} = schema;
+
+/** Creates collection of Endpoints for common operations on a given data/schema.
+ *
+ * @see https://resthooks.io/rest/api/createResource
+ */
+export default function createResource(_ref) {
+  let {
+      path,
+      schema,
+      Endpoint = RestEndpoint,
+      optimistic
+    } = _ref,
+    extraOptions = _objectWithoutPropertiesLoose(_ref, _excluded);
+  const shortenedPath = shortenPath(path);
+  const getName = name => `${schema == null ? void 0 : schema.name}.${name}`;
+  const extraMutateOptions = Object.assign({}, extraOptions);
+  const extraPartialOptions = Object.assign({}, extraOptions);
+  const get = new Endpoint(Object.assign({}, extraOptions, {
+    path,
+    schema,
+    name: getName('get')
+  }));
+  if (optimistic) {
+    extraMutateOptions.getOptimisticResponse = optimisticUpdate;
+    extraPartialOptions.getOptimisticResponse = optimisticPartial(get);
+  }
+  const getList = new Endpoint(Object.assign({}, extraMutateOptions, {
+    path: shortenedPath,
+    schema: new Collection([schema]),
+    name: getName('getList')
+  }));
+  return {
+    get,
+    getList,
+    create: getList.push.extend({
+      name: getName('create')
+    }),
+    update: new Endpoint(Object.assign({}, extraMutateOptions, {
+      path,
+      schema,
+      method: 'PUT',
+      name: getName('update')
+    })),
+    partialUpdate: new Endpoint(Object.assign({}, extraPartialOptions, {
+      path,
+      schema,
+      method: 'PATCH',
+      name: getName('partialUpdate')
+    })),
+    delete: new Endpoint(Object.assign({}, extraMutateOptions, {
+      path,
+      schema: schema.process ? new Invalidate(schema) : schema,
+      method: 'DELETE',
+      name: getName('delete'),
+      process(res, params) {
+        return res && Object.keys(res).length ? res : params;
+      },
+      getOptimisticResponse: optimistic ? optimisticDelete : undefined
+    }))
+  };
+}
+function optimisticUpdate(snap, params, body) {
+  return Object.assign({}, params, body);
+}
+function optimisticPartial(getEndpoint) {
+  return function (snap, params, body) {
+    const {
+      data
+    } = snap.getResponse(getEndpoint, params);
+    if (!data) throw new AbortOptimistic();
+    return Object.assign({}, params, data, body);
+  };
+}
+function optimisticDelete(snap, params) {
+  return params;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["AbortOptimistic","schema","RestEndpoint","shortenPath","Invalidate","Collection","createResource","_ref","path","Endpoint","optimistic","extraOptions","_objectWithoutPropertiesLoose","_excluded","shortenedPath","getName","name","extraMutateOptions","Object","assign","extraPartialOptions","get","getOptimisticResponse","optimisticUpdate","optimisticPartial","getList","create","push","extend","update","method","partialUpdate","delete","process","res","params","keys","length","optimisticDelete","undefined","snap","body","getEndpoint","data","getResponse"],"sources":["../../src/next/createResource.ts"],"sourcesContent":["import {\n  AbortOptimistic,\n  SnapshotInterface,\n  schema,\n} from '@data-client/endpoint';\nimport type { Schema, Denormalize } from '@data-client/endpoint';\n\nimport { ResourceGenerics, ResourceOptions } from './resourceTypes.js';\nimport RestEndpoint, {\n  GetEndpoint,\n  MutateEndpoint,\n  RestInstance,\n  RestTypeNoBody,\n} from './RestEndpoint.js';\nimport { PathArgs, ShortenPath } from '../pathTypes.js';\nimport { shortenPath } from '../RestHelpers.js';\n\nconst { Invalidate, Collection } = schema;\n\n/** Creates collection of Endpoints for common operations on a given data/schema.\n *\n * @see https://resthooks.io/rest/api/createResource\n */\nexport default function createResource<O extends ResourceGenerics>({\n  path,\n  schema,\n  Endpoint = RestEndpoint,\n  optimistic,\n  ...extraOptions\n}: Readonly<O> & ResourceOptions): Resource<O> {\n  const shortenedPath = shortenPath(path);\n  const getName = (name: string) => `${(schema as any)?.name}.${name}`;\n  const extraMutateOptions = { ...extraOptions };\n  const extraPartialOptions = { ...extraOptions };\n  const get: GetEndpoint<{ path: O['path']; schema: O['schema'] }> =\n    new Endpoint({\n      ...extraOptions,\n      path,\n      schema,\n      name: getName('get'),\n    }) as any;\n  if (optimistic) {\n    (extraMutateOptions as any).getOptimisticResponse = optimisticUpdate;\n    (extraPartialOptions as any).getOptimisticResponse = optimisticPartial(get);\n  }\n  const getList = new Endpoint({\n    ...extraMutateOptions,\n    path: shortenedPath,\n    schema: new Collection([schema as any]),\n    name: getName('getList'),\n  });\n  return {\n    get,\n    getList,\n    create: getList.push.extend({ name: getName('create') }),\n    update: new Endpoint({\n      ...extraMutateOptions,\n      path,\n      schema,\n      method: 'PUT',\n      name: getName('update'),\n    }),\n    partialUpdate: new Endpoint({\n      ...extraPartialOptions,\n      path,\n      schema,\n      method: 'PATCH',\n      name: getName('partialUpdate'),\n    }),\n    delete: new Endpoint({\n      ...extraMutateOptions,\n      path,\n      schema: (schema as any).process ? new Invalidate(schema as any) : schema,\n      method: 'DELETE',\n      name: getName('delete'),\n      process(res: any, params: any) {\n        return res && Object.keys(res).length ? res : params;\n      },\n      getOptimisticResponse: optimistic ? (optimisticDelete as any) : undefined,\n    }),\n  } as any;\n}\n\nfunction optimisticUpdate(snap: SnapshotInterface, params: any, body: any) {\n  return {\n    ...params,\n    ...body,\n  };\n}\nfunction optimisticPartial(getEndpoint: GetEndpoint) {\n  return function (snap: SnapshotInterface, params: any, body: any) {\n    const { data } = snap.getResponse(getEndpoint, params) as { data: any };\n    if (!data) throw new AbortOptimistic();\n    return {\n      ...params,\n      ...data,\n      // even tho we don't always have two arguments, the extra one will simply be undefined which spreads fine\n      ...body,\n    };\n  };\n}\nfunction optimisticDelete(snap: SnapshotInterface, params: any) {\n  return params;\n}\n\nexport interface Resource<\n  O extends ResourceGenerics = { path: string; schema: any },\n> {\n  /** Get a singular item\n   *\n   * @see https://resthooks.io/rest/api/createResource#get\n   */\n  get: GetEndpoint<{ path: O['path']; schema: O['schema'] }>;\n  /** Get a list of item\n   *\n   * @see https://resthooks.io/rest/api/createResource#getlist\n   */\n  getList: 'searchParams' extends keyof O\n    ? GetEndpoint<{\n        path: ShortenPath<O['path']>;\n        schema: schema.Collection<[O['schema']]>;\n        searchParams: O['searchParams'];\n      }>\n    : GetEndpoint<{\n        path: ShortenPath<O['path']>;\n        schema: schema.Collection<[O['schema']]>;\n        searchParams: Record<string, number | string | boolean> | undefined;\n      }>;\n  /** Create a new item (POST)\n   *\n   * @see https://resthooks.io/rest/api/createResource#create\n   */\n  create: 'searchParams' extends keyof O\n    ? MutateEndpoint<{\n        path: ShortenPath<O['path']>;\n        schema: schema.Collection<[O['schema']]>['push'];\n        body: 'body' extends keyof O\n          ? O['body']\n          : Partial<Denormalize<O['schema']>>;\n        searchParams: O['searchParams'];\n      }>\n    : MutateEndpoint<{\n        path: ShortenPath<O['path']>;\n        schema: schema.Collection<[O['schema']]>['push'];\n        body: 'body' extends keyof O\n          ? O['body']\n          : Partial<Denormalize<O['schema']>>;\n      }>;\n  /** Update an item (PUT)\n   *\n   * @see https://resthooks.io/rest/api/createResource#update\n   */\n  update: 'body' extends keyof O\n    ? MutateEndpoint<{\n        path: O['path'];\n        body: O['body'];\n        schema: O['schema'];\n      }>\n    : MutateEndpoint<{\n        path: O['path'];\n        body: Partial<Denormalize<O['schema']>>;\n        schema: O['schema'];\n      }>;\n  /** Update an item (PATCH)\n   *\n   * @see https://resthooks.io/rest/api/createResource#partialupdate\n   */\n  partialUpdate: 'body' extends keyof O\n    ? MutateEndpoint<{\n        path: O['path'];\n        body: Partial<O['body']>;\n        schema: O['schema'];\n      }>\n    : MutateEndpoint<{\n        path: O['path'];\n        body: Partial<Denormalize<O['schema']>>;\n        schema: O['schema'];\n      }>;\n  /** Delete an item (DELETE)\n   *\n   * @see https://resthooks.io/rest/api/createResource#delete\n   */\n  delete: RestTypeNoBody<\n    PathArgs<O['path']>,\n    O['schema'] extends schema.EntityInterface & { process: any }\n      ? schema.Invalidate<O['schema']>\n      : O['schema'],\n    undefined,\n    Partial<PathArgs<O['path']>>,\n    {\n      path: O['path'];\n    }\n  >;\n}\n"],"mappings":"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"}

package/legacy/next/index.js

@@ -0,0 +1,4 @@
+export * from './RestEndpoint.js';
+export { default as RestEndpoint } from './RestEndpoint.js';
+export { default as createResource } from './createResource.js';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJkZWZhdWx0IiwiUmVzdEVuZHBvaW50IiwiY3JlYXRlUmVzb3VyY2UiXSwic291cmNlcyI6WyIuLi8uLi9zcmMvbmV4dC9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL1Jlc3RFbmRwb2ludC5qcyc7XG5leHBvcnQgeyBkZWZhdWx0IGFzIFJlc3RFbmRwb2ludCB9IGZyb20gJy4vUmVzdEVuZHBvaW50LmpzJztcbmV4cG9ydCB7IGRlZmF1bHQgYXMgY3JlYXRlUmVzb3VyY2UgfSBmcm9tICcuL2NyZWF0ZVJlc291cmNlLmpzJztcbmV4cG9ydCB0eXBlIHsgUmVzb3VyY2UgfSBmcm9tICcuL2NyZWF0ZVJlc291cmNlLmpzJztcbmV4cG9ydCB0eXBlIHsgUmVzb3VyY2VPcHRpb25zLCBSZXNvdXJjZUdlbmVyaWNzIH0gZnJvbSAnLi9yZXNvdXJjZVR5cGVzLmpzJztcbiJdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUI7QUFDakMsU0FBU0EsT0FBTyxJQUFJQyxZQUFZLFFBQVEsbUJBQW1CO0FBQzNELFNBQVNELE9BQU8sSUFBSUUsY0FBYyxRQUFRLHFCQUFxQiJ9

package/legacy/next/resourceTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL25leHQvcmVzb3VyY2VUeXBlcy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFNjaGVtYSB9IGZyb20gJ0BkYXRhLWNsaWVudC9lbmRwb2ludCc7XG5cbmltcG9ydCBSZXN0RW5kcG9pbnQgZnJvbSAnLi9SZXN0RW5kcG9pbnQuanMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIFJlc291cmNlR2VuZXJpY3Mge1xuICByZWFkb25seSBwYXRoOiBzdHJpbmc7XG4gIHJlYWRvbmx5IHNjaGVtYTogU2NoZW1hO1xuICAvKiogT25seSB1c2VkIGZvciB0eXBlcyAqL1xuICByZWFkb25seSBib2R5PzogYW55O1xuICAvKiogT25seSB1c2VkIGZvciB0eXBlcyAqL1xuICByZWFkb25seSBzZWFyY2hQYXJhbXM/OiBhbnk7XG59XG5leHBvcnQgaW50ZXJmYWNlIFJlc291cmNlT3B0aW9ucyB7XG4gIEVuZHBvaW50PzogdHlwZW9mIFJlc3RFbmRwb2ludDtcbiAgdXJsUHJlZml4Pzogc3RyaW5nO1xuICByZXF1ZXN0SW5pdD86IFJlcXVlc3RJbml0O1xuICBnZXRIZWFkZXJzPyhoZWFkZXJzOiBIZWFkZXJzSW5pdCk6IFByb21pc2U8SGVhZGVyc0luaXQ+IHwgSGVhZGVyc0luaXQ7XG4gIGdldFJlcXVlc3RJbml0Pyhib2R5OiBhbnkpOiBQcm9taXNlPFJlcXVlc3RJbml0PiB8IFJlcXVlc3RJbml0O1xuICBmZXRjaFJlc3BvbnNlPyhpbnB1dDogUmVxdWVzdEluZm8sIGluaXQ6IFJlcXVlc3RJbml0KTogUHJvbWlzZTxhbnk+O1xuICBwYXJzZVJlc3BvbnNlPyhyZXNwb25zZTogUmVzcG9uc2UpOiBQcm9taXNlPGFueT47XG4gIC8qKiBEZWZhdWx0IGRhdGEgZXhwaXJ5IGxlbmd0aCwgd2lsbCBmYWxsIGJhY2sgdG8gTmV0d29ya01hbmFnZXIgZGVmYXVsdCBpZiBub3QgZGVmaW5lZCAqL1xuICByZWFkb25seSBkYXRhRXhwaXJ5TGVuZ3RoPzogbnVtYmVyO1xuICAvKiogRGVmYXVsdCBlcnJvciBleHBpcnkgbGVuZ3RoLCB3aWxsIGZhbGwgYmFjayB0byBOZXR3b3JrTWFuYWdlciBkZWZhdWx0IGlmIG5vdCBkZWZpbmVkICovXG4gIHJlYWRvbmx5IGVycm9yRXhwaXJ5TGVuZ3RoPzogbnVtYmVyO1xuICAvKiogUG9sbCB3aXRoIGF0IGxlYXN0IHRoaXMgZnJlcXVlbmN5IGluIG1pbGlzZWNvbmRzICovXG4gIHJlYWRvbmx5IHBvbGxGcmVxdWVuY3k/OiBudW1iZXI7XG4gIC8qKiBNYXJrcyBjYWNoZWQgcmVzb3VyY2VzIGFzIGludmFsaWQgaWYgdGhleSBhcmUgc3RhbGUgKi9cbiAgcmVhZG9ubHkgaW52YWxpZElmU3RhbGU/OiBib29sZWFuO1xuICAvKiogRGV0ZXJtaW5lcyB3aGV0aGVyIHRvIHRocm93IG9yIGZhbGxiYWNrIHRvICovXG4gIGVycm9yUG9saWN5PyhlcnJvcjogYW55KTogJ2hhcmQnIHwgJ3NvZnQnIHwgdW5kZWZpbmVkO1xuICBvcHRpbWlzdGljPzogYm9vbGVhbjtcbn1cbiJdLCJtYXBwaW5ncyI6IiJ9

package/legacy/paginatedCollections.js

@@ -0,0 +1,29 @@
+export function paginatedMerge(existing, incoming) {
+  const existingSet = new Set(existing);
+  const mergedList = [...existing];
+  for (const pk of incoming) {
+    if (!existingSet.has(pk)) mergedList.push(pk);
+  }
+  return mergedList;
+}
+export const paginatedFilter = removeCursor => (...args) => {
+  const noCursorArgs = removeCursor(...args);
+  return collectionKey => {
+    var _noCursorArgs$;
+    return shallowEqual(collectionKey, (_noCursorArgs$ = noCursorArgs[0]) != null ? _noCursorArgs$ : {});
+  };
+};
+function shallowEqual(object1, object2) {
+  const keys1 = Object.keys(object1);
+  const keys2 = Object.keys(object2);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (const key of keys1) {
+    if (object1[key] != object2[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/legacy/paginationUpdate.js

@@ -0,0 +1,36 @@
+import getArrayPath from './getArrayPath.js';
+export default function paginationUpdate(endpoint, removeCursor) {
+  // infer path from schema. if schema is undefined assume array is top level
+  const path = getArrayPath(endpoint.schema);
+  if (path === false) throw new Error('schema has no array');
+  return (newPage, ...args) => ({
+    [endpoint.key(...removeCursor(...args))]: existing => {
+      const existingList = getIn(existing, path);
+      // using set so our lookups are O(1) in case this is large
+      const existingSet = new Set(existingList);
+      const addedList = getIn(newPage, path).filter(pk => !existingSet.has(pk));
+      const mergedResults = [...existingList, ...addedList];
+      return setIn(newPage, path, mergedResults);
+    }
+  });
+}
+const getIn = (results, path) => {
+  let cur = results;
+  for (const p of path) {
+    if (!cur) return [];
+    cur = cur[p];
+  }
+  return cur || [];
+};
+const setIn = (results, path, values) => {
+  if (path.length === 0) return values;
+  const newResults = Object.assign({}, results);
+  let cur = newResults;
+  for (let i = 0; i < path.length - 1; i++) {
+    const p = path[i];
+    cur = cur[p] = Object.assign({}, cur[p]);
+  }
+  cur[path[path.length - 1]] = values;
+  return newResults;
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/legacy/paramsToString.js

@@ -0,0 +1,6 @@
+export default function paramsToString(searchParams) {
+  const params = new URLSearchParams(searchParams);
+  params.sort();
+  return params.toString();
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJwYXJhbXNUb1N0cmluZyIsInNlYXJjaFBhcmFtcyIsInBhcmFtcyIsIlVSTFNlYXJjaFBhcmFtcyIsInNvcnQiLCJ0b1N0cmluZyJdLCJzb3VyY2VzIjpbIi4uL3NyYy9wYXJhbXNUb1N0cmluZy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBwYXJhbXNUb1N0cmluZyhcbiAgc2VhcmNoUGFyYW1zOiBSZWFkb25seTxSZWNvcmQ8c3RyaW5nLCBzdHJpbmcgfCBudW1iZXIgfCBib29sZWFuPj4sXG4pIHtcbiAgY29uc3QgcGFyYW1zID0gbmV3IFVSTFNlYXJjaFBhcmFtcyhzZWFyY2hQYXJhbXMgYXMgYW55KTtcbiAgcGFyYW1zLnNvcnQoKTtcbiAgcmV0dXJuIHBhcmFtcy50b1N0cmluZygpO1xufVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxlQUFlLFNBQVNBLGNBQWNBLENBQ3BDQyxZQUFpRSxFQUNqRTtFQUNBLE1BQU1DLE1BQU0sR0FBRyxJQUFJQyxlQUFlLENBQUNGLFlBQW1CLENBQUM7RUFDdkRDLE1BQU0sQ0FBQ0UsSUFBSSxDQUFDLENBQUM7RUFDYixPQUFPRixNQUFNLENBQUNHLFFBQVEsQ0FBQyxDQUFDO0FBQzFCIn0=

package/legacy/paramsToString.native.js

@@ -0,0 +1,9 @@
+export default function paramsToString(searchParams) {
+  const params = new URLSearchParams(searchParams);
+  try {
+    params.sort();
+    // eslint-disable-next-line no-empty
+  } catch (_unused) {}
+  return params.toString();
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJwYXJhbXNUb1N0cmluZyIsInNlYXJjaFBhcmFtcyIsInBhcmFtcyIsIlVSTFNlYXJjaFBhcmFtcyIsInNvcnQiLCJfdW51c2VkIiwidG9TdHJpbmciXSwic291cmNlcyI6WyIuLi9zcmMvcGFyYW1zVG9TdHJpbmcubmF0aXZlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIHBhcmFtc1RvU3RyaW5nKFxuICBzZWFyY2hQYXJhbXM6IFJlYWRvbmx5PFJlY29yZDxzdHJpbmcsIHN0cmluZyB8IG51bWJlcj4+LFxuKSB7XG4gIGNvbnN0IHBhcmFtcyA9IG5ldyBVUkxTZWFyY2hQYXJhbXMoc2VhcmNoUGFyYW1zIGFzIGFueSk7XG4gIHRyeSB7XG4gICAgcGFyYW1zLnNvcnQoKTtcbiAgICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tZW1wdHlcbiAgfSBjYXRjaCB7fVxuICByZXR1cm4gcGFyYW1zLnRvU3RyaW5nKCk7XG59XG4iXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsU0FBU0EsY0FBY0EsQ0FDcENDLFlBQXVELEVBQ3ZEO0VBQ0EsTUFBTUMsTUFBTSxHQUFHLElBQUlDLGVBQWUsQ0FBQ0YsWUFBbUIsQ0FBQztFQUN2RCxJQUFJO0lBQ0ZDLE1BQU0sQ0FBQ0UsSUFBSSxDQUFDLENBQUM7SUFDYjtFQUNGLENBQUMsQ0FBQyxPQUFBQyxPQUFBLEVBQU0sQ0FBQztFQUNULE9BQU9ILE1BQU0sQ0FBQ0ksUUFBUSxDQUFDLENBQUM7QUFDMUIifQ==

package/legacy/pathTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/legacy/test-fixtures.js

@@ -0,0 +1,111 @@
+export const payload = {
+  id: 5,
+  title: 'hi ho',
+  content: 'whatever',
+  tags: ['a', 'best', 'react']
+};
+export const createPayload = {
+  id: 1,
+  title: 'hi ho',
+  content: 'whatever',
+  tags: ['a', 'best', 'react']
+};
+export const articlesPages = {
+  prevPage: '23asdl',
+  nextPage: 's3f3',
+  results: [{
+    id: 23,
+    title: 'the first draft',
+    content: 'the best things in life com efree',
+    tags: ['one', 'two']
+  }, {
+    id: 44,
+    title: 'the second book',
+    content: 'the best things in life com efree',
+    tags: ['hbh', 'wew']
+  }, {
+    id: 2,
+    title: 'the third novel',
+    content: 'the best things in life com efree',
+    tags: ['free', 'honey']
+  }, {
+    id: 643,
+    title: 'a long time ago',
+    content: 'the best things in life com efree'
+  }]
+};
+export const users = [{
+  id: 23,
+  username: 'bob',
+  email: 'bob@bob.com',
+  isAdmin: false
+}, {
+  id: 7342,
+  username: 'lindsey',
+  email: 'lindsey@bob.com',
+  isAdmin: true
+}];
+export const nested = [{
+  id: 5,
+  title: 'hi ho',
+  content: 'whatever',
+  tags: ['a', 'best', 'react'],
+  author: {
+    id: 23,
+    username: 'bob'
+  }
+}, {
+  id: 3,
+  title: 'the next time',
+  content: 'whatever',
+  author: {
+    id: 23,
+    username: 'charles',
+    email: 'bob@bob.com'
+  }
+}];
+export const moreNested = [{
+  id: 7,
+  title: 'article 7',
+  content: 'whatever',
+  tags: ['blah'],
+  author: {
+    id: 23,
+    username: 'bob'
+  }
+}, {
+  id: 8,
+  title: 'article 8',
+  content: 'whatever',
+  author: {
+    id: 27,
+    username: 'zac',
+    email: 'zac@bob.com'
+  }
+}];
+export const valuesFixture = {
+  first: {
+    id: 1,
+    title: 'first thing',
+    content: 'blah',
+    tags: []
+  },
+  second: {
+    id: 2,
+    name: 'second thing',
+    content: 'blah',
+    tags: []
+  }
+};
+export const paginatedFirstPage = {
+  nextPage: '2',
+  data: {
+    results: nested
+  }
+};
+export const paginatedSecondPage = {
+  data: {
+    results: moreNested
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/legacy/utiltypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vc3JjL3V0aWx0eXBlcy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogRXh0cmFjdHMgb25seSB0aGUga2V5cyB0aGF0IHdpbGwgYmUgcmVxdWlyZWRcbiAqXG4gKiBSZW1vdmVzIG9wdGlvbmFsLCBhcyB3ZWxsIGFzIHVuYm91bmRlZCAoYWthICdzdHJpbmcnKVxuICpcbiAqIEBleGFtcGxlXG4gYGBgXG5SZXF1aXJlZEtleXM8e1xuICBvcHQ/OiBzdHJpbmc7XG4gIGJvYjogc3RyaW5nO1xuICBhbGljZTogbnVtYmVyO1xuICBbazogc3RyaW5nXTogc3RyaW5nIHwgbnVtYmVyIHwgdW5kZWZpbmVkO1xufT4gLy8gPSAnYm9iJyB8ICdhbGljZSdcbiBgYGBcbiAqL1xuZXhwb3J0IHR5cGUgUmVxdWlyZWRLZXlzPFQ+ID0gVmFsdWVzPE9ubHlSZXF1aXJlZDxUPj47XG5cbnR5cGUgT25seVJlcXVpcmVkPFQ+ID0ge1xuICBbSyBpbiBrZXlvZiBUIGFzIHN0cmluZyBleHRlbmRzIEsgPyBuZXZlciA6IEtdLT86IHt9IGV4dGVuZHMgUGljazxULCBLPlxuICAgID8gbmV2ZXJcbiAgICA6IEs7XG59O1xuXG4vLyBleGNsdWRlIG51bWJlciBvbmx5IHJlcXVpcmVkIGZvciB0eXBlc2NyaXB0IDQuNCBhbmQgYmVsb3dcbi8vIGh0dHBzOi8vd3d3LnR5cGVzY3JpcHRsYW5nLm9yZy9wbGF5P3RzPTQuNC40I2NvZGUvQzRUd0RncGdCQWdsQzhVRGVVQkdCN1ZBdUtCbllBVGdKWUIyQTVnTnhRRGFBMWp2c2VRTG80Q3NBUG82V1ZBTDRVQXNBQ2dSSWlBQTh3NkFzQ2loSVVBRW9RQWpnRmNpQkNBQk1BMGhCQzRBUEFCVUFmQWlnQTFBSVlBYmRSQk1CNUV2WkFxTlczV2ZQbWhVV0ZKYVZsNWNHZzNEeTlOYlIwLUt5UVJLQm85S0ZJb1drTjBBRE1vVXloYlhEeENIaWhKWUFnU0hXSzBnSDRvRWdnQU53Z0NLQnc5WmdCYU9wd2tQbktKU3VyaWdBVWlBR05hTXdBYUtEMXpaSlNvQnFiV2dtV1V6c0NCTVdFRmFEdEhad1RFVXpwc3ZOTm1RSkZEcUFCaEt5alBOVmpmR0NXRGlLZ0FJVCtWaXlJRnlUM3V2MGV6MFF4eWNKa2U1aUFBXG50eXBlIFZhbHVlczxUPiA9IFRbRXhjbHVkZTxrZXlvZiBULCBudW1iZXI+XTtcbiJdLCJtYXBwaW5ncyI6IiJ9

package/lib/NetworkError.d.ts

@@ -0,0 +1,11 @@
+/** An error with a Rest Endpoint fetch
+ *
+ * @see https://resthooks.io/rest/api/NetworkError
+ */
+export default class NetworkError extends Error {
+    status: number;
+    response: Response;
+    name: string;
+    constructor(response: Response);
+}
+//# sourceMappingURL=NetworkError.d.ts.map

package/lib/NetworkError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkError.d.ts","sourceRoot":"","sources":["../src/NetworkError.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,KAAK;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,QAAQ,CAAC;IAC3B,IAAI,SAAkB;gBAEV,QAAQ,EAAE,QAAQ;CAO/B"}