#2910

Committed 29 Sep 2024 12:26AM UTC coverage: 61.791% (+0.1%) from 61.654%

Build # #2910

Build Type

Committed by

Commit Message

Fix typing of `Stripe.V2.Event` (#2193)

Pull Request Pull Request #2192: Support for APIs in the new API version 2024-09-30

Run Details

1316 of 3273 branches covered (40.21%)

Branch coverage included in aggregate %.

196 of 207 new or added lines in 23 files covered. (94.69%)

250 existing lines in 9 files now uncovered.

3052 of 3796 relevant lines covered (80.4%)

192.98 hits per line

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

93.95

/src/utils.ts

import * as qs from 'qs';
import {
  RequestData,
  UrlInterpolator,
  RequestArgs,
  StripeResourceObject,
  RequestHeaders,
  MultipartRequestData,
  RequestAuthenticator,
  StripeRequest,
  ApiMode,
} from './Types.js';

const OPTIONS_KEYS = [
  'apiKey',
  'idempotencyKey',
  'stripeAccount',
  'apiVersion',
  'maxNetworkRetries',
  'timeout',
  'host',
  'authenticator',
  'stripeContext',
  'additionalHeaders',
];

type Settings = {
  timeout?: number;
  maxNetworkRetries?: number;
};

type Options = {
  authenticator?: RequestAuthenticator | null;
  host: string | null;
  settings: Settings;
  streaming?: boolean;
  headers: RequestHeaders;
};

export function isOptionsHash(o: unknown): boolean | unknown {
  return (
    o &&
    typeof o === 'object' &&
    OPTIONS_KEYS.some((prop) => Object.prototype.hasOwnProperty.call(o, prop))
  );
}

/**
 * Stringifies an Object, accommodating nested objects
 * (forming the conventional key 'parent[child]=value')
 */
export function queryStringifyRequestData(
  data: RequestData | string,
  apiMode?: ApiMode
): string {
  return (
    qs
      .stringify(data, {
        serializeDate: (d: Date) => Math.floor(d.getTime() / 1000).toString(),
        arrayFormat: apiMode == 'v2' ? 'repeat' : 'indices',
      })
      // Don't use strict form encoding by changing the square bracket control
      // characters back to their literals. This is fine by the server, and
      // makes these parameter strings easier to read.
      .replace(/%5B/g, '[')
      .replace(/%5D/g, ']')
  );
}

/**
 * Outputs a new function with interpolated object property values.
 * Use like so:
 *   const fn = makeURLInterpolator('some/url/{param1}/{param2}');
 *   fn({ param1: 123, param2: 456 }); // => 'some/url/123/456'
 */
export const makeURLInterpolator = ((): ((s: string) => UrlInterpolator) => {
  const rc = {
    '\n': '\\n',
    '"': '\\"',
    '\u2028': '\\u2028',
    '\u2029': '\\u2029',
  } as Record<string, string>;
  return (str: string): UrlInterpolator => {
    const cleanString = str.replace(/["\n\r\u2028\u2029]/g, ($0) => rc[$0]);
    return (outputs: Record<string, unknown>): string => {
      return cleanString.replace(/\{([\s\S]+?)\}/g, ($0, $1) =>
        // @ts-ignore
        encodeURIComponent(outputs[$1] || '')
      );
    };
  };
})();

export function extractUrlParams(path: string): Array<string> {
  const params = path.match(/\{\w+\}/g);
  if (!params) {
    return [];
  }

  return params.map((param) => param.replace(/[{}]/g, ''));
}

/**
 * Return the data argument from a list of arguments
 *
 * @param {object[]} args
 * @returns {object}
 */
export function getDataFromArgs(args: RequestArgs): RequestData {
  if (!Array.isArray(args) || !args[0] || typeof args[0] !== 'object') {
    return {};
  }

  if (!isOptionsHash(args[0])) {
    return args.shift();
  }

  const argKeys = Object.keys(args[0]);

  const optionKeysInArgs = argKeys.filter((key) => OPTIONS_KEYS.includes(key));

  // In some cases options may be the provided as the first argument.
  // Here we're detecting a case where there are two distinct arguments
  // (the first being args and the second options) and with known
  // option keys in the first so that we can warn the user about it.
  if (
    optionKeysInArgs.length > 0 &&
    optionKeysInArgs.length !== argKeys.length
  ) {
    emitWarning(
      `Options found in arguments (${optionKeysInArgs.join(
        ', '
      )}). Did you mean to pass an options object? See https://github.com/stripe/stripe-node/wiki/Passing-Options.`
    );
  }

  return {};
}

/**
 * Return the options hash from a list of arguments
 */
export function getOptionsFromArgs(args: RequestArgs): Options {
  const opts: Options = {
    host: null,
    headers: {},
    settings: {},
  };
  if (args.length > 0) {
    const arg = args[args.length - 1];
    if (typeof arg === 'string') {
      opts.authenticator = createApiKeyAuthenticator(args.pop() as string);
    } else if (isOptionsHash(arg)) {
      const params = {...(args.pop() as Record<string, unknown>)};

      const extraKeys = Object.keys(params).filter(
        (key) => !OPTIONS_KEYS.includes(key)
      );

      if (extraKeys.length) {
        emitWarning(
          `Invalid options found (${extraKeys.join(', ')}); ignoring.`
        );
      }

      if (params.apiKey) {
        opts.authenticator = createApiKeyAuthenticator(params.apiKey as string);
      }
      if (params.idempotencyKey) {
        opts.headers['Idempotency-Key'] = params.idempotencyKey as string;
      }
      if (params.stripeAccount) {
        opts.headers['Stripe-Account'] = params.stripeAccount as string;
      }
      if (params.stripeContext) {
        if (opts.headers['Stripe-Account']) {
          throw new Error(
            "Can't specify both stripeAccount and stripeContext."
          );
        }
        opts.headers['Stripe-Context'] = params.stripeContext as string;
      }
      if (params.apiVersion) {
        opts.headers['Stripe-Version'] = params.apiVersion as string;
      }
      if (Number.isInteger(params.maxNetworkRetries)) {
        opts.settings.maxNetworkRetries = params.maxNetworkRetries as number;
      }
      if (Number.isInteger(params.timeout)) {
        opts.settings.timeout = params.timeout as number;
      }
      if (params.host) {
        opts.host = params.host as string;
      }
      if (params.authenticator) {
        if (params.apiKey) {
          throw new Error("Can't specify both apiKey and authenticator.");
        }
        if (typeof params.authenticator !== 'function') {
          throw new Error(
            'The authenticator must be a function ' +
              'receiving a request as the first parameter.'
          );
        }
        opts.authenticator = params.authenticator as RequestAuthenticator;
      }
      if (params.additionalHeaders) {
        opts.headers = params.additionalHeaders as {
          [headerName: string]: string;
        };
      }
    }
  }
  return opts;
}

/**
 * Provide simple "Class" extension mechanism.
 * <!-- Public API accessible via Stripe.StripeResource.extend -->
 */
export function protoExtend(
  this: any,
  sub: any
): {new (...args: any[]): StripeResourceObject} {
  // eslint-disable-next-line @typescript-eslint/no-this-alias
  const Super = this;
  const Constructor = Object.prototype.hasOwnProperty.call(sub, 'constructor')
    ? sub.constructor
    : function(this: StripeResourceObject, ...args: any[]): void {
        Super.apply(this, args);
      };

  // This initialization logic is somewhat sensitive to be compatible with
  // divergent JS implementations like the one found in Qt. See here for more
  // context:
  //
  // https://github.com/stripe/stripe-node/pull/334
  Object.assign(Constructor, Super);
  Constructor.prototype = Object.create(Super.prototype);
  Object.assign(Constructor.prototype, sub);

  return Constructor;
}

/**
 * Remove empty values from an object
 */
export function removeNullish<T extends Record<string, unknown>>(obj: T): T {
  if (typeof obj !== 'object') {
    throw new Error('Argument must be an object');
  }

  return Object.keys(obj).reduce<Record<string, unknown>>((result, key) => {
    if (obj[key] != null) {
      result[key] = obj[key];
    }
    return result;
  }, {}) as T;
}

/**
 * Normalize standard HTTP Headers:
 * {'foo-bar': 'hi'}
 * becomes
 * {'Foo-Bar': 'hi'}
 */
export function normalizeHeaders(
  obj: RequestHeaders | null
): RequestHeaders | null {
  if (!(obj && typeof obj === 'object')) {
    return obj;
  }

  return Object.keys(obj).reduce<RequestHeaders>((result, header) => {
    result[normalizeHeader(header)] = obj[header];
    return result;
  }, {});
}

/**
 * Stolen from https://github.com/marten-de-vries/header-case-normalizer/blob/master/index.js#L36-L41
 * without the exceptions which are irrelevant to us.
 */
export function normalizeHeader(header: string): string {
  return header
    .split('-')
    .map((text) => text.charAt(0).toUpperCase() + text.substr(1).toLowerCase())
    .join('-');
}

export function callbackifyPromiseWithTimeout<T>(
  promise: Promise<T>,
  callback: ((error: unknown, result: T | null) => void) | null
): Promise<T | void> {
  if (callback) {
    // Ensure callback is called outside of promise stack.
    return promise.then(
      (res) => {
        setTimeout(() => {
          callback(null, res);
        }, 0);
      },
      (err) => {
        setTimeout(() => {
          callback(err, null);
        }, 0);
      }
    );
  }

  return promise;
}

/**
 * Allow for special capitalization cases (such as OAuth)
 */
export function pascalToCamelCase(name: string): string {
  if (name === 'OAuth') {
    return 'oauth';
  } else {
    return name[0].toLowerCase() + name.substring(1);
  }
}

export function emitWarning(warning: string): void {
  if (typeof process.emitWarning !== 'function') {
    return console.warn(
      `Stripe: ${warning}`
    ); /* eslint-disable-line no-console */
  }

  return process.emitWarning(warning, 'Stripe');
}

export function isObject(obj: unknown): boolean {
  const type = typeof obj;
  return (type === 'function' || type === 'object') && !!obj;
}

// For use in multipart requests
export function flattenAndStringify(
  data: MultipartRequestData
): Record<string, string | Uint8Array> {
  const result: Record<string, string | Uint8Array> = {};

  const step = (obj: MultipartRequestData, prevKey: string | null): void => {
    Object.entries(obj).forEach(([key, value]) => {
      const newKey = prevKey ? `${prevKey}[${key}]` : key;

      if (isObject(value)) {
        if (
          !(value instanceof Uint8Array) &&
          !Object.prototype.hasOwnProperty.call(value, 'data')
        ) {
          // Non-buffer non-file Objects are recursively flattened
          return step(value, newKey);
        } else {
          // Buffers and file objects are stored without modification
          result[newKey] = value;
        }
      } else {
        // Primitives are converted to strings
        result[newKey] = String(value);
      }
    });
  };

  step(data, null);

  return result;
}

export function validateInteger(
  name: string,
  n: unknown,
  defaultVal?: number
): number {
  if (!Number.isInteger(n)) {
    if (defaultVal !== undefined) {
      return defaultVal;
    } else {
      throw new Error(`${name} must be an integer`);
    }
  }

  return n as number;
}

export function determineProcessUserAgentProperties(): Record<string, string> {
  return typeof process === 'undefined'
    ? {}
    : {
        lang_version: process.version,
        platform: process.platform,
      };
}

export function createApiKeyAuthenticator(
  apiKey: string
): RequestAuthenticator {
  const authenticator = (request: StripeRequest): Promise<void> => {
    request.headers.Authorization = 'Bearer ' + apiKey;
    return Promise.resolve();
  };

  // For testing
  authenticator._apiKey = apiKey;

  return authenticator;
}

/**
 * Joins an array of Uint8Arrays into a single Uint8Array
 */
export function concat(arrays: Array<Uint8Array>): Uint8Array {
  const totalLength = arrays.reduce((len, array) => len + array.length, 0);
  const merged = new Uint8Array(totalLength);

  let offset = 0;
  arrays.forEach((array) => {
    merged.set(array, offset);
    offset += array.length;
  });

  return merged;
}

/**
 * Replaces Date objects with Unix timestamps
 */
function dateTimeReplacer(this: any, key: string, value: any): string {
  if (this[key] instanceof Date) {
    return Math.floor(this[key].getTime() / 1000).toString();
  }

  return value;
}

/**
 * JSON stringifies an Object, replacing Date objects with Unix timestamps
 */
export function jsonStringifyRequestData(data: RequestData | string): string {
  return JSON.stringify(data, dateTimeReplacer);
}

/**
 * Inspects the given path to determine if the endpoint is for v1 or v2 API
 */
export function getAPIMode(path?: string): ApiMode {
  if (!path) {
    return 'v1';
  }
  return path.startsWith('/v2') ? 'v2' : 'v1';
}

1	import * as qs from 'qs';	3✔
2	import {
3	RequestData,
4	UrlInterpolator,
5	RequestArgs,
6	StripeResourceObject,
7	RequestHeaders,
8	MultipartRequestData,
9	RequestAuthenticator,
10	StripeRequest,
11	ApiMode,
12	} from './Types.js';
13
14	const OPTIONS_KEYS = [	3✔
15	'apiKey',
16	'idempotencyKey',
17	'stripeAccount',
18	'apiVersion',
19	'maxNetworkRetries',
20	'timeout',
21	'host',
22	'authenticator',
23	'stripeContext',
24	'additionalHeaders',
25	];
26
27	type Settings = {
28	timeout?: number;
29	maxNetworkRetries?: number;
30	};
31
32	type Options = {
33	authenticator?: RequestAuthenticator \| null;
34	host: string \| null;
35	settings: Settings;
36	streaming?: boolean;
37	headers: RequestHeaders;
38	};
39
40	export function isOptionsHash(o: unknown): boolean \| unknown {	3✔
41	return (	560✔
42	o &&	1,669✔
43	typeof o === 'object' &&
44	OPTIONS_KEYS.some((prop) => Object.prototype.hasOwnProperty.call(o, prop))	5,283✔
45	);
46	}
47
48	/**
49	* Stringifies an Object, accommodating nested objects
50	* (forming the conventional key 'parent[child]=value')
51	*/
52	export function queryStringifyRequestData(	3✔
53	data: RequestData \| string,
54	apiMode?: ApiMode
55	): string {
56	return (	1,812✔
57	qs
58	.stringify(data, {
59	serializeDate: (d: Date) => Math.floor(d.getTime() / 1000).toString(),	4✔
60	arrayFormat: apiMode == 'v2' ? 'repeat' : 'indices',	1,812✔
61	})
62	// Don't use strict form encoding by changing the square bracket control
63	// characters back to their literals. This is fine by the server, and
64	// makes these parameter strings easier to read.
65	.replace(/%5B/g, '[')
66	.replace(/%5D/g, ']')
67	);
68	}
69
70	/**
71	* Outputs a new function with interpolated object property values.
72	* Use like so:
73	* const fn = makeURLInterpolator('some/url/{param1}/{param2}');
74	* fn({ param1: 123, param2: 456 }); // => 'some/url/123/456'
75	*/
76	export const makeURLInterpolator = ((): ((s: string) => UrlInterpolator) => {	3✔
77	const rc = {	3✔
78	'\n': '\\n',
79	'"': '\\"',
80	'\u2028': '\\u2028',
81	'\u2029': '\\u2029',
82	} as Record<string, string>;
83	return (str: string): UrlInterpolator => {	3✔
84	const cleanString = str.replace(/["\n\r\u2028\u2029]/g, ($0) => rc[$0]);	46,431✔
85	return (outputs: Record<string, unknown>): string => {	46,431✔
86	return cleanString.replace(/\{([\s\S]+?)\}/g, ($0, $1) =>	979✔
87	// @ts-ignore
88	encodeURIComponent(outputs[$1] \|\| '')	565✔
89	);
90	};
91	};
92	})();
93
94	export function extractUrlParams(path: string): Array<string> {	3✔
95	const params = path.match(/\{\w+\}/g);	872✔
96	if (!params) {	872✔
97	return [];	369✔
98	}
99
100	return params.map((param) => param.replace(/[{}]/g, ''));	561✔
101	}
102
103	/**
104	* Return the data argument from a list of arguments
105	*
106	* @param {object[]} args
107	* @returns {object}
108	*/
109	export function getDataFromArgs(args: RequestArgs): RequestData {	3✔
110	if (!Array.isArray(args) \|\| !args[0] \|\| typeof args[0] !== 'object') {	1,240✔
111	return {};	723✔
112	}
113
114	if (!isOptionsHash(args[0])) {	517✔
115	return args.shift();	508✔
116	}
117
118	const argKeys = Object.keys(args[0]);	9✔
119
120	const optionKeysInArgs = argKeys.filter((key) => OPTIONS_KEYS.includes(key));	12✔
121
122	// In some cases options may be the provided as the first argument.
123	// Here we're detecting a case where there are two distinct arguments
124	// (the first being args and the second options) and with known
125	// option keys in the first so that we can warn the user about it.
126	if (	9✔
127	optionKeysInArgs.length > 0 &&	18✔
128	optionKeysInArgs.length !== argKeys.length
129	) {
130	emitWarning(	1✔
131	`Options found in arguments (${optionKeysInArgs.join(
132	', '
133	)}). Did you mean to pass an options object? See https://github.com/stripe/stripe-node/wiki/Passing-Options.`
134	);
135	}
136
137	return {};	9✔
138	}
139
140	/**
141	* Return the options hash from a list of arguments
142	*/
143	export function getOptionsFromArgs(args: RequestArgs): Options {	3✔
144	const opts: Options = {	952✔
145	host: null,
146	headers: {},
147	settings: {},
148	};
149	if (args.length > 0) {	952✔
150	const arg = args[args.length - 1];	71✔
151	if (typeof arg === 'string') {	71✔
152	opts.authenticator = createApiKeyAuthenticator(args.pop() as string);	28✔
153	} else if (isOptionsHash(arg)) {	43✔
154	const params = {...(args.pop() as Record<string, unknown>)};	33✔
155
156	const extraKeys = Object.keys(params).filter(	33✔
157	(key) => !OPTIONS_KEYS.includes(key)	46✔
158	);
159
160	if (extraKeys.length) {	33✔
161	emitWarning(	1✔
162	`Invalid options found (${extraKeys.join(', ')}); ignoring.`
163	);
164	}
165
166	if (params.apiKey) {	33✔
167	opts.authenticator = createApiKeyAuthenticator(params.apiKey as string);	7✔
168	}
169	if (params.idempotencyKey) {	33✔
170	opts.headers['Idempotency-Key'] = params.idempotencyKey as string;	8✔
171	}
172	if (params.stripeAccount) {	33✔
173	opts.headers['Stripe-Account'] = params.stripeAccount as string;	1✔
174	}
175	if (params.stripeContext) {	33✔
176	if (opts.headers['Stripe-Account']) {	1!
NEW 177	throw new Error(	×
178	"Can't specify both stripeAccount and stripeContext."
179	);
180	}
181	opts.headers['Stripe-Context'] = params.stripeContext as string;	1✔
182	}
183	if (params.apiVersion) {	33✔
184	opts.headers['Stripe-Version'] = params.apiVersion as string;	7✔
185	}
186	if (Number.isInteger(params.maxNetworkRetries)) {	33✔
187	opts.settings.maxNetworkRetries = params.maxNetworkRetries as number;	8✔
188	}
189	if (Number.isInteger(params.timeout)) {	33✔
190	opts.settings.timeout = params.timeout as number;	2✔
191	}
192	if (params.host) {	33✔
193	opts.host = params.host as string;	6✔
194	}
195	if (params.authenticator) {	33!
NEW 196	if (params.apiKey) {	×
NEW 197	throw new Error("Can't specify both apiKey and authenticator.");	×
198	}
NEW 199	if (typeof params.authenticator !== 'function') {	×
NEW 200	throw new Error(	×
201	'The authenticator must be a function ' +
202	'receiving a request as the first parameter.'
203	);
204	}
NEW 205	opts.authenticator = params.authenticator as RequestAuthenticator;	×
206	}
207	if (params.additionalHeaders) {	33✔
208	opts.headers = params.additionalHeaders as {	2✔
209	[headerName: string]: string;
210	};
211	}
212	}
213	}
214	return opts;	952✔
215	}
216
217	/**
218	* Provide simple "Class" extension mechanism.
219	* <!-- Public API accessible via Stripe.StripeResource.extend -->
220	*/
221	export function protoExtend(	3✔
222	this: any,
223	sub: any
224	): {new (...args: any[]): StripeResourceObject} {
225	// eslint-disable-next-line @typescript-eslint/no-this-alias
226	const Super = this;	395✔
227	const Constructor = Object.prototype.hasOwnProperty.call(sub, 'constructor')	395✔
228	? sub.constructor
229	: function(this: StripeResourceObject, ...args: any[]): void {
230	Super.apply(this, args);	22,186✔
231	};
232
233	// This initialization logic is somewhat sensitive to be compatible with
234	// divergent JS implementations like the one found in Qt. See here for more
235	// context:
236	//
237	// https://github.com/stripe/stripe-node/pull/334
238	Object.assign(Constructor, Super);	395✔
239	Constructor.prototype = Object.create(Super.prototype);	395✔
240	Object.assign(Constructor.prototype, sub);	395✔
241
242	return Constructor;	395✔
243	}
244
245	/**
246	* Remove empty values from an object
247	*/
248	export function removeNullish<T extends Record<string, unknown>>(obj: T): T {	3✔
249	if (typeof obj !== 'object') {	2,642✔
250	throw new Error('Argument must be an object');	1✔
251	}
252
253	return Object.keys(obj).reduce<Record<string, unknown>>((result, key) => {	2,641✔
254	if (obj[key] != null) {	22,379✔
255	result[key] = obj[key];	15,614✔
256	}
257	return result;	22,379✔
258	}, {}) as T;
259	}
260
261	/**
262	* Normalize standard HTTP Headers:
263	* {'foo-bar': 'hi'}
264	* becomes
265	* {'Foo-Bar': 'hi'}
266	*/
267	export function normalizeHeaders(	3✔
268	obj: RequestHeaders \| null
269	): RequestHeaders \| null {
270	if (!(obj && typeof obj === 'object')) {	881✔
271	return obj;	6✔
272	}
273
274	return Object.keys(obj).reduce<RequestHeaders>((result, header) => {	875✔
275	result[normalizeHeader(header)] = obj[header];	15✔
276	return result;	15✔
277	}, {});
278	}
279
280	/**
281	* Stolen from https://github.com/marten-de-vries/header-case-normalizer/blob/master/index.js#L36-L41
282	* without the exceptions which are irrelevant to us.
283	*/
284	export function normalizeHeader(header: string): string {	3✔
285	return header	15✔
286	.split('-')
287	.map((text) => text.charAt(0).toUpperCase() + text.substr(1).toLowerCase())	28✔
288	.join('-');
289	}
290
291	export function callbackifyPromiseWithTimeout<T>(	3✔
292	promise: Promise<T>,
293	callback: ((error: unknown, result: T \| null) => void) \| null
294	): Promise<T \| void> {
295	if (callback) {	919✔
296	// Ensure callback is called outside of promise stack.
297	return promise.then(	75✔
298	(res) => {
299	setTimeout(() => {	53✔
300	callback(null, res);	53✔
301	}, 0);
302	},
303	(err) => {
304	setTimeout(() => {	22✔
305	callback(err, null);	22✔
306	}, 0);
307	}
308	);
309	}
310
311	return promise;	844✔
312	}
313
314	/**
315	* Allow for special capitalization cases (such as OAuth)
316	*/
317	export function pascalToCamelCase(name: string): string {	3✔
318	if (name === 'OAuth') {	12,496✔
319	return 'oauth';	176✔
320	} else {
321	return name[0].toLowerCase() + name.substring(1);	12,320✔
322	}
323	}
324
325	export function emitWarning(warning: string): void {	3✔
326	if (typeof process.emitWarning !== 'function') {	3!
327	return console.warn(	×
328	`Stripe: ${warning}`
329	); /* eslint-disable-line no-console */
330	}
331
332	return process.emitWarning(warning, 'Stripe');	3✔
333	}
334
335	export function isObject(obj: unknown): boolean {	3✔
336	const type = typeof obj;	45✔
337	return (type === 'function' \|\| type === 'object') && !!obj;	45✔
338	}
339
340	// For use in multipart requests
341	export function flattenAndStringify(	3✔
342	data: MultipartRequestData
343	): Record<string, string \| Uint8Array> {
344	const result: Record<string, string \| Uint8Array> = {};	12✔
345
346	const step = (obj: MultipartRequestData, prevKey: string \| null): void => {	12✔
347	Object.entries(obj).forEach(([key, value]) => {	23✔
348	const newKey = prevKey ? `${prevKey}[${key}]` : key;	45✔
349
350	if (isObject(value)) {	45✔
351	if (	21✔
352	!(value instanceof Uint8Array) &&	41✔
353	!Object.prototype.hasOwnProperty.call(value, 'data')
354	) {
355	// Non-buffer non-file Objects are recursively flattened
356	return step(value, newKey);	11✔
357	} else {
358	// Buffers and file objects are stored without modification
359	result[newKey] = value;	10✔
360	}
361	} else {
362	// Primitives are converted to strings
363	result[newKey] = String(value);	24✔
364	}
365	});
366	};
367
368	step(data, null);	12✔
369
370	return result;	12✔
371	}
372
373	export function validateInteger(	3✔
374	name: string,
375	n: unknown,
376	defaultVal?: number
377	): number {
378	if (!Number.isInteger(n)) {	452✔
379	if (defaultVal !== undefined) {	358✔
380	return defaultVal;	352✔
381	} else {
382	throw new Error(`${name} must be an integer`);	6✔
383	}
384	}
385
386	return n as number;	94✔
387	}
388
389	export function determineProcessUserAgentProperties(): Record<string, string> {	3✔
390	return typeof process === 'undefined'	41!
391	? {}
392	: {
393	lang_version: process.version,
394	platform: process.platform,
395	};
396	}
397
398	export function createApiKeyAuthenticator(	3✔
399	apiKey: string
400	): RequestAuthenticator {
401	const authenticator = (request: StripeRequest): Promise<void> => {	210✔
402	request.headers.Authorization = 'Bearer ' + apiKey;	895✔
403	return Promise.resolve();	895✔
404	};
405
406	// For testing
407	authenticator._apiKey = apiKey;	210✔
408
409	return authenticator;	210✔
410	}
411
412	/**
413	* Joins an array of Uint8Arrays into a single Uint8Array
414	*/
415	export function concat(arrays: Array<Uint8Array>): Uint8Array {	3✔
416	const totalLength = arrays.reduce((len, array) => len + array.length, 0);	9✔
417	const merged = new Uint8Array(totalLength);	8✔
418
419	let offset = 0;	8✔
420	arrays.forEach((array) => {	8✔
421	merged.set(array, offset);	9✔
422	offset += array.length;	9✔
423	});
424
425	return merged;	8✔
426	}
427
428	/**
429	* Replaces Date objects with Unix timestamps
430	*/
431	function dateTimeReplacer(this: any, key: string, value: any): string {
432	if (this[key] instanceof Date) {	13✔
433	return Math.floor(this[key].getTime() / 1000).toString();	2✔
434	}
435
436	return value;	11✔
437	}
438
439	/**
440	* JSON stringifies an Object, replacing Date objects with Unix timestamps
441	*/
442	export function jsonStringifyRequestData(data: RequestData \| string): string {	3✔
443	return JSON.stringify(data, dateTimeReplacer);	7✔
444	}
445
446	/**
447	* Inspects the given path to determine if the endpoint is for v1 or v2 API
448	*/
449	export function getAPIMode(path?: string): ApiMode {	3✔
450	if (!path) {	2,712✔
451	return 'v1';	11✔
452	}
453	return path.startsWith('/v2') ? 'v2' : 'v1';	2,701✔
454	}

stripe / stripe-node / #2910

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