@data-client/core 0.1.0 → 0.2.1

package/src/manager/__tests__/subscriptionManager.ts

@@ -1,14 +1,10 @@
 import { Article, PollingArticleResource } from '__tests__/new';
 
 import { actionTypes, Controller, initialState } from '../..';
-import { legacyActions } from '../../types';
+import { SubscribeAction, UnsubscribeAction } from '../../types';
 import SubscriptionManager, { Subscription } from '../SubscriptionManager.js';
 
-type SubscribeAction = legacyActions.SubscribeAction;
-
-type UnsubscribeAction = legacyActions.UnsubscribeAction;
-
-const { UNSUBSCRIBE_TYPE, SUBSCRIBE_TYPE, RECEIVE_TYPE } = actionTypes;
+const { UNSUBSCRIBE_TYPE, SUBSCRIBE_TYPE, SET_TYPE } = actionTypes;
 
 function onError(e: any) {
   e.preventDefault();
@@ -60,11 +56,10 @@ describe('SubscriptionManager', () => {
         : () => Promise.resolve(payload);
       return {
         type: SUBSCRIBE_TYPE,
+        endpoint: PollingArticleResource.get,
         meta: {
-          schema: Article,
           key: PollingArticleResource.get.key({ id: payload.id }),
-          fetch,
-          options: { pollFrequency: 1000 },
+          args: [{ id: payload.id }],
         },
       };
     }
@@ -73,9 +68,10 @@ describe('SubscriptionManager', () => {
     ): UnsubscribeAction {
       return {
         type: UNSUBSCRIBE_TYPE,
+        endpoint: PollingArticleResource.get,
         meta: {
           key: PollingArticleResource.get.key({ id: payload.id }),
-          options: { pollFrequency: 1000 },
+          args: [{ id: payload.id }],
         },
       };
     }
@@ -100,7 +96,6 @@ describe('SubscriptionManager', () => {
     });
     it('subscribe should add a subscription (no frequency)', () => {
       const action = createSubscribeAction({ id: 597 });
-      delete action.meta.options;
       middleware(API)(next)(action);
 
       expect(next).not.toHaveBeenCalled();
@@ -153,7 +148,6 @@ describe('SubscriptionManager', () => {
       );
 
       const action = createUnsubscribeAction({ id: 50, title: 'four cakes' });
-      delete action.meta.options;
       (manager as any).subscriptions[action.meta.key].remove.mockImplementation(
         () => true,
       );
@@ -197,7 +191,7 @@ describe('SubscriptionManager', () => {
     });
 
     it('should let other actions pass through', () => {
-      const action = { type: RECEIVE_TYPE };
+      const action = { type: SET_TYPE };
       next.mockReset();
 
       middleware(API)(next)(action as any);

package/src/manager/applyManager.ts

@@ -8,6 +8,7 @@ export default function applyManager(
 ): Middleware[] {
   return managers.map(manager => {
     const middleware = manager.getMiddleware();
+    // TODO(breaking): remove this once controller prop is no longer supported
     return ({ dispatch, getState }) => {
       (controller as any).dispatch = dispatch;
       (controller as any).getState = getState;

package/src/middlewareTypes.ts

@@ -1,19 +1,14 @@
 import type Controller from './controller/Controller.js';
-//import type { ActionTypes as LegacyActionTypes } from './legacyActions.js';
-import type { ActionTypes } from './newActions.js';
-import {
-  ActionTypes as LegacyActionTypes,
-  CombinedActionTypes,
-  State,
-} from './types.js';
+import { ActionTypes, State } from './types.js';
 
 type RHDispatch<Actions = any> = (value: Actions) => Promise<void>;
 
 export interface MiddlewareAPI<R extends RestHooksReducer = RestHooksReducer>
-  extends Controller<RHDispatch<CombinedActionTypes>> {
-  controller: Controller<RHDispatch<CombinedActionTypes>>;
+  extends Controller<RHDispatch<ActionTypes>> {
+  /** @deprecated use members directly instead */
+  controller: Controller<RHDispatch<ActionTypes>>;
 }
-export interface MiddlewareController<Actions = LegacyActionTypes>
+export interface MiddlewareController<Actions = ActionTypes>
   extends Controller<RHDispatch<Actions>> {
   controller: Controller<RHDispatch<Actions>>;
 }

package/src/newActions.ts

@@ -17,41 +17,52 @@ import type {
 } from './actionTypes.js';
 import type { EndpointUpdateFunction } from './controller/types.js';
 
+type EndpointAndUpdate<E extends EndpointInterface> = EndpointInterface & {
+  update?: EndpointUpdateFunction<E>;
+};
+type EndpointDefault = EndpointInterface & {
+  update?: EndpointUpdateFunction<EndpointInterface>;
+};
+
 /* RECEIVE */
-export interface ReceiveMeta {
+export interface SetMeta {
   args: readonly any[];
+  key: string;
   fetchedAt: number;
   date: number;
   expiresAt: number;
 }
-export interface ReceiveActionSuccess<
-  E extends EndpointInterface = EndpointInterface,
+export interface SetActionSuccess<
+  E extends EndpointAndUpdate<E> = EndpointDefault,
 > {
   type: typeof SET_TYPE;
   endpoint: E;
-  meta: ReceiveMeta;
+  meta: SetMeta;
   payload: ResolveType<E>;
   error?: false;
 }
-export interface ReceiveActionError<
-  E extends EndpointInterface = EndpointInterface,
+export interface SetActionError<
+  E extends EndpointAndUpdate<E> = EndpointDefault,
 > {
   type: typeof SET_TYPE;
   endpoint: E;
-  meta: ReceiveMeta;
+  meta: SetMeta;
   payload: UnknownError;
   error: true;
 }
-export type ReceiveAction<E extends EndpointInterface = EndpointInterface> =
-  | ReceiveActionSuccess<E>
-  | ReceiveActionError<E>;
+export type SetAction<E extends EndpointAndUpdate<E> = EndpointDefault> =
+  | SetActionSuccess<E>
+  | SetActionError<E>;
 
-export type SetAction<E extends EndpointInterface = EndpointInterface> =
-  ReceiveAction<E>;
+// TODO(breaking): Remove - legacy name compatibility
+/** @deprecated use SetAction instead */
+export type ReceiveAction<E extends EndpointAndUpdate<E> = EndpointDefault> =
+  SetAction<E>;
 
 /* FETCH */
 export interface FetchMeta {
   args: readonly any[];
+  key: string;
   throttle: boolean;
   resolve: (value?: any | PromiseLike<any>) => void;
   reject: (reason?: any) => void;
@@ -61,7 +72,7 @@ export interface FetchMeta {
   nm?: boolean;
 }
 
-export interface FetchAction<E extends EndpointInterface = EndpointInterface> {
+export interface FetchAction<E extends EndpointAndUpdate<E> = EndpointDefault> {
   type: typeof FETCH_TYPE;
   endpoint: E;
   meta: FetchMeta;
@@ -70,36 +81,34 @@ export interface FetchAction<E extends EndpointInterface = EndpointInterface> {
 
 /* OPTIMISTIC */
 export interface OptimisticAction<
-  E extends EndpointInterface & {
-    update?: EndpointUpdateFunction<E>;
-  } = EndpointInterface & {
-    update?: EndpointUpdateFunction<EndpointInterface>;
-  },
+  E extends EndpointAndUpdate<E> = EndpointDefault,
 > {
   type: typeof OPTIMISTIC_TYPE;
   endpoint: E;
-  meta: ReceiveMeta;
-  error?: boolean;
+  meta: SetMeta;
+  error?: false;
 }
 
 /* SUBSCRIBE */
 export interface SubscribeAction<
-  E extends EndpointInterface = EndpointInterface,
+  E extends EndpointAndUpdate<E> = EndpointDefault,
 > {
   type: typeof SUBSCRIBE_TYPE;
   endpoint: E;
   meta: {
     args: readonly any[];
+    key: string;
   };
 }
 
 export interface UnsubscribeAction<
-  E extends EndpointInterface = EndpointInterface,
+  E extends EndpointAndUpdate<E> = EndpointDefault,
 > {
   type: typeof UNSUBSCRIBE_TYPE;
   endpoint: E;
   meta: {
     args: readonly any[];
+    key: string;
   };
 }
 
@@ -132,9 +141,10 @@ export interface GCAction {
 export type ActionTypes =
   | FetchAction
   | OptimisticAction
-  | ReceiveAction
+  | SetAction
   | SubscribeAction
   | UnsubscribeAction
   | InvalidateAction
+  | InvalidateAllAction
   | ResetAction
   | GCAction;

package/src/next/index.ts

@@ -1,2 +1,2 @@
-export { default as Controller } from './Controller.js';
-export * from './Controller.js';
+export { default as Controller } from '../controller/Controller.js';
+export * from '../controller/Controller.js';