feat: Add Resource+Entity to legacy (#924)

Author: ntucker

__tests__/legacy.ts

@@ -1,4 +1,4 @@
-import { MutateShape, Resource, schemas } from 'rest-hooks';
+import { MutateShape, Resource, Delete } from '@rest-hooks/legacy';
 
 export class UserResource extends Resource {
   readonly id: number | undefined = undefined;
@@ -66,7 +66,7 @@ export class CoolerArticleResource extends ArticleResource {
 
   static deleteShape<T extends typeof Resource>(
     this: T,
-  ): MutateShape<schemas.Delete<T>, Readonly<object>, unknown> {
+  ): MutateShape<Delete<T>, Readonly<object>, unknown> {
     return super.deleteShape() as any;
   }
 }

jest.config.js

@@ -8,6 +8,7 @@ const baseConfig = {
     'react-integration/hooks/useSelection',
     'packages/test',
     'packages/experimental',
+    'packages/legacy/src/resource',
   ],
   testURL: 'http://localhost',
 };

packages/legacy/src/__tests__/useStatefulResource.tsx

@@ -7,7 +7,7 @@ import { makeRenderRestHook, makeCacheProvider } from '@rest-hooks/test';
 import nock from 'nock';
 
 import { payload, payload2, users, nested } from './fixtures';
-import { useStatefulResource } from '..';
+import useStatefulResource from '../useStatefulResource';
 
 function onError(e: any) {
   e.preventDefault();

packages/legacy/src/index.ts

@@ -1,85 +1,10 @@
-import {
-  useRetrieve,
-  useError,
-  Schema,
-  useDenormalized,
-  StateContext,
-  hasUsableData,
-  useMeta,
-  ParamsFromShape,
+export * from './resource';
+export { default as useStatefulResource } from './useStatefulResource';
+export type {
+  FetchShape,
   ReadShape,
-  __INTERNAL__,
-} from '@rest-hooks/core';
-import type {
-  Denormalize,
-  DenormalizeNullable,
-  ErrorTypes,
+  MutateShape,
+  DeleteShape,
+  SetShapeParams,
+  ParamsFromShape,
 } from '@rest-hooks/core';
-import { denormalize } from '@rest-hooks/normalizr';
-import { useContext } from 'react';
-
-const { inferResults } = __INTERNAL__;
-
-type CondNull<P, A, B> = P extends null ? A : B;
-
-type StatefulReturn<S extends Schema, P> = CondNull<
-  P,
-  {
-    data: DenormalizeNullable<S>;
-    loading: false;
-    error: undefined;
-  },
-  | {
-      data: Denormalize<S>;
-      loading: false;
-      error: undefined;
-    }
-  | { data: DenormalizeNullable<S>; loading: true; error: undefined }
-  | { data: DenormalizeNullable<S>; loading: false; error: ErrorTypes }
->;
-
-/** Ensure a resource is available; loading and error returned explicitly. */
-export function useStatefulResource<
-  Shape extends ReadShape<any, any>,
-  Params extends ParamsFromShape<Shape> | null,
->(fetchShape: Shape, params: Params): StatefulReturn<Shape['schema'], Params> {
-  const state = useContext(StateContext);
-  const [denormalized, ready, deleted, entitiesExpireAt] = useDenormalized(
-    fetchShape,
-    params,
-    state,
-  );
-  const error = useError(fetchShape, params, ready);
-
-  const maybePromise: Promise<any> | undefined = useRetrieve(
-    fetchShape,
-    params,
-    deleted && !error,
-    entitiesExpireAt,
-  );
-
-  if (maybePromise) {
-    maybePromise.catch(() => {});
-  }
-
-  const loading =
-    !hasUsableData(
-      fetchShape,
-      ready,
-      deleted,
-      useMeta(fetchShape, params)?.invalidated,
-    ) && !!maybePromise;
-  const data = loading
-    ? denormalize(
-        inferResults(fetchShape.schema, [params], state.indexes),
-        fetchShape.schema,
-        {},
-      )[0]
-    : denormalized;
-
-  return {
-    data,
-    loading,
-    error,
-  } as any;
-}

packages/legacy/src/resource/Delete.ts

@@ -0,0 +1,85 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+import { schema, AbstractInstanceType, DELETED } from '@rest-hooks/normalizr';
+
+export default class Delete<E extends schema.EntityInterface & { fromJS: any }>
+  implements schema.SchemaClass
+{
+  private declare _entity: E;
+
+  constructor(entity: E) {
+    if (process.env.NODE_ENV !== 'production' && !entity) {
+      throw new Error('Expected option "entity" not found on DeleteSchema.');
+    }
+    this._entity = entity;
+  }
+
+  get key() {
+    return this._entity.key;
+  }
+
+  normalize(
+    input: any,
+    parent: any,
+    key: string | undefined,
+    visit: (...args: any) => any,
+    addEntity: (...args: any) => any,
+    visitedEntities: Record<string, any>,
+  ): string | undefined {
+    // pass over already processed entities
+    if (typeof input === 'string') return input;
+    // TODO: what's store needs to be a differing type from fromJS
+    const processedEntity = this._entity.fromJS(input, parent, key);
+    const id = processedEntity.pk(parent, key);
+    if (
+      process.env.NODE_ENV !== 'production' &&
+      (id === undefined || id === '')
+    ) {
+      const error = new Error(
+        `Missing usable primary key when normalizing response.
+
+  This is likely due to a malformed response.
+  Try inspecting the network response or fetch() return value.
+  Or use debugging tools: https://resthooks.io/docs/guides/debugging
+  Learn more about schemas: https://resthooks.io/docs/api/schema
+
+  Delete(Entity): Delete(${(this._entity as any).name ?? this._entity})
+  Value: ${input && JSON.stringify(input, null, 2)}
+  `,
+      );
+      (error as any).status = 400;
+      throw error;
+    }
+    addEntity(this, DELETED, id);
+    return id;
+  }
+
+  infer(args: any, indexes: any, recurse: any): any {
+    return undefined;
+  }
+
+  denormalize(
+    id: string,
+    unvisit: schema.UnvisitFunction,
+  ): [AbstractInstanceType<E>, boolean, boolean] {
+    return unvisit(id, this._entity) as any;
+  }
+
+  /* istanbul ignore next */
+  _denormalizeNullable(): [
+    AbstractInstanceType<E> | undefined,
+    boolean,
+    false,
+  ] {
+    return [] as any;
+  }
+
+  /* istanbul ignore next */
+  _normalizeNullable(): string | undefined {
+    return [] as any;
+  }
+
+  /* istanbul ignore next */
+  merge(existing: any, incoming: any) {
+    return incoming;
+  }
+}