Merge pull request #45 from metsavaht/feature/redux-saga-resource-abo…

…rtcontroller

Add AbortSignal handling for `@thorgate/redux-saga-router`

README.md

@@ -117,7 +117,8 @@ endpoints. It's still possible to use Resources without a router(see [Resource a
  source of `ResponseWrapper`, `SuperagentResponse` and `Resource::ensureStatusAndJson` for guidance.
 - ``withCredentials`` *(bool)*: Allow request backend to send cookies/authentication headers, useful when using same API for server-side rendering.
 - ``allowAttachments`` *(bool)*: Allow POST like methods to send attachments.
-- ``signal``: *(AbortSignal)*: Pass in an [AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) object to abort the request when desired. Default: [null].
+- ``signal``: *(AbortSignal)*: Pass in an [AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) object to abort the request when desired. 
+ **Only supported via request config.** Default: [null].
 
 ## Error handling
 

package.json

@@ -15,8 +15,8 @@
  "run-examples": "lerna exec --scope=run-examples yarn start",
  "lint": "lerna --ignore=examples/* exec yarn lint",
  "test": "jest",
- "test:coverage": "yarn test --maxWorkers 16 --coverage",
- "precoveralls": "yarn test:coverage --no-cache --maxWorkers 16",
+ "test:coverage": "yarn test --maxWorkers 20 --coverage",
+ "precoveralls": "yarn test:coverage --no-cache --maxWorkers 20",
  "coveralls": "cat ./coverage/lcov.info | coveralls",
  "check-packages": "yarn clean && yarn build && yarn test && yarn lint",
  "bump-version": "lerna --ignore=examples/* version --no-push",

packages/core/src/createRouter.ts

@@ -2,7 +2,7 @@ import { isArray, isObject, isString } from '@tg-resources/is';
 
 import { Resource } from './resource';
 import { Router } from './router';
-import { ConfigType, ObjectMap, OptionalMap, RequestConfig } from './types';
+import { ConfigType, ObjectMap, OptionalMap, RouteConfig, RouteConfigType } from './types';
 
 
 export type ResourceTuple<Config = OptionalMap<ConfigType>> = [string, Config];
@@ -12,7 +12,7 @@ export const isResourceTuple = (value: any): value is ResourceTuple => (
 );
 
 
-export interface ResourceConstructorObject extends OptionalMap<ConfigType> {
+export interface ResourceConstructorObject extends OptionalMap<RouteConfigType> {
  apiEndpoint: string;
 }
 
@@ -32,28 +32,28 @@ export type ResourceOrExtendedRouter<T, Klass extends Resource> = {
 
 
 export interface ResourceClassConstructor<Klass> {
- new(apiEndpoint: string, config?: RequestConfig | null): Klass;
+ new(apiEndpoint: string, config?: RouteConfig | null): Klass;
 }
 
 
 export type CreateResourceFactory = <
  Klass extends Resource
 >(
- resourceKlass: ResourceClassConstructor<Klass>, apiEndpoint: string, config?: RequestConfig, options?: ObjectMap
+ resourceKlass: ResourceClassConstructor<Klass>, apiEndpoint: string, config?: RouteConfig, options?: ObjectMap
 ) => any;
 
 
 export const createResource: CreateResourceFactory = <
  Klass extends Resource
->(resourceKlass: ResourceClassConstructor<Klass>, apiEndpoint: string, config?: RequestConfig, _0?: ObjectMap): Klass => (
+>(resourceKlass: ResourceClassConstructor<Klass>, apiEndpoint: string, config?: RouteConfig, _0?: ObjectMap): Klass => (
  new resourceKlass(apiEndpoint, config)
 );
 
 
 export function createRouter<
  Klass extends Resource, T extends ObjectMap = {}
 >(
- routes: T, config: RequestConfig | null, resourceKlass: ResourceClassConstructor<Klass>,
+ routes: T, config: RouteConfig, resourceKlass: ResourceClassConstructor<Klass>,
  createResourceFactory: CreateResourceFactory = createResource
 ) {
  const routeMap: {
@@ -83,7 +83,7 @@ export function createRouter<
  'string',
  '[string, config]',
  '{apiEndpoint: string, ..config}',
- '{ ...any }',
+ 'Router',
  ];
  throw new Error(`Unknown type used "${key}", one of [${types.join(',')}] is allowed`);
  }

packages/core/src/resource.ts

@@ -7,13 +7,15 @@ import { Route } from './route';
 import {
  AllowedFetchMethods,
  AllowedPostMethods,
- Attachments, ConfigType,
+ Attachments,
+ ConfigType,
  ObjectMap,
  Query,
  RequestConfig,
  ResourceErrorInterface,
  ResourceInterface,
  ResponseInterface,
+ RouteConfig,
 } from './types';
 import { mergeConfig, serializeCookies } from './util';
 
@@ -24,7 +26,7 @@ export abstract class Resource extends Route implements ResourceInterface {
  * @param apiEndpoint Endpoint used for this resource. Supports ES6 token syntax, e.g: "/foo/bar/${pk}"
  * @param config Customize config for this resource (see `Router.config`)
  */
- public constructor(apiEndpoint: string, config: RequestConfig = null) {
+ public constructor(apiEndpoint: string, config: RouteConfig = null) {
  super(config);
  this._apiEndpoint = apiEndpoint;
  }

packages/core/src/route.ts

@@ -1,19 +1,25 @@
 import {
- ConfigType, ObjectMap,
+ ObjectMap,
  RequestConfig,
+ RouteConfig,
+ RouteConfigType,
  RouteInterface,
  RouterInterface,
 } from './types';
 
 
 export abstract class Route implements RouteInterface {
- protected _customConfig: RequestConfig = null;
+ protected _customConfig: RouteConfig = null;
  protected _routeName: string = '';
  protected _parent: RouterInterface | null = null;
  protected _config: RequestConfig = null;
 
- protected constructor(config: RequestConfig = null) {
+ protected constructor(config: RouteConfig = null) {
  this._customConfig = config;
+
+ if (config && 'signal' in config) {
+ throw new Error('AbortSignal is not supported at top-level.');
+ }
  }
 
  public get parent() {
@@ -66,9 +72,9 @@ export abstract class Route implements RouteInterface {
  return this._config;
  }
 
- public abstract config(): ConfigType;
+ public abstract config(): RouteConfigType;
 
- public setConfig(config: RequestConfig) {
+ public setConfig(config: RouteConfig) {
  // Update _customConfig
  this._customConfig = {
  ...this._customConfig,

packages/core/src/router.ts

@@ -4,14 +4,13 @@ import DEFAULTS from './constants';
 import { Resource } from './resource';
 import { Route } from './route';
 import {
- ConfigType,
  Optional,
- OptionalMap,
- RequestConfig,
  ResourceInterface,
+ RouteConfig,
+ RouteConfigType,
  RouteInterface,
  RouteMap,
- RouterInterface
+ RouterInterface,
 } from './types';
 import { mergeConfig } from './util';
 
@@ -69,12 +68,12 @@ export function bindResources(routes: RouteMap, $this: RouterInterface) {
 
 export class Router extends Route implements RouterInterface {
  public static defaultRoutes: Optional<RouteMap> = null;
- public static defaultConfig: Optional<OptionalMap<ConfigType>> = null;
+ public static defaultConfig: RouteConfig = null;
  public _childKeys: string[] = [];
 
  [key: string]: ResourceInterface | RouterInterface | any;
 
- public constructor(routes: Optional<RouteMap> = null, config?: RequestConfig) {
+ public constructor(routes: Optional<RouteMap> = null, config: RouteConfig = null) {
  super(config);
 
  const defaultRoutes = (this.constructor as typeof Router).defaultRoutes;
@@ -118,7 +117,7 @@ export class Router extends Route implements RouterInterface {
  );
  }
 
- return this._config as ConfigType;
+ return this._config as RouteConfigType;
  }
 
  public clearConfigCache() {

packages/core/src/types.ts

@@ -1,3 +1,6 @@
+import { Omit } from '@tg-resources/is';
+
+
 export type Optional<T> = T | null;
 
 export type OptionalMap<T> = {
@@ -91,6 +94,15 @@ export interface ConfigType {
 }
 
 
+/**
+ * Router and Resource config
+ */
+export type RouteConfigType = Omit<ConfigType, 'signal'>;
+
+
+export type RouteConfig = Optional<OptionalMap<RouteConfigType>>;
+
+
 export type RequestConfig = Optional<OptionalMap<ConfigType>>;
 
 
@@ -229,8 +241,8 @@ export interface RouteInterface {
  getHeaders(): ObjectMap<string | null>;
  getCookies(): ObjectMap<string | null>;
 
- config(requestConfig?: RequestConfig): ConfigType;
- setConfig(config: RequestConfig): void;
+ config(requestConfig?: RequestConfig): RouteConfigType;
+ setConfig(config: RouteConfigType): void;
  clearConfigCache(): void;
 }
 
@@ -253,6 +265,8 @@ export type ResourcePostMethod<
 export interface ResourceInterface extends RouteInterface {
  readonly apiEndpoint: string;
 
+ config(requestConfig?: RequestConfig): ConfigType;
+
  fetch<
  R = any, Params extends { [K in keyof Params]?: string } = {}
  >(kwargs?: Params | null, query?: Query | null, requestConfig?: RequestConfig | null): Promise<R> | any;

packages/core/test/router.test.ts

@@ -66,6 +66,12 @@ describe('routers work', () => {
  },
  } as any);
  }).toThrow(/All routes must be instances of Router or Resource/);
+
+ expect(() => {
+ new Router(null, {
+ signal: new Error('fake') as any,
+ });
+ }).toThrow(/AbortSignal is not supported at top-level/);
  });
 
  test('rebind fails', () => {

packages/is/src/index.ts

@@ -52,3 +52,6 @@ export const isAbortSignal = (signal: any): signal is AbortSignal => {
 export interface Constructable<T> {
  new(...args: any[]): T;
 }
+
+
+export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;

packages/saga-router/README.md

@@ -176,6 +176,7 @@ This package adds extra configuration methods for `Router` and `Resource`.
 - ``onRequestError`` *(Function)*: Optional function with signature `(error: ErrorType, resource: Resource, options: ResourceSagaRunnerConfig) => void | SagaIterator`.
  This can be used to handle Sentry missing error handling.
 - ``initializeSaga`` *(bool)*: **Advanced usage:** Initialize Saga iterator. This option disables usage of ``call`` effect.
+- ``signal`` *(AbortSignal|null)*: **Advanced usage:** Manually provide signal to abort request. If it is not provided then AbortController is created internally and triggered when task is cancelled.
 
 For additional configuration, see [Configuration](https:/thorgate/tg-resources/tree/master/README.md#configuration).
 

packages/saga-router/src/SagaResource.ts

@@ -7,10 +7,12 @@ import {
  Resource,
  ResourceFetchMethods,
  ResourcePostMethods,
- RouterInterface } from 'tg-resources';
+ RouterInterface,
+} from 'tg-resources';
 
+import { DEFAULT_CONFIG } from './constants';
 import { resourceSagaRunner } from './resourceSagaRunner';
-import { ResourceSagaRunnerConfig, SagaConfigType, SagaRequestConfig } from './types';
+import { ResourceSagaRunnerConfig, SagaConfigType, SagaRequestConfig, SagaRouteConfig } from './types';
 
 
 export function isSagaResource<Klass extends Resource>(obj: any): obj is SagaResource<Klass> {
@@ -29,7 +31,7 @@ export function isSagaResourceInitialized(obj: any, config: SagaRequestConfig):
 export class SagaResource<Klass extends Resource> extends Resource {
  public constructor(
  apiEndpoint: string,
- config: SagaRequestConfig = null,
+ config: SagaRouteConfig = null,
  resourceKlass: { new(apiEndpoint: string, config?: RequestConfig): Klass; },
  ) {
  super(apiEndpoint, config as Pick<typeof config, keyof RequestConfig>);
@@ -82,7 +84,10 @@ export class SagaResource<Klass extends Resource> extends Resource {
  }
 
  public config(requestConfig?: SagaRequestConfig): SagaConfigType {
- return this._resource.config(requestConfig) as SagaConfigType;
+ return {
+ ...DEFAULT_CONFIG,
+ ...this._resource.config(requestConfig),
+ } as SagaConfigType;
  }
 
  /* istanbul ignore next: not in use directly */

packages/saga-router/src/constants.ts

@@ -0,0 +1,10 @@
+import { SagaConfigTypeBase } from './types';
+
+
+export const DEFAULT_CONFIG: SagaConfigTypeBase = {
+ initializeSaga: false,
+
+ mutateRequestConfig: null,
+
+ onRequestError: null,
+};

packages/saga-router/src/createSagaRouter.ts

@@ -2,16 +2,16 @@ import {
  CreateResourceFactory,
  createRouter,
  ObjectMap,
- RequestConfig,
  Resource,
  ResourceClassConstructor,
  ResourceConstructorObject,
  ResourceTuple,
- Router
+ RouteConfig,
+ Router,
 } from 'tg-resources';
 
 import { SagaResource } from './SagaResource';
-import { SagaRequestConfig } from './types';
+import { SagaRouteConfig } from './types';
 
 
 // Was required to copy this here as well - Type matching did not work correctly otherwise
@@ -26,15 +26,15 @@ export type ResourceOrExtendedRouter<T, Klass extends Resource> = {
 
 
 export const createSagaResource: CreateResourceFactory = <Klass extends Resource>(
- resourceKlass: ResourceClassConstructor<Klass>, apiEndpoint: string, config?: RequestConfig
+ resourceKlass: ResourceClassConstructor<Klass>, apiEndpoint: string, config?: RouteConfig
 ) => {
  return new SagaResource<Klass>(apiEndpoint, config, resourceKlass);
 };
 
 export function createSagaRouter<
  Klass extends Resource, T extends ObjectMap = {}
 >(
- routes: T, config: SagaRequestConfig | null, resourceKlass: ResourceClassConstructor<Klass>
+ routes: T, config: SagaRouteConfig | null, resourceKlass: ResourceClassConstructor<Klass>
 ) {
  const router = createRouter(routes, config, resourceKlass, createSagaResource) as any;