@data-client/rest 0.1.0

package/dist/next.js

@@ -0,0 +1,520 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var endpoint = require('@data-client/endpoint');
+var pathToRegexp = require('path-to-regexp');
+
+function unwrapExports (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function createCommonjsModule(fn, module) {
+	return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+
+var classPrivateFieldLooseBase = createCommonjsModule(function (module) {
+function _classPrivateFieldBase(receiver, privateKey) {
+  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
+    throw new TypeError("attempted to use private field on non-instance");
+  }
+  return receiver;
+}
+module.exports = _classPrivateFieldBase, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+var _classPrivateFieldLooseBase = unwrapExports(classPrivateFieldLooseBase);
+
+var classPrivateFieldLooseKey = createCommonjsModule(function (module) {
+var id = 0;
+function _classPrivateFieldKey(name) {
+  return "__private_" + id++ + "_" + name;
+}
+module.exports = _classPrivateFieldKey, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+var _classPrivateFieldLooseKey = unwrapExports(classPrivateFieldLooseKey);
+
+function extractCollection(s, mapper) {
+  if (typeof s !== 'object' || s === undefined || Array.isArray(s)) return;
+  if (s instanceof endpoint.schema.Collection) {
+    return mapper(s);
+  }
+  const objCopy = {
+    ...(s instanceof endpoint.schema.Object ? s.schema : s)
+  };
+  for (const k in objCopy) {
+    if (!objCopy[k]) continue;
+    const collection = extractCollection(objCopy[k], mapper);
+    if (collection) return collection;
+  }
+}
+
+function mapCollection(s, mapper) {
+  if (typeof s !== 'object' || s === undefined) return s;
+  if (s instanceof endpoint.schema.Collection) {
+    return mapper(s);
+  }
+  const objCopy = {
+    ...(s instanceof endpoint.schema.Object ? s.schema : s)
+  };
+  for (const k in objCopy) {
+    if (!objCopy[k]) continue;
+    objCopy[k] = mapCollection(objCopy[k], mapper);
+  }
+  return objCopy;
+}
+
+/** An error with a Rest Endpoint fetch
+ *
+ * @see https://resthooks.io/rest/api/NetworkError
+ */
+class NetworkError extends Error {
+  constructor(response) {
+    super(response.statusText || `Network response not 'ok': ${response.status}`);
+    this.name = 'NetworkError';
+    this.status = response.status;
+    this.response = response;
+  }
+}
+
+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;
+}
+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;
+}
+
+function getArrayPath(s) {
+  if (typeof s !== 'object') return false;
+  if (s === undefined || s instanceof endpoint.schema.Array || Array.isArray(s)) {
+    return [];
+  }
+  const o = s instanceof endpoint.schema.Object ? s.schema : s;
+  for (const k in o) {
+    if (!o[k]) continue;
+    const path = getArrayPath(o[k]);
+    if (path !== false) {
+      // mutation is ok because there is only one path
+      path.unshift(k);
+      return path;
+    }
+  }
+  return false;
+}
+
+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 = {
+    ...results
+  };
+  let cur = newResults;
+  for (let i = 0; i < path.length - 1; i++) {
+    const p = path[i];
+    cur = cur[p] = {
+      ...cur[p]
+    };
+  }
+  cur[path[path.length - 1]] = values;
+  return newResults;
+};
+
+function paramsToString(searchParams) {
+  const params = new URLSearchParams(searchParams);
+  params.sort();
+  return params.toString();
+}
+
+const urlBaseCache = Object.create(null);
+function getUrlBase(path) {
+  if (!(path in urlBaseCache)) {
+    urlBaseCache[path] = pathToRegexp.compile(path, {
+      encode: encodeURIComponent,
+      validate: false
+    });
+  }
+  return urlBaseCache[path];
+}
+const urlTokensCache = Object.create(null);
+function getUrlTokens(path) {
+  if (!(path in urlTokensCache)) {
+    urlTokensCache[path] = new Set(pathToRegexp.parse(path).map(t => typeof t === 'string' ? t : `${t['name']}`));
+  }
+  return urlTokensCache[path];
+}
+const proto = Object.prototype;
+const gpo = Object.getPrototypeOf;
+function isPojo(obj) {
+  if (obj === null || typeof obj !== 'object') {
+    return false;
+  }
+  return gpo(obj) === proto;
+}
+function shortenPath(path) {
+  // this is for when not specifying a specific item like create/list
+  let shortUrlRoot = path.substring(0, path.lastIndexOf(':'));
+  if (shortUrlRoot[shortUrlRoot.length - 1] === '/') shortUrlRoot = shortUrlRoot.substring(0, shortUrlRoot.length - 1);
+  return shortUrlRoot;
+}
+
+/** Simplifies endpoint definitions that follow REST patterns
+ *
+ * @see https://resthooks.io/rest/api/RestEndpoint
+ */
+var _hasBody = /*#__PURE__*/_classPrivateFieldLooseKey("hasBody");
+class RestEndpoint extends endpoint.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 = {
+      ...this.requestInit,
+      method: this.method,
+      signal: this.signal,
+      body
+    };
+    if (!body || bodyIsPojo) {
+      init.headers = {
+        // 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.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
+    {
+      fetch: this.fetch,
+      ...options
+    });
+    return instance;
+  }
+  paginated(removeCursor) {
+    if (typeof removeCursor === 'string') {
+      const fieldName = removeCursor;
+      removeCursor = ({
+        ...params
+      }) => {
+        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;
+  }
+};
+
+const {
+  Invalidate,
+  Collection
+} = endpoint.schema;
+
+/** Creates collection of Endpoints for common operations on a given data/schema.
+ *
+ * @see https://resthooks.io/rest/api/createResource
+ */
+function createResource({
+  path,
+  schema,
+  Endpoint = RestEndpoint,
+  optimistic,
+  ...extraOptions
+}) {
+  const shortenedPath = shortenPath(path);
+  const getName = name => `${schema == null ? void 0 : schema.name}.${name}`;
+  const extraMutateOptions = {
+    ...extraOptions
+  };
+  const extraPartialOptions = {
+    ...extraOptions
+  };
+  const get = new Endpoint({
+    ...extraOptions,
+    path,
+    schema,
+    name: getName('get')
+  });
+  if (optimistic) {
+    extraMutateOptions.getOptimisticResponse = optimisticUpdate;
+    extraPartialOptions.getOptimisticResponse = optimisticPartial(get);
+  }
+  const getList = new Endpoint({
+    ...extraMutateOptions,
+    path: shortenedPath,
+    schema: new Collection([schema]),
+    name: getName('getList')
+  });
+  return {
+    get,
+    getList,
+    create: getList.push.extend({
+      name: getName('create')
+    }),
+    update: new Endpoint({
+      ...extraMutateOptions,
+      path,
+      schema,
+      method: 'PUT',
+      name: getName('update')
+    }),
+    partialUpdate: new Endpoint({
+      ...extraPartialOptions,
+      path,
+      schema,
+      method: 'PATCH',
+      name: getName('partialUpdate')
+    }),
+    delete: new Endpoint({
+      ...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 {
+    ...params,
+    ...body
+  };
+}
+function optimisticPartial(getEndpoint) {
+  return function (snap, params, body) {
+    const {
+      data
+    } = snap.getResponse(getEndpoint, params);
+    if (!data) throw new endpoint.AbortOptimistic();
+    return {
+      ...params,
+      ...data,
+      // even tho we don't always have two arguments, the extra one will simply be undefined which spreads fine
+      ...body
+    };
+  };
+}
+function optimisticDelete(snap, params) {
+  return params;
+}
+
+exports.RestEndpoint = RestEndpoint;
+exports.createResource = createResource;

package/dist/package.json

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

package/legacy/NetworkError.js

@@ -0,0 +1,13 @@
+/** An error with a Rest Endpoint fetch
+ *
+ * @see https://resthooks.io/rest/api/NetworkError
+ */
+export default class NetworkError extends Error {
+  constructor(response) {
+    super(response.statusText || `Network response not 'ok': ${response.status}`);
+    this.name = 'NetworkError';
+    this.status = response.status;
+    this.response = response;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJOZXR3b3JrRXJyb3IiLCJFcnJvciIsImNvbnN0cnVjdG9yIiwicmVzcG9uc2UiLCJzdGF0dXNUZXh0Iiwic3RhdHVzIiwibmFtZSJdLCJzb3VyY2VzIjpbIi4uL3NyYy9OZXR3b3JrRXJyb3IudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqIEFuIGVycm9yIHdpdGggYSBSZXN0IEVuZHBvaW50IGZldGNoXG4gKlxuICogQHNlZSBodHRwczovL3Jlc3Rob29rcy5pby9yZXN0L2FwaS9OZXR3b3JrRXJyb3JcbiAqL1xuZXhwb3J0IGRlZmF1bHQgY2xhc3MgTmV0d29ya0Vycm9yIGV4dGVuZHMgRXJyb3Ige1xuICBkZWNsYXJlIHN0YXR1czogbnVtYmVyO1xuICBkZWNsYXJlIHJlc3BvbnNlOiBSZXNwb25zZTtcbiAgbmFtZSA9ICdOZXR3b3JrRXJyb3InO1xuXG4gIGNvbnN0cnVjdG9yKHJlc3BvbnNlOiBSZXNwb25zZSkge1xuICAgIHN1cGVyKFxuICAgICAgcmVzcG9uc2Uuc3RhdHVzVGV4dCB8fCBgTmV0d29yayByZXNwb25zZSBub3QgJ29rJzogJHtyZXNwb25zZS5zdGF0dXN9YCxcbiAgICApO1xuICAgIHRoaXMuc3RhdHVzID0gcmVzcG9uc2Uuc3RhdHVzO1xuICAgIHRoaXMucmVzcG9uc2UgPSByZXNwb25zZTtcbiAgfVxufVxuIl0sIm1hcHBpbmdzIjoiQUFBQTtBQUNBO0FBQ0E7QUFDQTtBQUNBLGVBQWUsTUFBTUEsWUFBWSxTQUFTQyxLQUFLLENBQUM7RUFLOUNDLFdBQVdBLENBQUNDLFFBQWtCLEVBQUU7SUFDOUIsS0FBSyxDQUNIQSxRQUFRLENBQUNDLFVBQVUsSUFBSyw4QkFBNkJELFFBQVEsQ0FBQ0UsTUFBTyxFQUN2RSxDQUFDO0lBQUMsS0FMSkMsSUFBSSxHQUFHLGNBQWM7SUFNbkIsSUFBSSxDQUFDRCxNQUFNLEdBQUdGLFFBQVEsQ0FBQ0UsTUFBTTtJQUM3QixJQUFJLENBQUNGLFFBQVEsR0FBR0EsUUFBUTtFQUMxQjtBQUNGIn0=

package/legacy/OptionsToFunction.js

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