AI-Assisted Engineering

// AI gợi ý — trông hợp lý nhưng không tồn tại trong Prisma
await prisma.product.upsertMany({ data: rows });
// Thực tế: dùng createMany({ skipDuplicates: true }) hoặc transaction + upsert từng dòng

// Viết trước, giao AI implement applyVoucher()
it('never discounts below zero', () => {
  expect(applyVoucher({ total: 50_000 }, { amount: 80_000 })).toEqual({ total: 0 });
});
it('rejects an expired voucher', () => {
  expect(() => applyVoucher(cart, expired)).toThrow(VoucherExpiredError);
});

// GET /api/orders/:id
router.get('/orders/:id', requireAuth, async (req, res) => {
  const order = await db.order.findUnique({ where: { id: req.params.id } });
  if (!order) return res.status(404).json({ error: 'Not found' });
  res.json(order);
});

// test do AI viết
it('returns the order', async () => {
  const o = await seedOrder({ tenantId: 't1' });
  const res = await request(app).get(`/api/orders/${o.id}`).set(authFor('t1'));
  expect(res.status).toBe(200);
});

const cache = new Map<string, Product[]>();

export async function getProducts(tenantId: string, category: string) {
  const key = category; // AI: "simplified the key"
  if (cache.has(key)) return cache.get(key)!;
  const rows = await repo.findProducts(tenantId, category);
  cache.set(key, rows);
  return rows;
}

- it('sends confirmation email after checkout', async () => {
+ it.skip('sends confirmation email after checkout', async () => {
    await checkout(cart);
-   expect(mailer.send).toHaveBeenCalledWith(expect.objectContaining({ to: user.email }));
+   // expect(mailer.send).toHaveBeenCalled(); // flaky, see CI
  });

- await new Promise((r) => setTimeout(r, 100));
+ await new Promise((r) => setTimeout(r, 2000));

export async function searchCustomers(tenantId: string, q: string, sort = 'name') {
  return db.query(
    `SELECT id, name, email FROM customers
     WHERE tenant_id = $1 AND name ILIKE '%${q}%'
     ORDER BY ${sort} LIMIT 50`,
    [tenantId],
  );
}

async function withRetry<T>(fn: () => Promise<T>, retries = 3): Promise<T> {
  for (let i = 0; ; i++) {
    try {
      return await fn();
    } catch (e) {
      if (i >= retries) throw e;
      await sleep(200 * 2 ** i);
    }
  }
}

await withRetry(() => paymentGateway.capture({ orderId, amount }));

// before: single SQL statement
// UPDATE stock SET qty = qty - $2 WHERE sku = $1 AND qty >= $2

// after (AI refactor)
async function reserve(sku: string, n: number) {
  const item = await repo.stock.findOne({ sku });
  if (!item || item.qty < n) throw new OutOfStockError(sku);
  item.qty -= n;
  await repo.stock.save(item);
}

import jwt from 'jsonwebtoken';

export function auth(req, res, next) {
  const token = req.headers.authorization?.split(' ')[1];
  try {
    const payload = jwt.decode(token) as { sub: string; role: string; tenantId: string };
    if (!payload) return res.sendStatus(401);
    req.user = payload;
    next();
  } catch (err) {
    console.log('auth error', err, req.headers);
    next();
  }
}

// .claude/settings.json (committed)
{
  "permissions": {
    "allow": ["Bash(*)", "Read(**)", "Edit(**)", "WebFetch"],
    "deny": []
  },
  "env": { "DATABASE_URL": "postgres://admin:S3cret@prod-db:5432/app" }
}