curl -X POST https://chromaflow.app/api/github/import \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "repository": "username/repo-name",
    "branch": "main",
    "import_history": true
  }'

curl -X POST https://chromaflow.app/api/supabase/create-project \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "project_name": "my-app",
    "database_schema": {
      "users": {
        "id": "uuid primary key",
        "email": "text unique",
        "created_at": "timestamp"
      },
      "posts": {
        "id": "uuid primary key",
        "user_id": "uuid references users(id)",
        "content": "text",
        "created_at": "timestamp"
      }
    },
    "enable_rls": true,
    "enable_realtime": true
  }'

// Automatically generated from your Supabase schema
export interface Database {
  public: {
    Tables: {
      users: {
        Row: {
          id: string
          email: string
          created_at: string
        }
        Insert: {
          id?: string
          email: string
          created_at?: string
        }
        Update: {
          id?: string
          email?: string
          created_at?: string
        }
      }
      posts: {
        Row: {
          id: string
          user_id: string
          content: string
          created_at: string
        }
        Insert: {
          id?: string
          user_id: string
          content: string
          created_at?: string
        }
        Update: {
          id?: string
          user_id?: string
          content?: string
          created_at?: string
        }
      }
    }
  }
}

// Automatically generated subscription hook
import { useEffect, useState } from 'react'
import { supabase } from './supabase-client'

export function useRealtimePosts() {
  const [posts, setPosts] = useState([])

  useEffect(() => {
    // Initial fetch
    supabase
      .from('posts')
      .select('*, users(email)')
      .order('created_at', { ascending: false })
      .then(({ data }) => setPosts(data || []))

    // Real-time subscription
    const subscription = supabase
      .channel('posts-channel')
      .on('postgres_changes', 
        { event: '*', schema: 'public', table: 'posts' },
        (payload) => {
          if (payload.eventType === 'INSERT') {
            setPosts(prev => [payload.new, ...prev])
          } else if (payload.eventType === 'UPDATE') {
            setPosts(prev => prev.map(post => 
              post.id === payload.new.id ? payload.new : post
            ))
          } else if (payload.eventType === 'DELETE') {
            setPosts(prev => prev.filter(post => 
              post.id !== payload.old.id
            ))
          }
        }
      )
      .subscribe()

    return () => {
      subscription.unsubscribe()
    }
  }, [])

  return posts
}

curl -X POST https://chromaflow.app/api/stripe/create-checkout \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "price_id": "price_1234567890",
    "success_url": "https://app.com/success",
    "cancel_url": "https://app.com/cancel",
    "metadata": {
      "user_id": "user_abc123"
    }
  }'

// Automatically generated Stripe webhook handler
import { ActionFunction } from '@remix-run/cloudflare'
import Stripe from 'stripe'
import { db } from '~/utils/db.server'

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!)
const endpointSecret = process.env.STRIPE_WEBHOOK_SECRET!

export const action: ActionFunction = async ({ request }) => {
  const sig = request.headers.get('stripe-signature')!
  const body = await request.text()

  let event: Stripe.Event

  try {
    event = stripe.webhooks.constructEvent(body, sig, endpointSecret)
  } catch (err) {
    console.error('Webhook signature verification failed')
    return new Response('Webhook Error', { status: 400 })
  }

  // Handle the event
  switch (event.type) {
    case 'checkout.session.completed':
      const session = event.data.object as Stripe.Checkout.Session
      
      // Update user subscription status
      await db.user.update({
        where: { id: session.metadata.user_id },
        data: {
          subscription_status: 'active',
          stripe_customer_id: session.customer as string,
          stripe_subscription_id: session.subscription as string
        }
      })
      break

    case 'customer.subscription.deleted':
      const subscription = event.data.object as Stripe.Subscription
      
      // Handle subscription cancellation
      await db.user.update({
        where: { stripe_subscription_id: subscription.id },
        data: { subscription_status: 'cancelled' }
      })
      break

    // ... handle other event types
  }

  return new Response('Success', { status: 200 })
}