@depup/stripe 21.0.0-depup.0

package/esm/net/NodeHttpClient.js

@@ -0,0 +1,103 @@
+import * as http_ from 'http';
+import * as https_ from 'https';
+import { HttpClient, HttpClientResponse, } from './HttpClient.js';
+// `import * as http_ from 'http'` creates a "Module Namespace Exotic Object"
+// which is immune to monkey-patching, whereas http_.default (in an ES Module context)
+// will resolve to the same thing as require('http'), which is
+// monkey-patchable. We care about this because users in their test
+// suites might be using a library like "nock" which relies on the ability
+// to monkey-patch and intercept calls to http.request.
+const http = http_.default || http_;
+const https = https_.default || https_;
+const defaultHttpAgent = new http.Agent({ keepAlive: true });
+const defaultHttpsAgent = new https.Agent({ keepAlive: true });
+/**
+ * HTTP client which uses the Node `http` and `https` packages to issue
+ * requests.`
+ */
+export class NodeHttpClient extends HttpClient {
+    constructor(agent) {
+        super();
+        this._agent = agent;
+    }
+    /** @override. */
+    getClientName() {
+        return 'node';
+    }
+    makeRequest(host, port, path, method, headers, requestData, protocol, timeout) {
+        const isInsecureConnection = protocol === 'http';
+        let agent = this._agent;
+        if (!agent) {
+            agent = isInsecureConnection ? defaultHttpAgent : defaultHttpsAgent;
+        }
+        const requestPromise = new Promise((resolve, reject) => {
+            const req = (isInsecureConnection ? http : https).request({
+                host: host,
+                port: port,
+                path,
+                method,
+                agent,
+                headers,
+                ciphers: 'DEFAULT:!aNULL:!eNULL:!LOW:!EXPORT:!SSLv2:!MD5',
+            });
+            req.setTimeout(timeout, () => {
+                req.destroy(HttpClient.makeTimeoutError());
+            });
+            req.on('response', (res) => {
+                resolve(new NodeHttpClientResponse(res));
+            });
+            req.on('error', (error) => {
+                reject(error);
+            });
+            req.once('socket', (socket) => {
+                if (socket.connecting) {
+                    socket.once(isInsecureConnection ? 'connect' : 'secureConnect', () => {
+                        // Send payload; we're safe:
+                        req.write(requestData);
+                        req.end();
+                    });
+                }
+                else {
+                    // we're already connected
+                    req.write(requestData);
+                    req.end();
+                }
+            });
+        });
+        return requestPromise;
+    }
+}
+export class NodeHttpClientResponse extends HttpClientResponse {
+    constructor(res) {
+        // @ts-ignore
+        super(res.statusCode, res.headers || {});
+        this._res = res;
+    }
+    getRawResponse() {
+        return this._res;
+    }
+    toStream(streamCompleteCallback) {
+        // The raw response is itself the stream, so we just return that. To be
+        // backwards compatible, we should invoke the streamCompleteCallback only
+        // once the stream has been fully consumed.
+        this._res.once('end', () => streamCompleteCallback());
+        return this._res;
+    }
+    toJSON() {
+        return new Promise((resolve, reject) => {
+            let response = '';
+            this._res.setEncoding('utf8');
+            this._res.on('data', (chunk) => {
+                response += chunk;
+            });
+            this._res.once('end', () => {
+                try {
+                    resolve(JSON.parse(response));
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
+    }
+}

package/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/esm/platform/NodePlatformFunctions.js

@@ -0,0 +1,94 @@
+import * as crypto from 'crypto';
+import { EventEmitter } from 'events';
+import { NodeCryptoProvider } from '../crypto/NodeCryptoProvider.js';
+import { NodeHttpClient } from '../net/NodeHttpClient.js';
+import { PlatformFunctions } from './PlatformFunctions.js';
+import { StripeError } from '../Error.js';
+import { concat } from '../utils.js';
+import { arch, release } from 'os';
+class StreamProcessingError extends StripeError {
+}
+/**
+ * Specializes WebPlatformFunctions using APIs available in Node.js.
+ */
+export class NodePlatformFunctions extends PlatformFunctions {
+    /** @override */
+    uuid4() {
+        // available in: v14.17.x+
+        if (crypto.randomUUID) {
+            return crypto.randomUUID();
+        }
+        return super.uuid4();
+    }
+    /** @override */
+    getPlatformInfo() {
+        return `${process.platform} ${release()} ${arch()}`;
+    }
+    /**
+     * @override
+     * Secure compare, from https://github.com/freewil/scmp
+     */
+    secureCompare(a, b) {
+        if (!a || !b) {
+            throw new Error('secureCompare must receive two arguments');
+        }
+        // return early here if buffer lengths are not equal since timingSafeEqual
+        // will throw if buffer lengths are not equal
+        if (a.length !== b.length) {
+            return false;
+        }
+        // use crypto.timingSafeEqual if available (since Node.js v6.6.0),
+        // otherwise use our own scmp-internal function.
+        if (crypto.timingSafeEqual) {
+            const textEncoder = new TextEncoder();
+            const aEncoded = textEncoder.encode(a);
+            const bEncoded = textEncoder.encode(b);
+            return crypto.timingSafeEqual(aEncoded, bEncoded);
+        }
+        return super.secureCompare(a, b);
+    }
+    createEmitter() {
+        return new EventEmitter();
+    }
+    /** @override */
+    tryBufferData(data) {
+        if (!(data.file.data instanceof EventEmitter)) {
+            return Promise.resolve(data);
+        }
+        const bufferArray = [];
+        return new Promise((resolve, reject) => {
+            data.file.data
+                .on('data', (line) => {
+                bufferArray.push(line);
+            })
+                .once('end', () => {
+                // @ts-ignore
+                const bufferData = Object.assign({}, data);
+                bufferData.file.data = concat(bufferArray);
+                resolve(bufferData);
+            })
+                .on('error', (err) => {
+                reject(new StreamProcessingError({
+                    message: 'An error occurred while attempting to process the file for upload.',
+                    detail: err,
+                }));
+            });
+        });
+    }
+    /** @override */
+    createNodeHttpClient(agent) {
+        return new NodeHttpClient(agent);
+    }
+    /** @override */
+    createDefaultHttpClient() {
+        return new NodeHttpClient();
+    }
+    /** @override */
+    createNodeCryptoProvider() {
+        return new NodeCryptoProvider();
+    }
+    /** @override */
+    createDefaultCryptoProvider() {
+        return this.createNodeCryptoProvider();
+    }
+}

package/esm/platform/PlatformFunctions.js

@@ -0,0 +1,94 @@
+import { FetchHttpClient } from '../net/FetchHttpClient.js';
+import { SubtleCryptoProvider } from '../crypto/SubtleCryptoProvider.js';
+/**
+ * Interface encapsulating various utility functions whose
+ * implementations depend on the platform / JS runtime.
+ */
+export class PlatformFunctions {
+    constructor() {
+        this._fetchFn = null;
+        this._agent = null;
+    }
+    /**
+     * Returns platform info string for telemetry, or null if unavailable.
+     */
+    getPlatformInfo() {
+        return null;
+    }
+    /**
+     * Generates a v4 UUID. See https://stackoverflow.com/a/2117523
+     */
+    uuid4() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    /**
+     * Compares strings in constant time.
+     */
+    secureCompare(a, b) {
+        // return early here if buffer lengths are not equal
+        if (a.length !== b.length) {
+            return false;
+        }
+        const len = a.length;
+        let result = 0;
+        for (let i = 0; i < len; ++i) {
+            result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+        }
+        return result === 0;
+    }
+    /**
+     * Creates an event emitter.
+     */
+    createEmitter() {
+        throw new Error('createEmitter not implemented.');
+    }
+    /**
+     * Checks if the request data is a stream. If so, read the entire stream
+     * to a buffer and return the buffer.
+     */
+    tryBufferData(data) {
+        throw new Error('tryBufferData not implemented.');
+    }
+    /**
+     * Creates an HTTP client which uses the Node `http` and `https` packages
+     * to issue requests.
+     */
+    createNodeHttpClient(agent) {
+        throw new Error('createNodeHttpClient not implemented.');
+    }
+    /**
+     * 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.
+     */
+    createFetchHttpClient(fetchFn) {
+        return new FetchHttpClient(fetchFn);
+    }
+    /**
+     * Creates an HTTP client using runtime-specific APIs.
+     */
+    createDefaultHttpClient() {
+        throw new Error('createDefaultHttpClient not implemented.');
+    }
+    /**
+     * Creates a CryptoProvider which uses the Node `crypto` package for its computations.
+     */
+    createNodeCryptoProvider() {
+        throw new Error('createNodeCryptoProvider not implemented.');
+    }
+    /**
+     * Creates a CryptoProvider which uses the SubtleCrypto interface of the Web Crypto API.
+     */
+    createSubtleCryptoProvider(subtleCrypto) {
+        return new SubtleCryptoProvider(subtleCrypto);
+    }
+    createDefaultCryptoProvider() {
+        throw new Error('createDefaultCryptoProvider not implemented.');
+    }
+}

package/esm/platform/WebPlatformFunctions.js

@@ -0,0 +1,34 @@
+import { PlatformFunctions } from './PlatformFunctions.js';
+import { StripeEmitter } from '../StripeEmitter.js';
+/**
+ * Specializes WebPlatformFunctions using APIs available in Web workers.
+ */
+export class WebPlatformFunctions extends PlatformFunctions {
+    /** @override */
+    createEmitter() {
+        return new StripeEmitter();
+    }
+    /** @override */
+    tryBufferData(data) {
+        if (data.file.data instanceof ReadableStream) {
+            throw new Error('Uploading a file as a stream is not supported in non-Node environments. Please open or upvote an issue at github.com/stripe/stripe-node if you use this, detailing your use-case.');
+        }
+        return Promise.resolve(data);
+    }
+    /** @override */
+    createNodeHttpClient() {
+        throw new Error('Stripe: `createNodeHttpClient()` is not available in non-Node environments. Please use `createFetchHttpClient()` instead.');
+    }
+    /** @override */
+    createDefaultHttpClient() {
+        return super.createFetchHttpClient();
+    }
+    /** @override */
+    createNodeCryptoProvider() {
+        throw new Error('Stripe: `createNodeCryptoProvider()` is not available in non-Node environments. Please use `createSubtleCryptoProvider()` instead.');
+    }
+    /** @override */
+    createDefaultCryptoProvider() {
+        return this.createSubtleCryptoProvider();
+    }
+}

package/esm/resources/AccountLinks.js

@@ -0,0 +1,6 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const AccountLinks = StripeResource.extend({
+    create: stripeMethod({ method: 'POST', fullPath: '/v1/account_links' }),
+});

package/esm/resources/AccountSessions.js

@@ -0,0 +1,6 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const AccountSessions = StripeResource.extend({
+    create: stripeMethod({ method: 'POST', fullPath: '/v1/account_sessions' }),
+});

package/esm/resources/Accounts.js

@@ -0,0 +1,98 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../StripeResource.js';
+const stripeMethod = StripeResource.method;
+// Since path can either be `account` or `accounts`, support both through stripeMethod path
+export const Accounts = StripeResource.extend({
+    create: stripeMethod({ method: 'POST', fullPath: '/v1/accounts' }),
+    retrieve(id, ...args) {
+        // No longer allow an api key to be passed as the first string to this function due to ambiguity between
+        // old account ids and api keys. To request the account for an api key, send null as the id
+        if (typeof id === 'string') {
+            return stripeMethod({
+                method: 'GET',
+                fullPath: '/v1/accounts/{id}',
+            }).apply(this, [id, ...args]);
+        }
+        else {
+            if (id === null || id === undefined) {
+                // Remove id as stripeMethod would complain of unexpected argument
+                [].shift.apply([id, ...args]);
+            }
+            return stripeMethod({
+                method: 'GET',
+                fullPath: '/v1/account',
+            }).apply(this, [id, ...args]);
+        }
+    },
+    update: stripeMethod({ method: 'POST', fullPath: '/v1/accounts/{account}' }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/accounts',
+        methodType: 'list',
+    }),
+    del: stripeMethod({ method: 'DELETE', fullPath: '/v1/accounts/{account}' }),
+    createExternalAccount: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/accounts/{account}/external_accounts',
+    }),
+    createLoginLink: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/accounts/{account}/login_links',
+    }),
+    createPerson: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/accounts/{account}/persons',
+    }),
+    deleteExternalAccount: stripeMethod({
+        method: 'DELETE',
+        fullPath: '/v1/accounts/{account}/external_accounts/{id}',
+    }),
+    deletePerson: stripeMethod({
+        method: 'DELETE',
+        fullPath: '/v1/accounts/{account}/persons/{person}',
+    }),
+    listCapabilities: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/accounts/{account}/capabilities',
+        methodType: 'list',
+    }),
+    listExternalAccounts: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/accounts/{account}/external_accounts',
+        methodType: 'list',
+    }),
+    listPersons: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/accounts/{account}/persons',
+        methodType: 'list',
+    }),
+    reject: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/accounts/{account}/reject',
+    }),
+    retrieveCurrent: stripeMethod({ method: 'GET', fullPath: '/v1/account' }),
+    retrieveCapability: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/accounts/{account}/capabilities/{capability}',
+    }),
+    retrieveExternalAccount: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/accounts/{account}/external_accounts/{id}',
+    }),
+    retrievePerson: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/accounts/{account}/persons/{person}',
+    }),
+    updateCapability: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/accounts/{account}/capabilities/{capability}',
+    }),
+    updateExternalAccount: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/accounts/{account}/external_accounts/{id}',
+    }),
+    updatePerson: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/accounts/{account}/persons/{person}',
+    }),
+});

package/esm/resources/ApplePayDomains.js

@@ -0,0 +1,19 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const ApplePayDomains = StripeResource.extend({
+    create: stripeMethod({ method: 'POST', fullPath: '/v1/apple_pay/domains' }),
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/apple_pay/domains/{domain}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/apple_pay/domains',
+        methodType: 'list',
+    }),
+    del: stripeMethod({
+        method: 'DELETE',
+        fullPath: '/v1/apple_pay/domains/{domain}',
+    }),
+});

package/esm/resources/ApplicationFees.js

@@ -0,0 +1,31 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const ApplicationFees = StripeResource.extend({
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/application_fees/{id}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/application_fees',
+        methodType: 'list',
+    }),
+    createRefund: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/application_fees/{id}/refunds',
+    }),
+    listRefunds: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/application_fees/{id}/refunds',
+        methodType: 'list',
+    }),
+    retrieveRefund: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/application_fees/{fee}/refunds/{id}',
+    }),
+    updateRefund: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/application_fees/{fee}/refunds/{id}',
+    }),
+});

package/esm/resources/Apps/Secrets.js

@@ -0,0 +1,16 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const Secrets = StripeResource.extend({
+    create: stripeMethod({ method: 'POST', fullPath: '/v1/apps/secrets' }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/apps/secrets',
+        methodType: 'list',
+    }),
+    deleteWhere: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/apps/secrets/delete',
+    }),
+    find: stripeMethod({ method: 'GET', fullPath: '/v1/apps/secrets/find' }),
+});

package/esm/resources/Balance.js

@@ -0,0 +1,6 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const Balance = StripeResource.extend({
+    retrieve: stripeMethod({ method: 'GET', fullPath: '/v1/balance' }),
+});

package/esm/resources/BalanceSettings.js

@@ -0,0 +1,7 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const BalanceSettings = StripeResource.extend({
+    retrieve: stripeMethod({ method: 'GET', fullPath: '/v1/balance_settings' }),
+    update: stripeMethod({ method: 'POST', fullPath: '/v1/balance_settings' }),
+});

package/esm/resources/BalanceTransactions.js

@@ -0,0 +1,14 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const BalanceTransactions = StripeResource.extend({
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/balance_transactions/{id}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/balance_transactions',
+        methodType: 'list',
+    }),
+});

package/esm/resources/Billing/Alerts.js

@@ -0,0 +1,24 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const Alerts = StripeResource.extend({
+    create: stripeMethod({ method: 'POST', fullPath: '/v1/billing/alerts' }),
+    retrieve: stripeMethod({ method: 'GET', fullPath: '/v1/billing/alerts/{id}' }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/billing/alerts',
+        methodType: 'list',
+    }),
+    activate: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/billing/alerts/{id}/activate',
+    }),
+    archive: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/billing/alerts/{id}/archive',
+    }),
+    deactivate: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/billing/alerts/{id}/deactivate',
+    }),
+});

package/esm/resources/Billing/CreditBalanceSummary.js

@@ -0,0 +1,9 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const CreditBalanceSummary = StripeResource.extend({
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/billing/credit_balance_summary',
+    }),
+});

package/esm/resources/Billing/CreditBalanceTransactions.js

@@ -0,0 +1,14 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const CreditBalanceTransactions = StripeResource.extend({
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/billing/credit_balance_transactions/{id}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/billing/credit_balance_transactions',
+        methodType: 'list',
+    }),
+});

package/esm/resources/Billing/CreditGrants.js

@@ -0,0 +1,27 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const CreditGrants = StripeResource.extend({
+    create: stripeMethod({ method: 'POST', fullPath: '/v1/billing/credit_grants' }),
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/billing/credit_grants/{id}',
+    }),
+    update: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/billing/credit_grants/{id}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/billing/credit_grants',
+        methodType: 'list',
+    }),
+    expire: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/billing/credit_grants/{id}/expire',
+    }),
+    voidGrant: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/billing/credit_grants/{id}/void',
+    }),
+});

package/esm/resources/Billing/MeterEventAdjustments.js

@@ -0,0 +1,9 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const MeterEventAdjustments = StripeResource.extend({
+    create: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/billing/meter_event_adjustments',
+    }),
+});

package/esm/resources/Billing/MeterEvents.js

@@ -0,0 +1,6 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const MeterEvents = StripeResource.extend({
+    create: stripeMethod({ method: 'POST', fullPath: '/v1/billing/meter_events' }),
+});

package/esm/resources/Billing/Meters.js

@@ -0,0 +1,26 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const Meters = StripeResource.extend({
+    create: stripeMethod({ method: 'POST', fullPath: '/v1/billing/meters' }),
+    retrieve: stripeMethod({ method: 'GET', fullPath: '/v1/billing/meters/{id}' }),
+    update: stripeMethod({ method: 'POST', fullPath: '/v1/billing/meters/{id}' }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/billing/meters',
+        methodType: 'list',
+    }),
+    deactivate: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/billing/meters/{id}/deactivate',
+    }),
+    listEventSummaries: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/billing/meters/{id}/event_summaries',
+        methodType: 'list',
+    }),
+    reactivate: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/billing/meters/{id}/reactivate',
+    }),
+});