@openstax/ts-utils 1.33.0 → 1.34.0

package/packages/utils/src/config/lambdaParameterConfig.ts

@@ -0,0 +1,49 @@
+import type { GetParameterCommandOutput } from '@aws-sdk/client-ssm';
+import fetch from 'node-fetch';
+import { assertDefined } from '../assertions';
+import { retryWithDelay } from '../misc/helpers';
+import { envConfig } from './envConfig';
+import { ConfigValueProvider, resolveConfigValue } from '.';
+
+const lambdaExtensionUrl = 'http://localhost:2773';
+let lambdaExtensionReadyPromise: Promise<unknown>;
+
+/**
+ * Returns a value from the AWS Parameter Store. Can only be used during in AWS Lambda, and
+ * requires that the AWS Parameters and Secrets Lambda Extension Layer be included in the Lambda.
+ * This extension has built-in caching for requested parameters.
+ *
+ * @param parameterName the name of the parameter; can be a literal name (string) or can itself
+ * be accessed via another parameter by giving a configuration value provider.
+ * @example const someValue = resolveConfig(lambdaParameterConfig('some-parameter-name'));
+ * @returns the configuration value provider for the value
+ */
+export const lambdaParameterConfig = (parameterName: ConfigValueProvider<string>): ConfigValueProvider<string> => async() => {
+  const token = await resolveConfigValue(envConfig('AWS_SESSION_TOKEN', 'runtime'));
+  const name = await resolveConfigValue(parameterName);
+
+  if (!lambdaExtensionReadyPromise) {
+    // This request will return 400 Bad Request,
+    // but we only care that it'll block until the extension is ready
+    lambdaExtensionReadyPromise = retryWithDelay(() => fetch(lambdaExtensionUrl));
+  }
+  await lambdaExtensionReadyPromise;
+
+  const resp = await retryWithDelay(() => fetch(
+    // Port 2773 is the default port for the extension
+    `${lambdaExtensionUrl}/systemsmanager/parameters/get?name=${name}&withDecryption=true`,
+    { headers: { 'X-Aws-Parameters-Secrets-Token': token } }
+  ));
+
+  if (resp.ok) {
+    const response = await resp.json() as GetParameterCommandOutput;
+    const parameter = assertDefined(
+      response.Parameter, `aws GetParameter response missing Parameter key for ${name}"`
+    );
+    return assertDefined(parameter.Value, `aws GetParameter response missing Parameter.Value key for ${name}"`);
+  } else {
+    throw new Error(
+      `HTTP Error Response ${resp.status} ${resp.statusText} while fetching parameter ${name}`
+    );
+  }
+};

package/{dist/esm/config/replaceConfig.js → packages/utils/src/config/replaceConfig.ts}

@@ -1,4 +1,6 @@
 import { resolveConfigValue } from './resolveConfigValue';
+import { ConfigValueProvider } from '.';
+
 /**
  * Substitutes configuration values into a provided string.
  * Performs a string substitution using configuration values
@@ -9,10 +11,18 @@ import { resolveConfigValue } from './resolveConfigValue';
  * @example replaceConfig('https://[host]', { '[host]': envConfig('HOST') })
  * @returns the string after substitution is complete
  */
-export const replaceConfig = (base, replacements) => {
-    return async () => {
-        const resolved = await Promise.all(Object.entries(replacements)
-            .map(async ([token, replacement]) => [token, await resolveConfigValue(replacement)]));
-        return resolved.reduce((result, [token, replacement]) => result.replace(token, replacement), await resolveConfigValue(base));
-    };
+export const replaceConfig = (
+  base: ConfigValueProvider<string>,
+  replacements: {[token: string]: ConfigValueProvider<string>}
+): ConfigValueProvider<string> => {
+
+  return async() => {
+    const resolved = await Promise.all(Object.entries(replacements)
+      .map(async([token, replacement]) => [token, await resolveConfigValue(replacement)] as const)
+    );
+
+    return resolved.reduce(
+      (result, [token, replacement]) => result.replace(token, replacement)
+    , await resolveConfigValue(base));
+  };
 };

package/packages/utils/src/config/resolveConfigValue.ts

@@ -0,0 +1,10 @@
+import type { ConfigValue, ConfigValueProvider } from '.';
+
+/**
+ * resolves a config value into a string, to be used inside of things that are provided configurations
+ */
+export const resolveConfigValue = async<V extends ConfigValue>(provider: ConfigValueProvider<V>): Promise<V> => {
+  return typeof provider === 'function'
+    ? await provider()
+    : provider;
+};

package/packages/utils/src/errors/index.spec.ts

@@ -0,0 +1,35 @@
+import { ConflictError, ForbiddenError, InvalidRequestError, NotFoundError, SessionExpiredError, UnauthorizedError } from '.';
+
+describe('errorIsType', () => {
+  it('returns true for same error type', () => {
+    expect(InvalidRequestError.matches(new InvalidRequestError())).toBe(true);
+  });
+  it('returns false for different error type', () => {
+    expect(InvalidRequestError.matches(new UnauthorizedError())).toBe(false);
+  });
+  it('returns false random input', () => {
+    expect(InvalidRequestError.matches(new Error())).toBe(false);
+    expect(InvalidRequestError.matches('asdf')).toBe(false);
+  });
+});
+
+describe('custom error constructors', () => {
+  it('use TYPE as default message', () => {
+    expect(new InvalidRequestError().message).toBe(InvalidRequestError.TYPE);
+    expect(new UnauthorizedError().message).toBe(UnauthorizedError.TYPE);
+    expect(new ForbiddenError().message).toBe(ForbiddenError.TYPE);
+    expect(new NotFoundError().message).toBe(NotFoundError.TYPE);
+    expect(new SessionExpiredError().message).toBe(SessionExpiredError.TYPE);
+    expect(new ConflictError().message).toBe(ConflictError.TYPE);
+  });
+
+  it('allow custom messages', () => {
+    const customMessage = 'Some Error';
+    expect(new InvalidRequestError(customMessage).message).toBe(customMessage);
+    expect(new UnauthorizedError(customMessage).message).toBe(customMessage);
+    expect(new ForbiddenError(customMessage).message).toBe(customMessage);
+    expect(new NotFoundError(customMessage).message).toBe(customMessage);
+    expect(new SessionExpiredError(customMessage).message).toBe(customMessage);
+    expect(new ConflictError(customMessage).message).toBe(customMessage);
+  });
+});

package/{dist/esm/errors/index.js → packages/utils/src/errors/index.ts}

@@ -1,3 +1,5 @@
+import type { JsonCompatibleStruct } from '../routing';
+
 /*
  * if code is split into multiple bundles, sometimes each bundle
  * will get its own definition of this module and then instanceof checks
@@ -10,13 +12,17 @@
  *   error instanceof InvalidRequestError
  *
  */
-const errorIsType = (t) => (e) => e instanceof Error
-    && e.constructor.TYPE === t.TYPE;
+const errorIsType = <T extends {TYPE: string}>(t: T) => (e: any): e is T =>
+  e instanceof Error
+  && (e as any).constructor.TYPE === t.TYPE;
+
 /**
  * Returns true if the error is defined in this library
  */
-export const isAppError = (e) => e instanceof Error
-    && typeof e.constructor.TYPE === 'string';
+export const isAppError = (e: any): e is Error & {constructor: {TYPE: string}} =>
+  e instanceof Error
+  && typeof (e as any).constructor.TYPE === 'string';
+
 /**
  * Invalid request error
  *
@@ -24,12 +30,13 @@ export const isAppError = (e) => e instanceof Error
  * `InvalidRequestError`; `instanceof` checks may not work if code is split into multiple bundles
  */
 export class InvalidRequestError extends Error {
-    constructor(message) {
-        super(message || InvalidRequestError.TYPE);
-    }
+  static readonly TYPE = 'InvalidRequestError';
+  static matches = errorIsType(InvalidRequestError);
+  constructor(message?: string) {
+    super(message || InvalidRequestError.TYPE);
+  }
 }
-InvalidRequestError.TYPE = 'InvalidRequestError';
-InvalidRequestError.matches = errorIsType(InvalidRequestError);
+
 /**
  * Validation Error
  *
@@ -37,14 +44,19 @@ InvalidRequestError.matches = errorIsType(InvalidRequestError);
  * `ValidationError`; `instanceof` checks may not work if code is split into multiple bundles
  */
 export class ValidationError extends Error {
-    constructor(data) {
-        super(InvalidRequestError.TYPE);
-        this.data = data;
-    }
-    getData() { return this.data; }
+  static readonly TYPE = 'ValidationError';
+  static matches = errorIsType(ValidationError);
+
+  private data: JsonCompatibleStruct;
+  constructor(data: JsonCompatibleStruct) {
+    super(InvalidRequestError.TYPE);
+
+    this.data = data;
+  }
+
+  getData() { return this.data; }
 }
-ValidationError.TYPE = 'ValidationError';
-ValidationError.matches = errorIsType(ValidationError);
+
 /**
  * Unauthorized error
  *
@@ -52,12 +64,13 @@ ValidationError.matches = errorIsType(ValidationError);
  * `UnauthorizedError`; `instanceof` checks may not work if code is split into multiple bundles
  */
 export class UnauthorizedError extends Error {
-    constructor(message) {
-        super(message || UnauthorizedError.TYPE);
-    }
+  static readonly TYPE = 'UnauthorizedError';
+  static matches = errorIsType(UnauthorizedError);
+  constructor(message?: string) {
+    super(message || UnauthorizedError.TYPE);
+  }
 }
-UnauthorizedError.TYPE = 'UnauthorizedError';
-UnauthorizedError.matches = errorIsType(UnauthorizedError);
+
 /**
  * Forbidden error
  *
@@ -65,12 +78,13 @@ UnauthorizedError.matches = errorIsType(UnauthorizedError);
  * `ForbiddenError`; `instanceof` checks may not work if code is split into multiple bundles
  */
 export class ForbiddenError extends Error {
-    constructor(message) {
-        super(message || ForbiddenError.TYPE);
-    }
+  static readonly TYPE = 'ForbiddenError';
+  static matches = errorIsType(ForbiddenError);
+  constructor(message?: string) {
+    super(message || ForbiddenError.TYPE);
+  }
 }
-ForbiddenError.TYPE = 'ForbiddenError';
-ForbiddenError.matches = errorIsType(ForbiddenError);
+
 /**
  * Not found error
  *
@@ -78,12 +92,13 @@ ForbiddenError.matches = errorIsType(ForbiddenError);
  * `NotFoundError`; `instanceof` checks may not work if code is split into multiple bundles
  */
 export class NotFoundError extends Error {
-    constructor(message) {
-        super(message || NotFoundError.TYPE);
-    }
+  static readonly TYPE = 'NotFoundError';
+  static matches = errorIsType(NotFoundError);
+  constructor(message?: string) {
+    super(message || NotFoundError.TYPE);
+  }
 }
-NotFoundError.TYPE = 'NotFoundError';
-NotFoundError.matches = errorIsType(NotFoundError);
+
 /**
  * Session expired error
  *
@@ -91,12 +106,13 @@ NotFoundError.matches = errorIsType(NotFoundError);
  * `SessionExpiredError`; `instanceof` checks may not work if code is split into multiple bundles
  */
 export class SessionExpiredError extends Error {
-    constructor(message) {
-        super(message || SessionExpiredError.TYPE);
-    }
+  static readonly TYPE = 'SessionExpiredError';
+  static matches = errorIsType(SessionExpiredError);
+  constructor(message?: string) {
+    super(message || SessionExpiredError.TYPE);
+  }
 }
-SessionExpiredError.TYPE = 'SessionExpiredError';
-SessionExpiredError.matches = errorIsType(SessionExpiredError);
+
 /**
  * Conflict error
  *
@@ -104,9 +120,9 @@ SessionExpiredError.matches = errorIsType(SessionExpiredError);
  * `ConflictError`; `instanceof` checks may not work if code is split into multiple bundles
  */
 export class ConflictError extends Error {
-    constructor(message) {
-        super(message || ConflictError.TYPE);
-    }
+  static readonly TYPE = 'ConflictError';
+  static matches = errorIsType(ConflictError);
+  constructor(message?: string) {
+    super(message || ConflictError.TYPE);
+  }
 }
-ConflictError.TYPE = 'ConflictError';
-ConflictError.matches = errorIsType(ConflictError);

package/packages/utils/src/fetch/fetchStatusRetry.spec.ts

@@ -0,0 +1,197 @@
+import { fetchStatusRetry } from './fetchStatusRetry';
+import { Response } from '.';
+
+describe('fetchStatusRetry', () => {
+  let setTimeoutSpy: jest.SpyInstance;
+  let timeouts: Array<number | undefined>;
+
+  const doBeforeEach = () => {
+    timeouts = [];
+    setTimeoutSpy = jest.spyOn(global, 'setTimeout')
+      .mockImplementation((fn, timeout) => {
+        timeouts.push(timeout);
+        fn();
+        return 1 as any;
+      });
+  };
+
+  const doAfterEach = () => {
+    setTimeoutSpy.mockReset();
+  };
+
+  beforeEach(doBeforeEach);
+  afterEach(doAfterEach);
+
+  it('fetches normally', async() => {
+    const base = jest.fn();
+    const withRetry = fetchStatusRetry(base, {status: [502], retries: 7});
+
+    const response: Response = {
+      status: 200,
+      headers: {get: () => 'application/json'},
+      json: () => Promise.resolve({}),
+      text: () => Promise.resolve('some error')
+    };
+
+    base.mockReturnValue(Promise.resolve(response));
+
+    expect(await withRetry('/some/url')).toBe(response);
+    expect(base).toHaveBeenCalledTimes(1);
+  });
+
+  it('fetches normally with no statuses', async() => {
+    const base = jest.fn();
+    const withRetry = fetchStatusRetry(base, {retries: 7});
+
+    const response: Response = {
+      status: 200,
+      headers: {get: () => 'application/json'},
+      json: () => Promise.resolve({}),
+      text: () => Promise.resolve('some error')
+    };
+
+    base.mockReturnValue(Promise.resolve(response));
+
+    expect(await withRetry('/some/url')).toBe(response);
+    expect(base).toHaveBeenCalledTimes(1);
+  });
+
+  it('retries on bad status', async() => {
+    const base = jest.fn();
+    const withRetry = fetchStatusRetry(base, {status: [502], retries: 7});
+
+    base.mockReturnValueOnce(Promise.resolve({
+      status: 502,
+      headers: {get: () => 'application/json'},
+      json: () => Promise.resolve({}),
+      text: () => Promise.resolve('some error')
+    }));
+
+    const response: Response = {
+      status: 200,
+      headers: {get: () => 'application/json'},
+      json: () => Promise.resolve({}),
+      text: () => Promise.resolve('some error')
+    };
+
+    base.mockReturnValue(Promise.resolve(response));
+
+    expect(await withRetry('/some/url')).toBe(response);
+    expect(base).toHaveBeenCalledTimes(2);
+  });
+
+  it('has limited retries', async() => {
+    const base = jest.fn();
+    const withRetry = fetchStatusRetry(base, {status: [502], retries: 1});
+
+    base.mockReturnValueOnce(Promise.resolve({
+      status: 502,
+      headers: {get: () => 'application/json'},
+      json: () => Promise.resolve({}),
+      text: () => Promise.resolve('some error')
+    }));
+    base.mockReturnValueOnce(Promise.resolve({
+      status: 502,
+      headers: {get: () => 'application/json'},
+      json: () => Promise.resolve({}),
+      text: () => Promise.resolve('some error')
+    }));
+
+    const response: Response = {
+      status: 200,
+      headers: {get: () => 'application/json'},
+      json: () => Promise.resolve({}),
+      text: () => Promise.resolve('some error')
+    };
+
+    base.mockReturnValue(Promise.resolve(response));
+
+    await expect(withRetry('/some/url')).rejects.toThrowErrorMatchingInlineSnapshot('"fetch failed /some/url -- 502: some error"');
+    expect(base).toHaveBeenCalledTimes(2);
+  });
+
+  it('retries on failed fetch', async() => {
+    const base = jest.fn();
+    const withRetry = fetchStatusRetry(base, {status: [502], retries: 7});
+
+    base.mockReturnValueOnce(Promise.reject(new Error('type error failed to fetch or whatever')));
+
+    const response: Response = {
+      status: 200,
+      headers: {get: () => 'application/json'},
+      json: () => Promise.resolve({}),
+      text: () => Promise.resolve('some error')
+    };
+
+    base.mockReturnValue(Promise.resolve(response));
+
+    expect(await withRetry('/some/url')).toBe(response);
+    expect(base).toHaveBeenCalledTimes(2);
+  });
+
+  it('has limited retries on failed to fetch', async() => {
+    const base = jest.fn();
+    const withRetry = fetchStatusRetry(base, {status: [502], retries: 1});
+
+    base.mockReturnValueOnce(Promise.reject(new Error('type error failed to fetch or whatever')));
+    base.mockReturnValueOnce(Promise.reject(new Error('type error failed to fetch or whatever')));
+
+    const response: Response = {
+      status: 200,
+      headers: {get: () => 'application/json'},
+      json: () => Promise.resolve({}),
+      text: () => Promise.resolve('some error')
+    };
+
+    base.mockReturnValue(Promise.resolve(response));
+
+    await expect(withRetry('/some/url')).rejects.toThrowErrorMatchingInlineSnapshot('"type error failed to fetch or whatever"');
+    expect(base).toHaveBeenCalledTimes(2);
+  });
+
+  describe('timeout functionality', () => {
+    beforeEach(() => {
+      setTimeoutSpy.mockRestore();
+      jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+      doBeforeEach();
+    });
+
+    it('fetches normally with timeout option but completes before timeout', async() => {
+      const base = jest.fn();
+      const withRetry = fetchStatusRetry(base, {status: [502], timeout: 1000, retries: 1});
+
+      const response: Response = {
+        status: 200,
+        headers: {get: () => 'application/json'},
+        json: () => Promise.resolve({}),
+        text: () => Promise.resolve('some error')
+      };
+
+      base.mockReturnValue(Promise.resolve(response));
+
+      const result = withRetry('/some/url');
+      expect(await result).toBe(response);
+      expect(base).toHaveBeenCalledTimes(1);
+    });
+
+    it('times out when request takes too long', async() => {
+      const base = jest.fn();
+      const withRetry = fetchStatusRetry(base, {timeout: 100, retries: 0});
+
+      const pendingPromise = new Promise(() => {});
+      base.mockReturnValue(pendingPromise);
+
+      const resultPromise = withRetry('/some/url');
+      
+      jest.advanceTimersByTime(100);
+      
+      await expect(resultPromise).rejects.toThrowErrorMatchingInlineSnapshot('"fetch timeout after 100ms: /some/url"');
+      expect(base).toHaveBeenCalledTimes(1);
+    });
+
+  });
+});

package/packages/utils/src/fetch/fetchStatusRetry.ts

@@ -0,0 +1,33 @@
+import { RetryOptions, retryWithDelay } from '../misc/helpers';
+import { GenericFetch } from '.';
+
+interface Options extends RetryOptions {
+  status?: number[];
+  timeout?: number;
+}
+
+export const fetchStatusRetry = (base: GenericFetch, options: Options): GenericFetch => {
+
+  return (...params) => retryWithDelay(() => {
+    const fetchPromise = base(...params).then(r => {
+      if (options.status?.includes(r.status)) {
+        return r.text().then(text => {
+          throw new Error(`fetch failed ${params[0]} -- ${r.status}: ${text}`);
+        });
+      }
+      return r;
+    });
+
+    if (options.timeout) {
+      const timeoutPromise = new Promise<never>((_, reject) => {
+        setTimeout(() => {
+          reject(new Error(`fetch timeout after ${options.timeout}ms: ${params[0]}`));
+        }, options.timeout);
+      });
+
+      return Promise.race([fetchPromise, timeoutPromise]);
+    }
+
+    return fetchPromise;
+  }, options);
+};

package/packages/utils/src/fetch/index.spec.ts

@@ -0,0 +1,34 @@
+import { fetchError, fetchIdle, fetchLoading, FetchStateType, fetchSuccess, stateHasData, stateHasError } from '.';
+
+describe('creators', () => {
+  it('creates FetchStateLoading', () => {
+    expect(fetchLoading()).toEqual({type: 'loading'});
+  });
+  it('creates FetchStateLoading, with data', () => {
+    expect(fetchLoading({type: FetchStateType.ERROR, error: 'some error', data: 'other data'})).toEqual({type: 'loading', data: 'other data'});
+  });
+  it('creates FetchStateError', () => {
+    expect(fetchError('hello')).toEqual({type: 'error', error: 'hello'});
+  });
+  it('creates FetchStateSuccess', () => {
+    expect(fetchSuccess('wow, such success')).toEqual({type: 'success', data: 'wow, such success'});
+  });
+  it('creates FetchStateIdle', () => {
+    expect(fetchIdle()).toEqual({type: 'idle'});
+  });
+});
+
+describe('guards', () => {
+  it('returns true with data', () => {
+    expect(stateHasData(fetchSuccess('wow'))).toBe(true);
+  });
+  it('returns false with data', () => {
+    expect(stateHasData(fetchLoading())).toBe(false);
+  });
+  it('returns true with error', () => {
+    expect(stateHasError(fetchError('wow'))).toBe(true);
+  });
+  it('returns false with error', () => {
+    expect(stateHasError(fetchLoading())).toBe(false);
+  });
+});

package/packages/utils/src/fetch/index.ts

@@ -0,0 +1,87 @@
+import { METHOD } from '../routing';
+
+/*
+ * these are just helpers for formatting responses, they don't actually do any loading. especially in UI development they
+ * help with continuity over loading, reloading, saving, and errors. this is pretty nice in typescript because you have to deal
+ * with the possibility that the result state is in a loading or error state. if you avoid dealing with those states you need
+ * to write very clear code to ignore them, which easily presents missing functionality like errors that are not being messaged
+ * to the user.
+ * */
+export enum FetchStateType {
+  SUCCESS = 'success',
+  ERROR = 'error',
+  LOADING = 'loading',
+  IDLE = 'idle',
+}
+
+export type FetchState<D, E> = FetchStateLoading<D>
+  | FetchStateError<D, E>
+  | FetchStateSuccess<D>
+  | FetchStateIdle;
+
+type FetchStateLoading<D> = {type: FetchStateType.LOADING; data?: D};
+type FetchStateError<D, E> = {type: FetchStateType.ERROR; data?: D; error: E};
+type FetchStateSuccess<D> = {type: FetchStateType.SUCCESS; data: D};
+type FetchStateIdle = {type: FetchStateType.IDLE};
+
+/*
+ * keeps existing data but sets the new status
+ *
+ * const state = fetchLoading(previousState)
+ * */
+export const fetchLoading = <D, E>(previous?: FetchState<D, E>): FetchStateLoading<D>  => ({type: FetchStateType.LOADING, ...(previous && 'data' in previous ? {data: previous.data} : {})});
+
+/*
+ * keeps existing data but sets the new status and error value
+ *
+ * const state = fetchError(error, previousState)
+ * */
+export const fetchError = <D, E>(error: E, previous?: FetchState<D, E>): FetchStateError<D, E> => ({...previous, type: FetchStateType.ERROR, error});
+
+/*
+ * formats data with success type
+ *
+ * const state = fetchSuccess(newData)
+ * */
+export const fetchSuccess = <D>(data: D): FetchStateSuccess<D> => ({type: FetchStateType.SUCCESS, data});
+
+/*
+ * formats data with idle type
+ *
+ * const state = fetchIdle(newData)
+ * */
+export const fetchIdle = (): FetchStateIdle => ({type: FetchStateType.IDLE});
+
+/*
+ * guard for checking if the state has result data, it might be true for any state type.
+ * */
+export const stateHasData = <D, E>(state: {type: FetchStateType; data?: D; error?: E}): state is {type: FetchStateType; data: D} => 'data' in state;
+/*
+ * guard for checking if the state has an error, it might be true for error or loading states.
+ * */
+export const stateHasError = <D, E>(state: {type: FetchStateType; data?: D; error?: E}): state is {type: FetchStateType; error: E} => 'error' in state;
+
+/*
+ * a minimal fetch interface that is compatible with both WindowOrWorkerGlobalScope['fetch'] and node-fetch
+ * only the features needed by this library are defined here. the generic is so that utilities can set
+ * themselves up to accept input fetchConfig that may extend this.
+ */
+export type FetchConfig = {
+  credentials?: 'include' | 'omit' | 'same-origin';
+  method?: METHOD;
+  body?: string;
+  headers?: {[key: string]: string};
+};
+type Headers = {
+  get: (name: string) => string | null;
+};
+export type Response = {
+  status: number;
+  headers: Headers;
+  json: () => Promise<any>;
+  text: () => Promise<string>;
+};
+export type GenericFetch<C extends FetchConfig = FetchConfig, R extends Response = Response> =
+  (url: string, fetchConfig?: C) => Promise<R>;
+
+export type ConfigForFetch<F> = F extends GenericFetch<infer C, any> ? C : never;