Lovable Cloud: Kompletní průvodce serverless backendem

Lovable Cloud představuje revoluci v serverless backend development. Kombinuje sílu Supabase s jednoduchostí Lovable platformy, což umožňuje vytvářet komplexní backend logiku bez správy infrastruktury. Tento průvodce vás provede od základů po pokročilé patterns.

Co je Lovable Cloud a proč ho použít

Lovable Cloud je managed backend služba integrovaná přímo do Lovable platformy. Na rozdíl od samostatného Supabase projektu získáváte:

• Zero-config setup: Backend je připraven okamžitě, žádná konfigurace
• Automatické deploye: Edge functions se deployují při každém save
• Integrované secrets: Bezpečné ukládání API klíčů
• Unified billing: Vše v jedné faktuře
• AI-assisted development: Lovable generuje backend kód z popisu

Komponenty Lovable Cloud

Edge Functions - Serverless logika

TypeScript/Deno funkce běžící globálně na edge. Ideální pro API endpoints, webhooks, scheduled jobs.

PostgreSQL databáze

Plně managed Supabase PostgreSQL s automatickými backupy, connection pooling a real-time subscriptions.

Authentication

Built-in auth s podporou OAuth (Google, GitHub, Apple), magic links, email/password a phone auth.

Storage

File uploads s CDN distribucí, image transformations a security policies.

Real-time

WebSocket subscriptions pro live updates, presence a broadcast channels.

Edge Functions - Kompletní průvodce

Základní struktura edge function

// supabase/functions/hello-world/index.ts
import { serve } from "https://deno.land/std@0.168.0/http/server.ts"
import { corsHeaders } from "../_shared/cors.ts"

serve(async (req) => {
  // Handle CORS preflight
  if (req.method === "OPTIONS") {
    return new Response("ok", { headers: corsHeaders })
  }

  try {
    const { name } = await req.json()
    
    const data = {
      message: `Hello ${name}!`,
      timestamp: new Date().toISOString()
    }

    return new Response(
      JSON.stringify(data),
      { 
        headers: { 
          ...corsHeaders,
          "Content-Type": "application/json" 
        } 
      }
    )
  } catch (error) {
    return new Response(
      JSON.stringify({ error: error.message }),
      { 
        status: 400,
        headers: { 
          ...corsHeaders,
          "Content-Type": "application/json" 
        } 
      }
    )
  }
})

Praktický příklad: Stripe Webhook Handler

// supabase/functions/stripe-webhook/index.ts
import { serve } from "https://deno.land/std@0.168.0/http/server.ts"
import Stripe from "https://esm.sh/stripe@13.0.0"
import { createClient } from "https://esm.sh/@supabase/supabase-js@2"

const stripe = new Stripe(Deno.env.get("STRIPE_SECRET_KEY")!, {
  apiVersion: "2023-10-16"
})

const supabase = createClient(
  Deno.env.get("SUPABASE_URL")!,
  Deno.env.get("SUPABASE_SERVICE_ROLE_KEY")!
)

serve(async (req) => {
  const signature = req.headers.get("stripe-signature")!
  const body = await req.text()
  
  let event: Stripe.Event
  
  try {
    event = stripe.webhooks.constructEvent(
      body,
      signature,
      Deno.env.get("STRIPE_WEBHOOK_SECRET")!
    )
  } catch (err) {
    console.error("Webhook signature verification failed")
    return new Response(JSON.stringify({ error: "Invalid signature" }), { status: 400 })
  }
  
  switch (event.type) {
    case "checkout.session.completed": {
      const session = event.data.object as Stripe.Checkout.Session
      
      // Update user subscription in database
      await supabase
        .from("subscriptions")
        .upsert({
          user_id: session.client_reference_id,
          stripe_customer_id: session.customer,
          status: "active",
          plan: session.metadata?.plan || "pro"
        })
      break
    }
    
    case "customer.subscription.deleted": {
      const subscription = event.data.object as Stripe.Subscription
      
      await supabase
        .from("subscriptions")
        .update({ status: "canceled" })
        .eq("stripe_customer_id", subscription.customer)
      break
    }
  }
  
  return new Response(JSON.stringify({ received: true }), {
    headers: { "Content-Type": "application/json" }
  })
})

Supabase Database Integration

Databázové operace z edge functions

import { createClient } from "https://esm.sh/@supabase/supabase-js@2"

// Service role client - bypasses RLS
const supabaseAdmin = createClient(
  Deno.env.get("SUPABASE_URL")!,
  Deno.env.get("SUPABASE_SERVICE_ROLE_KEY")!
)

// Insert data
const { data, error } = await supabaseAdmin
  .from("users")
  .insert({ 
    email: "user@example.com",
    name: "John Doe",
    created_at: new Date().toISOString()
  })
  .select()
  .single()

// Query with filters and joins
const { data: orders } = await supabaseAdmin
  .from("orders")
  .select(\`
    *,
    user:users(name, email),
    items:order_items(product_id, quantity, price)
  \`)
  .eq("status", "pending")
  .gte("created_at", "2024-01-01")
  .order("created_at", { ascending: false })
  .limit(50)

Row Level Security (RLS) Best Practices

-- Enable RLS on table
ALTER TABLE users ENABLE ROW LEVEL SECURITY;

-- Policy: Users can only read their own data
CREATE POLICY "Users can view own data" ON users
  FOR SELECT
  USING (auth.uid() = id);

-- Policy: Users can update their own profile
CREATE POLICY "Users can update own profile" ON users
  FOR UPDATE
  USING (auth.uid() = id)
  WITH CHECK (auth.uid() = id);

-- Policy: Admins can read all data
CREATE POLICY "Admins can view all" ON users
  FOR SELECT
  USING (
    EXISTS (
      SELECT 1 FROM user_roles 
      WHERE user_id = auth.uid() 
      AND role = 'admin'
    )
  );

-- Policy: Public profiles are visible to everyone
CREATE POLICY "Public profiles visible" ON profiles
  FOR SELECT
  USING (is_public = true OR auth.uid() = user_id);

Best Practices pro Lovable Cloud

Security

• Vždy používejte RLS pro uživatelská data - nikdy neexponujte service role key na frontendu
• Secrets ukládejte v Supabase secrets, ne v kódu
• Validujte všechny vstupy pomocí Zod nebo podobné knihovny
• Implementujte rate limiting pro veřejné endpoints

Performance

• Minimalizujte cold starts pomocí warm-up requests
• Používejte connection pooling (pgbouncer) pro databázové operace
• Cache časté queries pomocí edge caching
• Optimalizujte bundle size - importujte jen potřebné moduly

Monitoring a Debugging

• Používejte console.log pro debugging - logy jsou v Supabase dashboard
• Implementujte strukturované logování pro production
• Nastavte alerts pro error rates a latency
• Monitorujte database performance pomocí pg_stat_statements

Deployment a CI/CD

Lovable Cloud automaticky deployuje edge functions při každém uložení. Pro pokročilé use cases:

• Preview deployments: Každý branch má vlastní preview URL
• Environment variables: Separate secrets pro development/production
• Rollbacks: Snadný návrat k předchozí verzi přes dashboard
• Logs: Real-time logging a historical log search

Pricing a Limity

Tier	Edge Invocations	Database	Storage	Bandwidth
Free	500K/měsíc	500MB	1GB	2GB
Pro ($25/m)	2M/měsíc	8GB	100GB	50GB
Team	Unlimited	Unlimited	Unlimited	Unlimited

Pro většinu MVP a early-stage startupů je Free nebo Pro tier více než dostačující.