#2904

Committed 27 Sep 2024 07:41PM UTC coverage: 61.791% (-0.04%) from 61.83%

Build # #2904

Build Type

push

Committed by

Commit Message

Adding support for the new Usage Billing APIs (#2184)

Run Details

1316 of 3273 branches covered (40.21%)

Branch coverage included in aggregate %.

183 of 194 new or added lines in 19 files covered. (94.33%)

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

90.83

/src/stripe.core.ts

import * as _Error from './Error.js';
import {RequestSender} from './RequestSender.js';
import {StripeResource} from './StripeResource.js';
import {
  AppInfo,
  RequestAuthenticator,
  StripeObject,
  UserProvidedConfig,
  RequestData,
  RequestOptions,
} from './Types.js';
import {WebhookObject, WebhookEvent, createWebhooks} from './Webhooks.js';
import {ApiVersion} from './apiVersion.js';
import {CryptoProvider} from './crypto/CryptoProvider.js';
import {HttpClient, HttpClientResponse} from './net/HttpClient.js';
import {PlatformFunctions} from './platform/PlatformFunctions.js';
import * as resources from './resources.js';
import {
  createApiKeyAuthenticator,
  determineProcessUserAgentProperties,
  pascalToCamelCase,
  validateInteger,
} from './utils.js';

const DEFAULT_HOST = 'api.stripe.com';
const DEFAULT_PORT = '443';
const DEFAULT_BASE_PATH = '/v1/';
const DEFAULT_API_VERSION = ApiVersion;

const DEFAULT_TIMEOUT = 80000;

const MAX_NETWORK_RETRY_DELAY_SEC = 5;
const INITIAL_NETWORK_RETRY_DELAY_SEC = 0.5;

const APP_INFO_PROPERTIES = ['name', 'version', 'url', 'partner_id'];
const ALLOWED_CONFIG_PROPERTIES = [
  'authenticator',
  'apiVersion',
  'typescript',
  'maxNetworkRetries',
  'httpAgent',
  'httpClient',
  'timeout',
  'host',
  'port',
  'protocol',
  'telemetry',
  'appInfo',
  'stripeAccount',
  'stripeContext',
];

type RequestSenderFactory = (stripe: StripeObject) => RequestSender;

const defaultRequestSenderFactory: RequestSenderFactory = (stripe) =>
  new RequestSender(stripe, StripeResource.MAX_BUFFERED_REQUEST_METRICS);

export function createStripe(
  platformFunctions: PlatformFunctions,
  requestSender: RequestSenderFactory = defaultRequestSenderFactory
): typeof Stripe {
  Stripe.PACKAGE_VERSION = '16.12.0';
  Stripe.USER_AGENT = {
    bindings_version: Stripe.PACKAGE_VERSION,
    lang: 'node',
    publisher: 'stripe',
    uname: null,
    typescript: false,
    ...determineProcessUserAgentProperties(),
  };
  Stripe.StripeResource = StripeResource;
  Stripe.resources = resources;
  Stripe.HttpClient = HttpClient;
  Stripe.HttpClientResponse = HttpClientResponse;
  Stripe.CryptoProvider = CryptoProvider;

  // Previously Stripe.webhooks was just the createWebhooks() factory function
  // however going forward it will be a WebhookObject instance. To maintain
  // backwards compatibility it is currently a factory function that also
  // complies to the WebhookObject signature. The factory function signature
  // will be removed as a breaking change in the next major release.
  // See https://github.com/stripe/stripe-node/issues/1956
  function createWebhooksDefault(fns = platformFunctions): WebhookObject {
    return createWebhooks(fns);
  }
  Stripe.webhooks = Object.assign(
    createWebhooksDefault,
    createWebhooks(platformFunctions)
  );

  function Stripe(
    this: StripeObject,
    key: string,
    config: Record<string, unknown> = {}
  ): void {
    if (!(this instanceof Stripe)) {
      return new (Stripe as any)(key, config);
    }

    const props = this._getPropsFromConfig(config);

    this._platformFunctions = platformFunctions;

    Object.defineProperty(this, '_emitter', {
      value: this._platformFunctions.createEmitter(),
      enumerable: false,
      configurable: false,
      writable: false,
    });

    this.VERSION = Stripe.PACKAGE_VERSION;

    this.on = this._emitter.on.bind(this._emitter);
    this.once = this._emitter.once.bind(this._emitter);
    this.off = this._emitter.removeListener.bind(this._emitter);

    const agent = props.httpAgent || null;

    this._api = {
      host: props.host || DEFAULT_HOST,
      port: props.port || DEFAULT_PORT,
      protocol: props.protocol || 'https',
      basePath: DEFAULT_BASE_PATH,
      version: props.apiVersion || DEFAULT_API_VERSION,
      timeout: validateInteger('timeout', props.timeout, DEFAULT_TIMEOUT),
      maxNetworkRetries: validateInteger(
        'maxNetworkRetries',
        props.maxNetworkRetries,
        2
      ),
      agent: agent,
      httpClient:
        props.httpClient ||
        (agent
          ? this._platformFunctions.createNodeHttpClient(agent)
          : this._platformFunctions.createDefaultHttpClient()),
      dev: false,
      stripeAccount: props.stripeAccount || null,
      stripeContext: props.stripeContext || null,
    };

    const typescript = props.typescript || false;
    if (typescript !== Stripe.USER_AGENT.typescript) {
      // The mutation here is uncomfortable, but likely fastest;
      // serializing the user agent involves shelling out to the system,
      // and given some users may instantiate the library many times without switching between TS and non-TS,
      // we only want to incur the performance hit when that actually happens.
      Stripe.USER_AGENT.typescript = typescript;
    }

    if (props.appInfo) {
      this._setAppInfo(props.appInfo);
    }

    this._prepResources();
    this._setAuthenticator(key, props.authenticator);

    this.errors = _Error;

    // Once Stripe.webhooks looses the factory function signature in a future release
    // then this should become this.webhooks = Stripe.webhooks
    this.webhooks = createWebhooksDefault();

    this._prevRequestMetrics = [];
    this._enableTelemetry = props.telemetry !== false;

    this._requestSender = requestSender(this);

    // Expose StripeResource on the instance too
    // @ts-ignore
    this.StripeResource = Stripe.StripeResource;
  }

  Stripe.errors = _Error;

  Stripe.createNodeHttpClient = platformFunctions.createNodeHttpClient;

  /**
   * Creates an HTTP client for issuing Stripe API requests which uses the Web
   * Fetch API.
   *
   * A fetch function can optionally be passed in as a parameter. If none is
   * passed, will default to the default `fetch` function in the global scope.
   */
  Stripe.createFetchHttpClient = platformFunctions.createFetchHttpClient;

  /**
   * Create a CryptoProvider which uses the built-in Node crypto libraries for
   * its crypto operations.
   */
  Stripe.createNodeCryptoProvider = platformFunctions.createNodeCryptoProvider;

  /**
   * Creates a CryptoProvider which uses the Subtle Crypto API from the Web
   * Crypto API spec for its crypto operations.
   *
   * A SubtleCrypto interface can optionally be passed in as a parameter. If none
   * is passed, will default to the default `crypto.subtle` object in the global
   * scope.
   */
  Stripe.createSubtleCryptoProvider =
    platformFunctions.createSubtleCryptoProvider;

  Stripe.prototype = {
    // Properties are set in the constructor above
    _appInfo: undefined!,
    on: null!,
    off: null!,
    once: null!,
    VERSION: null!,
    StripeResource: null!,
    webhooks: null!,
    errors: null!,
    _api: null!,
    _prevRequestMetrics: null!,
    _emitter: null!,
    _enableTelemetry: null!,
    _requestSender: null!,
    _platformFunctions: null!,

    rawRequest(
      method: string,
      path: string,
      params?: RequestData,
      options?: RequestOptions
    ): Promise<any> {
      return this._requestSender._rawRequest(method, path, params, options);
    },

    /**
     * @private
     */
    _setAuthenticator(
      key: string,
      authenticator: RequestAuthenticator | undefined
    ): void {
      if (key && authenticator) {
        throw new Error("Can't specify both apiKey and authenticator");
      }

      if (!key && !authenticator) {
        throw new Error('Neither apiKey nor config.authenticator provided');
      }

      this._authenticator = key
        ? createApiKeyAuthenticator(key)
        : authenticator;
    },

    /**
     * @private
     * This may be removed in the future.
     */
    _setAppInfo(info: AppInfo): void {
      if (info && typeof info !== 'object') {
        throw new Error('AppInfo must be an object.');
      }

      if (info && !info.name) {
        throw new Error('AppInfo.name is required');
      }

      info = info || {};

      this._appInfo = APP_INFO_PROPERTIES.reduce<Record<string, any>>(
        (accum: Record<string, any>, prop) => {
          if (typeof info[prop] == 'string') {
            accum = accum || {};

            accum[prop] = info[prop];
          }

          return accum;
        },
        // @ts-ignore
        undefined
      );
    },

    /**
     * @private
     * This may be removed in the future.
     */
    _setApiField<K extends keyof StripeObject['_api']>(
      key: K,
      value: StripeObject['_api'][K]
    ): void {
      this._api[key] = value;
    },

    /**
     * @private
     * Please open or upvote an issue at github.com/stripe/stripe-node
     * if you use this, detailing your use-case.
     *
     * It may be deprecated and removed in the future.
     */
    getApiField<K extends keyof StripeObject['_api']>(
      key: K
    ): StripeObject['_api'][K] {
      return this._api[key];
    },

    setClientId(clientId: string): void {
      this._clientId = clientId;
    },

    getClientId(): string | undefined {
      return this._clientId;
    },

    /**
     * @private
     * Please open or upvote an issue at github.com/stripe/stripe-node
     * if you use this, detailing your use-case.
     *
     * It may be deprecated and removed in the future.
     */
    getConstant: (c: string): unknown => {
      switch (c) {
        case 'DEFAULT_HOST':
          return DEFAULT_HOST;
        case 'DEFAULT_PORT':
          return DEFAULT_PORT;
        case 'DEFAULT_BASE_PATH':
          return DEFAULT_BASE_PATH;
        case 'DEFAULT_API_VERSION':
          return DEFAULT_API_VERSION;
        case 'DEFAULT_TIMEOUT':
          return DEFAULT_TIMEOUT;
        case 'MAX_NETWORK_RETRY_DELAY_SEC':
          return MAX_NETWORK_RETRY_DELAY_SEC;
        case 'INITIAL_NETWORK_RETRY_DELAY_SEC':
          return INITIAL_NETWORK_RETRY_DELAY_SEC;
      }
      return ((Stripe as unknown) as Record<string, unknown>)[c];
    },

    getMaxNetworkRetries(): number {
      return this.getApiField('maxNetworkRetries');
    },

    /**
     * @private
     * This may be removed in the future.
     */
    _setApiNumberField(
      prop: keyof StripeObject['_api'],
      n: number,
      defaultVal?: number
    ): void {
      const val = validateInteger(prop, n, defaultVal);

      this._setApiField(prop, val);
    },

    getMaxNetworkRetryDelay(): number {
      return MAX_NETWORK_RETRY_DELAY_SEC;
    },

    getInitialNetworkRetryDelay(): number {
      return INITIAL_NETWORK_RETRY_DELAY_SEC;
    },

    /**
     * @private
     * Please open or upvote an issue at github.com/stripe/stripe-node
     * if you use this, detailing your use-case.
     *
     * It may be deprecated and removed in the future.
     *
     * Gets a JSON version of a User-Agent and uses a cached version for a slight
     * speed advantage.
     */
    getClientUserAgent(cb: (userAgent: string) => void): void {
      return this.getClientUserAgentSeeded(Stripe.USER_AGENT, cb);
    },

    /**
     * @private
     * Please open or upvote an issue at github.com/stripe/stripe-node
     * if you use this, detailing your use-case.
     *
     * It may be deprecated and removed in the future.
     *
     * Gets a JSON version of a User-Agent by encoding a seeded object and
     * fetching a uname from the system.
     */
    getClientUserAgentSeeded(
      seed: Record<string, string | boolean | null>,
      cb: (userAgent: string) => void
    ): void {
      this._platformFunctions.getUname().then((uname: string | null) => {
        const userAgent: Record<string, string> = {};
        for (const field in seed) {
          if (!Object.prototype.hasOwnProperty.call(seed, field)) {
            continue;
          }
          userAgent[field] = encodeURIComponent(seed[field] ?? 'null');
        }

        // URI-encode in case there are unusual characters in the system's uname.
        userAgent.uname = encodeURIComponent(uname || 'UNKNOWN');

        const client = this.getApiField('httpClient');
        if (client) {
          userAgent.httplib = encodeURIComponent(client.getClientName());
        }

        if (this._appInfo) {
          userAgent.application = this._appInfo;
        }

        cb(JSON.stringify(userAgent));
      });
    },

    /**
     * @private
     * Please open or upvote an issue at github.com/stripe/stripe-node
     * if you use this, detailing your use-case.
     *
     * It may be deprecated and removed in the future.
     */
    getAppInfoAsString(): string {
      if (!this._appInfo) {
        return '';
      }

      let formatted = this._appInfo.name;

      if (this._appInfo.version) {
        formatted += `/${this._appInfo.version}`;
      }

      if (this._appInfo.url) {
        formatted += ` (${this._appInfo.url})`;
      }

      return formatted;
    },

    getTelemetryEnabled(): boolean {
      return this._enableTelemetry;
    },

    /**
     * @private
     * This may be removed in the future.
     */
    _prepResources(): void {
      for (const name in resources) {
        if (!Object.prototype.hasOwnProperty.call(resources, name)) {
          continue;
        }

        // @ts-ignore
        this[pascalToCamelCase(name)] = new resources[name](this);
      }
    },

    /**
     * @private
     * This may be removed in the future.
     */
    _getPropsFromConfig(config: Record<string, unknown>): UserProvidedConfig {
      // If config is null or undefined, just bail early with no props
      if (!config) {
        return {};
      }

      // config can be an object or a string
      const isString = typeof config === 'string';
      const isObject = config === Object(config) && !Array.isArray(config);

      if (!isObject && !isString) {
        throw new Error('Config must either be an object or a string');
      }

      // If config is a string, we assume the old behavior of passing in a string representation of the api version
      if (isString) {
        return {
          apiVersion: config,
        };
      }

      // If config is an object, we assume the new behavior and make sure it doesn't contain any unexpected values
      const values = Object.keys(config).filter(
        (value) => !ALLOWED_CONFIG_PROPERTIES.includes(value)
      );

      if (values.length > 0) {
        throw new Error(
          `Config object may only contain the following: ${ALLOWED_CONFIG_PROPERTIES.join(
            ', '
          )}`
        );
      }

      return config;
    },

    parseThinEvent(
      payload: string | Uint8Array,
      header: string | Uint8Array,
      secret: string,
      tolerance?: number,
      cryptoProvider?: CryptoProvider,
      receivedAt?: number
    ): WebhookEvent {
      // parses and validates the event payload all in one go
      return this.webhooks.constructEvent(
        payload,
        header,
        secret,
        tolerance,
        cryptoProvider,
        receivedAt
      );
    },

    parseSnapshotEvent(
      payload: string | Uint8Array,
      header: string | Uint8Array,
      secret: string,
      tolerance?: number,
      cryptoProvider?: CryptoProvider,
      receivedAt?: number
    ): WebhookEvent {
      return this.webhooks.constructEvent(
        payload,
        header,
        secret,
        tolerance,
        cryptoProvider,
        receivedAt
      );
    },
  } as StripeObject;

  return Stripe;
}

1	import * as _Error from './Error.js';	3✔
2	import {RequestSender} from './RequestSender.js';	3✔
3	import {StripeResource} from './StripeResource.js';	3✔
4	import {
5	AppInfo,
6	RequestAuthenticator,
7	StripeObject,
8	UserProvidedConfig,
9	RequestData,
10	RequestOptions,
11	} from './Types.js';
12	import {WebhookObject, WebhookEvent, createWebhooks} from './Webhooks.js';	3✔
13	import {ApiVersion} from './apiVersion.js';	3✔
14	import {CryptoProvider} from './crypto/CryptoProvider.js';	3✔
15	import {HttpClient, HttpClientResponse} from './net/HttpClient.js';	3✔
16	import {PlatformFunctions} from './platform/PlatformFunctions.js';
17	import * as resources from './resources.js';	3✔
18	import {	3✔
19	createApiKeyAuthenticator,
20	determineProcessUserAgentProperties,
21	pascalToCamelCase,
22	validateInteger,
23	} from './utils.js';
24
25	const DEFAULT_HOST = 'api.stripe.com';	3✔
26	const DEFAULT_PORT = '443';	3✔
27	const DEFAULT_BASE_PATH = '/v1/';	3✔
28	const DEFAULT_API_VERSION = ApiVersion;	3✔
29
30	const DEFAULT_TIMEOUT = 80000;	3✔
31
32	const MAX_NETWORK_RETRY_DELAY_SEC = 5;	3✔
33	const INITIAL_NETWORK_RETRY_DELAY_SEC = 0.5;	3✔
34
35	const APP_INFO_PROPERTIES = ['name', 'version', 'url', 'partner_id'];	3✔
36	const ALLOWED_CONFIG_PROPERTIES = [	3✔
37	'authenticator',
38	'apiVersion',
39	'typescript',
40	'maxNetworkRetries',
41	'httpAgent',
42	'httpClient',
43	'timeout',
44	'host',
45	'port',
46	'protocol',
47	'telemetry',
48	'appInfo',
49	'stripeAccount',
50	'stripeContext',
51	];
52
53	type RequestSenderFactory = (stripe: StripeObject) => RequestSender;
54
55	const defaultRequestSenderFactory: RequestSenderFactory = (stripe) =>	3✔
56	new RequestSender(stripe, StripeResource.MAX_BUFFERED_REQUEST_METRICS);	138✔
57
58	export function createStripe(	3✔
59	platformFunctions: PlatformFunctions,
60	requestSender: RequestSenderFactory = defaultRequestSenderFactory	5✔
61	): typeof Stripe {
62	Stripe.PACKAGE_VERSION = '16.12.0';	41✔
63	Stripe.USER_AGENT = {	41✔
64	bindings_version: Stripe.PACKAGE_VERSION,
65	lang: 'node',
66	publisher: 'stripe',
67	uname: null,
68	typescript: false,
69	...determineProcessUserAgentProperties(),
70	};
71	Stripe.StripeResource = StripeResource;	41✔
72	Stripe.resources = resources;	41✔
73	Stripe.HttpClient = HttpClient;	41✔
74	Stripe.HttpClientResponse = HttpClientResponse;	41✔
75	Stripe.CryptoProvider = CryptoProvider;	41✔
76
77	// Previously Stripe.webhooks was just the createWebhooks() factory function
78	// however going forward it will be a WebhookObject instance. To maintain
79	// backwards compatibility it is currently a factory function that also
80	// complies to the WebhookObject signature. The factory function signature
81	// will be removed as a breaking change in the next major release.
82	// See https://github.com/stripe/stripe-node/issues/1956
83	function createWebhooksDefault(fns = platformFunctions): WebhookObject {	174✔
84	return createWebhooks(fns);	174✔
85	}
86	Stripe.webhooks = Object.assign(	41✔
87	createWebhooksDefault,
88	createWebhooks(platformFunctions)
89	);
90
91	function Stripe(
92	this: StripeObject,
93	key: string,
94	config: Record<string, unknown> = {}	75✔
95	): void {
96	if (!(this instanceof Stripe)) {	361✔
97	return new (Stripe as any)(key, config);	178✔
98	}
99
100	const props = this._getPropsFromConfig(config);	183✔
101
102	this._platformFunctions = platformFunctions;	180✔
103
104	Object.defineProperty(this, '_emitter', {	180✔
105	value: this._platformFunctions.createEmitter(),
106	enumerable: false,
107	configurable: false,
108	writable: false,
109	});
110
111	this.VERSION = Stripe.PACKAGE_VERSION;	180✔
112
113	this.on = this._emitter.on.bind(this._emitter);	180✔
114	this.once = this._emitter.once.bind(this._emitter);	180✔
115	this.off = this._emitter.removeListener.bind(this._emitter);	180✔
116
117	const agent = props.httpAgent \|\| null;	180✔
118
119	this._api = {	180✔
120	host: props.host \|\| DEFAULT_HOST,	330✔
121	port: props.port \|\| DEFAULT_PORT,	331✔
122	protocol: props.protocol \|\| 'https',	332✔
123	basePath: DEFAULT_BASE_PATH,
124	version: props.apiVersion \|\| DEFAULT_API_VERSION,	354✔
125	timeout: validateInteger('timeout', props.timeout, DEFAULT_TIMEOUT),
126	maxNetworkRetries: validateInteger(
127	'maxNetworkRetries',
128	props.maxNetworkRetries,
129	2
130	),
131	agent: agent,
132	httpClient:
133	props.httpClient \|\|	357✔
134	(agent	177✔
135	? this._platformFunctions.createNodeHttpClient(agent)
136	: this._platformFunctions.createDefaultHttpClient()),
137	dev: false,
138	stripeAccount: props.stripeAccount \|\| null,	358✔
139	stripeContext: props.stripeContext \|\| null,	357✔
140	};
141
142	const typescript = props.typescript \|\| false;	180✔
143	if (typescript !== Stripe.USER_AGENT.typescript) {	180✔
144	// The mutation here is uncomfortable, but likely fastest;
145	// serializing the user agent involves shelling out to the system,
146	// and given some users may instantiate the library many times without switching between TS and non-TS,
147	// we only want to incur the performance hit when that actually happens.
148	Stripe.USER_AGENT.typescript = typescript;	2✔
149	}
150
151	if (props.appInfo) {	180✔
152	this._setAppInfo(props.appInfo);	10✔
153	}
154
155	this._prepResources();	176✔
156	this._setAuthenticator(key, props.authenticator);	176✔
157
158	this.errors = _Error;	174✔
159
160	// Once Stripe.webhooks looses the factory function signature in a future release
161	// then this should become this.webhooks = Stripe.webhooks
162	this.webhooks = createWebhooksDefault();	174✔
163
164	this._prevRequestMetrics = [];	174✔
165	this._enableTelemetry = props.telemetry !== false;	174✔
166
167	this._requestSender = requestSender(this);	174✔
168
169	// Expose StripeResource on the instance too
170	// @ts-ignore
171	this.StripeResource = Stripe.StripeResource;	174✔
172	}
173
174	Stripe.errors = _Error;	41✔
175
176	Stripe.createNodeHttpClient = platformFunctions.createNodeHttpClient;	41✔
177
178	/**
179	* Creates an HTTP client for issuing Stripe API requests which uses the Web
180	* Fetch API.
181	*
182	* A fetch function can optionally be passed in as a parameter. If none is
183	* passed, will default to the default `fetch` function in the global scope.
184	*/
185	Stripe.createFetchHttpClient = platformFunctions.createFetchHttpClient;	41✔
186
187	/**
188	* Create a CryptoProvider which uses the built-in Node crypto libraries for
189	* its crypto operations.
190	*/
191	Stripe.createNodeCryptoProvider = platformFunctions.createNodeCryptoProvider;	41✔
192
193	/**
194	* Creates a CryptoProvider which uses the Subtle Crypto API from the Web
195	* Crypto API spec for its crypto operations.
196	*
197	* A SubtleCrypto interface can optionally be passed in as a parameter. If none
198	* is passed, will default to the default `crypto.subtle` object in the global
199	* scope.
200	*/
201	Stripe.createSubtleCryptoProvider =	41✔
202	platformFunctions.createSubtleCryptoProvider;
203
204	Stripe.prototype = {	41✔
205	// Properties are set in the constructor above
206	_appInfo: undefined!,
207	on: null!,
208	off: null!,
209	once: null!,
210	VERSION: null!,
211	StripeResource: null!,
212	webhooks: null!,
213	errors: null!,
214	_api: null!,
215	_prevRequestMetrics: null!,
216	_emitter: null!,
217	_enableTelemetry: null!,
218	_requestSender: null!,
219	_platformFunctions: null!,
220
221	rawRequest(
222	method: string,
223	path: string,
224	params?: RequestData,
225	options?: RequestOptions
226	): Promise<any> {
227	return this._requestSender._rawRequest(method, path, params, options);	8✔
228	},
229
230	/**
231	* @private
232	*/
233	_setAuthenticator(
234	key: string,
235	authenticator: RequestAuthenticator \| undefined
236	): void {
237	if (key && authenticator) {	176✔
238	throw new Error("Can't specify both apiKey and authenticator");	1✔
239	}
240
241	if (!key && !authenticator) {	175✔
242	throw new Error('Neither apiKey nor config.authenticator provided');	1✔
243	}
244
245	this._authenticator = key	174✔
246	? createApiKeyAuthenticator(key)
247	: authenticator;
248	},
249
250	/**
251	* @private
252	* This may be removed in the future.
253	*/
254	_setAppInfo(info: AppInfo): void {
255	if (info && typeof info !== 'object') {	10✔
256	throw new Error('AppInfo must be an object.');	1✔
257	}
258
259	if (info && !info.name) {	9✔
260	throw new Error('AppInfo.name is required');	3✔
261	}
262
263	info = info \|\| {};	6!
264
265	this._appInfo = APP_INFO_PROPERTIES.reduce<Record<string, any>>(	6✔
266	(accum: Record<string, any>, prop) => {
267	if (typeof info[prop] == 'string') {	24✔
268	accum = accum \|\| {};	14✔
269
270	accum[prop] = info[prop];	14✔
271	}
272
273	return accum;	24✔
274	},
275	// @ts-ignore
276	undefined
277	);
278	},
279
280	/**
281	* @private
282	* This may be removed in the future.
283	*/
284	_setApiField<K extends keyof StripeObject['_api']>(
285	key: K,
286	value: StripeObject['_api'][K]
287	): void {
288	this._api[key] = value;	80✔
289	},
290
291	/**
292	* @private
293	* Please open or upvote an issue at github.com/stripe/stripe-node
294	* if you use this, detailing your use-case.
295	*
296	* It may be deprecated and removed in the future.
297	*/
298	getApiField<K extends keyof StripeObject['_api']>(
299	key: K
300	): StripeObject['_api'][K] {
301	return this._api[key];	31,429✔
302	},
303
304	setClientId(clientId: string): void {
305	this._clientId = clientId;	7✔
306	},
307
308	getClientId(): string \| undefined {
309	return this._clientId;	6✔
310	},
311
312	/**
313	* @private
314	* Please open or upvote an issue at github.com/stripe/stripe-node
315	* if you use this, detailing your use-case.
316	*
317	* It may be deprecated and removed in the future.
318	*/
319	getConstant: (c: string): unknown => {
320	switch (c) {	899!
321	case 'DEFAULT_HOST':
322	return DEFAULT_HOST;	18✔
323	case 'DEFAULT_PORT':
324	return DEFAULT_PORT;	×
325	case 'DEFAULT_BASE_PATH':
326	return DEFAULT_BASE_PATH;	×
327	case 'DEFAULT_API_VERSION':
328	return DEFAULT_API_VERSION;	×
329	case 'DEFAULT_TIMEOUT':
330	return DEFAULT_TIMEOUT;	×
331	case 'MAX_NETWORK_RETRY_DELAY_SEC':
332	return MAX_NETWORK_RETRY_DELAY_SEC;	×
333	case 'INITIAL_NETWORK_RETRY_DELAY_SEC':
334	return INITIAL_NETWORK_RETRY_DELAY_SEC;	×
335	}
336	return ((Stripe as unknown) as Record<string, unknown>)[c];	881✔
337	},
338
339	getMaxNetworkRetries(): number {
340	return this.getApiField('maxNetworkRetries');	1,759✔
341	},
342
343	/**
344	* @private
345	* This may be removed in the future.
346	*/
347	_setApiNumberField(
348	prop: keyof StripeObject['_api'],
349	n: number,
350	defaultVal?: number
351	): void {
352	const val = validateInteger(prop, n, defaultVal);	82✔
353
354	this._setApiField(prop, val);	80✔
355	},
356
357	getMaxNetworkRetryDelay(): number {
358	return MAX_NETWORK_RETRY_DELAY_SEC;	37✔
359	},
360
361	getInitialNetworkRetryDelay(): number {
362	return INITIAL_NETWORK_RETRY_DELAY_SEC;	37✔
363	},
364
365	/**
366	* @private
367	* Please open or upvote an issue at github.com/stripe/stripe-node
368	* if you use this, detailing your use-case.
369	*
370	* It may be deprecated and removed in the future.
371	*
372	* Gets a JSON version of a User-Agent and uses a cached version for a slight
373	* speed advantage.
374	*/
375	getClientUserAgent(cb: (userAgent: string) => void): void {
376	return this.getClientUserAgentSeeded(Stripe.USER_AGENT, cb);	880✔
377	},
378
379	/**
380	* @private
381	* Please open or upvote an issue at github.com/stripe/stripe-node
382	* if you use this, detailing your use-case.
383	*
384	* It may be deprecated and removed in the future.
385	*
386	* Gets a JSON version of a User-Agent by encoding a seeded object and
387	* fetching a uname from the system.
388	*/
389	getClientUserAgentSeeded(
390	seed: Record<string, string \| boolean \| null>,
391	cb: (userAgent: string) => void
392	): void {
393	this._platformFunctions.getUname().then((uname: string \| null) => {	885✔
394	const userAgent: Record<string, string> = {};	885✔
395	for (const field in seed) {	885✔
396	if (!Object.prototype.hasOwnProperty.call(seed, field)) {	6,165!
397	continue;	×
398	}
399	userAgent[field] = encodeURIComponent(seed[field] ?? 'null');	6,165✔
400	}
401
402	// URI-encode in case there are unusual characters in the system's uname.
403	userAgent.uname = encodeURIComponent(uname \|\| 'UNKNOWN');	885✔
404
405	const client = this.getApiField('httpClient');	885✔
406	if (client) {	885!
407	userAgent.httplib = encodeURIComponent(client.getClientName());	885✔
408	}
409
410	if (this._appInfo) {	885✔
411	userAgent.application = this._appInfo;	1✔
412	}
413
414	cb(JSON.stringify(userAgent));	885✔
415	});
416	},
417
418	/**
419	* @private
420	* Please open or upvote an issue at github.com/stripe/stripe-node
421	* if you use this, detailing your use-case.
422	*
423	* It may be deprecated and removed in the future.
424	*/
425	getAppInfoAsString(): string {
426	if (!this._appInfo) {	2✔
427	return '';	1✔
428	}
429
430	let formatted = this._appInfo.name;	1✔
431
432	if (this._appInfo.version) {	1!
433	formatted += `/${this._appInfo.version}`;	1✔
434	}
435
436	if (this._appInfo.url) {	1!
437	formatted += ` (${this._appInfo.url})`;	1✔
438	}
439
440	return formatted;	1✔
441	},
442
443	getTelemetryEnabled(): boolean {
444	return this._enableTelemetry;	1,406✔
445	},
446
447	/**
448	* @private
449	* This may be removed in the future.
450	*/
451	_prepResources(): void {
452	for (const name in resources) {	176✔
453	if (!Object.prototype.hasOwnProperty.call(resources, name)) {	12,496!
454	continue;	×
455	}
456
457	// @ts-ignore
458	this[pascalToCamelCase(name)] = new resources[name](this);	12,496✔
459	}
460	},
461
462	/**
463	* @private
464	* This may be removed in the future.
465	*/
466	_getPropsFromConfig(config: Record<string, unknown>): UserProvidedConfig {
467	// If config is null or undefined, just bail early with no props
468	if (!config) {	183✔
469	return {};	4✔
470	}
471
472	// config can be an object or a string
473	const isString = typeof config === 'string';	179✔
474	const isObject = config === Object(config) && !Array.isArray(config);	179✔
475
476	if (!isObject && !isString) {	179✔
477	throw new Error('Config must either be an object or a string');	2✔
478	}
479
480	// If config is a string, we assume the old behavior of passing in a string representation of the api version
481	if (isString) {	177✔
482	return {	3✔
483	apiVersion: config,
484	};
485	}
486
487	// If config is an object, we assume the new behavior and make sure it doesn't contain any unexpected values
488	const values = Object.keys(config).filter(	174✔
489	(value) => !ALLOWED_CONFIG_PROPERTIES.includes(value)	159✔
490	);
491
492	if (values.length > 0) {	174✔
493	throw new Error(	1✔
494	`Config object may only contain the following: ${ALLOWED_CONFIG_PROPERTIES.join(
495	', '
496	)}`
497	);
498	}
499
500	return config;	173✔
501	},
502
503	parseThinEvent(
504	payload: string \| Uint8Array,
505	header: string \| Uint8Array,
506	secret: string,
507	tolerance?: number,
508	cryptoProvider?: CryptoProvider,
509	receivedAt?: number
510	): WebhookEvent {
511	// parses and validates the event payload all in one go
512	return this.webhooks.constructEvent(	2✔
513	payload,
514	header,
515	secret,
516	tolerance,
517	cryptoProvider,
518	receivedAt
519	);
520	},
521
522	parseSnapshotEvent(
523	payload: string \| Uint8Array,
524	header: string \| Uint8Array,
525	secret: string,
526	tolerance?: number,
527	cryptoProvider?: CryptoProvider,
528	receivedAt?: number
529	): WebhookEvent {
NEW 530	return this.webhooks.constructEvent(	×
531	payload,
532	header,
533	secret,
534	tolerance,
535	cryptoProvider,
536	receivedAt
537	);
538	},
539	} as StripeObject;
540
541	return Stripe;	41✔
542	}

stripe / stripe-node / #2904

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