@data-client/rest 0.1.0 → 0.3.0

package/src/next/__tests__/RestEndpoint.ts

@@ -1,1333 +0,0 @@
-import { Entity } from '@data-client/endpoint';
-import { useController } from '@data-client/react';
-import { useSuspense } from '@data-client/react';
-import { CacheProvider } from '@data-client/react';
-import { Article, CoolerArticle, CoolerArticleResource } from '__tests__/new';
-import nock from 'nock';
-
-import { makeRenderRestHook } from '../../../../test';
-import {
-  payload,
-  createPayload,
-  users,
-  nested,
-  moreNested,
-  paginatedFirstPage,
-  paginatedSecondPage,
-} from '../../test-fixtures';
-import RestEndpoint, {
-  Defaults,
-  RestEndpointConstructorOptions,
-  RestGenerics,
-} from '../RestEndpoint';
-
-export class User extends Entity {
-  readonly id: number | undefined = undefined;
-  readonly username: string = '';
-  readonly email: string = '';
-  readonly isAdmin: boolean = false;
-
-  pk() {
-    return this.id?.toString();
-  }
-}
-const getUser = new RestEndpoint({
-  path: 'http\\://test.com/user/:id',
-  name: 'User.get',
-  schema: User,
-  method: 'GET',
-  searchParams: {} as { extra?: string },
-});
-export class PaginatedArticle extends Entity {
-  readonly id: number | undefined = undefined;
-  readonly title: string = '';
-  readonly content: string = '';
-  readonly author: number | null = null;
-  readonly tags: string[] = [];
-
-  pk() {
-    return this.id?.toString();
-  }
-
-  static schema = {
-    author: User,
-  };
-}
-const getArticleList = new RestEndpoint({
-  urlPrefix: 'http://test.com',
-  path: '/article-paginated',
-  schema: {
-    nextPage: '',
-    data: { results: [PaginatedArticle] },
-  },
-  method: 'GET',
-});
-const getNextPage = getArticleList.paginated(
-  (v: { cursor: string | number }) => [],
-);
-
-const getArticleList2 = new RestEndpoint({
-  urlPrefix: 'http://test.com/article-paginated/',
-  path: ':group',
-  name: 'get',
-  schema: {
-    nextPage: '',
-    data: { results: [PaginatedArticle] },
-  },
-  method: 'GET',
-});
-const getNextPage2 = getArticleList2.paginated(
-  ({
-    cursor,
-    ...rest
-  }: {
-    cursor: string | number;
-    group: string | number;
-  }) => [rest],
-);
-
-describe('RestEndpoint', () => {
-  const renderRestHook: ReturnType<typeof makeRenderRestHook> =
-    makeRenderRestHook(CacheProvider);
-  let mynock: nock.Scope;
-
-  beforeEach(() => {
-    nock(/.*/)
-      .persist()
-      .defaultReplyHeaders({
-        'Access-Control-Allow-Origin': '*',
-        'Content-Type': 'application/json',
-      })
-      .options(/.*/)
-      .reply(200)
-      .get(`/article-cooler/${payload.id}`)
-      .reply(200, payload)
-      .delete(`/article-cooler/${payload.id}`)
-      .reply(204, '')
-      .delete(`/article/${payload.id}`)
-      .reply(200, {})
-      .get(`/article-cooler/0`)
-      .reply(403, {})
-      .get(`/article-cooler/666`)
-      .reply(200, '')
-      .get(`/article-cooler`)
-      .reply(200, nested)
-      .post(`/article-cooler`)
-      .reply(200, createPayload)
-      .get(`/user`)
-      .reply(200, users);
-    mynock = nock(/.*/).defaultReplyHeaders({
-      'Access-Control-Allow-Origin': '*',
-      'Content-Type': 'application/json',
-    });
-  });
-
-  afterEach(() => {
-    nock.cleanAll();
-  });
-
-  it('testKey should match keys', () => {
-    expect(getArticleList.testKey(getArticleList.key())).toBeTruthy();
-    expect(
-      getUser.testKey(getUser.key({ id: '100', extra: '345' })),
-    ).toBeTruthy();
-    expect(getUser.testKey(getUser.key({ id: 'xxx?*' }))).toBeTruthy();
-  });
-
-  it('should assign members', () => {
-    expect(getUser.path).toBe('http\\://test.com/user/:id');
-    expect(getUser.sideEffect).toBe(undefined);
-    expect(getUser.method).toBe('GET');
-
-    // @ts-expect-error
-    () => getUser.notassigned;
-    // @ts-expect-error
-    const a: true = getUser.sideEffect;
-    // @ts-expect-error
-    const b: 'POST' = getUser.method;
-    // @ts-expect-error
-    ((m: 'POST') => {})(getUser.method);
-
-    const updateUser = new RestEndpoint({
-      path: 'http\\://test.com/user/:id',
-      name: 'update',
-      schema: User,
-      method: 'POST',
-    });
-    expect(updateUser.sideEffect).toBe(true);
-    // @ts-expect-error
-    const y: undefined = updateUser.sideEffect;
-  });
-
-  it('only optional path means the arg is not required', () => {
-    const ep = new RestEndpoint({ path: '/users/:id?/:group?' });
-    const epbody = new RestEndpoint({
-      path: '/users/:id?/:group?',
-      body: { title: '' },
-    });
-    () => ep();
-    () => ep({ id: 5 });
-    () => ep({ group: 5 });
-    () => ep({ id: 5, group: 5 });
-    () => epbody({ title: 'hi' });
-    () => epbody({ id: 5 }, { title: 'hi' });
-    () => epbody({ group: 5 }, { title: 'hi' });
-    () => epbody({ id: 5, group: 5 }, { title: 'hi' });
-    // @ts-expect-error
-    () => epbody({ title: 'hi' }, { title: 'hi' });
-  });
-
-  /* TODO: it('should allow sideEffect overrides', () => {
-    const weirdGetUser = new RestEndpoint({
-      path: 'http\\://test.com/user/:id',
-      name: 'getter',
-      schema: User,
-      method: 'POST',
-      sideEffect: undefined,
-    });
-
-    expect(weirdGetUser.sideEffect).toBe(undefined);
-    //s @ts-expect-error
-    //const y: true = weirdGetUser.sideEffect;
-  });*/
-
-  it('should handle simple urls', () => {
-    expect(getUser.url({ id: '5' })).toBe('http://test.com/user/5');
-    expect(getUser.url({ id: '100' })).toBe('http://test.com/user/100');
-
-    // @ts-expect-error
-    () => getUser.url({ sdf: '5' });
-  });
-
-  it('should handle multiarg urls', () => {
-    const getMyUser = new RestEndpoint({
-      path: 'http\\://test.com/groups/:group/users/:id',
-      schema: User,
-      method: 'GET',
-      extra: 5,
-    });
-
-    expect(getMyUser.url({ group: 'big', id: '5' })).toBe(
-      'http://test.com/groups/big/users/5',
-    );
-    expect(getMyUser.url({ group: 'big', id: '100' })).toBe(
-      'http://test.com/groups/big/users/100',
-    );
-
-    // missing required
-    expect(() =>
-      // @ts-expect-error
-      getMyUser.url({ id: '5' }),
-    ).toThrow();
-    // extra fields
-    () =>
-      getMyUser.url({
-        group: 'mygroup',
-        id: '5',
-        // @ts-expect-error
-        notexisting: 'hi',
-      });
-
-    // @ts-expect-error
-    () => useSuspense(getMyUser, { id: '5' });
-    // @ts-expect-error
-    () => useSuspense(getMyUser);
-    () => useSuspense(getMyUser, { group: 'yay', id: '5' });
-  });
-
-  it('should automatically name methods', () => {
-    expect(getUser.name).toBe('User.get');
-    expect(getArticleList.name).toMatchInlineSnapshot(
-      `"http://test.com/article-paginated"`,
-    );
-    expect(
-      getArticleList.extend({ path: '/:something' }).name,
-    ).toMatchInlineSnapshot(`"http://test.com/:something"`);
-  });
-
-  it('should update on get for a paginated resource', async () => {
-    mynock.get(`/article-paginated`).reply(200, paginatedFirstPage);
-    mynock.get(`/article-paginated?cursor=2`).reply(200, paginatedSecondPage);
-
-    const { result, waitForNextUpdate, controller } = renderRestHook(() => {
-      const { fetch } = useController();
-      const {
-        data: { results: articles },
-        nextPage,
-      } = useSuspense(getArticleList);
-      return { articles, nextPage, fetch };
-    });
-    await waitForNextUpdate();
-    // @ts-expect-error
-    () => controller.fetch(getNextPage);
-    // @ts-expect-error
-    () => controller.fetch(getNextPage, { fake: 5 });
-    expect(result.current.nextPage).toEqual(paginatedFirstPage.nextPage);
-    await controller.fetch(getNextPage, {
-      cursor: result.current.nextPage,
-    });
-    expect(result.current.articles.map(({ id }) => id)).toEqual([5, 3, 7, 8]);
-    expect(result.current.nextPage).toBeUndefined();
-  });
-
-  it('should update on get for a paginated resource with parameter in path', async () => {
-    mynock.get(`/article-paginated/happy`).reply(200, paginatedFirstPage);
-    mynock
-      .get(`/article-paginated/happy?cursor=2`)
-      .reply(200, paginatedSecondPage);
-
-    const { result, waitForNextUpdate } = renderRestHook(() => {
-      const { fetch } = useController();
-      const {
-        data: { results: articles },
-        nextPage,
-      } = useSuspense(getArticleList2, {
-        group: 'happy',
-      });
-      return { articles, nextPage, fetch };
-    });
-    await waitForNextUpdate();
-    // @ts-expect-error
-    () => result.current.fetch(getNextPage2);
-    // @ts-expect-error
-    () => result.current.fetch(getNextPage2, { fake: 5 });
-    // @ts-expect-error
-    () => result.current.fetch(getNextPage2, { group: 'happy' });
-    // @ts-expect-error
-    () => result.current.fetch(getNextPage2, { cursor: 2 });
-    await result.current.fetch(getNextPage2, {
-      group: 'happy',
-      cursor: 2,
-    });
-    expect(result.current.articles.map(({ id }) => id)).toEqual([5, 3, 7, 8]);
-  });
-
-  it('should deduplicate results', async () => {
-    mynock.get(`/article-paginated`).reply(200, paginatedFirstPage);
-    mynock.get(`/article-paginated?cursor=2`).reply(200, {
-      ...paginatedSecondPage,
-      results: [nested[nested.length - 1], ...moreNested],
-    });
-
-    const { result, waitForNextUpdate } = renderRestHook(() => {
-      const { fetch } = useController();
-      const {
-        data: { results: articles },
-        nextPage,
-      } = useSuspense(getArticleList);
-      return { articles, nextPage, fetch };
-    });
-    await waitForNextUpdate();
-    await result.current.fetch(getNextPage, {
-      cursor: 2,
-    });
-    //TODO: Why is this broken? expect(result.current.articles.map(({ id }) => id)).toEqual([5, 3, 7, 8]);
-  });
-
-  it('should not deep-merge deeply defined entities', async () => {
-    interface Complex {
-      firstvalue: number;
-      secondthing: {
-        arg?: number;
-        other?: string;
-      };
-    }
-    class ComplexEntity extends Entity {
-      readonly id: string = '';
-      readonly complexThing?: Complex = undefined;
-      readonly extra: string = '';
-
-      pk() {
-        return this.id;
-      }
-    }
-    const getComplex = new RestEndpoint({
-      path: '/complex-thing/:id',
-      schema: ComplexEntity,
-      method: 'GET',
-    });
-
-    const firstResponse = {
-      id: '5',
-      complexThing: {
-        firstvalue: 233,
-        secondthing: { arg: 88 },
-      },
-      extra: 'hi',
-    };
-    mynock.get(`/complex-thing/5`).reply(200, firstResponse);
-
-    const { result, waitForNextUpdate } = renderRestHook(() => {
-      const { fetch } = useController();
-      const article = useSuspense(getComplex, { id: '5' });
-      return { article, fetch };
-    });
-    await waitForNextUpdate();
-    expect(result.current.article).toEqual(firstResponse);
-
-    const secondResponse = {
-      id: '5',
-      complexThing: {
-        firstvalue: 5,
-        secondthing: { other: 'hi' },
-      },
-    };
-
-    mynock.get(`/complex-thing/5`).reply(200, secondResponse);
-    await result.current.fetch(getComplex, {
-      id: '5',
-    });
-    expect(result.current.article).toEqual({ ...secondResponse, extra: 'hi' });
-  });
-
-  it('overriding methods should work', async () => {
-    mynock.put(`/user/5`).reply(200, (uri, body: any) => ({
-      id: 5,
-      username: 'bob',
-      ...body,
-    }));
-    const updateUser = new RestEndpoint({
-      method: 'PUT',
-      path: 'http\\://test.com/user/:id',
-      name: 'get',
-      schema: User,
-      getRequestInit(body) {
-        if (body && isPojo(body)) {
-          return RestEndpoint.prototype.getRequestInit.call(this, {
-            ...body,
-            email: 'always@always.com',
-          });
-        }
-        return RestEndpoint.prototype.getRequestInit.call(this, body);
-      },
-    });
-    const response = await updateUser(
-      { id: 5 },
-      { username: 'micky', email: 'micky@gmail.com' },
-    );
-    expect(response).toMatchInlineSnapshot(`
-      {
-        "email": "always@always.com",
-        "id": 5,
-        "username": "micky",
-      }
-    `);
-  });
-
-  describe('class extensions', () => {
-    class DefaultUser extends User {
-      defaultUserExtra = 'yay';
-    }
-
-    class MyEndpoint<O extends RestGenerics = any> extends RestEndpoint<
-      Defaults<O, { schema: DefaultUser }>
-    > {
-      constructor(options: Readonly<RestEndpointConstructorOptions<O> & O>) {
-        super({ schema: DefaultUser, ...options } as any);
-      }
-
-      parseResponse(response: Response): Promise<any> {
-        return super.parseResponse(response);
-      }
-
-      getRequestInit(body: any) {
-        if (isPojo(body)) {
-          return super.getRequestInit({ ...body, email: 'always@always.com' });
-        }
-        return super.getRequestInit(body);
-      }
-
-      additional = 5;
-    }
-
-    it('should work with constructor', async () => {
-      mynock.put('/user/5').reply(200, (uri, body: any) => ({
-        id: 5,
-        username: 'bob',
-        ...body,
-      }));
-
-      const updateUser = new MyEndpoint({
-        method: 'PUT',
-        path: 'http\\://test.com/user/:id',
-        name: 'update',
-        schema: User,
-      });
-      const response = await updateUser(
-        { id: 5 },
-        { username: 'micky', email: 'micky@gmail.com' },
-      );
-      expect(response).toMatchInlineSnapshot(`
-        {
-          "email": "always@always.com",
-          "id": 5,
-          "username": "micky",
-        }
-      `);
-      expect(updateUser.additional).toBe(5);
-    });
-
-    it('setting body in extend should work', async () => {
-      mynock.put('/charmer/5').reply(200, (uri, body: any) => ({
-        id: 5,
-        username: 'bob',
-        ...body,
-      }));
-
-      const updateUser = new MyEndpoint({
-        method: 'PUT',
-        path: 'http\\://test.com/user/:id',
-        name: 'update',
-        schema: User,
-      }).extend({
-        body: 5,
-        path: 'http\\://test.com/charmer/:charm',
-      });
-      const response = await updateUser(
-        { charm: 5 },
-        // @ts-expect-error
-        { username: 'micky', email: 'micky@gmail.com' },
-      );
-      () => updateUser({ charm: 5 }, 5);
-      expect(response).toMatchInlineSnapshot(`
-        {
-          "email": "always@always.com",
-          "id": 5,
-          "username": "micky",
-        }
-      `);
-      expect(updateUser.additional).toBe(5);
-      const nobody = updateUser.extend({
-        path: 'http\\://test.com/user/:charm',
-        body: undefined,
-      });
-      () => nobody({ charm: 5 });
-      // @ts-expect-error
-      () => nobody({ id: 5 });
-    });
-
-    it('setting body in extend should work without path', async () => {
-      mynock.put('/user/5').reply(200, (uri, body: any) => ({
-        id: 5,
-        username: 'bob',
-        ...body,
-      }));
-
-      const updateUser = new MyEndpoint({
-        method: 'PUT',
-        path: 'http\\://test.com/user/:id',
-        name: 'update',
-        schema: User,
-      }).extend({
-        body: 5,
-      });
-      const response = await updateUser(
-        { id: 5 },
-        // @ts-expect-error
-        { username: 'micky', email: 'micky@gmail.com' },
-      );
-      () => updateUser({ id: 5 }, 5);
-      expect(response).toMatchInlineSnapshot(`
-        {
-          "email": "always@always.com",
-          "id": 5,
-          "username": "micky",
-        }
-      `);
-      expect(updateUser.additional).toBe(5);
-      const nobody = updateUser.extend({
-        path: 'http\\://test.com/user/:charm',
-        body: undefined,
-      });
-      () => nobody({ charm: 5 });
-      // @ts-expect-error
-      () => nobody({ id: 5 });
-
-      const updateUser2 = new MyEndpoint({
-        method: 'PUT',
-        path: 'http\\://test.com/user/:id',
-        name: 'update',
-        schema: User,
-      }).extend({
-        searchParams: {} as { isAdmin: boolean },
-      });
-      () =>
-        updateUser2(
-          { id: 5, isAdmin: true },
-          { username: 'micky', email: 'micky@gmail.com' },
-        );
-      () =>
-        // @ts-expect-error
-        updateUser2({ id: 5 }, { username: 'micky', email: 'micky@gmail.com' });
-      () =>
-        updateUser2(
-          // @ts-expect-error
-          { isAdmin: true },
-          { username: 'micky', email: 'micky@gmail.com' },
-        );
-
-      const updateBasic = new MyEndpoint({
-        method: 'PUT',
-        path: 'http\\://test.com/user/:id',
-        name: 'update',
-        schema: User,
-      });
-      () =>
-        updateBasic({ id: 5 }, { username: 'micky', email: 'micky@gmail.com' });
-      () =>
-        updateBasic(
-          // @ts-expect-error
-          { id: 5, isAdmin: true },
-          { username: 'micky', email: 'micky@gmail.com' },
-        );
-    });
-
-    it('should work with default schema in class definition', async () => {
-      mynock.get('/user/5').reply(200, (uri, body: any) => ({
-        id: 5,
-        username: 'bob',
-        email: 'bob@gmail.com',
-      }));
-
-      const getUser = new MyEndpoint({
-        path: 'http\\://test.com/user/:id',
-        name: 'update',
-      });
-      const { result, waitForNextUpdate } = renderRestHook(() => {
-        return useSuspense(getUser, { id: 5 });
-      });
-      await waitForNextUpdate();
-
-      expect(result.current.username).toBe('bob');
-      // @ts-expect-error
-      expect(result.current.sdfsd).toBeUndefined();
-      expect(result.current.defaultUserExtra).toBe('yay');
-      expect(result.current.email).toBe('bob@gmail.com');
-    });
-
-    it('should work with default path in class definition', async () => {
-      mynock.get('/user/5').reply(200, (uri, body: any) => ({
-        id: 5,
-        username: 'bob',
-        email: 'bob@gmail.com',
-      }));
-      // this seems like a less common use case; so we're fine with it being annoying
-      class UserEndpoint<
-        O extends Partial<RestGenerics> = {
-          schema: DefaultUser;
-          path: 'http\\://test.com/user/:id';
-        },
-      > extends MyEndpoint<
-        Defaults<O, { schema: DefaultUser; path: 'http\\://test.com/user/:id' }>
-      > {
-        constructor({
-          path = 'http\\://test.com/user/:id',
-          ...options
-        }: Readonly<O & { name: string }>) {
-          super({ path, ...options } as any);
-        }
-      }
-
-      const getUser = new UserEndpoint({
-        method: 'GET',
-        name: 'update',
-      });
-      const { result, waitForNextUpdate } = renderRestHook(() => {
-        return useSuspense(getUser, { id: 5 });
-      });
-      await waitForNextUpdate();
-
-      expect(result.current.username).toBe('bob');
-      // @ts-expect-error
-      expect(result.current.sdfsd).toBeUndefined();
-      expect(result.current.defaultUserExtra).toBe('yay');
-      expect(result.current.email).toBe('bob@gmail.com');
-
-      // @ts-expect-error
-      () => getUser({ group: 5 });
-      // @ts-expect-error
-      () => useSuspense(getUser, { group: 5 });
-      // @ts-expect-error
-      () => useSuspense(getUser);
-    });
-
-    it('should work with extends', async () => {
-      mynock.put('/6/user/5').reply(200, (uri, body: any) => ({
-        id: 5,
-        username: 'charles',
-        ...body,
-      }));
-
-      const updateUser = new MyEndpoint({
-        method: 'PUT',
-        path: 'http\\://test.com/user/:id',
-        name: 'update',
-        schema: User,
-      }).extend({
-        path: 'http\\://test.com/:group/user/:id',
-        body: 0 as Partial<User>,
-      });
-      expect(updateUser.additional).toBe(5);
-      expect(updateUser.method).toBe('PUT');
-      const response = await updateUser(
-        { group: '6', id: 5 },
-        { email: 'micky@gmail.com' },
-      );
-      expect(response).toMatchInlineSnapshot(`
-        {
-          "email": "always@always.com",
-          "id": 5,
-          "username": "charles",
-        }
-      `);
-    });
-
-    it('should work with extends', async () => {
-      mynock.get('/6/user/5').reply(200, (uri, body: any) => ({
-        id: 5,
-        username2: 'charles',
-        ...body,
-      }));
-      class User2 extends Entity {
-        readonly id: number | undefined = undefined;
-        readonly username2: string = '';
-        readonly email: string = '';
-        readonly isAdmin: boolean = false;
-
-        pk() {
-          return this.id?.toString();
-        }
-      }
-
-      const getUserBase = new MyEndpoint({
-        method: 'GET',
-        path: 'http\\://test.com/user/:id',
-        name: 'getuser',
-        schema: User,
-      });
-      const getUser = getUserBase.extend({
-        path: 'http\\://test.com/:group/user/:id',
-        schema: User2,
-      });
-      getUserBase.body;
-      expect(getUserBase.name).toBe('getuser');
-      expect(getUserBase.extend({ method: 'GET' }).name).toBe('getuser');
-      expect(getUser.name).toBe('getuser');
-      expect(getUser.additional).toBe(5);
-      expect(getUser.method).toBe('GET');
-      const user = await getUser({ group: '6', id: 5 });
-      expect(user.username2).toBe('charles');
-      () => {
-        const a = useSuspense(getUser, { group: '6', id: 5 });
-        // @ts-expect-error
-        a.username;
-      };
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      expect(user.username).toBeUndefined();
-      expect(user).toMatchInlineSnapshot(`
-        {
-          "id": 5,
-          "username2": "charles",
-        }
-      `);
-
-      const newBody = getUser
-        .extend({
-          body: {} as { title: string },
-          dataExpiryLength: 0,
-        })
-        .extend({ dataExpiryLength: 5 });
-      () => newBody({ group: 'hi', id: 'what' }, { title: 'cool' });
-      // @ts-expect-error
-      () => newBody({ id: 'what' }, { title: 'cool' });
-      // @ts-expect-error
-      () => newBody({ title: 'cool' });
-      // @ts-expect-error
-      () => newBody({ group: 'hi', id: 'what' });
-      // @ts-expect-error
-      () => newBody({ group: 'hi', id: 'what' }, { sdfsd: 'cool' });
-
-      const bodyNoPath = newBody.extend({
-        path: '/',
-      });
-      const bodyNoParams = bodyNoPath.extend({
-        body: {} as { happy: string },
-      });
-      () => bodyNoParams({ happy: 'cool' });
-      // @ts-expect-error
-      () => bodyNoParams({ group: 'hi', id: 'what' }, { happy: 'cool' });
-      // @ts-expect-error
-      () => bodyNoParams({ group: 'hi', id: 'what' }, { title: 'cool' });
-      // @ts-expect-error
-      () => bodyNoParams({ sdfd: 'cool' });
-
-      const searchParams = getUser.extend({
-        path: 'http\\://test.com/:group/user/:id',
-        searchParams: {} as { isAdmin?: boolean; sort: 'asc' | 'desc' },
-      });
-      () => searchParams({ group: 'hi', id: 'what', sort: 'asc' });
-      () =>
-        searchParams({ group: 'hi', id: 'what', sort: 'asc', isAdmin: true });
-      // @ts-expect-error
-      () => searchParams({ group: 'hi', id: 'what', sort: 'abc' });
-      // @ts-expect-error
-      () => searchParams({ group: 'hi', id: 'what' });
-      // @ts-expect-error
-      () => searchParams.url({ group: 'hi', id: 'what' });
-      expect(
-        searchParams.url({
-          group: 'hi',
-          id: 'what',
-          sort: 'desc',
-          isAdmin: true,
-        }),
-      ).toMatchInlineSnapshot(
-        `"http://test.com/hi/user/what?isAdmin=true&sort=desc"`,
-      );
-
-      const searchParams2 = searchParams.extend({
-        searchParams: {} as { bigger: boolean },
-      });
-      () => searchParams2({ group: 'hi', id: 'what', bigger: true });
-      () => searchParams2({ group: 'hi', id: 'what', bigger: false });
-      // @ts-expect-error
-      () => searchParams2({ group: 'hi', id: 'what', bigger: 5 });
-      // @ts-expect-error
-      () => searchParams2({ group: 'hi', id: 'what', sort: 'asc' });
-      // @ts-expect-error
-      () => searchParams2({ group: 'hi', id: 'what' });
-      // @ts-expect-error
-      () => searchParams2.url({ group: 'hi', id: 'what' });
-      expect(
-        searchParams2.url({
-          group: 'hi',
-          id: 'what',
-          bigger: true,
-        }),
-      ).toMatchInlineSnapshot(`"http://test.com/hi/user/what?bigger=true"`);
-
-      const searchParams3 = getUserBase.extend({
-        searchParams: {} as { bigger: boolean },
-      });
-      () => searchParams3({ id: 'what', bigger: true });
-      () => searchParams3({ id: 'what', bigger: false });
-      // @ts-expect-error
-      () => searchParams3({ id: 'what', bigger: 5 });
-      // @ts-expect-error
-      () => searchParams3({ id: 'what', sort: 'asc' });
-      // @ts-expect-error
-      () => searchParams3({ id: 'what' });
-      // @ts-expect-error
-      () => searchParams3.url({ id: 'what' });
-      expect(
-        searchParams3.url({
-          id: 'what',
-          bigger: true,
-        }),
-      ).toMatchInlineSnapshot(`"http://test.com/user/what?bigger=true"`);
-
-      const searchParams4 = getUserBase
-        .extend({
-          path: '/users',
-        })
-        .extend({ searchParams: {} as { bigger?: boolean } | undefined });
-      () => searchParams4({ bigger: true });
-      () => searchParams4();
-      () => searchParams4({});
-      // @ts-expect-error
-      () => searchParams4({ id: 'what', bigger: false });
-      // @ts-expect-error
-      () => searchParams4({ bigger: 5 });
-      // @ts-expect-error
-      () => searchParams4({ id: 'what' });
-      // @ts-expect-error
-      () => searchParams4.url({ id: 'what' });
-      expect(
-        searchParams4.url({
-          bigger: true,
-        }),
-      ).toMatchInlineSnapshot(`"/users?bigger=true"`);
-      expect(searchParams4.url()).toMatchInlineSnapshot(`"/users"`);
-    });
-  });
-  it('extending with name should work', () => {
-    const endpoint = CoolerArticleResource.get.extend({ name: 'mything' });
-    const endpoint2 = CoolerArticleResource.get.extend({ path: '/:bob' });
-    expect(CoolerArticleResource.get.name).toMatchInlineSnapshot(
-      `"CoolerArticle.get"`,
-    );
-    expect(endpoint.name).toBe('mything');
-    expect(endpoint2.name).toMatchInlineSnapshot(`"CoolerArticle.get"`);
-  });
-  it('should infer default method when sideEffect is set', async () => {
-    const endpoint = new RestEndpoint({
-      sideEffect: true,
-      path: 'http\\://test.com/article-cooler',
-      body: 0 as any,
-      schema: CoolerArticle,
-    }).extend({ name: 'createarticle' });
-    expect(endpoint.method).toBe('POST');
-    const article = await endpoint(payload);
-    expect(article).toMatchInlineSnapshot(`
-      {
-        "content": "whatever",
-        "id": 1,
-        "tags": [
-          "a",
-          "best",
-          "react",
-        ],
-        "title": "hi ho",
-      }
-    `);
-  });
-
-  describe('body type setting', () => {
-    it('should work in constructors', () => {
-      interface TodoInterface {
-        title: string;
-        completed: boolean;
-      }
-      const update = new RestEndpoint({
-        path: '/:id',
-        method: 'POST',
-        body: {} as TodoInterface,
-      });
-      () => update({ id: 5 }, { title: 'updated', completed: true });
-      // @ts-expect-error
-      () => update({ id: 5 });
-      // @ts-expect-error
-      () => update({ id: 5 }, { title: 5, completed: true });
-      // @ts-expect-error
-      () => update({ id: 5 }, { completed: true });
-    });
-  });
-
-  describe('process() return type setting', () => {
-    const getArticle = new RestEndpoint({
-      path: 'http\\://test.com/article-cooler/:id',
-      process(value): CoolerArticle {
-        return value;
-      },
-    });
-
-    it('should work with constructors', async () => {
-      const article = await getArticle({ id: '5' });
-      article.author;
-      // @ts-expect-error
-      article.asdf;
-      () => useSuspense(getArticle, { id: '5' }).content;
-      // @ts-expect-error
-      () => useSuspense(getArticle, { id: '5' }).asdf;
-    });
-
-    it('should set on .extend()', async () => {
-      const getExtends = new RestEndpoint({
-        path: 'http\\://test.com/article-cooler/:id',
-      }).extend({
-        process(value: any): CoolerArticle {
-          return value;
-        },
-      });
-      const ex = await getExtends({ id: '5' });
-      ex.author;
-      // @ts-expect-error
-      ex.asdf;
-      () => useSuspense(getExtends, { id: '5' }).content;
-      // @ts-expect-error
-      () => useSuspense(getExtends, { id: '5' }).asdf;
-    });
-
-    it('should override existing type on .extend()', async () => {
-      const getOverride = getArticle.extend({
-        process(value: any, param: any): { asdf: string } {
-          return value;
-        },
-      });
-      const ov = await getOverride({ id: '5' });
-      ov.asdf;
-      // @ts-expect-error
-      ov.author;
-      () => useSuspense(getOverride, { id: '5' }).asdf;
-      // @ts-expect-error
-      () => useSuspense(getOverride, { id: '5' }).content;
-    });
-
-    it('should maintain existing type on .extend() when not specified', async () => {
-      const getOverride = getArticle.extend({
-        dataExpiryLength: 7,
-      });
-      const ov = await getOverride({ id: '5' });
-      ov.author;
-      // @ts-expect-error
-      ov.asdf;
-    });
-
-    it('should maintain existing type on .extend() when process is not supplied but path is', async () => {
-      const getOverride = getArticle.extend({
-        path: '/:a/:b',
-      });
-      async () => {
-        const ov = await getOverride({ a: '5', b: '7' });
-        ov.author;
-        // @ts-expect-error
-        ov.asdf;
-      };
-    });
-
-    it('should override existing type on .extend() when path is also supplied', async () => {
-      const getOverride = getArticle.extend({
-        path: '/:a/:b',
-        process(value: any, param: any): { asdf: string } {
-          return value;
-        },
-      });
-      async () => {
-        const ov = await getOverride({ a: '5', b: '7' });
-        ov.asdf;
-        // @ts-expect-error
-        ov.author;
-      };
-      () => useSuspense(getOverride, { a: '5', b: '7' }).asdf;
-      // @ts-expect-error
-      () => useSuspense(getOverride, { a: '5', b: '7' }).content;
-    });
-  });
-
-  it('extend options should match function of path set', () => {
-    const endpoint = new RestEndpoint({
-      sideEffect: true,
-      path: 'http\\://test.com/article-cooler/:id',
-      body: 0 as any,
-      schema: CoolerArticle,
-      getOptimisticResponse(snap, params, body) {
-        params.id;
-        // @ts-expect-error
-        params.two;
-
-        body.hi;
-      },
-    }).extend({
-      path: '/:group/next/:two',
-      body: undefined,
-      getOptimisticResponse(snap, params) {
-        params.two;
-        params.group;
-        // @ts-expect-error
-        params.id;
-      },
-    });
-
-    const endpoint2 = new RestEndpoint({
-      sideEffect: true,
-      path: 'http\\://test.com/article-cooler/:id',
-      body: 0 as any,
-      schema: CoolerArticle,
-      getOptimisticResponse(snap, params, body) {
-        params.id;
-        // @ts-expect-error
-        params.two;
-
-        body.hi;
-      },
-    }).extend({
-      getOptimisticResponse(snap, params, body) {
-        params.id;
-        // @ts-expect-error
-        params.two;
-
-        body.hi;
-      },
-    });
-  });
-});
-
-describe('RestEndpoint.fetch()', () => {
-  const id = 5;
-  const idHtml = 6;
-  const idNoContent = 7;
-  const payload = {
-    id,
-    title: 'happy',
-    author: User.fromJS({ id: 5 }),
-  };
-  const putResponseBody = {
-    id,
-    title: 'happy',
-    completed: true,
-  };
-  const patchPayload = {
-    title: 'happy',
-  };
-  const patchResponseBody = {
-    id,
-    title: 'happy',
-    completed: false,
-  };
-
-  beforeEach(() => {
-    nock(/.*/)
-      .defaultReplyHeaders({
-        'Access-Control-Allow-Origin': '*',
-        'Content-Type': 'application/json',
-      })
-      .options(/.*/)
-      .reply(200)
-      .get(`/article-cooler/${payload.id}`)
-      .reply(200, payload)
-      .get(`/article-cooler/${idHtml}`)
-      .reply(200, '<body>this is html</body>')
-      .get(`/article-cooler/${idNoContent}`)
-      .reply(204, '')
-      .post('/article-cooler')
-      .reply((uri, requestBody) => [
-        201,
-        requestBody,
-        { 'content-type': 'application/json' },
-      ])
-      .put('/article-cooler/5')
-      .reply((uri, requestBody) => {
-        let body = requestBody as any;
-        if (typeof requestBody === 'string') {
-          body = JSON.parse(requestBody);
-        }
-        for (const key of Object.keys(CoolerArticle.fromJS({}))) {
-          if (key !== 'id' && !(key in body)) {
-            return [400, {}, { 'content-type': 'application/json' }];
-          }
-        }
-        return [200, putResponseBody, { 'content-type': 'application/json' }];
-      })
-      .patch('/article-cooler/5')
-      .reply(() => [
-        200,
-        patchResponseBody,
-        { 'content-type': 'application/json' },
-      ])
-      .intercept('/article-cooler/5', 'DELETE')
-      .reply(200, {});
-  });
-
-  afterEach(() => {
-    nock.cleanAll();
-  });
-
-  it('should GET', async () => {
-    const article = await CoolerArticleResource.get({
-      id: payload.id,
-    });
-    expect(article).toBeDefined();
-    if (!article) {
-      throw new Error('ahh');
-    }
-    expect(article.title).toBe(payload.title);
-  });
-
-  it('should POST', async () => {
-    const payload2 = { id: 20, content: 'better task' };
-    const article = await CoolerArticleResource.create(payload2);
-    expect(article).toMatchObject(payload2);
-  });
-
-  it('should PUT with multipart form data', async () => {
-    const payload2 = { id: 500, content: 'another' };
-    let lastRequest: any;
-    nock(/.*/)
-      .defaultReplyHeaders({
-        'Access-Control-Allow-Origin': '*',
-      })
-      .put('/article-cooler/500')
-      .reply(function (uri, requestBody) {
-        lastRequest = this.req;
-        return [201, payload2, { 'Content-Type': 'application/json' }];
-      });
-    const newPhoto = new Blob();
-    const body = new FormData();
-    body.append('photo', newPhoto);
-
-    const article = await CoolerArticleResource.update.extend({
-      path: CoolerArticleResource.update.path,
-      body: new FormData(),
-    })({ id: '500' }, body);
-    expect(lastRequest.headers['content-type']).toContain(
-      'multipart/form-data',
-    );
-    expect(article).toMatchObject(payload2);
-  });
-
-  it('should DELETE', async () => {
-    const res = await CoolerArticleResource.delete({
-      id: payload.id,
-    });
-    expect(res).toEqual({ id });
-  });
-
-  it('should PUT', async () => {
-    const response = await CoolerArticleResource.update(
-      { id: payload.id },
-      { ...CoolerArticle.fromJS(payload) },
-    );
-    expect(response).toEqual(putResponseBody);
-  });
-
-  it('should PATCH', async () => {
-    const response = await CoolerArticleResource.partialUpdate(
-      { id },
-      patchPayload,
-    );
-    expect(response).toEqual(patchResponseBody);
-  });
-
-  it('should throw if response is not json', async () => {
-    let error: any;
-    try {
-      await CoolerArticleResource.get({ id: idHtml });
-    } catch (e) {
-      error = e;
-    }
-    expect(error).toBeDefined();
-    // This is very weird, but we're forced to use node-fetch for react native
-    // node-fetch doesn't handle errors consistently with normal fetch implementations, so this won't work
-    // react-native itself should match this correctly however.
-    if (typeof window !== 'undefined') expect(error.status).toBe(400);
-  });
-
-  it('should throw if network is down', async () => {
-    const oldError = console.error;
-    console.error = () => {};
-
-    const id = 10;
-    nock(/.*/)
-      .defaultReplyHeaders({
-        'Access-Control-Allow-Origin': '*',
-        'Content-Type': 'application/json',
-      })
-      .get(`/article-cooler/${id}`)
-      .replyWithError(new TypeError('Network Down'));
-
-    let error: any;
-    try {
-      await CoolerArticleResource.get({ id });
-    } catch (e) {
-      error = e;
-    }
-    expect(error).toBeDefined();
-    expect(error.status).toBe(500);
-
-    // eslint-disable-next-line require-atomic-updates
-    console.error = oldError;
-  });
-
-  it('should return raw response if status is 204 No Content', async () => {
-    const res = await CoolerArticleResource.get({ id: idNoContent });
-    expect(res).toBe(null);
-  });
-
-  it('should reject if content-type is not json with schema', async () => {
-    const id = 8;
-    const text = '<body>this is html</body>';
-    nock(/.*/)
-      .defaultReplyHeaders({
-        'Access-Control-Allow-Origin': '*',
-        'Content-Type': 'application/json',
-      })
-      .get(`/article-cooler/${id}`)
-      .reply(200, text, { 'content-type': 'html/text' });
-
-    await expect(
-      async () => await CoolerArticleResource.get({ id }),
-    ).rejects.toMatchSnapshot();
-  });
-
-  it('should reject if content-type does not exist with schema', async () => {
-    const id = 10;
-    const text = '<body>this is html</body>';
-    nock(/.*/)
-      .defaultReplyHeaders({
-        'Access-Control-Allow-Origin': '*',
-      })
-      .get(`/article-cooler/${id}`)
-      .reply(200, text, {});
-
-    await expect(
-      async () => await CoolerArticleResource.get({ id }),
-    ).rejects.toMatchSnapshot();
-  });
-
-  it('should return text if content-type is not json with no schema', async () => {
-    const id = 8;
-    const text = '<body>this is html</body>';
-    nock(/.*/)
-      .defaultReplyHeaders({
-        'Access-Control-Allow-Origin': '*',
-        'Content-Type': 'application/json',
-      })
-      .get(`/article-cooler/${id}`)
-      .reply(200, text, { 'content-type': 'html/text' });
-
-    const res = await CoolerArticleResource.get.extend({ schema: undefined })({
-      id,
-    });
-    expect(res).toBe('<body>this is html</body>');
-  });
-
-  it('should return text if content-type does not exist with no schema', async () => {
-    const id = 10;
-    const text = '<body>this is html</body>';
-    nock(/.*/)
-      .defaultReplyHeaders({
-        'Access-Control-Allow-Origin': '*',
-      })
-      .get(`/article-cooler/${id}`)
-      .reply(200, text, {});
-
-    const res = await CoolerArticleResource.get.extend({ schema: undefined })({
-      id,
-    });
-    expect(res).toBe(text);
-  });
-
-  it('should reject with custom message if content type is set but json parsable', async () => {
-    const id = 8;
-    nock(/.*/)
-      .defaultReplyHeaders({
-        'Access-Control-Allow-Origin': '*',
-        'Content-Type': 'text',
-      })
-      .get(`/article-cooler/${id}`)
-      .reply(200, { id, title: 'hi' }, {});
-
-    await expect(
-      async () => await CoolerArticleResource.get({ id }),
-    ).rejects.toMatchSnapshot();
-  });
-
-  it('should still work with empty content-type', async () => {
-    const id = 8;
-    nock(/.*/)
-      .defaultReplyHeaders({
-        'Access-Control-Allow-Origin': '*',
-      })
-      .get(`/article-cooler/${id}`)
-      .reply(200, { id, title: 'hi' });
-
-    const res = await CoolerArticleResource.get({
-      id,
-    });
-    expect(res).toEqual({ id, title: 'hi' });
-  });
-
-  it('without Collection in schema - endpoint.push schema should be null', () => {
-    expect(getArticleList2.push.schema).toBeFalsy();
-  });
-});
-const proto = Object.prototype;
-const gpo = Object.getPrototypeOf;
-
-function isPojo(obj: unknown): obj is Record<string, any> {
-  if (obj === null || typeof obj !== 'object') {
-    return false;
-  }
-  return gpo(obj) === proto;
-}