sparta_worlds 0.6.0

package/server/dist/twin/resources/events.js

@@ -0,0 +1,26 @@
+import { resourceMissing } from "../../core/errors.js";
+import { paginate } from "../pagination.js";
+import { getString } from "../params.js";
+function withPendingWebhooks(world, event) {
+    return { ...event.data, pending_webhooks: world.pendingWebhooksFor(event.id) };
+}
+function list(ctx) {
+    const { world, params } = ctx;
+    let events = world.listEvents().reverse();
+    const type = getString(params, "type");
+    if (type !== undefined)
+        events = events.filter((e) => e.type === type);
+    const items = events.map((e) => withPendingWebhooks(world, e));
+    return { body: paginate(items, params, "/v1/events", "event") };
+}
+function retrieve(ctx) {
+    const { world, pathParams } = ctx;
+    const event = world.getEvent(pathParams.id);
+    if (!event)
+        throw resourceMissing(pathParams.id, "event", "id");
+    return { body: withPendingWebhooks(world, event) };
+}
+export const eventRoutes = [
+    { method: "GET", pattern: "/v1/events", handler: list },
+    { method: "GET", pattern: "/v1/events/:id", handler: retrieve },
+];

package/server/dist/twin/resources/invoices.js

@@ -0,0 +1,217 @@
+import { invalidRequest, validationError } from "../../core/errors.js";
+import { deletedStub, invoiceItemShape, invoiceShape, lineItemShape } from "../build.js";
+import { paginate } from "../pagination.js";
+import { getInt, getMetadata, getString, requireCurrency, requireInt, requireString } from "../params.js";
+import { finalizeInvoiceCore, getOr404, oneCurrencyPerBalance, refuseBesidePendingCredits, settleInvoice, } from "./shared.js";
+function createInvoiceItem(ctx) {
+    const { world, params } = ctx;
+    const customerId = requireString(params, "customer");
+    const priceId = getString(params, "price");
+    const requestedQuantity = getInt(params, "quantity") ?? 1;
+    if (requestedQuantity < 0)
+        throw validationError("This value must be greater than or equal to 0.", { param: "quantity" });
+    const bare = priceId === undefined ? { amount: requireInt(params, "amount"), currency: requireCurrency(params) } : null;
+    const description = getString(params, "description") ?? null;
+    const metadata = getMetadata(params) ?? {};
+    const customer = getOr404(world, "customers", customerId, "customer", "customer");
+    let amount;
+    let currency;
+    let quantity;
+    let priceObj = null;
+    if (bare) {
+        ({ amount, currency } = bare);
+        quantity = 1;
+    }
+    else {
+        priceObj = getOr404(world, "prices", priceId, "price", "price");
+        amount = priceObj.unit_amount * requestedQuantity;
+        currency = priceObj.currency;
+        quantity = requestedQuantity;
+    }
+    if (amount < 0) {
+        const param = bare ? "currency" : "price";
+        if (customer.currency === null) {
+            refuseBesidePendingCredits(world, customerId, currency, `this ${currency} credit line would be a second currency of credit, which the twin could not bank beside the first`, ctx.idempotencyKey, param);
+        }
+        else if (customer.currency !== currency) {
+            throw oneCurrencyPerBalance(`${customerId} holds ${String(customer.currency)} and this ${currency} credit line would become a ${currency} credit on the invoice that collects it`, ctx.idempotencyKey, param);
+        }
+    }
+    const item = invoiceItemShape({
+        id: world.nextId("ii"),
+        created: world.clock,
+        customer: customerId,
+        amount,
+        currency,
+        description,
+        quantity,
+        price: priceObj,
+        metadata,
+    });
+    world.insertObject("invoiceitems", item);
+    world.emitEvent("invoiceitem.created", item, { idempotencyKey: ctx.idempotencyKey });
+    return { body: item };
+}
+function retrieveInvoiceItem(ctx) {
+    return { body: getOr404(ctx.world, "invoiceitems", ctx.pathParams.id, "invoiceitem") };
+}
+function listInvoiceItems(ctx) {
+    const { world, params } = ctx;
+    let items = world.listObjects("invoiceitems").map((o) => o.data);
+    const customer = getString(params, "customer");
+    if (customer !== undefined)
+        items = items.filter((i) => i.customer === customer);
+    const pending = getString(params, "pending");
+    if (pending === "true")
+        items = items.filter((i) => i.invoice === null);
+    return { body: paginate(items, params, "/v1/invoiceitems", "invoiceitem") };
+}
+function createInvoice(ctx) {
+    const { world, params } = ctx;
+    const customerId = requireString(params, "customer");
+    const requestedCurrency = getString(params, "currency") === undefined ? undefined : requireCurrency(params);
+    const metadata = getMetadata(params) ?? {};
+    const description = getString(params, "description");
+    getOr404(world, "customers", customerId, "customer", "customer");
+    const pending = world
+        .listObjects("invoiceitems")
+        .map((o) => o.data)
+        .filter((i) => i.customer === customerId && i.invoice === null)
+        .reverse();
+    const currencies = [...new Set(pending.map((i) => i.currency))].sort();
+    if (requestedCurrency === undefined && currencies.length > 1) {
+        throw invalidRequest(`This customer has pending invoice items in more than one currency (${currencies.join(", ")}). Pass \`currency\` to say which of them this invoice collects.`, { param: "currency" });
+    }
+    const currency = requestedCurrency ?? currencies[0];
+    const pendingItems = pending.filter((i) => i.currency === currency);
+    if (pendingItems.length === 0) {
+        throw invalidRequest(`Nothing to invoice for customer ${customerId}.`, { code: "invoice_no_customer_line_items" });
+    }
+    const invoiceId = world.nextId("in");
+    const lines = pendingItems.map((item) => lineItemShape({
+        id: world.nextId("il"),
+        amount: item.amount,
+        currency: item.currency,
+        description: item.description,
+        invoice_item: item.id,
+        period: item.period,
+        price: item.price ?? null,
+        quantity: item.quantity,
+        type: "invoiceitem",
+    }));
+    const invoice = invoiceShape({
+        id: invoiceId,
+        created: world.clock,
+        customer: customerId,
+        currency,
+        lines,
+        metadata,
+    });
+    if (description !== undefined)
+        invoice.description = description;
+    world.insertObject("invoices", invoice);
+    for (const item of pendingItems) {
+        item.invoice = invoiceId;
+        world.updateObject("invoiceitems", item.id, item);
+    }
+    world.emitEvent("invoice.created", invoice, { idempotencyKey: ctx.idempotencyKey });
+    return { body: invoice };
+}
+function retrieveInvoice(ctx) {
+    return { body: getOr404(ctx.world, "invoices", ctx.pathParams.id, "invoice") };
+}
+function listInvoices(ctx) {
+    const { world, params } = ctx;
+    let items = world.listObjects("invoices").map((o) => o.data);
+    const customer = getString(params, "customer");
+    if (customer !== undefined)
+        items = items.filter((i) => i.customer === customer);
+    const status = getString(params, "status");
+    if (status !== undefined) {
+        if (!["draft", "open", "paid", "void", "uncollectible"].includes(status)) {
+            throw validationError(`Invalid status: ${status}`, { param: "status" });
+        }
+        items = items.filter((i) => i.status === status);
+    }
+    const subscription = getString(params, "subscription");
+    if (subscription !== undefined)
+        items = items.filter((i) => i.subscription === subscription);
+    return { body: paginate(items, params, "/v1/invoices", "invoice") };
+}
+function listInvoiceLines(ctx) {
+    const { world, params, pathParams } = ctx;
+    const invoice = getOr404(world, "invoices", pathParams.id, "invoice");
+    const lines = invoice.lines.data;
+    return { body: paginate([...lines], params, `/v1/invoices/${pathParams.id}/lines`, "line_item") };
+}
+function finalizeInvoice(ctx) {
+    const { world, pathParams } = ctx;
+    const invoice = getOr404(world, "invoices", pathParams.id, "invoice");
+    if (invoice.status !== "draft") {
+        throw invalidRequest(`This invoice can't be finalized because it's not a draft. You can only finalize draft invoices.`, { code: "invoice_not_editable" });
+    }
+    finalizeInvoiceCore(world, invoice, { idempotencyKey: ctx.idempotencyKey });
+    return { body: invoice };
+}
+function payInvoice(ctx) {
+    const { world, pathParams } = ctx;
+    const invoice = getOr404(world, "invoices", pathParams.id, "invoice");
+    if (invoice.status === "paid") {
+        throw invalidRequest(`Invoice ${invoice.id} is already paid.`, { code: "invoice_already_paid" });
+    }
+    if (invoice.status !== "open") {
+        throw invalidRequest(`This invoice can't be paid because its status is ${invoice.status}. Finalize the invoice first.`, { code: "invoice_not_payable" });
+    }
+    settleInvoice(world, invoice, { idempotencyKey: ctx.idempotencyKey });
+    return { body: invoice };
+}
+function voidInvoice(ctx) {
+    const { world, pathParams } = ctx;
+    const invoice = getOr404(world, "invoices", pathParams.id, "invoice");
+    if (invoice.status !== "open" && invoice.status !== "uncollectible") {
+        throw invalidRequest(`You cannot void this invoice because its status is ${invoice.status}. Only open or uncollectible invoices can be voided.`, {
+            code: "invoice_not_voidable",
+        });
+    }
+    invoice.status = "void";
+    invoice.status_transitions.voided_at = world.clock;
+    world.updateObject("invoices", invoice.id, invoice);
+    world.emitEvent("invoice.voided", invoice, { idempotencyKey: ctx.idempotencyKey });
+    return { body: invoice };
+}
+function markUncollectible(ctx) {
+    const { world, pathParams } = ctx;
+    const invoice = getOr404(world, "invoices", pathParams.id, "invoice");
+    if (invoice.status !== "open") {
+        throw invalidRequest(`Only open invoices can be marked uncollectible (status is ${invoice.status}).`);
+    }
+    invoice.status = "uncollectible";
+    invoice.status_transitions.marked_uncollectible_at = world.clock;
+    world.updateObject("invoices", invoice.id, invoice);
+    world.emitEvent("invoice.marked_uncollectible", invoice, { idempotencyKey: ctx.idempotencyKey });
+    return { body: invoice };
+}
+function deleteInvoice(ctx) {
+    const { world, pathParams } = ctx;
+    const invoice = getOr404(world, "invoices", pathParams.id, "invoice");
+    if (invoice.status !== "draft") {
+        throw invalidRequest(`You can only delete draft invoices. To remove this invoice from your books, void it instead.`);
+    }
+    world.deleteObject("invoices", pathParams.id);
+    world.emitEvent("invoice.deleted", invoice, { idempotencyKey: ctx.idempotencyKey });
+    return { body: deletedStub(pathParams.id, "invoice") };
+}
+export const invoiceRoutes = [
+    { method: "POST", pattern: "/v1/invoiceitems", handler: createInvoiceItem },
+    { method: "GET", pattern: "/v1/invoiceitems", handler: listInvoiceItems },
+    { method: "GET", pattern: "/v1/invoiceitems/:id", handler: retrieveInvoiceItem },
+    { method: "POST", pattern: "/v1/invoices", handler: createInvoice },
+    { method: "GET", pattern: "/v1/invoices", handler: listInvoices },
+    { method: "GET", pattern: "/v1/invoices/:id", handler: retrieveInvoice },
+    { method: "DELETE", pattern: "/v1/invoices/:id", handler: deleteInvoice },
+    { method: "GET", pattern: "/v1/invoices/:id/lines", handler: listInvoiceLines },
+    { method: "POST", pattern: "/v1/invoices/:id/finalize", handler: finalizeInvoice },
+    { method: "POST", pattern: "/v1/invoices/:id/pay", handler: payInvoice },
+    { method: "POST", pattern: "/v1/invoices/:id/void", handler: voidInvoice },
+    { method: "POST", pattern: "/v1/invoices/:id/mark_uncollectible", handler: markUncollectible },
+];

package/server/dist/twin/resources/payment_intents.js

@@ -0,0 +1,146 @@
+import { cardError, invalidRequest, resourceMissing, validationError } from "../../core/errors.js";
+import { chargeShape, paymentIntentShape } from "../build.js";
+import { paginate } from "../pagination.js";
+import { getBool, getMetadata, getString, requireCurrency, requireInt } from "../params.js";
+import { getOr404 } from "./shared.js";
+const TEST_PAYMENT_METHODS = new Set(["pm_card_visa", "pm_card_chargeDeclined"]);
+function create(ctx) {
+    const { world, params } = ctx;
+    const amount = requireInt(params, "amount");
+    if (amount < 1)
+        throw validationError("This value must be greater than or equal to 1.", { param: "amount" });
+    const currency = requireCurrency(params);
+    const customerId = getString(params, "customer");
+    const description = getString(params, "description") ?? null;
+    const metadata = getMetadata(params) ?? {};
+    const confirm = getBool(params, "confirm") ?? false;
+    const paymentMethod = getString(params, "payment_method");
+    if (customerId !== undefined)
+        getOr404(world, "customers", customerId, "customer", "customer");
+    const pi = paymentIntentShape({
+        id: world.nextId("pi"),
+        created: world.clock,
+        amount,
+        currency,
+        customer: customerId ?? null,
+        description,
+        metadata,
+        clientSecretToken: world.nextToken(24),
+    });
+    world.insertObject("payment_intents", pi);
+    world.emitEvent("payment_intent.created", pi, { idempotencyKey: ctx.idempotencyKey });
+    if (confirm) {
+        return confirmPaymentIntent(ctx, pi, paymentMethod);
+    }
+    return { body: pi };
+}
+function confirmPaymentIntent(ctx, pi, pm) {
+    const { world } = ctx;
+    if (pi.status === "succeeded") {
+        throw invalidRequest(`This PaymentIntent's state is incompatible with the operation you were trying to perform. The PaymentIntent has a status of succeeded.`, { code: "payment_intent_unexpected_state" });
+    }
+    if (pi.status === "canceled") {
+        throw invalidRequest(`This PaymentIntent's state is incompatible with the operation you were trying to perform. The PaymentIntent has a status of canceled.`, { code: "payment_intent_unexpected_state" });
+    }
+    if (pm === undefined) {
+        throw invalidRequest("You cannot confirm this PaymentIntent because it's missing a payment method.", {
+            code: "payment_intent_payment_attempt_failed",
+        });
+    }
+    if (!TEST_PAYMENT_METHODS.has(pm)) {
+        throw resourceMissing(pm, "PaymentMethod", "payment_method");
+    }
+    pi.payment_method = pm;
+    if (pm === "pm_card_chargeDeclined") {
+        const charge = chargeShape({
+            id: world.nextId("ch"),
+            created: world.clock,
+            amount: pi.amount,
+            currency: pi.currency,
+            customer: pi.customer,
+            payment_intent: pi.id,
+            payment_method: pm,
+            status: "failed",
+            failure_code: "card_declined",
+            failure_message: "Your card was declined.",
+            description: pi.description,
+        });
+        world.insertObject("charges", charge);
+        pi.latest_charge = charge.id;
+        pi.status = "requires_payment_method";
+        pi.last_payment_error = {
+            charge: charge.id,
+            code: "card_declined",
+            decline_code: "generic_decline",
+            doc_url: "https://stripe.com/docs/error-codes/card-declined",
+            message: "Your card was declined.",
+            payment_method: { id: pm, object: "payment_method", type: "card" },
+            type: "card_error",
+        };
+        world.updateObject("payment_intents", pi.id, pi);
+        world.emitEvent("charge.failed", charge, { idempotencyKey: ctx.idempotencyKey });
+        world.emitEvent("payment_intent.payment_failed", pi, { idempotencyKey: ctx.idempotencyKey });
+        const err = cardError("card_declined", "Your card was declined.", { declineCode: "generic_decline" });
+        const body = err.toJSON();
+        body.error = { ...body.error, charge: charge.id, payment_intent: pi };
+        return { status: err.status, body };
+    }
+    const charge = chargeShape({
+        id: world.nextId("ch"),
+        created: world.clock,
+        amount: pi.amount,
+        currency: pi.currency,
+        customer: pi.customer,
+        payment_intent: pi.id,
+        payment_method: pm,
+        status: "succeeded",
+        description: pi.description,
+    });
+    world.insertObject("charges", charge);
+    pi.status = "succeeded";
+    pi.amount_received = pi.amount;
+    pi.latest_charge = charge.id;
+    pi.last_payment_error = null;
+    world.updateObject("payment_intents", pi.id, pi);
+    world.emitEvent("charge.succeeded", charge, { idempotencyKey: ctx.idempotencyKey });
+    world.emitEvent("payment_intent.succeeded", pi, { idempotencyKey: ctx.idempotencyKey });
+    return { body: pi };
+}
+function confirm(ctx) {
+    const pm = getString(ctx.params, "payment_method");
+    const pi = getOr404(ctx.world, "payment_intents", ctx.pathParams.id, "payment_intent");
+    return confirmPaymentIntent(ctx, pi, pm);
+}
+function cancel(ctx) {
+    const { world, pathParams } = ctx;
+    const pi = getOr404(world, "payment_intents", pathParams.id, "payment_intent");
+    if (pi.status !== "requires_payment_method") {
+        throw invalidRequest(`You cannot cancel this PaymentIntent because it has a status of ${pi.status}.`, {
+            code: "payment_intent_unexpected_state",
+        });
+    }
+    pi.status = "canceled";
+    pi.canceled_at = world.clock;
+    pi.cancellation_reason = getString(ctx.params, "cancellation_reason") ?? "requested_by_customer";
+    world.updateObject("payment_intents", pi.id, pi);
+    world.emitEvent("payment_intent.canceled", pi, { idempotencyKey: ctx.idempotencyKey });
+    return { body: pi };
+}
+function retrieve(ctx) {
+    return { body: getOr404(ctx.world, "payment_intents", ctx.pathParams.id, "payment_intent") };
+}
+function list(ctx) {
+    const { world, params } = ctx;
+    let items = world.listObjects("payment_intents").map((o) => o.data);
+    const customer = getString(params, "customer");
+    if (customer !== undefined)
+        items = items.filter((p) => p.customer === customer);
+    return { body: paginate(items, params, "/v1/payment_intents", "payment_intent") };
+}
+export const paymentIntentRoutes = [
+    { method: "POST", pattern: "/v1/payment_intents", handler: create },
+    { method: "GET", pattern: "/v1/payment_intents", handler: list },
+    { method: "GET", pattern: "/v1/payment_intents/:id", handler: retrieve },
+    { method: "POST", pattern: "/v1/payment_intents/:id/confirm", handler: confirm },
+    { method: "POST", pattern: "/v1/payment_intents/:id/cancel", handler: cancel },
+];

package/server/dist/twin/resources/products.js

@@ -0,0 +1,92 @@
+import { validationError } from "../../core/errors.js";
+import { priceShape, productShape } from "../build.js";
+import { paginate } from "../pagination.js";
+import { getBool, getInt, getMetadata, getString, requireCurrency, requireInt, requireString } from "../params.js";
+import { getOr404 } from "./shared.js";
+function createProduct(ctx) {
+    const { world, params } = ctx;
+    const product = productShape({
+        id: world.nextId("prod"),
+        created: world.clock,
+        name: requireString(params, "name"),
+        description: getString(params, "description") ?? null,
+        active: getBool(params, "active") ?? true,
+        metadata: getMetadata(params) ?? {},
+    });
+    world.insertObject("products", product);
+    world.emitEvent("product.created", product, { idempotencyKey: ctx.idempotencyKey });
+    return { body: product };
+}
+function retrieveProduct(ctx) {
+    return { body: getOr404(ctx.world, "products", ctx.pathParams.id, "product") };
+}
+function listProducts(ctx) {
+    const { world, params } = ctx;
+    let items = world.listObjects("products").map((o) => o.data);
+    const active = getBool(params, "active");
+    if (active !== undefined)
+        items = items.filter((p) => p.active === active);
+    return { body: paginate(items, params, "/v1/products", "product") };
+}
+function createPrice(ctx) {
+    const { world, params } = ctx;
+    const productId = requireString(params, "product");
+    const unitAmount = requireInt(params, "unit_amount");
+    if (unitAmount < 0)
+        throw validationError("This value must be greater than or equal to 0.", { param: "unit_amount" });
+    const currency = requireCurrency(params);
+    let recurring = null;
+    const rec = params.recurring;
+    if (rec !== undefined) {
+        const interval = getString(rec, "interval");
+        if (!interval || !["day", "week", "month", "year"].includes(interval)) {
+            throw validationError("Invalid recurring[interval]: must be one of day, week, month, or year", {
+                param: "recurring[interval]",
+            });
+        }
+        recurring = {
+            interval: interval,
+            interval_count: getInt(rec, "interval_count") ?? 1,
+        };
+    }
+    const nickname = getString(params, "nickname") ?? null;
+    const active = getBool(params, "active") ?? true;
+    const metadata = getMetadata(params) ?? {};
+    getOr404(world, "products", productId, "product", "product");
+    const price = priceShape({
+        id: world.nextId("price"),
+        created: world.clock,
+        product: productId,
+        unit_amount: unitAmount,
+        currency,
+        nickname,
+        active,
+        recurring,
+        metadata,
+    });
+    world.insertObject("prices", price);
+    world.emitEvent("price.created", price, { idempotencyKey: ctx.idempotencyKey });
+    return { body: price };
+}
+function retrievePrice(ctx) {
+    return { body: getOr404(ctx.world, "prices", ctx.pathParams.id, "price") };
+}
+function listPrices(ctx) {
+    const { world, params } = ctx;
+    let items = world.listObjects("prices").map((o) => o.data);
+    const product = getString(params, "product");
+    if (product !== undefined)
+        items = items.filter((p) => p.product === product);
+    const active = getBool(params, "active");
+    if (active !== undefined)
+        items = items.filter((p) => p.active === active);
+    return { body: paginate(items, params, "/v1/prices", "price") };
+}
+export const productRoutes = [
+    { method: "POST", pattern: "/v1/products", handler: createProduct },
+    { method: "GET", pattern: "/v1/products", handler: listProducts },
+    { method: "GET", pattern: "/v1/products/:id", handler: retrieveProduct },
+    { method: "POST", pattern: "/v1/prices", handler: createPrice },
+    { method: "GET", pattern: "/v1/prices", handler: listPrices },
+    { method: "GET", pattern: "/v1/prices/:id", handler: retrievePrice },
+];

package/server/dist/twin/resources/refunds.js

@@ -0,0 +1,103 @@
+import { invalidRequest, resourceMissing, validationError } from "../../core/errors.js";
+import { refundShape } from "../build.js";
+import { paginate } from "../pagination.js";
+import { getInt, getMetadata, getString, requireCurrency } from "../params.js";
+import { getOr404 } from "./shared.js";
+function formatAmount(cents, currency) {
+    const symbol = currency === "usd" ? "$" : currency === "eur" ? "€" : currency === "gbp" ? "£" : `${currency.toUpperCase()} `;
+    return `${symbol}${(cents / 100).toFixed(2)}`;
+}
+function create(ctx) {
+    const { world, params } = ctx;
+    const chargeId = getString(params, "charge");
+    const paymentIntentId = getString(params, "payment_intent");
+    if (chargeId === undefined && paymentIntentId === undefined) {
+        throw validationError("One of the following params should be provided for this request: payment_intent or charge.", {
+            code: "parameter_missing",
+        });
+    }
+    if (chargeId !== undefined && paymentIntentId !== undefined) {
+        throw validationError("Only one of the following params may be provided for this request: payment_intent or charge.");
+    }
+    const requestedAmount = getInt(params, "amount");
+    if (requestedAmount !== undefined && requestedAmount < 1)
+        throw validationError("This value must be greater than or equal to 1.", { param: "amount" });
+    const reason = getString(params, "reason");
+    if (reason !== undefined && !["duplicate", "fraudulent", "requested_by_customer"].includes(reason)) {
+        throw validationError(`Invalid reason: must be one of duplicate, fraudulent, or requested_by_customer`, {
+            param: "reason",
+        });
+    }
+    const metadata = getMetadata(params) ?? {};
+    const currency = params.currency === undefined || params.currency === "" ? undefined : requireCurrency(params);
+    let charge;
+    if (chargeId !== undefined) {
+        charge = getOr404(world, "charges", chargeId, "charge", "charge");
+    }
+    else {
+        const pi = getOr404(world, "payment_intents", paymentIntentId, "payment_intent", "payment_intent");
+        const latest = pi.latest_charge;
+        if (!latest) {
+            throw invalidRequest(`This PaymentIntent does not have a successful charge to refund.`, {
+                param: "payment_intent",
+            });
+        }
+        const stored = world.getObject("charges", latest);
+        if (!stored)
+            throw resourceMissing(latest, "charge");
+        charge = stored.data;
+    }
+    if (charge.status !== "succeeded") {
+        throw invalidRequest(`The charge ${charge.id} has failed, and thus cannot be refunded.`, { param: "charge" });
+    }
+    if (currency !== undefined && currency !== charge.currency) {
+        throw invalidRequest(`The refund's currency (${currency}) must match the currency of the charge (${String(charge.currency)}).`, { param: "currency" });
+    }
+    const alreadyRefunded = charge.amount_refunded;
+    const chargeAmount = charge.amount;
+    const remaining = chargeAmount - alreadyRefunded;
+    if (remaining <= 0) {
+        throw invalidRequest(`Charge ${charge.id} has already been refunded.`, { code: "charge_already_refunded" });
+    }
+    const amount = requestedAmount ?? remaining;
+    if (amount > remaining) {
+        const currency = charge.currency;
+        throw invalidRequest(`Refund amount (${formatAmount(amount, currency)}) is greater than unrefunded amount on charge (${formatAmount(remaining, currency)})`, { param: "amount" });
+    }
+    const refund = refundShape({
+        id: world.nextId("re"),
+        created: world.clock,
+        amount,
+        currency: charge.currency,
+        charge: charge.id,
+        payment_intent: charge.payment_intent ?? null,
+        reason: reason ?? null,
+        metadata,
+    });
+    world.insertObject("refunds", refund);
+    charge.amount_refunded = alreadyRefunded + amount;
+    charge.refunded = charge.amount_refunded === chargeAmount;
+    world.updateObject("charges", charge.id, charge);
+    world.emitEvent("charge.refunded", charge, { idempotencyKey: ctx.idempotencyKey });
+    world.emitEvent("refund.created", refund, { idempotencyKey: ctx.idempotencyKey });
+    return { body: refund };
+}
+function retrieve(ctx) {
+    return { body: getOr404(ctx.world, "refunds", ctx.pathParams.id, "refund") };
+}
+function list(ctx) {
+    const { world, params } = ctx;
+    let items = world.listObjects("refunds").map((o) => o.data);
+    const charge = getString(params, "charge");
+    if (charge !== undefined)
+        items = items.filter((r) => r.charge === charge);
+    const paymentIntent = getString(params, "payment_intent");
+    if (paymentIntent !== undefined)
+        items = items.filter((r) => r.payment_intent === paymentIntent);
+    return { body: paginate(items, params, "/v1/refunds", "refund") };
+}
+export const refundRoutes = [
+    { method: "POST", pattern: "/v1/refunds", handler: create },
+    { method: "GET", pattern: "/v1/refunds", handler: list },
+    { method: "GET", pattern: "/v1/refunds/:id", handler: retrieve },
+];