240 lines
9.6 KiB
JavaScript
240 lines
9.6 KiB
JavaScript
import http from 'node:http'
|
|
|
|
/**
|
|
* Stripe-Nachbau für Tests. stripe-node spricht ihn über config.stripe.apiBase (STRIPE_API_BASE)
|
|
* an. Objekte werden vorab in die Maps gelegt; jeder Aufruf landet in calls als
|
|
* { method, path, query, body } (Formular-Schlüssel flach, z. B. 'items[0][price]').
|
|
*/
|
|
export async function startFakeStripe() {
|
|
const subscriptions = new Map()
|
|
const prices = new Map()
|
|
const invoices = new Map()
|
|
const products = new Map()
|
|
const coupons = new Map()
|
|
const billingPortalConfigurations = new Map()
|
|
const customers = new Map()
|
|
const checkoutSessions = new Map()
|
|
const calls = []
|
|
let seq = 0
|
|
const nextId = (prefix) => `${prefix}_test_${(seq += 1)}`
|
|
|
|
const flat = (params) => Object.fromEntries(params.entries())
|
|
const noSuch = (what, id) => [404, { error: { type: 'invalid_request_error', code: 'resource_missing', message: `No such ${what}: '${id}'` } }]
|
|
const listOf = (data) => ({ object: 'list', data, has_more: false, url: '/v1/list' })
|
|
|
|
const readBody = (req) =>
|
|
new Promise((resolve) => {
|
|
let raw = ''
|
|
req.on('data', (chunk) => (raw += chunk))
|
|
req.on('end', () => resolve(new URLSearchParams(raw)))
|
|
})
|
|
|
|
// Stripe serialisiert verschachtelte Parameter (z. B. recurring[interval]=month) als flache
|
|
// Formularschluessel. Fuer die Routen selbst wieder zu einem verschachtelten Objekt zusammenbauen.
|
|
const unflatten = (params) => {
|
|
const root = {}
|
|
for (const [rawKey, value] of params.entries()) {
|
|
const path = rawKey.match(/[^[\]]+/g) || [rawKey]
|
|
let node = root
|
|
path.forEach((key, i) => {
|
|
if (i === path.length - 1) {
|
|
node[key] = value
|
|
} else {
|
|
if (!(key in node)) node[key] = /^\d+$/.test(path[i + 1]) ? [] : {}
|
|
node = node[key]
|
|
}
|
|
})
|
|
}
|
|
return root
|
|
}
|
|
|
|
const route = (method, path, query, body) => {
|
|
let m
|
|
if (method === 'GET' && (m = path.match(/^\/v1\/subscriptions\/([^/]+)$/))) {
|
|
return subscriptions.has(m[1]) ? [200, subscriptions.get(m[1])] : noSuch('subscription', m[1])
|
|
}
|
|
if (method === 'GET' && (m = path.match(/^\/v1\/prices\/([^/]+)$/))) {
|
|
return prices.has(m[1]) ? [200, prices.get(m[1])] : noSuch('price', m[1])
|
|
}
|
|
if (method === 'GET' && path === '/v1/prices') {
|
|
const keys = [...query.entries()].filter(([k]) => /^lookup_keys\[\d*\]$/.test(k)).map(([, v]) => v)
|
|
const active = query.get('active')
|
|
const found = [...prices.values()].filter(
|
|
(p) => (!keys.length || keys.includes(p.lookup_key)) && (active === null || String(p.active !== false) === active)
|
|
)
|
|
return [200, listOf(found)]
|
|
}
|
|
if (method === 'POST' && path === '/v1/prices') {
|
|
const data = unflatten(body)
|
|
// Wie echtes Stripe: ein lookup_key darf nur an einem aktiven Preis gleichzeitig haengen
|
|
// (Fix round 1, Important 1 - haertet den Nachbau, ensurePrice fragt vorher ohnehin per GET)
|
|
if (data.lookup_key) {
|
|
const clash = [...prices.values()].find((p) => p.lookup_key === data.lookup_key && p.active !== false)
|
|
if (clash) {
|
|
return [400, { error: { type: 'invalid_request_error', param: 'lookup_key', message: `An active price already exists for lookup_key: '${data.lookup_key}'.` } }]
|
|
}
|
|
}
|
|
const obj = {
|
|
id: nextId('price'),
|
|
object: 'price',
|
|
active: true,
|
|
product: data.product,
|
|
currency: data.currency || 'eur',
|
|
unit_amount: data.unit_amount != null ? Number(data.unit_amount) : null,
|
|
recurring: data.recurring ? { interval: data.recurring.interval } : null,
|
|
tax_behavior: data.tax_behavior || null,
|
|
lookup_key: data.lookup_key || null,
|
|
nickname: data.nickname || null,
|
|
}
|
|
prices.set(obj.id, obj)
|
|
return [200, obj]
|
|
}
|
|
if (method === 'GET' && (m = path.match(/^\/v1\/invoices\/([^/]+)$/))) {
|
|
return invoices.has(m[1]) ? [200, invoices.get(m[1])] : noSuch('invoice', m[1])
|
|
}
|
|
// scripts/stripe-products.mjs --pruefen liest das Produkt zurueck (Beschreibung, Bild)
|
|
if (method === 'GET' && (m = path.match(/^\/v1\/products\/([^/]+)$/))) {
|
|
return products.has(m[1]) ? [200, products.get(m[1])] : noSuch('product', m[1])
|
|
}
|
|
if (method === 'POST' && path === '/v1/products') {
|
|
const data = unflatten(body)
|
|
const obj = {
|
|
id: nextId('prod'),
|
|
object: 'product',
|
|
active: true,
|
|
name: data.name || '',
|
|
description: data.description ?? null,
|
|
statement_descriptor: data.statement_descriptor ?? null,
|
|
images: data.images || [],
|
|
metadata: data.metadata || {},
|
|
}
|
|
products.set(obj.id, obj)
|
|
return [200, obj]
|
|
}
|
|
if (method === 'GET' && (m = path.match(/^\/v1\/coupons\/([^/]+)$/))) {
|
|
return coupons.has(m[1]) ? [200, coupons.get(m[1])] : noSuch('coupon', m[1])
|
|
}
|
|
if (method === 'POST' && path === '/v1/coupons') {
|
|
const data = unflatten(body)
|
|
const id = data.id || nextId('coupon')
|
|
// Wie echtes Stripe: Name auf 40 Zeichen begrenzt, IDs eindeutig (Fix round 1, Important 1)
|
|
if (data.name && data.name.length > 40) {
|
|
return [400, { error: { type: 'invalid_request_error', param: 'name', message: 'Name must be no more than 40 characters.' } }]
|
|
}
|
|
if (coupons.has(id)) {
|
|
return [400, { error: { type: 'invalid_request_error', message: `Coupon with ID '${id}' already exists.` } }]
|
|
}
|
|
const obj = {
|
|
id,
|
|
object: 'coupon',
|
|
valid: true,
|
|
name: data.name || null,
|
|
amount_off: data.amount_off != null ? Number(data.amount_off) : null,
|
|
currency: data.currency || null,
|
|
duration: data.duration || 'once',
|
|
metadata: data.metadata || {},
|
|
}
|
|
coupons.set(id, obj)
|
|
return [200, obj]
|
|
}
|
|
// Checkout (Neuabschluss): Kunde suchen/anlegen, Checkout-Sitzung anlegen (F10)
|
|
if (method === 'GET' && path === '/v1/customers/search') {
|
|
// Suchsyntax wie in getOrCreateStripeCustomer: metadata['webklarCustomerId']:'c1'
|
|
const m2 = (query.get('query') || '').match(/metadata\['(\w+)'\]:'([^']*)'/)
|
|
const found = [...customers.values()].filter((c) => !m2 || c.metadata?.[m2[1]] === m2[2])
|
|
return [200, { object: 'search_result', data: found, has_more: false, url: '/v1/customers/search' }]
|
|
}
|
|
if (method === 'POST' && path === '/v1/customers') {
|
|
const data = unflatten(body)
|
|
const obj = {
|
|
id: nextId('cus'),
|
|
object: 'customer',
|
|
email: data.email ?? null,
|
|
name: data.name ?? null,
|
|
address: data.address ?? null,
|
|
invoice_settings: data.invoice_settings || {},
|
|
metadata: data.metadata || {},
|
|
}
|
|
customers.set(obj.id, obj)
|
|
return [200, obj]
|
|
}
|
|
if (method === 'POST' && path === '/v1/checkout/sessions') {
|
|
const data = unflatten(body)
|
|
const id = nextId('cs')
|
|
const obj = {
|
|
id,
|
|
object: 'checkout.session',
|
|
url: `https://checkout.stripe.test/c/pay/${id}`,
|
|
mode: data.mode || 'payment',
|
|
customer: data.customer ?? null,
|
|
client_reference_id: data.client_reference_id ?? null,
|
|
subscription: null,
|
|
metadata: data.metadata || {},
|
|
subscription_data: data.subscription_data || {},
|
|
}
|
|
checkoutSessions.set(id, obj)
|
|
return [200, obj]
|
|
}
|
|
if (method === 'GET' && path === '/v1/billing_portal/configurations') {
|
|
const active = query.get('active')
|
|
const found = [...billingPortalConfigurations.values()].filter(
|
|
(c) => active === null || String(c.active !== false) === active
|
|
)
|
|
return [200, listOf(found)]
|
|
}
|
|
if (method === 'POST' && path === '/v1/billing_portal/configurations') {
|
|
const data = unflatten(body)
|
|
const obj = {
|
|
id: nextId('bpc'),
|
|
object: 'billing_portal.configuration',
|
|
active: true,
|
|
business_profile: data.business_profile || {},
|
|
default_return_url: data.default_return_url || null,
|
|
features: data.features || {},
|
|
metadata: data.metadata || {},
|
|
}
|
|
billingPortalConfigurations.set(obj.id, obj)
|
|
return [200, obj]
|
|
}
|
|
if (method === 'POST' && (m = path.match(/^\/v1\/billing_portal\/configurations\/([^/]+)$/))) {
|
|
const existing = billingPortalConfigurations.get(m[1])
|
|
if (!existing) return noSuch('configuration', m[1])
|
|
const data = unflatten(body)
|
|
const updated = {
|
|
...existing,
|
|
...data,
|
|
business_profile: { ...existing.business_profile, ...(data.business_profile || {}) },
|
|
features: { ...existing.features, ...(data.features || {}) },
|
|
metadata: { ...existing.metadata, ...(data.metadata || {}) },
|
|
}
|
|
billingPortalConfigurations.set(m[1], updated)
|
|
return [200, updated]
|
|
}
|
|
return [404, { error: { type: 'invalid_request_error', message: `No such route: ${method} ${path}` } }]
|
|
}
|
|
|
|
const server = http.createServer(async (req, res) => {
|
|
const url = new URL(req.url, 'http://127.0.0.1')
|
|
const body = await readBody(req)
|
|
calls.push({ method: req.method, path: url.pathname, query: flat(url.searchParams), body: flat(body) })
|
|
const [status, payload] = route(req.method, url.pathname, url.searchParams, body)
|
|
res.writeHead(status, { 'Content-Type': 'application/json', 'Request-Id': `req_test_${calls.length}` })
|
|
res.end(JSON.stringify(payload))
|
|
})
|
|
await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve))
|
|
|
|
return {
|
|
url: `http://127.0.0.1:${server.address().port}`,
|
|
calls,
|
|
subscriptions,
|
|
prices,
|
|
invoices,
|
|
products,
|
|
coupons,
|
|
billingPortalConfigurations,
|
|
customers,
|
|
checkoutSessions,
|
|
close: () => new Promise((resolve) => server.close(resolve)),
|
|
}
|
|
}
|