@data-client/core 0.15.0-beta-20251022142546-a457d1596871fb28f1a91f2531cc259db4d55a9c → 0.15.0

package/src/mock/MockController.ts

@@ -0,0 +1,146 @@
+import {
+  actionTypes,
+  Controller,
+  DataClientDispatch,
+  GenericDispatch,
+} from '../index.js';
+import { collapseFixture } from './collapseFixture.js';
+import { createFixtureMap } from './createFixtureMap.js';
+import type { Fixture, Interceptor } from './fixtureTypes.js';
+import { MockProps } from './mockTypes.js';
+
+export function MockController<TBase extends typeof Controller, T>(
+  Base: TBase,
+  {
+    fixtures = [],
+    getInitialInterceptorData = () => ({}) as any,
+  }: MockProps<T>,
+): TBase {
+  const [fixtureMap, interceptors] = createFixtureMap(fixtures);
+
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  return class MockedController<
+    D extends GenericDispatch = DataClientDispatch,
+  > extends Base<D> {
+    // legacy compatibility (re-declaration)
+    // TODO: drop when drop support for destructuring (0.14 and below)
+    declare protected _dispatch: D;
+
+    fixtureMap: Map<string, Fixture> = fixtureMap;
+    interceptors: Interceptor<any>[] = interceptors;
+    interceptorData: T = getInitialInterceptorData();
+
+    constructor(...args: any[]) {
+      super(...args);
+
+      // legacy compatibility
+      // TODO: drop when drop support for destructuring (0.14 and below)
+      if (!this._dispatch) {
+        this._dispatch = (args[0] as any).dispatch;
+      }
+    }
+
+    // legacy compatibility - we need this to work with 0.14 and below as they do not have this setter
+    // TODO: drop when drop support for destructuring (0.14 and below)
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    set dispatch(dispatch: D) {
+      this._dispatch = dispatch;
+    }
+
+    get dispatch(): D {
+      return ((action: Parameters<D>[0]): Promise<void> => {
+        // support legacy that has _TYPE suffix
+        if (action.type === (actionTypes.FETCH ?? actionTypes.FETCH_TYPE)) {
+          // eslint-disable-next-line prefer-const
+          let { key, args } = action;
+          let fixture: Fixture | Interceptor | undefined;
+          if (this.fixtureMap.has(key)) {
+            fixture = this.fixtureMap.get(key) as Fixture;
+            if (!args) args = fixture.args;
+            // exact matches take priority; now test ComputedFixture
+          } else {
+            for (const cfix of this.interceptors) {
+              if (cfix.endpoint.testKey(key)) {
+                fixture = cfix;
+                break;
+              }
+            }
+          }
+          // we have a match
+          if (fixture !== undefined) {
+            const replacedAction: typeof action = {
+              ...action,
+            };
+            const delayMs =
+              typeof fixture.delay === 'function' ?
+                fixture.delay(...(args as any))
+              : (fixture.delay ?? 0);
+
+            if ('fetchResponse' in fixture) {
+              const { fetchResponse } = fixture;
+              fixture = {
+                endpoint: fixture.endpoint,
+                response(...args) {
+                  const endpoint = (action.endpoint as any).extend({
+                    fetchResponse: (input: RequestInfo, init: RequestInit) => {
+                      const ret = fetchResponse.call(this, input, init);
+                      return Promise.resolve(
+                        new Response(JSON.stringify(ret), {
+                          status: 200,
+                          headers: new Headers({
+                            'Content-Type': 'application/json',
+                          }),
+                        }),
+                      );
+                    },
+                  });
+                  return (endpoint as any)(...args);
+                },
+              };
+            }
+            const fetch = async () => {
+              if (!fixture) {
+                throw new Error('No fixture found');
+              }
+              // delayCollapse determines when the fixture function is 'collapsed' (aka 'run')
+              // collapsed: https://en.wikipedia.org/wiki/Copenhagen_interpretation
+              if (fixture.delayCollapse) {
+                await new Promise(resolve => setTimeout(resolve, delayMs));
+              }
+              const result = await collapseFixture(
+                fixture as any,
+                args as any,
+                this.interceptorData,
+              );
+              if (!fixture.delayCollapse && delayMs) {
+                await new Promise(resolve => setTimeout(resolve, delayMs));
+              }
+              if (result.error) {
+                throw result.response;
+              }
+              return result.response;
+            };
+            if (typeof (replacedAction.endpoint as any).extend === 'function') {
+              replacedAction.endpoint = (replacedAction.endpoint as any).extend(
+                {
+                  fetch,
+                },
+              );
+            } else {
+              // TODO: full testing of this
+              replacedAction.endpoint = fetch as any;
+              (replacedAction.endpoint as any).__proto__ = action.endpoint;
+            }
+
+            // TODO: make super.dispatch (once we drop support for destructuring)
+            return this._dispatch(replacedAction);
+          }
+        }
+        // TODO: make super.dispatch (once we drop support for destructuring)
+        return this._dispatch(action);
+      }) as any;
+    }
+  };
+}

package/src/mock/collapseFixture.ts

@@ -0,0 +1,21 @@
+import type { Fixture, ResponseInterceptor } from './fixtureTypes.js';
+
+export async function collapseFixture(
+  fixture: Fixture | ResponseInterceptor,
+  args: any[],
+  interceptorData: any,
+) {
+  let error = 'error' in fixture ? fixture.error : false;
+  let response = fixture.response;
+  if (typeof fixture.response === 'function') {
+    try {
+      response = await fixture.response.apply(interceptorData, args);
+      // dispatch goes through user-code that can sometimes fail.
+      // let's ensure we always handle errors
+    } catch (e: any) {
+      response = e;
+      error = true;
+    }
+  }
+  return { response, error };
+}

package/src/mock/createFixtureMap.ts

@@ -0,0 +1,26 @@
+import type { Fixture, Interceptor } from './fixtureTypes.js';
+
+export function createFixtureMap(fixtures: (Fixture | Interceptor)[] = []) {
+  const map: Map<string, Fixture> = new Map();
+  const computed: Interceptor[] = [];
+  for (const fixture of fixtures) {
+    if ('args' in fixture) {
+      if (typeof fixture.response !== 'function') {
+        const key = fixture.endpoint.key(...fixture.args);
+        map.set(key, fixture);
+      } else {
+        // this has to be a typo. probably needs to remove args
+        console.warn(
+          `Fixture found with function response, and explicit args. Interceptors should not specify args.
+${fixture.endpoint.name}: ${JSON.stringify(fixture.args)}
+
+Treating as Interceptor`,
+        );
+        computed.push(fixture as any);
+      }
+    } else {
+      computed.push(fixture);
+    }
+  }
+  return [map, computed] as const;
+}

package/src/mock/fixtureTypes.ts

@@ -0,0 +1,121 @@
+import type { EndpointInterface, ResolveType } from '@data-client/endpoint';
+
+type Updater = (
+  result: any,
+  ...args: any
+) => Record<string, (...args: any) => any>;
+
+export interface SuccessFixtureEndpoint<
+  E extends EndpointInterface & { update?: Updater } = EndpointInterface,
+> {
+  readonly endpoint: E;
+  readonly args: Parameters<E>;
+  readonly response:
+    | ResolveType<E>
+    | ((...args: Parameters<E>) => ResolveType<E>);
+  readonly error?: false;
+  /** Number of miliseconds to wait before resolving */
+  readonly delay?: number;
+  /** Waits to run `response()` after `delay` time */
+  readonly delayCollapse?: boolean;
+}
+
+export interface ResponseInterceptor<
+  T = any,
+  E extends EndpointInterface & {
+    update?: Updater;
+    testKey(key: string): boolean;
+  } = EndpointInterface & { testKey(key: string): boolean },
+> {
+  readonly endpoint: E;
+  response(this: T, ...args: Parameters<E>): ResolveType<E>;
+  /** Number of miliseconds (or function that returns) to wait before resolving */
+  readonly delay?: number | ((...args: Parameters<E>) => number);
+  /** Waits to run `response()` after `delay` time */
+  readonly delayCollapse?: boolean;
+}
+export interface FetchInterceptor<
+  T = any,
+  E extends EndpointInterface & {
+    update?: Updater;
+    testKey(key: string): boolean;
+    fetchResponse(input: RequestInfo, init: RequestInit): Promise<Response>;
+    extend(options: any): any;
+  } = EndpointInterface & {
+    testKey(key: string): boolean;
+    fetchResponse(input: RequestInfo, init: RequestInit): Promise<Response>;
+    extend(options: any): any;
+  },
+> {
+  readonly endpoint: E;
+  fetchResponse(this: T, input: RequestInfo, init: RequestInit): ResolveType<E>;
+  /** Number of miliseconds (or function that returns) to wait before resolving */
+  readonly delay?: number | ((...args: Parameters<E>) => number);
+  /** Waits to run `response()` after `delay` time */
+  readonly delayCollapse?: boolean;
+}
+/** Interceptors match and compute dynamic responses based on args
+ *
+ * @see https://dataclient.io/docs/api/Fixtures#interceptor
+ */
+export type Interceptor<
+  T = any,
+  E extends EndpointInterface & {
+    update?: Updater;
+    testKey(key: string): boolean;
+    fetchResponse?(input: RequestInfo, init: RequestInit): Promise<Response>;
+    extend?(options: any): any;
+  } = EndpointInterface & {
+    testKey(key: string): boolean;
+    fetchResponse(input: RequestInfo, init: RequestInit): Promise<Response>;
+    extend(options: any): any;
+  },
+> =
+  | ResponseInterceptor<T, E>
+  | (E extends (
+      {
+        fetchResponse(input: RequestInfo, init: RequestInit): Promise<Response>;
+        extend(options: any): any;
+      }
+    ) ?
+      FetchInterceptor<T, E>
+    : never);
+
+export interface ErrorFixtureEndpoint<
+  E extends EndpointInterface & { update?: Updater } = EndpointInterface,
+> {
+  readonly endpoint: E;
+  readonly args: Parameters<E>;
+  readonly response: any;
+  readonly error: true;
+  /** Number of miliseconds to wait before resolving */
+  readonly delay?: number;
+  /** Waits to run `response()` after `delay` time */
+  readonly delayCollapse?: boolean;
+}
+
+export type FixtureEndpoint<
+  E extends EndpointInterface & { update?: Updater } = EndpointInterface,
+> = SuccessFixtureEndpoint<E> | ErrorFixtureEndpoint<E>;
+
+/** Represents a successful response
+ *
+ * @see https://dataclient.io/docs/api/Fixtures#successfixture
+ */
+export type SuccessFixture<
+  E extends EndpointInterface & { update?: Updater } = EndpointInterface,
+> = SuccessFixtureEndpoint<E>;
+/** Represents a failed/errored response
+ *
+ * @see https://dataclient.io/docs/api/Fixtures#errorfixtures
+ */
+export type ErrorFixture<
+  E extends EndpointInterface & { update?: Updater } = EndpointInterface,
+> = ErrorFixtureEndpoint<E>;
+/** Represents a static response
+ *
+ * @see https://dataclient.io/docs/api/Fixtures
+ */
+export type Fixture<
+  E extends EndpointInterface & { update?: Updater } = EndpointInterface,
+> = FixtureEndpoint<E>;

package/src/mock/index.ts

@@ -0,0 +1,16 @@
+export { MockController } from './MockController.js';
+export type { MockProps } from './mockTypes.js';
+export type {
+  Fixture,
+  SuccessFixture,
+  ErrorFixture,
+  Interceptor,
+  ResponseInterceptor,
+  FetchInterceptor,
+  FixtureEndpoint,
+  SuccessFixtureEndpoint,
+  ErrorFixtureEndpoint,
+} from './fixtureTypes.js';
+export { collapseFixture } from './collapseFixture.js';
+export { createFixtureMap } from './createFixtureMap.js';
+export { default as mockInitialState } from './mockState.js';

package/src/mock/mockState.ts

@@ -0,0 +1,56 @@
+import {
+  SetAction,
+  State,
+  ActionTypes,
+  Controller,
+  createReducer,
+  __INTERNAL__,
+} from '../index.js';
+import type { Fixture } from './fixtureTypes.js';
+
+const { initialState } = __INTERNAL__;
+
+export default function mockInitialState(
+  fixtures: Fixture[] = [],
+): State<unknown> {
+  const actions: SetAction[] = [];
+  const dispatch = (action: any) => {
+    actions.push(action);
+    return Promise.resolve();
+  };
+  const controller = new Controller({ dispatch });
+  const reducer: (
+    state: State<unknown> | undefined,
+    action: ActionTypes,
+  ) => State<unknown> = createReducer(controller);
+
+  fixtures.forEach(fixture => {
+    dispatchFixture(fixture, fixture.args, controller);
+  });
+  return actions.reduce(reducer, initialState);
+}
+
+function dispatchFixture(
+  fixture: Fixture,
+  args: any[],
+  controller: Controller,
+  fetchedAt?: number,
+) {
+  // eslint-disable-next-line prefer-const
+  let { endpoint } = fixture;
+  const { response, error } = fixture;
+  if (controller.resolve) {
+    controller.resolve(endpoint, {
+      args,
+      response,
+      error,
+      fetchedAt: fetchedAt ?? Date.now(),
+    });
+  } else {
+    if (error === true) {
+      controller.setError(endpoint, ...args, response);
+    } else {
+      controller.setResponse(endpoint, ...args, response);
+    }
+  }
+}

package/src/mock/mockTypes.ts

@@ -0,0 +1,6 @@
+import type { Fixture, Interceptor } from './fixtureTypes.js';
+
+export interface MockProps<T = any> {
+  readonly fixtures?: (Fixture | Interceptor<T>)[];
+  getInitialInterceptorData?: () => T;
+}

package/ts3.4/mock/MockController.d.ts

@@ -0,0 +1,4 @@
+import { Controller } from '../index.js';
+import { MockProps } from './mockTypes.js';
+export declare function MockController<TBase extends typeof Controller, T>(Base: TBase, { fixtures, getInitialInterceptorData, }: MockProps<T>): TBase;
+//# sourceMappingURL=MockController.d.ts.map

package/ts3.4/mock/collapseFixture.d.ts

@@ -0,0 +1,6 @@
+import { Fixture, ResponseInterceptor } from './fixtureTypes.js';
+export declare function collapseFixture(fixture: Fixture | ResponseInterceptor, args: any[], interceptorData: any): Promise<{
+    response: any;
+    error: boolean | undefined;
+}>;
+//# sourceMappingURL=collapseFixture.d.ts.map

package/ts3.4/mock/createFixtureMap.d.ts

@@ -0,0 +1,6 @@
+import { Fixture, Interceptor } from './fixtureTypes.js';
+export declare function createFixtureMap(fixtures?: (Fixture | Interceptor)[]): readonly [
+    Map<string, Fixture>,
+    Interceptor[]
+];
+//# sourceMappingURL=createFixtureMap.d.ts.map

package/ts3.4/mock/fixtureTypes.d.ts

@@ -0,0 +1,99 @@
+import { EndpointInterface, ResolveType } from '@data-client/endpoint';
+type Updater = (result: any, ...args: any) => Record<string, (...args: any) => any>;
+export interface SuccessFixtureEndpoint<E extends EndpointInterface & {
+    update?: Updater;
+} = EndpointInterface> {
+    readonly endpoint: E;
+    readonly args: Parameters<E>;
+    readonly response: ResolveType<E> | ((...args: Parameters<E>) => ResolveType<E>);
+    readonly error?: false;
+    /** Number of miliseconds to wait before resolving */
+    readonly delay?: number;
+    /** Waits to run `response()` after `delay` time */
+    readonly delayCollapse?: boolean;
+}
+export interface ResponseInterceptor<T = any, E extends EndpointInterface & {
+    update?: Updater;
+    testKey(key: string): boolean;
+} = EndpointInterface & {
+    testKey(key: string): boolean;
+}> {
+    readonly endpoint: E;
+    response(this: T, ...args: Parameters<E>): ResolveType<E>;
+    /** Number of miliseconds (or function that returns) to wait before resolving */
+    readonly delay?: number | ((...args: Parameters<E>) => number);
+    /** Waits to run `response()` after `delay` time */
+    readonly delayCollapse?: boolean;
+}
+export interface FetchInterceptor<T = any, E extends EndpointInterface & {
+    update?: Updater;
+    testKey(key: string): boolean;
+    fetchResponse(input: RequestInfo, init: RequestInit): Promise<Response>;
+    extend(options: any): any;
+} = EndpointInterface & {
+    testKey(key: string): boolean;
+    fetchResponse(input: RequestInfo, init: RequestInit): Promise<Response>;
+    extend(options: any): any;
+}> {
+    readonly endpoint: E;
+    fetchResponse(this: T, input: RequestInfo, init: RequestInit): ResolveType<E>;
+    /** Number of miliseconds (or function that returns) to wait before resolving */
+    readonly delay?: number | ((...args: Parameters<E>) => number);
+    /** Waits to run `response()` after `delay` time */
+    readonly delayCollapse?: boolean;
+}
+/** Interceptors match and compute dynamic responses based on args
+ *
+ * @see https://dataclient.io/docs/api/Fixtures#interceptor
+ */
+export type Interceptor<T = any, E extends EndpointInterface & {
+    update?: Updater;
+    testKey(key: string): boolean;
+    fetchResponse?(input: RequestInfo, init: RequestInit): Promise<Response>;
+    extend?(options: any): any;
+} = EndpointInterface & {
+    testKey(key: string): boolean;
+    fetchResponse(input: RequestInfo, init: RequestInit): Promise<Response>;
+    extend(options: any): any;
+}> = ResponseInterceptor<T, E> | (E extends ({
+    fetchResponse(input: RequestInfo, init: RequestInit): Promise<Response>;
+    extend(options: any): any;
+}) ? FetchInterceptor<T, E> : never);
+export interface ErrorFixtureEndpoint<E extends EndpointInterface & {
+    update?: Updater;
+} = EndpointInterface> {
+    readonly endpoint: E;
+    readonly args: Parameters<E>;
+    readonly response: any;
+    readonly error: true;
+    /** Number of miliseconds to wait before resolving */
+    readonly delay?: number;
+    /** Waits to run `response()` after `delay` time */
+    readonly delayCollapse?: boolean;
+}
+export type FixtureEndpoint<E extends EndpointInterface & {
+    update?: Updater;
+} = EndpointInterface> = SuccessFixtureEndpoint<E> | ErrorFixtureEndpoint<E>;
+/** Represents a successful response
+ *
+ * @see https://dataclient.io/docs/api/Fixtures#successfixture
+ */
+export type SuccessFixture<E extends EndpointInterface & {
+    update?: Updater;
+} = EndpointInterface> = SuccessFixtureEndpoint<E>;
+/** Represents a failed/errored response
+ *
+ * @see https://dataclient.io/docs/api/Fixtures#errorfixtures
+ */
+export type ErrorFixture<E extends EndpointInterface & {
+    update?: Updater;
+} = EndpointInterface> = ErrorFixtureEndpoint<E>;
+/** Represents a static response
+ *
+ * @see https://dataclient.io/docs/api/Fixtures
+ */
+export type Fixture<E extends EndpointInterface & {
+    update?: Updater;
+} = EndpointInterface> = FixtureEndpoint<E>;
+export {};
+//# sourceMappingURL=fixtureTypes.d.ts.map

package/ts3.4/mock/index.d.ts

@@ -0,0 +1,7 @@
+export { MockController } from './MockController.js';
+export { MockProps } from './mockTypes.js';
+export { Fixture, SuccessFixture, ErrorFixture, Interceptor, ResponseInterceptor, FetchInterceptor, FixtureEndpoint, SuccessFixtureEndpoint, ErrorFixtureEndpoint, } from './fixtureTypes.js';
+export { collapseFixture } from './collapseFixture.js';
+export { createFixtureMap } from './createFixtureMap.js';
+export { default as mockInitialState } from './mockState.js';
+//# sourceMappingURL=index.d.ts.map

package/ts3.4/mock/mockState.d.ts

@@ -0,0 +1,4 @@
+import { State } from '../index.js';
+import { Fixture } from './fixtureTypes.js';
+export default function mockInitialState(fixtures?: Fixture[]): State<unknown>;
+//# sourceMappingURL=mockState.d.ts.map

package/ts3.4/mock/mockTypes.d.ts

@@ -0,0 +1,6 @@
+import { Fixture, Interceptor } from './fixtureTypes.js';
+export interface MockProps<T = any> {
+    readonly fixtures?: (Fixture | Interceptor<T>)[];
+    getInitialInterceptorData?: () => T;
+}
+//# sourceMappingURL=mockTypes.d.ts.map