ANDJ/ANDJJJJJJ
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Complete Email Sortierer implementation with Appwrite and Stripe integration

Browse Source
This commit is contained in:
Kenso Grimm
2026-01-14 20:02:16 +01:00
commit 95349af50b
3355 changed files with 644802 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

351
server/node_modules/stripe/esm/stripe.core.js generated vendored Normal file
View File

@@ -0,0 +1,351 @@
import * as _Error from './Error.js';
import * as apiVersion from './apiVersion.js';
import * as resources from './resources.js';
import { HttpClient, HttpClientResponse } from './net/HttpClient.js';
import { determineProcessUserAgentProperties, pascalToCamelCase, validateInteger, } from './utils.js';
import { CryptoProvider } from './crypto/CryptoProvider.js';
import { RequestSender } from './RequestSender.js';
import { StripeResource } from './StripeResource.js';
import { createWebhooks } from './Webhooks.js';
const DEFAULT_HOST = 'api.stripe.com';
const DEFAULT_PORT = '443';
const DEFAULT_BASE_PATH = '/v1/';
const DEFAULT_API_VERSION = apiVersion.ApiVersion;
const DEFAULT_TIMEOUT = 80000;
const MAX_NETWORK_RETRY_DELAY_SEC = 2;
const INITIAL_NETWORK_RETRY_DELAY_SEC = 0.5;
const APP_INFO_PROPERTIES = ['name', 'version', 'url', 'partner_id'];
const ALLOWED_CONFIG_PROPERTIES = [
'apiVersion',
'typescript',
'maxNetworkRetries',
'httpAgent',
'httpClient',
'timeout',
'host',
'port',
'protocol',
'telemetry',
'appInfo',
'stripeAccount',
];
const defaultRequestSenderFactory = (stripe) => new RequestSender(stripe, StripeResource.MAX_BUFFERED_REQUEST_METRICS);
export function createStripe(platformFunctions, requestSender = defaultRequestSenderFactory) {
Stripe.PACKAGE_VERSION = '14.25.0';
Stripe.USER_AGENT = Object.assign({ 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) {
return createWebhooks(fns);
}
Stripe.webhooks = Object.assign(createWebhooksDefault, createWebhooks(platformFunctions));
function Stripe(key, config = {}) {
if (!(this instanceof Stripe)) {
return new Stripe(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 = {
auth: null,
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, 1),
agent: agent,
httpClient: props.httpClient ||
(agent
? this._platformFunctions.createNodeHttpClient(agent)
: this._platformFunctions.createDefaultHttpClient()),
dev: false,
stripeAccount: props.stripeAccount || 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._setApiKey(key);
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,
/**
* @private
*/
_setApiKey(key) {
if (key) {
this._setApiField('auth', `Bearer ${key}`);
}
},
/**
* @private
* This may be removed in the future.
*/
_setAppInfo(info) {
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((accum, 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(key, value) {
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(key) {
return this._api[key];
},
setClientId(clientId) {
this._clientId = clientId;
},
getClientId() {
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) => {
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[c];
},
getMaxNetworkRetries() {
return this.getApiField('maxNetworkRetries');
},
/**
* @private
* This may be removed in the future.
*/
_setApiNumberField(prop, n, defaultVal) {
const val = validateInteger(prop, n, defaultVal);
this._setApiField(prop, val);
},
getMaxNetworkRetryDelay() {
return MAX_NETWORK_RETRY_DELAY_SEC;
},
getInitialNetworkRetryDelay() {
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) {
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, cb) {
this._platformFunctions.getUname().then((uname) => {
var _a;
const userAgent = {};
for (const field in seed) {
userAgent[field] = encodeURIComponent((_a = seed[field]) !== null && _a !== void 0 ? _a : '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() {
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() {
return this._enableTelemetry;
},
/**
* @private
* This may be removed in the future.
*/
_prepResources() {
for (const name in resources) {
// @ts-ignore
this[pascalToCamelCase(name)] = new resources[name](this);
}
},
/**
* @private
* This may be removed in the future.
*/
_getPropsFromConfig(config) {
// 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;
},
};
return Stripe;
}