@data-client/rest 0.1.0

package/src/__tests__/hookifyResource.ts

@@ -0,0 +1,197 @@
+import { useController, useSuspense } from '@data-client/react';
+import { CacheProvider } from '@data-client/react';
+import { CoolerArticleResource, CoolerArticle, User } from '__tests__/new';
+import nock from 'nock';
+
+import { makeRenderRestHook } from '../../../test';
+import hookifyResource from '../hookifyResource';
+
+const CoolerArticleHookResource = hookifyResource(
+  CoolerArticleResource,
+  () => ({}),
+);
+
+function onError(e: any) {
+  e.preventDefault();
+}
+beforeEach(() => {
+  if (typeof addEventListener === 'function')
+    addEventListener('error', onError);
+});
+afterEach(() => {
+  if (typeof removeEventListener === 'function')
+    removeEventListener('error', onError);
+});
+
+describe('hookifyResource()', () => {
+  beforeAll(() => {
+    nock(/.*/)
+      .persist()
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'application/json',
+      })
+      .options(/.*/)
+      .reply(200);
+  });
+
+  afterAll(() => {
+    nock.cleanAll();
+  });
+
+  describe('HookableResource endpoints', () => {
+    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,
+    };
+
+    let renderRestHook: ReturnType<typeof makeRenderRestHook>;
+
+    beforeEach(() => {
+      renderRestHook = makeRenderRestHook(CacheProvider);
+
+      nock(/.*/)
+        .defaultReplyHeaders({
+          'Access-Control-Allow-Origin': '*',
+          'Content-Type': 'application/json',
+        })
+        .get(`/article-cooler/${payload.id}`)
+        .reply(200, payload)
+        .get(`/article-cooler`)
+        .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, {});
+    });
+
+    it('useDetail', async () => {
+      const { result, waitForNextUpdate } = renderRestHook(() =>
+        useSuspense(CoolerArticleHookResource.useGet(), { id: payload.id }),
+      );
+      await waitForNextUpdate();
+      expect(result.current).toBeDefined();
+      expect(result.current.title).toBe(payload.title);
+    });
+
+    it('useList', async () => {
+      const { result, waitForNextUpdate } = renderRestHook(() =>
+        useSuspense(CoolerArticleHookResource.useGetList()),
+      );
+      await waitForNextUpdate();
+      expect(result.current).toBeDefined();
+    });
+
+    it('useCreate', async () => {
+      const { result } = renderRestHook(() => ({
+        endpoint: CoolerArticleHookResource.useCreate(),
+        fetch: useController().fetch,
+      }));
+      const payload2 = { id: 20, content: 'better task' };
+      const article = await result.current.fetch(
+        result.current.endpoint,
+        payload2,
+      );
+      // @ts-expect-error
+      () => result.current.fetch(result.current.endpoint, {}, payload2);
+      expect(article).toMatchObject(payload2);
+    });
+
+    it('useDelete', async () => {
+      const { result } = renderRestHook(() => ({
+        endpoint: CoolerArticleHookResource.useDelete(),
+        fetch: useController().fetch,
+      }));
+
+      const res = await result.current.fetch(result.current.endpoint, {
+        id: payload.id,
+      });
+      expect(res).toEqual({ id: 5 });
+    });
+
+    it('useUpdate', async () => {
+      const { result } = renderRestHook(() => ({
+        endpoint: CoolerArticleHookResource.useUpdate(),
+        fetch: useController().fetch,
+      }));
+
+      const res = await result.current.fetch(
+        result.current.endpoint,
+        { id: payload.id },
+        {
+          ...CoolerArticle.fromJS(payload),
+        },
+      );
+      expect(res).toEqual(putResponseBody);
+    });
+
+    it('usePartialUpdate', async () => {
+      const { result } = renderRestHook(() => ({
+        endpoint: CoolerArticleHookResource.usePartialUpdate(),
+        fetch: useController().fetch,
+      }));
+
+      const res = await result.current.fetch(
+        result.current.endpoint,
+        { id },
+        patchPayload,
+      );
+      expect(res).toEqual(patchResponseBody);
+    });
+
+    it('should use useFetchInit if defined (in endpoint method)', async () => {
+      const useFetchInit = jest.fn(() => ({}));
+      const FetchResource = hookifyResource(
+        CoolerArticleResource,
+        useFetchInit,
+      );
+      const articleDetail = FetchResource.useGet();
+      expect(articleDetail).toBeDefined();
+      expect(useFetchInit.mock.calls.length).toBeGreaterThan(0);
+    });
+  });
+});

package/src/__tests__/types.test.ts

@@ -0,0 +1,309 @@
+import { Entity, schema } from '@data-client/endpoint';
+import { User } from '__tests__/new';
+
+import createResource from '../createResource';
+import {
+  KeysToArgs,
+  PathArgs,
+  PathArgsAndSearch,
+  PathKeys,
+  ShortenPath,
+} from '../pathTypes';
+import RestEndpoint, { GetEndpoint, NewGetEndpoint } from '../RestEndpoint';
+import { RequiredKeys } from '../utiltypes';
+
+describe('PathArgs', () => {
+  it('should infer types', () => {
+    type C =
+      'http\\://test.com/groups/:group?/\\:blah/users/:id?:extra?/:next\\?bob/:last';
+    function A(args: PathArgs<C>) {}
+    // @ts-expect-error
+    () => A({});
+    () => A({ next: 'hi', last: 'ho' });
+    // @ts-expect-error
+    () => A({ next: 'hi', last: 'ho', doesnotexist: 'hi' });
+    // @ts-expect-error
+    () => A({ next: 'hi', last: 'ho', blah: 'hi' });
+    () => A({ next: 'hi', last: 'ho', id: '5', group: 'whatever' });
+    () => A({ next: 'hi', last: 'ho', extra: '5', group: 'whatever' });
+  });
+
+  it('should infer types2', () => {
+    type C = 'http\\://test.com/article-cooler/:id?:title?';
+    function A(args: PathArgs<C>) {}
+    () => A({});
+    () => A({ id: 'ho' });
+    () => A({ title: 'ho' });
+    () => A({ id: 'ho', title: 'ho' });
+    // @ts-expect-error
+    () => A({ idasd: 'ho' });
+    // @ts-expect-error
+    () => A({ next: 'hi', title: 'ho', id: 'hi' });
+    // @ts-expect-error
+    () => A(5);
+  });
+
+  it('should infer types with other characters to stop', () => {
+    type C = 'http\\://test.com/search/issues?q=:q?%20repo\\::owner/:repo';
+    function A(args: PathArgs<C>) {}
+    () => A({ owner: 'data-client', repo: 'data-client' });
+    () => A({ owner: 'data-client', repo: 'data-client', q: 'is:issue' });
+    // @ts-expect-error
+    () => A({ idasd: 'ho' });
+    // @ts-expect-error
+    () => A({ owner: 'data-client', repo: 'data-client', extra: 'is:issue' });
+    // @ts-expect-error
+    () => A({ owner: 'data-client' });
+    // @ts-expect-error
+    () => A(5);
+  });
+
+  it('should be flexible for string type', () => {
+    class Parent {
+      constructor() {}
+      A(args: PathArgs<string>) {
+        const b = args['hi'];
+      }
+    }
+    class Child extends Parent {
+      A(args: { item: string }) {}
+    }
+    const thing = new Parent();
+    () => thing.A({});
+    () => thing.A({ next: 'hi', last: 'ho' });
+    const thing2 = new Child();
+    //@ts-expect-error
+    () => thing2.A({});
+    () => thing2.A({ item: 'win' });
+  });
+
+  it('works with no arguments', () => {
+    const a: GetEndpoint<PathArgs<'http\\://test.com/article-cooler/'>> =
+      0 as any;
+    () => a();
+    //@ts-expect-error
+    () => a({ page: '5' });
+    //@ts-expect-error
+    () => a({ sdf: '5' });
+    //@ts-expect-error
+    () => a(5);
+  });
+
+  it('works when combining with known types', () => {
+    const a: GetEndpoint<
+      PathArgs<ShortenPath<'/hi'>> & { page: string | number }
+    > = 0 as any;
+    () => a({ page: '5' });
+    //@ts-expect-error
+    () => a({ sdf: '5' });
+    //@ts-expect-error
+    () => a({ page: '5' }, { hi: '5' });
+    //@ts-expect-error
+    () => a();
+  });
+
+  it('works with unions of non-intersecting types', () => {
+    const a: GetEndpoint<{ id: string | number } | { title: string | number }> =
+      0 as any;
+    () => a({ id: '5' });
+    () => a({ title: '5' });
+    // @ts-expect-error
+    () => a({ id: '5', title: '5' });
+    // @ts-expect-error
+    () => a({ id: '5', sdfds: '5' });
+    //@ts-expect-error
+    () => a({ sdf: '5' });
+    //@ts-expect-error
+    () => a({ page: '5' }, { hi: '5' });
+    //@ts-expect-error
+    () => a();
+  });
+
+  it('works with optional positional args', () => {
+    const a: GetEndpoint<undefined | { cursor?: string | number }> = 0 as any;
+    () => a();
+    () => a({});
+    () => a({ cursor: 5 });
+    // @ts-expect-error
+    () => a({ id: '5' });
+    //@ts-expect-error
+    () => a({ cursor: '5' }, { cursor: '5' });
+  });
+
+  it('searchParams', () => {
+    const a: GetEndpoint<undefined | { cursor?: string | number }> = 0 as any;
+    () => a();
+    () => a({});
+    () => a({ cursor: 5 });
+    // @ts-expect-error
+    () => a({ id: '5' });
+    //@ts-expect-error
+    () => a({ cursor: '5' }, { cursor: '5' });
+  });
+
+  describe('PathArgsAndSearch', () => {
+    it('works with required path member', () => {
+      const a: GetEndpoint<
+        PathArgsAndSearch<'http\\://test.com/groups/:group/users/'>
+      > = 0 as any;
+      () => a({ group: '5' });
+      () => a({ group: '5', sdf: '5' });
+      //@ts-expect-error
+      () => a({ asdf: '5' });
+      //@ts-expect-error
+      () => a({});
+      //@ts-expect-error
+      () => a({ page: '5' }, { hi: '5' });
+      //@ts-expect-error
+      () => a();
+    });
+    it('works with no path members', () => {
+      const a: NewGetEndpoint<{
+        path: 'http\\://test.com/groups';
+        searchParams: Record<string, number | string | boolean> | undefined;
+      }> = 0 as any;
+      /*const a: GetEndpoint<PathArgsAndSearch<'http\\://test.com/groups/'>> =
+        0 as any;*/
+      () => a({ group: '5' });
+      () => a({ group: '5', sdf: '5' });
+      () => a();
+      () => a({ asdf: '5' });
+      () => a({});
+      //@ts-expect-error
+      () => a({ page: '5' }, { hi: '5' });
+
+      () => {
+        const b = a.extend({
+          searchParams: {} as { userId?: number | string } | undefined,
+        });
+        b({ userId: '5' });
+        b();
+        // @ts-expect-error
+        b({ sdf: '5' });
+      };
+    });
+  });
+});
+
+describe('RequiredKeys', () => {
+  type Y = {
+    opt?: string;
+    bob: string;
+    charles: number;
+    [k: string]: string | number | undefined;
+  };
+  const a: Record<RequiredKeys<Y>, any> = 5 as any;
+  () => a.bob;
+  () => a.charles;
+  // @ts-expect-error
+  () => a.opt;
+  // @ts-expect-error
+  () => a.sdfsdf;
+});
+
+it('RestEndpoint construct and extend with typed options', () => {
+  new RestEndpoint({
+    path: '/todos/',
+    getOptimisticResponse(snap, body) {
+      return body;
+    },
+    schema: User,
+    method: 'POST',
+  });
+  // variable/unknown number of args
+  new RestEndpoint({
+    path: '/todos/',
+    searchParams: {} as { userId?: string | number } | undefined,
+    getOptimisticResponse(snap, ...args) {
+      return args[args.length - 1];
+    },
+    schema: User,
+    method: 'POST',
+  });
+  new RestEndpoint({
+    path: '/todos/:id',
+    searchParams: {} as { userId?: string | number } | undefined,
+    getOptimisticResponse(snap, params, body) {
+      return body;
+    },
+    schema: User,
+    method: 'POST',
+  });
+  new RestEndpoint({
+    path: '/todos/:id',
+    searchParams: {} as { userId?: string | number } | undefined,
+    getOptimisticResponse(snap, params, body) {
+      return body;
+    },
+    schema: User,
+    method: 'POST',
+  });
+
+  const nopath = new RestEndpoint({
+    path: '/todos/',
+    schema: User,
+    method: 'POST',
+  });
+  const somepath = new RestEndpoint({
+    path: '/todos/:id',
+    schema: User,
+    method: 'POST',
+  });
+
+  nopath.extend({
+    getOptimisticResponse(snap, body) {
+      return body;
+    },
+  });
+  nopath.extend({
+    searchParams: {} as { userId?: string | number } | undefined,
+    getOptimisticResponse(snap, ...args) {
+      return args[args.length - 1];
+    },
+  });
+  somepath.extend({
+    searchParams: {} as { userId?: string | number } | undefined,
+    getOptimisticResponse(snap, args, body) {
+      return body;
+    },
+  });
+});
+
+it('should customize resources', () => {
+  class Todo extends Entity {
+    id = '';
+    userId = 0;
+    title = '';
+    completed = false;
+
+    static key = 'Todo';
+    pk() {
+      return this.id;
+    }
+  }
+
+  const TodoResourceBase = createResource({
+    path: '/todos/:id',
+    schema: Todo,
+  });
+  TodoResourceBase.create.extend({
+    searchParams: {} as { userId?: string | number } | undefined,
+    getOptimisticResponse(snap, ...args) {
+      return args[args.length - 1];
+    },
+  });
+  TodoResourceBase.create
+    .extend({
+      schema: new schema.Collection([Todo], {
+        argsKey(...args) {
+          return { a: 5 };
+        },
+      }),
+    })
+    .extend({
+      searchParams: {} as { userId?: string | number } | undefined,
+      getOptimisticResponse(snap, ...args) {
+        return args[args.length - 1];
+      },
+    });
+});

package/src/createResource.ts

@@ -0,0 +1,172 @@
+import {
+  AbortOptimistic,
+  schema,
+  SnapshotInterface,
+} from '@data-client/endpoint';
+import type {
+  Schema,
+  Denormalize,
+  EndpointExtraOptions,
+} from '@data-client/endpoint';
+
+import { PathArgs, ShortenPath } from './pathTypes.js';
+import RestEndpoint, {
+  NewGetEndpoint,
+  NewMutateEndpoint,
+  RestInstance,
+  RestTypeNoBody,
+} from './RestEndpoint.js';
+import { shortenPath } from './RestHelpers.js';
+
+const { Delete } = schema;
+
+/** Creates collection of Endpoints for common operations on a given data/schema.
+ *
+ * @see https://resthooks.io/rest/api/createResource
+ */
+export default function createResource<U extends string, S extends Schema>({
+  path,
+  schema,
+  Endpoint = RestEndpoint,
+  optimistic,
+  ...extraOptions
+}: {
+  readonly path: U;
+  readonly schema: S;
+  readonly Endpoint?: typeof RestEndpoint;
+  urlPrefix?: string;
+  optimistic?: boolean;
+} & EndpointExtraOptions): Resource<U, S> {
+  const shortenedPath = shortenPath(path);
+  const getName = (name: string) => `${(schema as any)?.name}.${name}`;
+  const extraMutateOptions = { ...extraOptions };
+  const extraPartialOptions = { ...extraOptions };
+  const get: NewGetEndpoint<{ path: U }, S> = new Endpoint({
+    ...extraOptions,
+    path,
+    schema,
+    name: getName('get'),
+  });
+  if (optimistic) {
+    (extraMutateOptions as any).getOptimisticResponse = optimisticUpdate;
+    (extraPartialOptions as any).getOptimisticResponse = optimisticPartial(get);
+  }
+  const getList = new Endpoint({
+    ...extraOptions,
+    path: shortenedPath,
+    schema: [schema],
+    name: getName('getList'),
+  });
+  return {
+    get,
+    getList,
+    create: new Endpoint({
+      ...extraMutateOptions,
+      path: shortenedPath,
+      schema,
+      method: 'POST',
+      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 as any).process ? new Delete(schema as any) : schema,
+      method: 'DELETE',
+      name: getName('delete'),
+      process(res, params) {
+        return res && Object.keys(res).length ? res : params;
+      },
+      getOptimisticResponse: optimistic ? (optimisticDelete as any) : undefined,
+    }),
+  } as any;
+}
+
+function optimisticUpdate(snap: SnapshotInterface, params: any, body: any) {
+  return {
+    ...params,
+    // even tho we don't always have two arguments, the extra one will simply be undefined which spreads fine
+    ...body,
+  };
+}
+function optimisticPartial(getEndpoint: NewGetEndpoint<any, any>) {
+  return function (snap: SnapshotInterface, params: any, body: any) {
+    const { data } = snap.getResponse(getEndpoint, params);
+    if (!data) throw new 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: SnapshotInterface, params: any) {
+  return params;
+}
+
+export interface Resource<U extends string, S extends Schema> {
+  /** Get a singular item
+   *
+   * @see https://resthooks.io/rest/api/createResource#get
+   */
+  get: NewGetEndpoint<{ path: U }, S>;
+  /** Get a list of item
+   *
+   * @see https://resthooks.io/rest/api/createResource#getlist
+   */
+  getList: NewGetEndpoint<
+    {
+      path: ShortenPath<U>;
+      searchParams: Record<string, number | string | boolean> | undefined;
+    },
+    S[]
+  >;
+  /** Create a new item (POST)
+   *
+   * @see https://resthooks.io/rest/api/createResource#create
+   */
+  create: NewMutateEndpoint<
+    { path: ShortenPath<U>; body: Partial<Denormalize<S>> },
+    S
+  >;
+  /** Update an item (PUT)
+   *
+   * @see https://resthooks.io/rest/api/createResource#update
+   */
+  update: NewMutateEndpoint<{ path: U; body: Partial<Denormalize<S>> }, S>;
+  /** Update an item (PATCH)
+   *
+   * @see https://resthooks.io/rest/api/createResource#partialupdate
+   */
+  partialUpdate: NewMutateEndpoint<
+    { path: U; body: Partial<Denormalize<S>> },
+    S
+  >;
+  /** Delete an item (DELETE)
+   *
+   * @see https://resthooks.io/rest/api/createResource#delete
+   */
+  delete: RestTypeNoBody<
+    PathArgs<U>,
+    S extends schema.EntityInterface & { process: any } ? schema.Delete<S> : S,
+    undefined,
+    Partial<PathArgs<U>>,
+    {
+      path: U;
+    }
+  >;
+}

package/src/extractCollection.ts

@@ -0,0 +1,34 @@
+import { Schema, schema } from '@data-client/endpoint';
+
+export default function extractCollection<
+  M extends <C extends schema.Collection>(collection: C) => any,
+  S extends Schema | undefined,
+>(s: S, mapper: M): ExtractCollection<S> | undefined {
+  if (typeof s !== 'object' || s === undefined || Array.isArray(s)) return;
+  if (s instanceof schema.Collection) {
+    return mapper(s as any);
+  }
+  const objCopy: Record<string, Schema> = {
+    ...(s instanceof schema.Object ? (s as any).schema : s),
+  };
+  for (const k in objCopy) {
+    if (!objCopy[k]) continue;
+    const collection = extractCollection(objCopy[k], mapper);
+    if (collection) return collection;
+  }
+}
+
+export type ExtractCollection<S extends Schema | undefined> =
+  S extends schema.CollectionInterface
+    ? S
+    : S extends schema.Object<infer T>
+    ? ExtractObject<T>
+    : S extends Exclude<Schema, { [K: string]: any }>
+    ? never
+    : S extends { [K: string]: Schema }
+    ? ExtractObject<S>
+    : never;
+
+export type ExtractObject<S extends Record<string, any>> = {
+  [K in keyof S]: S[K] extends Schema ? ExtractCollection<S[K]> : never;
+}[keyof S];