4232779217

Build Type

push

github

Committed by GitHub

Commit Message

Merge pull request #54 from mpyw/fix/array-index-broken

Run Details

127 of 147 branches covered (86.39%)

Branch coverage included in aggregate %.

3 of 3 new or added lines in 2 files covered. (100.0%)

3 existing lines in 1 file now uncovered.

110 of 114 relevant lines covered (96.49%)

70.26 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

76.77

/src/middleware.ts

import { createObjectTransformers } from './transformers';
import { isAxiosHeaders, isPlainObject } from './util';
import {
  ApplyCaseMiddleware,
  AxiosCaseMiddlewareOptions,
  CreateAxiosRequestInterceptor,
  CreateAxiosRequestTransformer,
  CreateAxiosResponseTransformer,
  ObjectTransformer,
  TransformableObject,
} from './types';

export const createSnakeParamsInterceptor: CreateAxiosRequestInterceptor = (
  options?
) => {
  const { snake } = createObjectTransformers(options?.caseFunctions);
  return (config): ReturnType<ReturnType<CreateAxiosRequestInterceptor>> => {
    if (config.params) {
      config.params = snake(config.params, options);
    }
    return config;
  };
};
export const createSnakeRequestTransformer: CreateAxiosRequestTransformer = (
  options?
) => {
  const { snake, header } = createObjectTransformers(options?.caseFunctions);
  return (
    data: unknown,
    headers?: unknown
  ): ReturnType<ReturnType<CreateAxiosRequestTransformer>> => {
    overwriteHeadersOrNoop(headers, header, options, [
      'common',
      'delete',
      'get',
      'head',
      'post',
      'put',
      'patch',
    ]);
    return snake(data, options);
  };
};
export const createCamelResponseTransformer: CreateAxiosResponseTransformer = (
  options?
) => {
  const { camel } = createObjectTransformers(options?.caseFunctions);
  return (
    data: unknown,
    headers?: unknown
  ): ReturnType<ReturnType<CreateAxiosResponseTransformer>> => {
    overwriteHeadersOrNoop(headers, camel, options);
    return camel(data, options);
  };
};
const overwriteHeadersOrNoop = (
  headers: unknown,
  fn: ObjectTransformer,
  options?: AxiosCaseMiddlewareOptions,
  excludedKeys?: string[]
): void => {
  if (
    options?.ignoreHeaders ||
    (!isPlainObject(headers) && !isAxiosHeaders(headers))
  ) {
    return;
  }
  for (const [key, value] of Object.entries(headers)) {
    fn(value, { overwrite: true, ...options });
    if ((excludedKeys || []).includes(key)) {
      continue;
    }
    if (isAxiosHeaders(headers)) {
      headers.delete(key);
      headers.set(
        Object.keys(fn({ [key]: null }, options) as TransformableObject)[0],
        value,
        true
      );
    } else {
      delete headers[key];
      headers[
        Object.keys(fn({ [key]: null }, options) as TransformableObject)[0]
      ] = value;
    }
  }
};

export const applyCaseMiddleware: ApplyCaseMiddleware = (axios, options?) => {
  axios.defaults.transformRequest = [
    options?.caseMiddleware?.requestTransformer ||
      createSnakeRequestTransformer(options),
    ...(Array.isArray(axios.defaults.transformRequest)
      ? axios.defaults.transformRequest
      : axios.defaults.transformRequest !== undefined
      ? [axios.defaults.transformRequest]
      : []),
  ];
  axios.defaults.transformResponse = [
    ...(Array.isArray(axios.defaults.transformResponse)
      ? axios.defaults.transformResponse
      : axios.defaults.transformResponse !== undefined
      ? [axios.defaults.transformResponse]
      : []),
    options?.caseMiddleware?.responseTransformer ||
      createCamelResponseTransformer(options),
  ];
  axios.interceptors.request.use(
    options?.caseMiddleware?.requestInterceptor ||
      createSnakeParamsInterceptor(options)
  );
  return axios;
};

1	import { createObjectTransformers } from './transformers';	2✔
2	import { isAxiosHeaders, isPlainObject } from './util';	2✔
3	import {
4	ApplyCaseMiddleware,
5	AxiosCaseMiddlewareOptions,
6	CreateAxiosRequestInterceptor,
7	CreateAxiosRequestTransformer,
8	CreateAxiosResponseTransformer,
9	ObjectTransformer,
10	TransformableObject,
11	} from './types';
12
13	export const createSnakeParamsInterceptor: CreateAxiosRequestInterceptor = (	2✔
14	options?
15	) => {
16	const { snake } = createObjectTransformers(options?.caseFunctions);	2!
17	return (config): ReturnType<ReturnType<CreateAxiosRequestInterceptor>> => {	2✔
18	if (config.params) {	4✔
19	config.params = snake(config.params, options);	4✔
20	}
21	return config;	4✔
22	};
23	};
24	export const createSnakeRequestTransformer: CreateAxiosRequestTransformer = (	2✔
25	options?
26	) => {
27	const { snake, header } = createObjectTransformers(options?.caseFunctions);	2!
28	return (	2✔
29	data: unknown,
30	headers?: unknown
31	): ReturnType<ReturnType<CreateAxiosRequestTransformer>> => {
32	overwriteHeadersOrNoop(headers, header, options, [	4✔
33	'common',
34	'delete',
35	'get',
36	'head',
37	'post',
38	'put',
39	'patch',
40	]);
41	return snake(data, options);	4✔
42	};
43	};
44	export const createCamelResponseTransformer: CreateAxiosResponseTransformer = (	2✔
45	options?
46	) => {
47	const { camel } = createObjectTransformers(options?.caseFunctions);	2!
48	return (	2✔
49	data: unknown,
50	headers?: unknown
51	): ReturnType<ReturnType<CreateAxiosResponseTransformer>> => {
52	overwriteHeadersOrNoop(headers, camel, options);	4✔
53	return camel(data, options);	4✔
54	};
55	};
56	const overwriteHeadersOrNoop = (	2✔
57	headers: unknown,
58	fn: ObjectTransformer,
59	options?: AxiosCaseMiddlewareOptions,
60	excludedKeys?: string[]
61	): void => {
62	if (	8!
63	options?.ignoreHeaders \|\|	48!
64	(!isPlainObject(headers) && !isAxiosHeaders(headers))
65	) {
66	return;	×
67	}
68	for (const [key, value] of Object.entries(headers)) {	24✔
69	fn(value, { overwrite: true, ...options });	24✔
70	if ((excludedKeys \|\| []).includes(key)) {	24!
UNCOV 71	continue;	×
72	}
73	if (isAxiosHeaders(headers)) {	24!
74	headers.delete(key);	24✔
75	headers.set(	24✔
76	Object.keys(fn({ [key]: null }, options) as TransformableObject)[0],
77	value,
78	true
79	);
80	} else {
UNCOV 81	delete headers[key];	×
UNCOV 82	headers[	×
83	Object.keys(fn({ [key]: null }, options) as TransformableObject)[0]
84	] = value;
85	}
86	}
87	};
88
89	export const applyCaseMiddleware: ApplyCaseMiddleware = (axios, options?) => {	2✔
90	axios.defaults.transformRequest = [	2✔
91	options?.caseMiddleware?.requestTransformer \|\|	16!
92	createSnakeRequestTransformer(options),
93	...(Array.isArray(axios.defaults.transformRequest)	2!
94	? axios.defaults.transformRequest
95	: axios.defaults.transformRequest !== undefined	×
96	? [axios.defaults.transformRequest]
97	: []),
98	];
99	axios.defaults.transformResponse = [	2✔
100	...(Array.isArray(axios.defaults.transformResponse)	2!
101	? axios.defaults.transformResponse
102	: axios.defaults.transformResponse !== undefined	×
103	? [axios.defaults.transformResponse]
104	: []),
105	options?.caseMiddleware?.responseTransformer \|\|	16!
106	createCamelResponseTransformer(options),
107	];
108	axios.interceptors.request.use(	2✔
109	options?.caseMiddleware?.requestInterceptor \|\|	16!
110	createSnakeParamsInterceptor(options)
111	);
112	return axios;	2✔
113	};

mpyw / axios-case-converter / 4232779217

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous