Zero DevOps E-commerce với Cloudflare Workers & Turborepo

{
  "$schema": "https://turbo.build/schema.json",
  "globalDependencies": [".env*"],
  "tasks": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": [".next/**", "!.next/cache/**", "dist/**", ".wrangler/**"]
    },
    "build:openapi": {
      "inputs": ["src/schemas/**/*.ts", "src/index.ts"],
      "outputs": ["dist/openapi.json"]
    },
    "generate:sdk": {
      "dependsOn": ["@ecommerce/contract#build:openapi"],
      "outputs": ["sdks/**"]
    },
    "db:migrate": {
      "cache": false
    },
    "test": {
      "dependsOn": ["^build"],
      "inputs": ["src/**/*.tsx", "src/**/*.ts", "test/**/*.ts"]
    },
    "lint": {
      "dependsOn": ["^build"]
    },
    "dev": {
      "cache": false,
      "persistent": true
    }
  }
}

import { z } from "zod";

export const CartItemSchema = z.object({
  productId: z.string().uuid({ message: "Product ID must be a valid UUID" }),
  variantId: z.string().min(1, { message: "Variant ID is required" }),
  sku: z.string().min(3),
  quantity: z.number().int().positive({ message: "Quantity must be greater than 0" }),
  unitPriceCents: z.number().int().nonnegative(),
});

export const AddToCartRequestSchema = z.object({
  cartId: z.string().uuid().optional(),
  item: CartItemSchema,
});

export const CartStateSchema = z.object({
  cartId: z.string().uuid(),
  currency: z.literal("VND"),
  items: z.array(CartItemSchema),
  subtotalCents: z.number().int().nonnegative(),
  taxCents: z.number().int().nonnegative(),
  totalCents: z.number().int().nonnegative(),
  updatedAt: z.string().datetime(),
});

export type CartItem = z.infer<typeof CartItemSchema>;
export type AddToCartRequest = z.infer<typeof AddToCartRequestSchema>;
export type CartState = z.infer<typeof CartStateSchema>;

name: Generate & Publish Mobile SDKs

on:
  push:
    branches:
      - main
    paths:
      - 'packages/contract/**'

jobs:
  build-and-generate:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Code
        uses: actions/checkout@v4

      - name: Setup Node.js & pnpm
        uses: pnpm/action-setup@v3
        with:
          version: 9
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: 'pnpm'

      - name: Setup Java (for OpenAPI Generator)
        uses: actions/setup-java@v4
        with:
          distribution: 'temurin'
          java-version: '17'

      - name: Install OpenAPI Generator CLI
        run: npm install -g @openapitools/openapi-generator-cli

      - name: Install Dependencies & Build OpenAPI Spec
        run: |
          pnpm install --frozen-lockfile
          pnpm --filter @ecommerce/contract build:openapi

      - name: Generate Dart SDK for Flutter
        run: |
          openapi-generator-cli generate \
            -i packages/contract/dist/openapi.json \
            -g dart \
            -o sdks/flutter_api_sdk \
            --additional-properties=pubName=aura_ecommerce_api,pubVersion=1.4.0

      - name: Generate Swift 5 SDK for iOS
        run: |
          openapi-generator-cli generate \
            -i packages/contract/dist/openapi.json \
            -g swift5 \
            -o sdks/ios_swift_sdk \
            --additional-properties=projectName=AuraEcommerceSDK,responseAs=AsyncAwait

      - name: Create Automated Pull Request
        uses: peter-evans/create-pull-request@v6
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          commit-message: 'chore(sdk): synchronize Mobile SDKs with latest OpenAPI contracts'
          title: '🤖 Auto-generated Mobile SDKs (Dart & Swift)'
          body: |
            This pull request was automatically generated by the CI pipeline in response to changes in `packages/contract`.
            - Regenerated `sdks/flutter_api_sdk`
            - Regenerated `sdks/ios_swift_sdk`
            Please verify integration tests before merging.
          branch: 'automated-sdk-sync'
          base: main

import { drizzle } from "drizzle-orm/d1";
import { eq, sql, and, gte } from "drizzle-orm";
import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";

// 1. Khai báo Database Schema
export const products = sqliteTable("products", {
  id: text("id").primaryKey(),
  name: text("name").notNull(),
  sku: text("sku").notNull().unique(),
  priceCents: integer("price_cents").notNull(),
  stockQuantity: integer("stock_quantity").notNull(),
  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
});

export const orders = sqliteTable("orders", {
  id: text("id").primaryKey(),
  customerId: text("customer_id").notNull(),
  totalCents: integer("total_cents").notNull(),
  status: text("status").notNull(), // 'pending', 'paid', 'failed'
  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
});

export const orderItems = sqliteTable("order_items", {
  id: text("id").primaryKey(),
  orderId: text("order_id").notNull().references(() => orders.id),
  productId: text("product_id").notNull().references(() => products.id),
  quantity: integer("quantity").notNull(),
  unitPriceCents: integer("unit_price_cents").notNull(),
});

export interface CheckoutPayload {
  customerId: string;
  items: Array<{ productId: string; quantity: number }>;
}

// 2. Logic xử lý Transaction tại Edge
export async function processOrderCheckout(
  d1Binding: D1Database,
  payload: CheckoutPayload
): Promise<{ orderId: string; totalCents: number }> {
  const db = drizzle(d1Binding);
  const orderId = crypto.randomUUID();
  const now = new Date();

  return await db.transaction(async (tx) => {
    let orderTotalCents = 0;
    const itemsToInsert: Array<{
      id: string;
      orderId: string;
      productId: string;
      quantity: number;
      unitPriceCents: number;
    }> = [];

    for (const item of payload.items) {
      // Truy vấn sản phẩm và kiểm tra tồn kho bằng Optimistic Lock
      const [product] = await tx
        .select()
        .from(products)
        .where(and(eq(products.id, item.productId), gte(products.stockQuantity, item.quantity)))
        .all();

      if (!product) {
        throw new Error(`Sản phẩm ${item.productId} không đủ tồn kho hoặc đã ngừng kinh doanh.`);
      }

      // Trừ số lượng tồn kho nguyên tử
      const updateResult = await tx
        .update(products)
        .set({
          stockQuantity: sql`${products.stockQuantity} - ${item.quantity}`,
          updatedAt: now,
        })
        .where(and(eq(products.id, item.productId), gte(products.stockQuantity, item.quantity)))
        .run();

      if (updateResult.meta.changes === 0) {
        throw new Error(`Xung đột đồng thời khi cập nhật kho cho sản phẩm ${item.productId}`);
      }

      const itemTotal = product.priceCents * item.quantity;
      orderTotalCents += itemTotal;

      itemsToInsert.push({
        id: crypto.randomUUID(),
        orderId,
        productId: product.id,
        quantity: item.quantity,
        unitPriceCents: product.priceCents,
      });
    }

    // Ghi nhận bản ghi Order
    await tx.insert(orders).values({
      id: orderId,
      customerId: payload.customerId,
      totalCents: orderTotalCents,
      status: "pending",
      createdAt: now,
    }).run();

    // Ghi nhận hàng loạt Order Items
    for (const orderItem of itemsToInsert) {
      await tx.insert(orderItems).values(orderItem).run();
    }

    return { orderId, totalCents: orderTotalCents };
  });
}

// apps/public-api/src/handlers/stripe-webhook.ts
export interface Env {
  DB: D1Database;
  IDEMPOTENCY_KV: KVNamespace;
  ORDER_EVENTS_QUEUE: Queue;
  STRIPE_WEBHOOK_SECRET: string;
}

export async function handleStripeWebhook(request: Request, env: Env): Promise<Response> {
  if (request.method !== "POST") {
    return new Response("Method Not Allowed", { status: 405 });
  }

  const signature = request.headers.get("stripe-signature");
  if (!signature) {
    return new Response("Missing stripe-signature header", { status: 400 });
  }

  const rawBody = await request.text();

  // 1. Trích xuất timestamp và chữ ký v1 từ header
  const elements = signature.split(",");
  const timestamp = elements.find((el) => el.startsWith("t="))?.split("=")[1];
  const v1Signature = elements.find((el) => el.startsWith("v1="))?.split("=")[1];

  if (!timestamp || !v1Signature) {
    return new Response("Invalid signature format", { status: 400 });
  }

  // 2. Xác minh chữ ký mật mã bằng Web Crypto API tiêu chuẩn
  const encoder = new TextEncoder();
  const signedPayload = `${timestamp}.${rawBody}`;
  const key = await crypto.subtle.importKey(
    "raw",
    encoder.encode(env.STRIPE_WEBHOOK_SECRET),
    { name: "HMAC", hash: "SHA-256" },
    false,
    ["verify"]
  );

  const signatureBytes = hexToUint8Array(v1Signature);
  const isValid = await crypto.subtle.verify(
    "HMAC",
    key,
    signatureBytes,
    encoder.encode(signedPayload)
  );

  if (!isValid) {
    return new Response("Cryptographic signature verification failed", { status: 401 });
  }

  const event = JSON.parse(rawBody);
  const eventId = event.id as string;

  // 3. Kiểm tra tính Idempotency trên Cloudflare KV
  const processed = await env.IDEMPOTENCY_KV.get(`webhook:stripe:${eventId}`);
  if (processed) {
    // Đã xử lý thành công trước đó, trả về HTTP 200 ngay lập tức
    return new Response(JSON.stringify({ received: true, deduplicated: true }), {
      headers: { "Content-Type": "application/json" },
    });
  }

  // 4. Xử lý sự kiện thanh toán thành công
  if (event.type === "checkout.session.completed") {
    const session = event.data.object;
    const orderId = session.metadata?.orderId;

    if (orderId) {
      // Cập nhật trạng thái đơn hàng trong D1
      await env.DB.prepare("UPDATE orders SET status = 'paid' WHERE id = ?")
        .bind(orderId)
        .run();

      // Đẩy sự kiện vào Cloudflare Queues để gửi email xác nhận & thông báo kho vận
      await env.ORDER_EVENTS_QUEUE.send({
        eventType: "ORDER_PAID",
        orderId,
        customerId: session.customer,
        timestamp: Date.now(),
      });
    }
  }

  // Đánh dấu sự kiện đã xử lý thành công (TTL 24 giờ)
  await env.IDEMPOTENCY_KV.put(`webhook:stripe:${eventId}`, "processed", {
    expirationTtl: 86400,
  });

  return new Response(JSON.stringify({ received: true }), {
    status: 200,
    headers: { "Content-Type": "application/json" },
  });
}

function hexToUint8Array(hexString: string): Uint8Array {
  const bytes = new Uint8Array(hexString.length / 2);
  for (let i = 0; i < hexString.length; i += 2) {
    bytes[i / 2] = parseInt(hexString.substring(i, i + 2), 16);
  }
  return bytes;
}

// apps/public-api/src/middleware/edge-cache.ts
export async function fetchProductWithCache(
  request: Request,
  env: { DB: D1Database; CACHE_KV: KVNamespace; CLOUDFLARE_ZONE_ID: string; CF_PURGE_TOKEN: string },
  productId: string
): Promise<Response> {
  const cacheKey = new URL(request.url).toString();
  const cache = caches.default;

  // 1. Đọc từ Cloudflare Edge Cache
  let response = await cache.match(cacheKey);
  if (response) {
    const headers = new Headers(response.headers);
    headers.set("X-Cache-Status", "HIT-EDGE");
    return new Response(response.body, { ...response, headers });
  }

  // 2. Cache Miss: Đọc dữ liệu từ D1
  const row = await env.DB.prepare("SELECT * FROM products WHERE id = ?").bind(productId).first();
  if (!row) {
    return new Response(JSON.stringify({ error: "Product Not Found" }), { status: 404 });
  }

  // 3. Gắn Cache-Tags cho phép xóa cache chính xác theo nhóm sản phẩm hoặc danh mục
  const responseBody = JSON.stringify(row);
  response = new Response(responseBody, {
    status: 200,
    headers: {
      "Content-Type": "application/json",
      "Cache-Control": "public, max-age=3600, s-maxage=86400, stale-while-revalidate=60",
      "Cache-Tag": `product-${productId},category-${row.category_id},catalog-all`,
      "X-Cache-Status": "MISS",
    },
  });

  // Lưu vào Edge Cache
  await cache.put(cacheKey, response.clone());
  return response;
}

// Hàm quản trị: Xóa Cache tức thì khi thay đổi giá sản phẩm
export async function purgeProductCache(
  productId: string,
  zoneId: string,
  apiToken: string
): Promise<boolean> {
  const purgeUrl = `https://api.cloudflare.com/client/v4/zones/${zoneId}/purge_cache`;
  const response = await fetch(purgeUrl, {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${apiToken}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      tags: [`product-${productId}`],
    }),
  });

  const result = (await response.json()) as { success: boolean };
  return result.success;
}