sparta_worlds 0.6.0

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

@@ -0,0 +1,113 @@
+import { invalidRequest, resourceMissing, UNSUPPORTED_PARAMETER_CODE } from "../../core/errors.js";
+import { chargeShape, invoicePrefixFor } from "../build.js";
+export function surfaceOf(path) {
+    return path.startsWith("/api/v2") ? "zendesk" : "stripe";
+}
+export function getOr404(world, resource, id, label, param = "id") {
+    if (!id)
+        throw resourceMissing(String(id), label, param);
+    const stored = world.getObject(resource, id);
+    if (!stored)
+        throw resourceMissing(id, label, param);
+    return stored.data;
+}
+export function oneCurrencyPerBalance(detail, idempotencyKey, param) {
+    const stored = idempotencyKey
+        ? " The twin had to read the customer to know, so this outcome is stored under the request's idempotency key like any executed error — retry a corrected request under a new key."
+        : "";
+    return invalidRequest(`worlds models one currency per customer balance: ${detail}; nothing was changed.${stored} See docs/scope.md, "Semantics simplifications".`, { code: UNSUPPORTED_PARAMETER_CODE, param });
+}
+export function pendingCreditCurrenciesBeside(world, customerId, currency) {
+    const others = new Set();
+    for (const { data: item } of world.listObjects("invoiceitems")) {
+        if (item.customer !== customerId || item.invoice !== null || item.amount >= 0)
+            continue;
+        if (item.currency !== currency)
+            others.add(item.currency);
+    }
+    return [...others].sort();
+}
+export function refuseBesidePendingCredits(world, customerId, currency, consequence, idempotencyKey, param) {
+    const others = pendingCreditCurrenciesBeside(world, customerId, currency);
+    if (others.length === 0)
+        return;
+    throw oneCurrencyPerBalance(`${customerId} has pending credit lines in ${others.join(" and ")}, which the invoice collecting them may hand back as a credit in that currency, and ${consequence}. Collect those lines onto an invoice in their currency first (add a charge line if its total would otherwise be negative).`, idempotencyKey, param);
+}
+export function assignInvoiceNumber(world, invoice) {
+    const customer = invoice.customer;
+    const seq = world.incrCounter(`invnum:${customer}`);
+    invoice.number = `${invoicePrefixFor(customer)}-${String(seq).padStart(4, "0")}`;
+}
+export function finalizeInvoiceCore(world, invoice, opts = {}) {
+    const at = opts.at ?? world.clock;
+    invoice.status = "open";
+    assignInvoiceNumber(world, invoice);
+    invoice.status_transitions.finalized_at = at;
+    const stored = world.getObject("customers", invoice.customer);
+    if (stored) {
+        const customer = stored.data;
+        const total = invoice.total;
+        const currency = invoice.currency;
+        const sameCurrency = customer.currency === currency;
+        const balance = sameCurrency ? customer.balance : 0;
+        const applied = balance < 0 ? -Math.min(-balance, Math.max(total, 0)) : balance;
+        let due = total + applied;
+        let newBalance = balance - applied;
+        if (due < 0) {
+            if (customer.currency === null) {
+                refuseBesidePendingCredits(world, customer.id, currency, `this ${currency} invoice's negative total would pin its balance to ${currency}, beside which the twin could not bank that credit`, opts.idempotencyKey);
+            }
+            else if (!sameCurrency) {
+                throw oneCurrencyPerBalance(`${String(customer.id)} holds ${String(customer.currency)} and this ${currency} invoice's negative total would become a ${currency} credit`, opts.idempotencyKey);
+            }
+            newBalance += due;
+            due = 0;
+        }
+        if (applied !== 0 || due !== total) {
+            invoice.starting_balance = balance;
+            invoice.ending_balance = newBalance;
+            invoice.amount_due = due;
+            invoice.amount_remaining = due;
+            customer.balance = newBalance;
+            if (newBalance !== 0 && customer.currency === null)
+                customer.currency = currency;
+            world.updateObject("customers", customer.id, customer);
+            world.emitEvent("customer.updated", customer, { idempotencyKey: opts.idempotencyKey });
+        }
+    }
+    world.updateObject("invoices", invoice.id, invoice);
+    world.emitEvent("invoice.finalized", invoice, { idempotencyKey: opts.idempotencyKey });
+    if (invoice.amount_remaining === 0) {
+        invoice.status = "paid";
+        invoice.paid = true;
+        invoice.status_transitions.paid_at = at;
+        world.updateObject("invoices", invoice.id, invoice);
+        world.emitEvent("invoice.paid", invoice, { idempotencyKey: opts.idempotencyKey });
+    }
+}
+export function settleInvoice(world, invoice, opts = {}) {
+    const amount = invoice.amount_remaining;
+    const charge = chargeShape({
+        id: world.nextId("ch"),
+        created: opts.chargeCreated ?? world.clock,
+        amount,
+        currency: invoice.currency,
+        customer: invoice.customer,
+        invoice: invoice.id,
+        status: "succeeded",
+        description: `Payment for invoice ${invoice.number ?? invoice.id}`,
+    });
+    world.insertObject("charges", charge);
+    invoice.status = "paid";
+    invoice.paid = true;
+    invoice.attempted = true;
+    invoice.attempt_count = invoice.attempt_count + 1;
+    invoice.amount_paid = invoice.amount_paid + amount;
+    invoice.amount_remaining = 0;
+    invoice.charge = charge.id;
+    invoice.status_transitions.paid_at = opts.chargeCreated ?? world.clock;
+    world.updateObject("invoices", invoice.id, invoice);
+    world.emitEvent("charge.succeeded", charge, { idempotencyKey: opts.idempotencyKey });
+    world.emitEvent("invoice.paid", invoice, { idempotencyKey: opts.idempotencyKey });
+    return { charge };
+}

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

@@ -0,0 +1,325 @@
+import { invalidRequest, validationError } from "../../core/errors.js";
+import { addInterval } from "../../core/time.js";
+import { invoiceItemShape, invoiceShape, lineItemShape, subscriptionShape } from "../build.js";
+import { paginate } from "../pagination.js";
+import { getBool, getMetadata, getString, requireString } from "../params.js";
+import { finalizeInvoiceCore, getOr404, oneCurrencyPerBalance, refuseBesidePendingCredits, settleInvoice, } from "./shared.js";
+function billingAnchorDay(sub) {
+    const anchor = typeof sub.billing_cycle_anchor === "number" ? sub.billing_cycle_anchor : sub.current_period_start;
+    return typeof anchor === "number" ? new Date(anchor * 1000).getUTCDate() : undefined;
+}
+function priceInterval(price) {
+    const recurring = price.recurring;
+    if (!recurring)
+        throw invalidRequest(`The price specified is set to \`type=one_time\` but this field only accepts prices with \`type=recurring\`.`, { param: "items[0][price]" });
+    return { interval: recurring.interval, count: recurring.interval_count };
+}
+function billPeriod(world, sub, opts) {
+    const item = sub.items.data[0];
+    const price = item.price;
+    const quantity = item.quantity;
+    const amount = price.unit_amount * quantity;
+    const product = world.getObject("products", price.product)?.data;
+    const line = lineItemShape({
+        id: world.nextId("il"),
+        amount,
+        currency: sub.currency,
+        description: `1 × ${product?.name ?? "subscription"} (at ${formatUnit(price)})`,
+        period: { start: sub.current_period_start, end: sub.current_period_end },
+        price,
+        quantity,
+        subscription: sub.id,
+        type: "subscription",
+    });
+    const pendingItems = world
+        .listObjects("invoiceitems")
+        .map((o) => o.data)
+        .filter((i) => i.customer === sub.customer && i.invoice === null && i.currency === sub.currency)
+        .reverse();
+    const invoiceId = world.nextId("in");
+    const sweptLines = 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: opts.at,
+        customer: sub.customer,
+        currency: sub.currency,
+        lines: [...sweptLines, line],
+        subscription: sub.id,
+        billing_reason: opts.reason,
+        period_start: sub.current_period_start,
+        period_end: sub.current_period_end,
+    });
+    world.insertObject("invoices", invoice);
+    for (const item of pendingItems) {
+        item.invoice = invoiceId;
+        world.updateObject("invoiceitems", item.id, item);
+    }
+    world.emitEvent("invoice.created", invoice, { idempotencyKey: opts.idempotencyKey });
+    finalizeInvoiceCore(world, invoice, { idempotencyKey: opts.idempotencyKey, at: opts.at });
+    if (invoice.amount_remaining > 0) {
+        settleInvoice(world, invoice, { idempotencyKey: opts.idempotencyKey, chargeCreated: opts.at });
+    }
+    sub.latest_invoice = invoice.id;
+    return invoice;
+}
+function formatUnit(price) {
+    const cents = price.unit_amount;
+    return `${(cents / 100).toFixed(2)} ${price.currency.toUpperCase()}`;
+}
+function create(ctx) {
+    const { world, params } = ctx;
+    const customerId = requireString(params, "customer");
+    const items = params.items;
+    if (!items || !Array.isArray(items) || items.length === 0 || !items[0]?.price) {
+        throw validationError("Missing required param: items[0][price].", {
+            code: "parameter_missing",
+            param: "items[0][price]",
+        });
+    }
+    if (items.length > 1) {
+        throw validationError("The twin supports exactly one item per subscription.", { param: "items" });
+    }
+    const quantity = items[0].quantity !== undefined ? Number(items[0].quantity) : 1;
+    if (!Number.isInteger(quantity) || quantity < 1)
+        throw validationError(`Invalid quantity`, { param: "items[0][quantity]" });
+    const cancelAtPeriodEnd = getBool(params, "cancel_at_period_end") ?? false;
+    const metadata = getMetadata(params) ?? {};
+    getOr404(world, "customers", customerId, "customer", "customer");
+    const price = getOr404(world, "prices", String(items[0].price), "price", "items[0][price]");
+    const { interval, count } = priceInterval(price);
+    const now = world.clock;
+    const sub = subscriptionShape({
+        id: world.nextId("sub"),
+        created: now,
+        customer: customerId,
+        currency: price.currency,
+        itemId: world.nextId("si"),
+        price,
+        quantity,
+        current_period_start: now,
+        current_period_end: addInterval(now, interval, count),
+        cancel_at_period_end: cancelAtPeriodEnd,
+        metadata,
+    });
+    world.insertObject("subscriptions", sub);
+    world.emitEvent("customer.subscription.created", sub, { idempotencyKey: ctx.idempotencyKey });
+    billPeriod(world, sub, { reason: "subscription_create", at: now, idempotencyKey: ctx.idempotencyKey });
+    world.updateObject("subscriptions", sub.id, sub);
+    return { body: sub };
+}
+function retrieve(ctx) {
+    return { body: getOr404(ctx.world, "subscriptions", ctx.pathParams.id, "subscription") };
+}
+function parsePlanChange(params) {
+    const prorationBehavior = getString(params, "proration_behavior") ?? "create_prorations";
+    if (!["create_prorations", "none"].includes(prorationBehavior)) {
+        throw validationError(`Invalid proration_behavior: ${prorationBehavior}`, { param: "proration_behavior" });
+    }
+    const items = params.items;
+    if (!items || !Array.isArray(items) || items.length === 0)
+        return undefined;
+    if (items.length > 1)
+        throw validationError("The twin supports exactly one item per subscription.", { param: "items" });
+    const requested = items[0];
+    const quantity = requested.quantity !== undefined ? Number(requested.quantity) : undefined;
+    if (quantity !== undefined && (!Number.isInteger(quantity) || quantity < 1))
+        throw validationError(`Invalid quantity`, { param: "items[0][quantity]" });
+    return {
+        itemId: requested.id,
+        price: requested.price !== undefined ? String(requested.price) : undefined,
+        quantity,
+        prorationBehavior,
+    };
+}
+function applyPlanChange(ctx, sub, change) {
+    const { world } = ctx;
+    const item = sub.items.data[0];
+    if (change.itemId !== undefined && change.itemId !== item.id) {
+        throw invalidRequest(`No such subscription item: '${change.itemId}'`, {
+            code: "resource_missing",
+            status: 404,
+            param: "items[0][id]",
+        });
+    }
+    if (change.price === undefined && change.quantity === undefined)
+        return;
+    const oldPrice = item.price;
+    const oldQuantity = item.quantity;
+    const newPrice = change.price !== undefined ? getOr404(world, "prices", change.price, "price", "items[0][price]") : oldPrice;
+    priceInterval(newPrice);
+    if (newPrice.currency !== sub.currency) {
+        throw invalidRequest(`Cannot change a subscription from ${String(sub.currency).toUpperCase()} to ${String(newPrice.currency).toUpperCase()}. Currency changes require a new subscription.`, { param: "items[0][price]" });
+    }
+    const newQuantity = change.quantity ?? oldQuantity;
+    if (newPrice.id === oldPrice.id && newQuantity === oldQuantity)
+        return;
+    if (change.prorationBehavior === "create_prorations") {
+        const periodStart = sub.current_period_start;
+        const periodEnd = sub.current_period_end;
+        const fraction = Math.max(0, Math.min(1, (periodEnd - world.clock) / (periodEnd - periodStart)));
+        const oldUnused = Math.round(oldPrice.unit_amount * oldQuantity * fraction);
+        const newRemaining = Math.round(newPrice.unit_amount * newQuantity * fraction);
+        if (oldUnused !== 0 || newRemaining !== 0) {
+            const customer = world.getObject("customers", sub.customer)?.data;
+            const wayOut = "pass proration_behavior=none to change the plan without prorations";
+            if (customer && customer.currency === null) {
+                refuseBesidePendingCredits(world, customer.id, sub.currency, `the prorations of this ${String(sub.currency)} subscription would be credit lines in a second currency, which the twin could not bank beside the first — ${wayOut}`, ctx.idempotencyKey, "proration_behavior");
+            }
+            else if (customer && customer.currency !== sub.currency) {
+                throw oneCurrencyPerBalance(`${String(customer.id)} holds ${String(customer.currency)} and the prorations of this ${String(sub.currency)} subscription would land on its next invoice, whose negative total the twin could not bank as a ${String(sub.currency)} credit beside that balance — ${wayOut}`, ctx.idempotencyKey, "proration_behavior");
+            }
+        }
+        const period = { start: world.clock, end: periodEnd };
+        const bookProration = (amount, description, price, quantity) => {
+            const proration = invoiceItemShape({
+                id: world.nextId("ii"),
+                created: world.clock,
+                customer: sub.customer,
+                amount,
+                currency: sub.currency,
+                description,
+                quantity,
+                price,
+                metadata: {},
+            });
+            proration.proration = true;
+            proration.period = period;
+            world.insertObject("invoiceitems", proration);
+            world.emitEvent("invoiceitem.created", proration, { idempotencyKey: ctx.idempotencyKey });
+        };
+        if (oldUnused !== 0)
+            bookProration(-oldUnused, `Unused time on ${oldPrice.nickname ?? oldPrice.id}`, oldPrice, oldQuantity);
+        if (newRemaining !== 0)
+            bookProration(newRemaining, `Remaining time on ${newPrice.nickname ?? newPrice.id}`, newPrice, newQuantity);
+    }
+    item.price = newPrice;
+    item.quantity = newQuantity;
+}
+function update(ctx) {
+    const { world, params, pathParams } = ctx;
+    const change = parsePlanChange(params);
+    const cancelAtPeriodEnd = getBool(params, "cancel_at_period_end");
+    const metadata = getMetadata(params);
+    const sub = getOr404(world, "subscriptions", pathParams.id, "subscription");
+    if (sub.status === "canceled") {
+        throw invalidRequest(`You cannot update a canceled subscription.`);
+    }
+    if (change !== undefined)
+        applyPlanChange(ctx, sub, change);
+    if (cancelAtPeriodEnd !== undefined) {
+        sub.cancel_at_period_end = cancelAtPeriodEnd;
+        sub.cancel_at = cancelAtPeriodEnd ? sub.current_period_end : null;
+        sub.cancellation_details.reason = cancelAtPeriodEnd ? "cancellation_requested" : null;
+    }
+    if (metadata !== undefined)
+        sub.metadata = { ...sub.metadata, ...metadata };
+    world.updateObject("subscriptions", sub.id, sub);
+    world.emitEvent("customer.subscription.updated", sub, { idempotencyKey: ctx.idempotencyKey });
+    return { body: sub };
+}
+function cancelNow(ctx) {
+    const { world, pathParams } = ctx;
+    const sub = getOr404(world, "subscriptions", pathParams.id, "subscription");
+    if (sub.status === "canceled") {
+        throw invalidRequest(`No such subscription: '${pathParams.id}'`, {
+            code: "resource_missing",
+            status: 404,
+            param: "id",
+        });
+    }
+    sub.status = "canceled";
+    sub.canceled_at = world.clock;
+    sub.ended_at = world.clock;
+    sub.cancel_at_period_end = false;
+    sub.cancellation_details.reason = "cancellation_requested";
+    world.updateObject("subscriptions", sub.id, sub);
+    world.emitEvent("customer.subscription.deleted", sub, { idempotencyKey: ctx.idempotencyKey });
+    return { body: sub };
+}
+function list(ctx) {
+    const { world, params } = ctx;
+    let items = world.listObjects("subscriptions").map((o) => o.data);
+    const customer = getString(params, "customer");
+    if (customer !== undefined)
+        items = items.filter((s) => s.customer === customer);
+    const status = getString(params, "status");
+    if (status !== undefined && status !== "all")
+        items = items.filter((s) => s.status === status);
+    else if (status === undefined)
+        items = items.filter((s) => s.status !== "canceled");
+    const priceId = getString(params, "price");
+    if (priceId !== undefined) {
+        items = items.filter((s) => s.items.data[0].price.id === priceId);
+    }
+    return { body: paginate(items, params, "/v1/subscriptions", "subscription") };
+}
+export const MAX_RENEWALS_PER_ADVANCE = 1000;
+export class RenewalFailed extends Error {
+    subscription;
+    boundary;
+    reason;
+    constructor(subscription, boundary, cause) {
+        const reason = cause instanceof Error ? cause.message : String(cause);
+        super(`worlds could not renew subscription ${subscription} at its period boundary ${boundary}: ${reason} The clock movement was rolled back — the clock did not move and nothing was written — and every movement across this boundary fails the same way until the world is reset or, with the clock in manual mode, a line in the invoice's currency brings its total to zero or above or the subscription is set to cancel_at_period_end.`);
+        this.name = "RenewalFailed";
+        this.subscription = subscription;
+        this.boundary = boundary;
+        this.reason = reason;
+    }
+}
+export function processRenewals(world) {
+    let billed = 0;
+    let pending = 0;
+    const subs = world.listObjects("subscriptions").reverse();
+    for (const stored of subs) {
+        const sub = stored.data;
+        if (sub.status !== "active")
+            continue;
+        let renewed = 0;
+        while (sub.current_period_end <= world.clock && renewed < MAX_RENEWALS_PER_ADVANCE) {
+            const boundary = sub.current_period_end;
+            if (sub.cancel_at_period_end) {
+                sub.status = "canceled";
+                sub.canceled_at = boundary;
+                sub.ended_at = boundary;
+                world.updateObject("subscriptions", sub.id, sub);
+                world.emitEvent("customer.subscription.deleted", sub);
+                break;
+            }
+            const item = sub.items.data[0];
+            const { interval, count } = priceInterval(item.price);
+            sub.current_period_start = boundary;
+            sub.current_period_end = addInterval(boundary, interval, count, billingAnchorDay(sub));
+            try {
+                billPeriod(world, sub, { reason: "subscription_cycle", at: boundary });
+            }
+            catch (err) {
+                throw new RenewalFailed(sub.id, boundary, err);
+            }
+            world.updateObject("subscriptions", sub.id, sub);
+            world.emitEvent("customer.subscription.updated", sub);
+            billed++;
+            renewed++;
+        }
+        if (sub.status === "active" && sub.current_period_end <= world.clock)
+            pending++;
+    }
+    return { billed, pending };
+}
+export const subscriptionRoutes = [
+    { method: "POST", pattern: "/v1/subscriptions", handler: create },
+    { method: "GET", pattern: "/v1/subscriptions", handler: list },
+    { method: "GET", pattern: "/v1/subscriptions/:id", handler: retrieve },
+    { method: "POST", pattern: "/v1/subscriptions/:id", handler: update },
+    { method: "DELETE", pattern: "/v1/subscriptions/:id", handler: cancelNow },
+];

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

@@ -0,0 +1,128 @@
+import { ZendeskError } from "../../core/errors.js";
+import { isoFromClock, ticketShape } from "../build.js";
+const STATUSES = ["new", "open", "pending", "hold", "solved", "closed"];
+const PRIORITIES = ["low", "normal", "high", "urgent"];
+function ticketId(raw) {
+    return raw.endsWith(".json") ? raw.slice(0, -5) : raw;
+}
+function notFound() {
+    return new ZendeskError(404, "RecordNotFound", "Not found");
+}
+function invalid(description, details) {
+    return new ZendeskError(422, "RecordInvalid", description, details);
+}
+function commentPublic(v) {
+    if (v === undefined || v === true || v === "true")
+        return true;
+    if (v === false || v === "false")
+        return false;
+    throw invalid(`Comment public: ${JSON.stringify(v)} is not a boolean`);
+}
+function wireTicket(data) {
+    const { comments: _comments, created: _created, ...rest } = data;
+    return rest;
+}
+function getTicket(ctx, rawId) {
+    const stored = ctx.world.getObject("tickets", ticketId(rawId));
+    if (!stored)
+        throw notFound();
+    return stored.data;
+}
+function create(ctx) {
+    const { world, params } = ctx;
+    const t = (params.ticket ?? {});
+    const subject = typeof t.subject === "string" ? t.subject : undefined;
+    const comment = (t.comment ?? {});
+    const body = typeof comment.body === "string" ? comment.body : typeof t.description === "string" ? t.description : undefined;
+    if (!subject || !body) {
+        throw invalid("Record validation errors", { base: [{ description: "Subject and comment body are required" }] });
+    }
+    const requester = (t.requester ?? {});
+    const priority = typeof t.priority === "string" ? t.priority : "normal";
+    if (!PRIORITIES.includes(priority)) {
+        throw invalid(`Priority: ${priority} is not a valid priority`);
+    }
+    const id = String(world.incrCounter("ticket_id"));
+    const ticket = ticketShape({
+        id,
+        created: world.clock,
+        subject,
+        description: body,
+        priority: priority,
+        status: "new",
+        requester: {
+            name: typeof requester.name === "string" ? requester.name : "Anonymous",
+            email: typeof requester.email === "string" ? requester.email : "anonymous@example.com",
+        },
+        tags: Array.isArray(t.tags) ? t.tags : [],
+    });
+    world.insertObject("tickets", ticket);
+    world.emitEvent("ticket.created", ticket, { idempotencyKey: ctx.idempotencyKey });
+    return { status: 201, body: { ticket: wireTicket(ticket) } };
+}
+function retrieve(ctx) {
+    return { body: { ticket: wireTicket(getTicket(ctx, ctx.pathParams.id)) } };
+}
+function list(ctx) {
+    const { world, params } = ctx;
+    let tickets = world
+        .listObjects("tickets")
+        .map((o) => o.data)
+        .reverse();
+    const status = typeof params.status === "string" ? params.status : undefined;
+    if (status !== undefined) {
+        if (!STATUSES.includes(status))
+            throw invalid(`Status: ${status} is not a valid status`);
+        tickets = tickets.filter((t) => t.status === status);
+    }
+    return { body: { tickets: tickets.map(wireTicket), count: tickets.length, next_page: null, previous_page: null } };
+}
+function update(ctx) {
+    const { world, params } = ctx;
+    const ticket = getTicket(ctx, ctx.pathParams.id);
+    if (ticket.status === "closed") {
+        throw invalid("Status: closed prevents ticket update");
+    }
+    const t = (params.ticket ?? {});
+    const status = typeof t.status === "string" ? t.status : undefined;
+    if (status !== undefined) {
+        if (!STATUSES.includes(status))
+            throw invalid(`Status: ${status} is not a valid status`);
+        ticket.status = status;
+    }
+    const priority = typeof t.priority === "string" ? t.priority : undefined;
+    if (priority !== undefined) {
+        if (!PRIORITIES.includes(priority))
+            throw invalid(`Priority: ${priority} is not a valid priority`);
+        ticket.priority = priority;
+    }
+    if (Array.isArray(t.tags))
+        ticket.tags = t.tags;
+    const comment = t.comment;
+    if (comment && typeof comment.body === "string") {
+        const comments = ticket.comments;
+        comments.push({
+            id: comments.length + 1,
+            author: "agent",
+            body: comment.body,
+            public: commentPublic(comment.public),
+            created_at: isoFromClock(world.clock),
+        });
+    }
+    ticket.updated_at = isoFromClock(world.clock);
+    world.updateObject("tickets", ticket.id, ticket);
+    world.emitEvent("ticket.updated", ticket, { idempotencyKey: ctx.idempotencyKey });
+    return { body: { ticket: wireTicket(ticket) } };
+}
+function comments(ctx) {
+    const ticket = getTicket(ctx, ctx.pathParams.id);
+    const list = ticket.comments;
+    return { body: { comments: list, count: list.length, next_page: null, previous_page: null } };
+}
+export const ticketRoutes = [
+    { method: "POST", pattern: "/api/v2/tickets.json", handler: create },
+    { method: "GET", pattern: "/api/v2/tickets.json", handler: list },
+    { method: "GET", pattern: "/api/v2/tickets/:id", handler: retrieve },
+    { method: "PUT", pattern: "/api/v2/tickets/:id", handler: update },
+    { method: "GET", pattern: "/api/v2/tickets/:id/comments.json", handler: comments },
+];