SaaS Globalization Strategy: Technical Preparation for Chinese, European, and US Markets

// src/lib/gdpr.ts
// GDPR-compliant data handling utilities

// 1. Explicit consent tracking
interface ConsentRecord {
  userId: string
  consentType: "analytics" | "marketing" | "functional" | "third_party"
  granted: boolean
  timestamp: number
  ipAddress: string // Anonymized
}

export async function recordConsent(
  userId: string,
  consentType: ConsentRecord["consentType"],
  granted: boolean
) {
  await env.DB.prepare(
    `INSERT INTO consent_records (user_id, consent_type, granted, timestamp, ip_address)
     VALUES (?, ?, ?, unixepoch(), ?)`
  ).bind(
    userId,
    consentType,
    granted ? 1 : 0,
    anonymizeIp(getClientIp())
  ).run()
}

// 2. Data portability export
export const exportUserData = createServerFn({ method: "GET" }).handler(
  async (_, { request }) => {
    const userId = await getUserId(request)

    const [profile, subscriptions, invoices, events] = await Promise.all([
      env.DB.prepare("SELECT * FROM users WHERE id = ?").bind(userId).first(),
      env.DB.prepare("SELECT * FROM subscriptions WHERE user_id = ?").bind(userId).all(),
      env.DB.prepare("SELECT * FROM invoices WHERE user_id = ?").bind(userId).all(),
      env.DB.prepare("SELECT * FROM analytics_events WHERE user_id = ?").bind(userId).all(),
    ])

    return Response.json({
      exportedAt: new Date().toISOString(),
      data: { profile, subscriptions, invoices, events },
    })
  }
)

// 3. Right to erasure (GDPR Article 17)
export const deleteUserData = createServerFn({ method: "POST" }).handler(
  async (_, { request }) => {
    const userId = await getUserId(request)

    // Anonymize personal data (keep transactional records for legal retention)
    await env.DB.batch([
      env.DB.prepare(`UPDATE users SET
        email = 'deleted-' || id || '@redacted.com',
        name = 'Deleted User',
        avatar_url = NULL,
        deleted_at = unixepoch()
        WHERE id = ?`).bind(userId),
      env.DB.prepare("DELETE FROM analytics_events WHERE user_id = ?").bind(userId),
      env.DB.prepare("DELETE FROM session_tokens WHERE user_id = ?").bind(userId),
    ])

    return { success: true }
  }
)

# wrangler.jsonc
{
  "name": "tanstack-ship",
  "compatibility_date": "2026-06-01",
  "workers_dev": false,
  "routes": [
    { "pattern": "tanstackship.com", "zone_id": "YOUR_ZONE_ID" },
    { "pattern": "eu.tanstackship.com", "zone_id": "YOUR_ZONE_ID", "custom_domain": true }
  ],
  "d1_databases": [
    { "binding": "DB", "database_id": "GLOBAL_DB", "database_name": "tanstack-ship" },
    { "binding": "EU_DB", "database_id": "EU_DB", "database_name": "tanstack-ship-eu" }
  ]
}

// Route EU users to EU D1 instance
async function getDb(request: Request) {
  const country = request.cf?.country
  if (country && EU_COUNTRIES.has(country)) {
    return env.EU_DB // GDPR-compliant D1 instance
  }
  return env.DB
}

// With Stripe, SEPA is handled via Payment Methods
const paymentIntent = await stripe.paymentIntents.create({
  amount: 2999, // €29.99
  currency: "eur",
  payment_method_types: ["sepa_debit", "card"],
  customer: customerId,
})

// src/lib/geo-routing.ts
// Route Chinese users to China-hosted instances

const CHINA_REGIONS = new Set(["CN", "HK", "MO"])

export async function getRegionalEndpoint(request: Request): Promise<string> {
  const country = request.cf?.country

  if (CHINA_REGIONS.has(country ?? "")) {
    // Route to China-hosted instance via Cloudflare China Network
    return "https://tanstack-ship.cn"
  }

  // Global instance
  return "https://tanstackship.com"
}

// src/lib/payment/china.ts
// Alipay integration via Stripe or direct API

// Option 1: Stripe (simplest, higher fees)
const paymentIntent = await stripe.paymentIntents.create({
  amount: 19900, // ¥199.00
  currency: "cny",
  payment_method_types: ["alipay", "card"],
  payment_method_options: {
    alipay: {},
  },
})

// Option 2: Direct Alipay API (lower fees, more setup)
import AlipaySdk from "alipay-sdk"

const alipaySdk = new AlipaySdk({
  appId: process.env.ALIPAY_APP_ID,
  privateKey: process.env.ALIPAY_PRIVATE_KEY,
})

const result = await alipaySdk.exec("alipay.trade.create", {
  bizContent: {
    out_trade_no: orderId,
    total_amount: "199.00",
    subject: "TanStack Ship - Pro Plan",
    product_code: "FAST_INSTANT_TRADE_PAY",
  },
})

// src/lib/auth/china.ts
// WeChat OAuth

// Step 1: Redirect user to WeChat authorization
export function getWeChatAuthUrl(redirectUri: string): string {
  const params = new URLSearchParams({
    appid: process.env.WECHAT_APP_ID,
    redirect_uri: redirectUri,
    response_type: "code",
    scope: "snsapi_login",
    state: crypto.randomUUID(),
  })
  return `https://open.weixin.qq.com/connect/qrconnect?${params}`
}

// Step 2: Exchange code for access token
export async function getWeChatToken(code: string) {
  const response = await fetch(
    `https://api.weixin.qq.com/sns/oauth2/access_token?` +
    new URLSearchParams({
      appid: process.env.WECHAT_APP_ID,
      secret: process.env.WECHAT_APP_SECRET,
      code,
      grant_type: "authorization_code",
    })
  )
  return response.json() as Promise<{
    access_token: string
    openid: string
    unionid: string
  }>
}

// src/lib/tax/us-sales-tax.ts
// Simplified sales tax calculation (use a service like TaxJar for production)

const STATE_TAX_RATES: Record<string, number> = {
  "CA": 0.0725,  // California base rate
  "NY": 0.04,    // New York state (county/city adds more)
  "TX": 0.0625,  // Texas
  "WA": 0.065,   // Washington
  // ... 45+ more states
}

export function calculateSalesTax(
  amount: number,
  state: string
): { taxRate: number; taxAmount: number; total: number } {
  const taxRate = STATE_TAX_RATES[state.toUpperCase()] ?? 0
  const taxAmount = Math.round(amount * taxRate * 100) / 100
  return { taxRate, taxAmount, total: amount + taxAmount }
}

// src/lib/ccpa.ts
// CCPA opt-out mechanism
export async function handleCcpOptOut(userId: string) {
  await env.DB.prepare(
    `INSERT INTO privacy_opt_outs (user_id, regulation, opted_out_at)
     VALUES (?, 'CCPA', unixepoch())`
  ).bind(userId).run()
}

// Do not sell my personal information endpoint
export const optOutOfSale = createServerFn({ method: "POST" }).handler(
  async (_, { request }) => {
    const userId = await getUserId(request)
    await handleCcpOptOut(userId)
    return { success: true }
  }
)

┌─────────────────────────────────────────────────┐
│                  Cloudflare                      │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────┐ │
│  │  US Worker   │  │  EU Worker   │  │ CN Edge  │ │
│  │  us-east     │  │  eu-west     │  │ (CF CN)  │ │
│  └──────┬───────┘  └──────┬───────┘  └────┬─────┘ │
│         │                 │               │        │
│  ┌──────▼───────┐  ┌──────▼───────┐  ┌────▼─────┐ │
│  │  US D1 DB    │  │  EU D1 DB    │  │ CN D1 DB │ │
│  │  (Virginia)  │  │ (Frankfurt)  │  │ (Beijing) │ │
│  └──────────────┘  └──────────────┘  └──────────┘ │
│         │                 │               │        │
│  ┌──────▼───────┐  ┌──────▼───────┐              │
│  │  US R2       │  │  EU R2       │              │
│  └──────────────┘  └──────────────┘              │
└─────────────────────────────────────────────────┘

// src/middleware/geo-router.ts
// Edge middleware that routes to the correct regional deployment

export const geoRouter = createServerFn({ method: "GET" }).handler(
  async (_, { request }) => {
    const country = request.cf?.country ?? "US"

    if (["CN", "HK", "MO"].includes(country)) {
      return env.CN_DB
    }

    if (EU_COUNTRIES.has(country)) {
      return env.EU_DB
    }

    return env.US_DB
  }
)

CREATE TABLE price_tiers (
  id TEXT PRIMARY KEY,
  product_id TEXT NOT NULL REFERENCES products(id),
  region TEXT NOT NULL CHECK (region IN ('US', 'EU', 'CN', 'ROW', 'GLOBAL')),
  currency TEXT NOT NULL,
  unit_amount INTEGER NOT NULL,  -- In smallest currency unit (cents, fen, etc.)
  interval TEXT NOT NULL CHECK (interval IN ('month', 'year')),
  tax_behavior TEXT NOT NULL DEFAULT 'exclusive' CHECK (tax_behavior IN ('inclusive', 'exclusive')),
  is_active INTEGER NOT NULL DEFAULT 1,
  created_at INTEGER NOT NULL DEFAULT (unixepoch()),
  updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
  UNIQUE(product_id, region, interval)
);

CREATE INDEX idx_price_tiers_region ON price_tiers(region);

// src/lib/pricing/regional.ts
export async function getRegionalPrice(
  productId: string,
  region: "US" | "EU" | "CN" | "ROW",
  interval: "month" | "year"
) {
  const price = await env.DB.prepare(
    `SELECT unit_amount, currency, tax_behavior
     FROM price_tiers
     WHERE product_id = ? AND region = ? AND interval = ? AND is_active = 1
     ORDER BY created_at DESC
     LIMIT 1`
  )
    .bind(productId, region, interval)
    .first()
  return price
}