Razvoj softvera

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29import { z } from 'zod';import { db, queue } from './infra';const CreateOrder = z.object({  customerId: z.string().uuid(),  items: z.array(z.object({ sku: z.string(), qty: z.number().int().positive() })).min(1),});/** * Idempotent by key: the same Idempotency-Key always returns the first result, * so a client that retries after a timeout cannot be charged twice. */export async function createOrder(req: Request): Promise<Response> {  const key = req.headers.get('Idempotency-Key');  if (!key) return problem(400, 'Idempotency-Key is required');  const parsed = CreateOrder.safeParse(await req.json());  if (!parsed.success) return problem(422, parsed.error.message);  const existing = await db.order.findUnique({ where: { idempotencyKey: key } });  if (existing) return Response.json(existing, { status: 200 });  const order = await db.$transaction((tx) =>    tx.order.create({ data: { ...parsed.data, idempotencyKey: key, status: 'pending' } })  );  await queue.publish('order.created', { orderId: order.id });  return Response.json(order, { status: 201 });}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19-- MariaDB here, because that is what this project runs. The engine is a-- per-project choice and none of the logic above depends on it.---- The unique index is what makes the retry path actually safe under concurrency,-- rather than safe most of the time: two simultaneous requests carrying the same-- key, one inserts, the other is rejected by the database rather than by luck.CREATE TABLE orders (  id              uuid NOT NULL DEFAULT uuid() PRIMARY KEY,  customer_id     uuid NOT NULL,  idempotency_key varchar(191) NOT NULL,  status          varchar(32) NOT NULL DEFAULT 'pending',  total_cents     bigint NOT NULL CHECK (total_cents >= 0),  created_at      timestamp NOT NULL DEFAULT current_timestamp,  CONSTRAINT fk_orders_customer FOREIGN KEY (customer_id) REFERENCES customers (id));CREATE UNIQUE INDEX orders_idempotency_key ON orders (idempotency_key);CREATE INDEX orders_customer_recent ON orders (customer_id, created_at DESC);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15/** * Consumes order.created. Backs off exponentially and gives up into a dead-letter * queue, so one malformed message cannot spin forever and starve the others. */queue.subscribe('order.created', async (message, { attempt }) => {  try {    const order = await db.order.findUniqueOrThrow({ where: { id: message.orderId } });    await invoices.issue(order);    await email.send('order-confirmed', order.customerId, { orderId: order.id });    await db.order.update({ where: { id: order.id }, data: { status: 'confirmed' } });  } catch (error) {    if (attempt >= 5) return message.deadLetter(error);    return message.retry({ delayMs: 2 ** attempt * 1000 });  }});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15name: cion: [push, pull_request]jobs:  verify:    runs-on: ubuntu-latest    steps:      - uses: actions/checkout@v4      - run: npm ci      - run: npm run lint      - run: npx tsc --noEmit      - run: npm test -- --coverage      - run: npm audit --audit-level=high      - name: Performance budget        run: npx lhci autorun --budget-path=budget.json