@data-client/core 0.1.0

package/src/controller/__tests__/getResponse.ts

@@ -0,0 +1,182 @@
+import { Endpoint, Entity } from '@data-client/endpoint';
+
+import { ExpiryStatus } from '../..';
+import { initialState } from '../../state/reducer/createReducer';
+import Contoller from '../Controller';
+
+describe('Controller.getResponse()', () => {
+  it('denormalizes schema with extra members but not set', () => {
+    const controller = new Contoller();
+    class Tacos extends Entity {
+      type = '';
+      id = '';
+      pk() {
+        return this.id;
+      }
+    }
+    const ep = new Endpoint(() => Promise.resolve(), {
+      key() {
+        return 'mytest';
+      },
+      schema: {
+        data: [Tacos],
+        extra: '',
+        page: {
+          first: null,
+          second: undefined,
+          third: 0,
+          complex: { complex: true, next: false },
+        },
+      },
+    });
+    const entities = {
+      Tacos: {
+        1: { id: '1', type: 'foo' },
+        2: { id: '2', type: 'bar' },
+      },
+    };
+
+    const state = {
+      ...initialState,
+      entities,
+      results: {
+        [ep.key()]: {
+          data: ['1', '2'],
+        },
+      },
+    };
+    const { data, expiryStatus } = controller.getResponse(ep, state);
+    expect(expiryStatus).toBe(ExpiryStatus.Valid);
+    expect(data).toMatchSnapshot();
+  });
+
+  it('denormalizes distinct schemas for null arg', () => {
+    const controller = new Contoller();
+    class Tacos extends Entity {
+      type = '';
+      id = '';
+      pk() {
+        return this.id;
+      }
+    }
+    const ep = new Endpoint(() => Promise.resolve(), {
+      key() {
+        return 'mytest';
+      },
+      schema: {
+        data: [Tacos],
+        extra: '',
+        page: {
+          first: null,
+          second: undefined,
+          third: 0,
+          complex: { complex: true, next: false },
+        },
+      },
+    });
+    const entities = {
+      Tacos: {
+        1: { id: '1', type: 'foo' },
+        2: { id: '2', type: 'bar' },
+      },
+    };
+
+    const state = {
+      ...initialState,
+      entities,
+      results: {
+        [ep.key()]: {
+          data: ['1', '2'],
+        },
+      },
+    };
+    const { data, expiryStatus } = controller.getResponse(ep, null, state);
+    expect(expiryStatus).toBe(ExpiryStatus.Valid);
+    // null args means don't fill anything in
+    expect(data.data).toBeUndefined();
+    expect(data).toMatchInlineSnapshot(`
+      {
+        "data": undefined,
+        "extra": "",
+        "page": {
+          "complex": {
+            "complex": true,
+            "next": false,
+          },
+          "first": null,
+          "second": undefined,
+          "third": 0,
+        },
+      }
+    `);
+    expect(controller.getResponse(ep, null, state).data).toStrictEqual(data);
+
+    const ep2 = ep.extend({ schema: { data: Tacos, nextPage: { five: '5' } } });
+    const data2 = controller.getResponse(ep2, null, state).data;
+    expect(data2.data).toBeUndefined();
+    expect(data2).toMatchInlineSnapshot(`
+      {
+        "data": undefined,
+        "nextPage": {
+          "five": "5",
+        },
+      }
+    `);
+  });
+
+  it('infers schema with extra members but not set', () => {
+    const controller = new Contoller();
+    class Tacos extends Entity {
+      type = '';
+      id = '';
+      pk() {
+        return this.id;
+      }
+    }
+    const ep = new Endpoint(({ id }: { id: string }) => Promise.resolve(), {
+      key({ id }) {
+        return `mytest ${id}`;
+      },
+      schema: {
+        data: Tacos,
+        extra: '',
+        page: {
+          first: null,
+          second: '',
+          third: 0,
+          complex: { complex: true, next: false },
+        },
+      },
+    });
+    const entities = {
+      Tacos: {
+        1: { id: '1', type: 'foo' },
+        2: { id: '2', type: 'bar' },
+      },
+    };
+
+    const state = {
+      ...initialState,
+      entities,
+      entityMeta: {
+        Tacos: {
+          1: { date: 1000000, expiresAt: 1100000, fetchedAt: 1000000 },
+          2: { date: 2000000, expiresAt: 2100000, fetchedAt: 2000000 },
+        },
+      },
+    };
+    const { data, expiryStatus, expiresAt } = controller.getResponse(
+      ep,
+      { id: '1' },
+      state,
+    );
+    expect(expiryStatus).toBe(ExpiryStatus.Valid);
+    expect(data).toMatchSnapshot();
+    expect(expiresAt).toBe(1100000);
+    // test caching
+    const second = controller.getResponse(ep, { id: '1' }, state);
+    expect(second.data.data).toBe(data.data);
+    expect(second.expiryStatus).toBe(expiryStatus);
+    expect(second.expiresAt).toBe(expiresAt);
+  });
+});

package/src/controller/createFetch.ts

@@ -0,0 +1,54 @@
+import type { EndpointInterface } from '@data-client/normalizr';
+
+import { EndpointUpdateFunction } from './types.js';
+import { FETCH_TYPE } from '../actionTypes.js';
+import type {
+  CompatibleFetchAction,
+  CompatibleFetchMeta,
+} from '../compatibleActions.js';
+
+/**
+ * Requesting a fetch to begin
+ */
+export default function createFetch<
+  E extends EndpointInterface & { update?: EndpointUpdateFunction<E> },
+>(
+  endpoint: E,
+  { args }: { args: readonly [...Parameters<E>] },
+): CompatibleFetchAction<E> {
+  const key = endpoint.key(...args);
+  let resolve: (value?: any | PromiseLike<any>) => void = 0 as any;
+  let reject: (reason?: any) => void = 0 as any;
+  const promise = new Promise<any>((a, b) => {
+    [resolve, reject] = [a, b];
+  });
+  const meta: CompatibleFetchMeta = {
+    schema: endpoint.schema,
+    type: endpoint.sideEffect ? ('mutate' as const) : ('read' as const),
+    args,
+    key,
+    throttle: !endpoint.sideEffect,
+    options: endpoint,
+    resolve,
+    reject,
+    promise,
+    createdAt: Date.now(),
+  };
+
+  if (endpoint.update) {
+    meta.update = endpoint.update;
+  }
+
+  // TODO: Remove once EOL on this deprecated piece
+  /* istanbul ignore if */
+  if (endpoint.optimisticUpdate) {
+    meta.optimisticResponse = endpoint.optimisticUpdate(...args);
+  }
+
+  return {
+    type: FETCH_TYPE,
+    payload: () => endpoint(...args) as any,
+    meta,
+    endpoint,
+  };
+}

package/src/controller/createInvalidate.ts

@@ -0,0 +1,16 @@
+import type { EndpointInterface } from '@data-client/normalizr';
+
+import { INVALIDATE_TYPE } from '../actionTypes.js';
+import type { InvalidateAction } from '../newActions.js';
+
+export default function createInvalidate<E extends EndpointInterface>(
+  endpoint: E,
+  { args }: { args: readonly [...Parameters<E>] },
+): InvalidateAction {
+  return {
+    type: INVALIDATE_TYPE,
+    meta: {
+      key: endpoint.key(...args),
+    },
+  };
+}

package/src/controller/createInvalidateAll.ts

@@ -0,0 +1,11 @@
+import { INVALIDATEALL_TYPE } from '../actionTypes.js';
+import type { InvalidateAllAction } from '../newActions.js';
+
+export default function createInvalidateAll(
+  testKey: (key: string) => boolean,
+): InvalidateAllAction {
+  return {
+    type: INVALIDATEALL_TYPE,
+    testKey,
+  };
+}

package/src/controller/createOptimistic.ts

@@ -0,0 +1,47 @@
+import type { EndpointInterface } from '@data-client/normalizr';
+
+import { EndpointUpdateFunction } from './types.js';
+import { OPTIMISTIC_TYPE } from '../actionTypes.js';
+import { OptimisticAction } from '../newActions.js';
+
+export default function createOptimistic<
+  E extends EndpointInterface & {
+    update?: EndpointUpdateFunction<E>;
+  },
+>(
+  endpoint: E,
+  {
+    args,
+    fetchedAt,
+  }: {
+    args: readonly [...Parameters<E>];
+    fetchedAt: number;
+  },
+): OptimisticAction<E> {
+  const expiryLength: number = endpoint.dataExpiryLength ?? 60000;
+  /* istanbul ignore next */
+  if (process.env.NODE_ENV === 'development' && expiryLength < 0) {
+    throw new Error('Negative expiry length are not allowed.');
+  }
+  const now = Date.now();
+  // TODO: Use correct type once we no longer need backcompat
+  const meta: any = {
+    args,
+    fetchedAt,
+    date: now,
+    expiresAt: now + expiryLength,
+    // For legacy support; TODO: remove
+    schema: endpoint.schema,
+    key: endpoint.key(...args),
+  };
+  // For legacy support; TODO: remove
+  if (endpoint.update) meta.update = endpoint.update;
+  if (endpoint.errorPolicy) meta.errorPolicy = endpoint.errorPolicy;
+
+  const action: OptimisticAction<E> = {
+    type: OPTIMISTIC_TYPE,
+    endpoint,
+    meta,
+  };
+  return action;
+}

package/src/controller/createReceive.ts

@@ -0,0 +1,85 @@
+import type { EndpointInterface, ResolveType } from '@data-client/normalizr';
+
+import { EndpointUpdateFunction } from './types.js';
+import { SET_TYPE } from '../actionTypes.js';
+import type {
+  CompatibleReceiveAction,
+  CompatibleReceiveMeta,
+} from '../compatibleActions.js';
+
+export default function createReceive<
+  E extends EndpointInterface & {
+    update?: EndpointUpdateFunction<E>;
+  },
+>(
+  endpoint: E,
+  options: {
+    args: readonly [...Parameters<E>];
+    response: Error;
+    fetchedAt?: number;
+    error: true;
+  },
+): CompatibleReceiveAction<E>;
+
+export default function createReceive<
+  E extends EndpointInterface & {
+    update?: EndpointUpdateFunction<E>;
+  },
+>(
+  endpoint: E,
+  options: {
+    args: readonly [...Parameters<E>];
+    response: ResolveType<E>;
+    fetchedAt?: number;
+    error?: false;
+  },
+): CompatibleReceiveAction<E>;
+
+export default function createReceive<
+  E extends EndpointInterface & {
+    update?: EndpointUpdateFunction<E>;
+  },
+>(
+  endpoint: E,
+  {
+    args,
+    fetchedAt,
+    response,
+    error = false,
+  }: {
+    args: readonly [...Parameters<E>];
+    response: any;
+    fetchedAt?: number;
+    error?: boolean;
+  },
+): CompatibleReceiveAction<E> {
+  const expiryLength: number = error
+    ? endpoint.errorExpiryLength ?? 1000
+    : endpoint.dataExpiryLength ?? 60000;
+  /* istanbul ignore next */
+  if (process.env.NODE_ENV === 'development' && expiryLength < 0) {
+    throw new Error('Negative expiry length are not allowed.');
+  }
+  const now = Date.now();
+  const meta: CompatibleReceiveMeta = {
+    args,
+    fetchedAt: fetchedAt ?? now,
+    date: now,
+    expiresAt: now + expiryLength,
+    // For legacy support; TODO: remove
+    schema: endpoint.schema,
+    key: endpoint.key(...args),
+  };
+  // For legacy support; TODO: remove
+  if (endpoint.update) meta.update = endpoint.update;
+  if (endpoint.errorPolicy) meta.errorPolicy = endpoint.errorPolicy;
+
+  const action: CompatibleReceiveAction<E> = {
+    type: SET_TYPE,
+    payload: response,
+    endpoint: endpoint,
+    meta,
+  };
+  if (error) (action as any).error = true;
+  return action;
+}

package/src/controller/createReset.ts

@@ -0,0 +1,9 @@
+import { RESET_TYPE } from '../actionTypes.js';
+import type { ResetAction } from '../newActions.js';
+
+export default function createReset(): ResetAction {
+  return {
+    type: RESET_TYPE,
+    date: Date.now(),
+  };
+}

package/src/controller/createSubscription.ts

@@ -0,0 +1,39 @@
+import type { EndpointInterface } from '@data-client/normalizr';
+
+import { SUBSCRIBE_TYPE, UNSUBSCRIBE_TYPE } from '../actionTypes.js';
+import type {
+  CompatibleSubscribeAction,
+  CompatibleUnsubscribeAction,
+} from '../compatibleActions.js';
+
+export function createSubscription<E extends EndpointInterface>(
+  endpoint: E,
+  { args }: { args: readonly [...Parameters<E>] },
+): CompatibleSubscribeAction<E> {
+  return {
+    type: SUBSCRIBE_TYPE,
+    endpoint,
+    meta: {
+      args,
+      key: endpoint.key(...args),
+      fetch: () => endpoint(...args),
+      schema: endpoint.schema,
+      options: endpoint,
+    },
+  };
+}
+
+export function createUnsubscription<E extends EndpointInterface>(
+  endpoint: E,
+  { args }: { args: readonly [...Parameters<E>] },
+): CompatibleUnsubscribeAction<E> {
+  return {
+    type: UNSUBSCRIBE_TYPE,
+    endpoint,
+    meta: {
+      args,
+      key: endpoint.key(...args),
+      options: endpoint,
+    },
+  };
+}

package/src/controller/types.ts

@@ -0,0 +1,22 @@
+import type {
+  Normalize,
+  EndpointInterface,
+  ResolveType,
+} from '@data-client/normalizr';
+
+export type ResultEntry<E extends EndpointInterface> = E['schema'] extends
+  | undefined
+  | null
+  ? ResolveType<E>
+  : Normalize<E['schema']>;
+
+export type EndpointUpdateFunction<
+  Source extends EndpointInterface,
+  Updaters extends Record<string, any> = Record<string, any>,
+> = (
+  source: ResultEntry<Source>,
+  // this is hopeless because typescript doesn't think it should be contravariant
+  ...args: any
+) => {
+  [K in keyof Updaters]: (result: Updaters[K]) => Updaters[K];
+};

package/src/endpoint/index.ts

@@ -0,0 +1,14 @@
+export type {
+  FetchShape,
+  ReadShape,
+  MutateShape,
+  DeleteShape,
+} from './shapes.js';
+export type {
+  SetShapeParams,
+  ParamsFromShape,
+  OptimisticUpdateParams,
+  SchemaFromShape,
+  BodyFromShape,
+  ReturnFromShape,
+} from './types.js';

package/src/endpoint/shapes.ts

@@ -0,0 +1,53 @@
+import {
+  Schema,
+  EndpointExtraOptions as FetchOptions,
+} from '@data-client/normalizr';
+
+/** Defines the shape of a network request */
+export interface FetchShape<
+  S extends Schema | undefined,
+  Params extends Readonly<object> = Readonly<object>,
+  Body extends Readonly<object | string> | void | unknown =
+    | Readonly<object | string>
+    | undefined,
+  Response = any,
+> {
+  readonly type: 'read' | 'mutate' | 'delete';
+  fetch(params: Params, body?: Body): Promise<Response>;
+  getFetchKey(params: Params): string;
+  readonly schema: S;
+  readonly options?: FetchOptions;
+}
+
+/** To change values on the server */
+export interface MutateShape<
+  S extends Schema | undefined,
+  Params extends Readonly<object> = Readonly<object>,
+  Body extends Readonly<object | string> | void | unknown =
+    | Readonly<object | string>
+    | undefined,
+  Response extends object | string | number | boolean | null = any,
+> extends FetchShape<S, Params, Body, Response> {
+  readonly type: 'mutate';
+  fetch(params: Params, body: Body): Promise<Response>;
+}
+
+/** Removes entities */
+export interface DeleteShape<
+  S extends Schema | undefined,
+  Params extends Readonly<object> = Readonly<object>,
+  Response extends object | string | number | boolean | null = any,
+> extends FetchShape<S, Params, undefined, Response> {
+  readonly type: 'mutate';
+  fetch(params: Params, ...args: any): Promise<Response>;
+}
+
+/** For retrieval requests */
+export interface ReadShape<
+  S extends Schema | undefined,
+  Params extends Readonly<object> = Readonly<object>,
+  Response extends object | string | number | boolean | null = any,
+> extends FetchShape<S, Params, undefined, Response> {
+  readonly type: 'read';
+  fetch(params: Params): Promise<Response>;
+}

package/src/endpoint/types.ts

@@ -0,0 +1,72 @@
+import { Schema } from '@data-client/normalizr';
+import type { Denormalize } from '@data-client/normalizr';
+
+import { FetchShape } from './shapes.js';
+import { UpdateFunction } from '../types.js';
+
+export type ResultShape<RS> = RS extends { schema: infer U } ? U : never;
+export type SelectReturn<RS> = RS extends {
+  select: (...args: any[]) => infer U;
+}
+  ? U
+  : never;
+export type AlwaysSelect<RS> = NonNullable<SelectReturn<RS>>;
+export type ParamArg<RS> = RS extends {
+  getFetchKey: (params: infer U) => any;
+}
+  ? U
+  : never;
+export type BodyArg<RS> = RS extends {
+  fetch: (url: any, body: infer U) => any;
+}
+  ? U
+  : never;
+
+/** Sets a FetchShape's Param type.
+ * Useful to constrain acceptable params (second arg) in hooks like useResource().
+ *
+ * @param [Shape] FetchShape to act upon
+ * @param [Params] what to set the Params to
+ */
+export type SetShapeParams<
+  Shape extends FetchShape<any, any, any>,
+  Params extends Readonly<object>,
+> = {
+  [K in keyof Shape]: Shape[K];
+} & (Shape['fetch'] extends (first: any, ...rest: infer Args) => infer Return
+  ? { fetch: (first: Params, ...rest: Args) => Return }
+  : never);
+
+/** Get the Params type for a given Shape */
+export type ParamsFromShape<S> = S extends {
+  fetch: (first: infer A, ...rest: any) => any;
+}
+  ? A
+  : S extends { getFetchKey: (first: infer A, ...rest: any) => any }
+  ? A
+  : never;
+
+/** Get the Schema type for a given Shape */
+export type SchemaFromShape<
+  F extends FetchShape<Schema | undefined, any, any>,
+> = F['schema'];
+
+/** Get the Body type for a given Shape */
+export type BodyFromShape<F extends FetchShape<any, any, any>> = Parameters<
+  F['fetch']
+>[1];
+
+export type OptimisticUpdateParams<
+  SourceSchema extends Schema | undefined,
+  DestShape extends FetchShape<any, any, any>,
+> = [
+  DestShape,
+  ParamsFromShape<DestShape>,
+  UpdateFunction<SourceSchema, SchemaFromShape<DestShape>>,
+];
+
+export type ReturnFromShape<S extends FetchShape<any, any, any>> = ReturnType<
+  S['fetch']
+> extends unknown
+  ? Promise<Denormalize<S['schema']>>
+  : ReturnType<S['fetch']>;