AppHighway + Supabase: Complete Backend Stack Without Servers

Step 1: Create PostgreSQL Trigger

-- Create function to call Edge Function
CREATE OR REPLACE FUNCTION validate_user_email()
RETURNS TRIGGER AS $$
BEGIN
  -- Call Edge Function with new user data
  PERFORM net.http_post(
    url := ''https://your-project.supabase.co/functions/v1/validate-email'',
    headers := jsonb_build_object(
      ''Content-Type'', ''application/json'',
      ''Authorization'', ''Bearer '' || current_setting(''app.edge_function_key'')
    ),
    body := jsonb_build_object(
      ''user_id'', NEW.id,
      ''email'', NEW.email
    )
  );
  
  RETURN NEW;
END;
$$ LANGUAGE plpgsql SECURITY DEFINER;

-- Attach trigger to users table
CREATE TRIGGER on_user_created
  AFTER INSERT ON auth.users
  FOR EACH ROW
  EXECUTE FUNCTION validate_user_email();

This trigger fires after a new user is inserted and calls the Edge Function with user details.

Step 2: Create Edge Function

// supabase/functions/validate-email/index.ts
import { serve } from 'https://deno.land/std@0.168.0/http/server.ts'
import { createClient } from 'https://esm.sh/@supabase/supabase-js@2'

const APPHIGHWAY_API_KEY = Deno.env.get('APPHIGHWAY_API_KEY')!
const SUPABASE_URL = Deno.env.get('SUPABASE_URL')!
const SUPABASE_SERVICE_KEY = Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')!

serve(async (req) => {
  try {
    const { user_id, email } = await req.json()

    // Call AppHighway Email Validator
    const response = await fetch('https://apphighway.com/api/v1/email-validator', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${APPHIGHWAY_API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ email })
    })

    const result = await response.json()

    // Update user metadata with validation results
    const supabase = createClient(SUPABASE_URL, SUPABASE_SERVICE_KEY)
    await supabase
      .from('user_profiles')
      .update({
        email_valid: result.is_valid,
        email_deliverable: result.is_deliverable,
        email_disposable: result.is_disposable,
        validated_at: new Date().toISOString()
      })
      .eq('user_id', user_id)

    return new Response(
      JSON.stringify({ success: true, validation: result }),
      { headers: { 'Content-Type': 'application/json' } }
    )
  } catch (error) {
    return new Response(
      JSON.stringify({ error: error.message }),
      { status: 500, headers: { 'Content-Type': 'application/json' } }
    )
  }
})

The Edge Function receives user data, validates email with AppHighway, and updates the database with results.

Edge Function Code

// supabase/functions/analyze-review/index.ts
import { serve } from 'https://deno.land/std@0.168.0/http/server.ts'
import { createClient } from 'https://esm.sh/@supabase/supabase-js@2'

const corsHeaders = {
  'Access-Control-Allow-Origin': '*',
  'Access-Control-Allow-Headers': 'authorization, x-client-info, apikey, content-type',
}

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

  try {
    // Get user from JWT
    const authHeader = req.headers.get('Authorization')!
    const supabase = createClient(
      Deno.env.get('SUPABASE_URL')!,
      Deno.env.get('SUPABASE_ANON_KEY')!,
      { global: { headers: { Authorization: authHeader } } }
    )

    const { data: { user } } = await supabase.auth.getUser()
    if (!user) throw new Error('Unauthorized')

    // Get review data from request
    const { review_id, review_text, product_id } = await req.json()

    // Call AppHighway Sentiment Analysis tool
    const sentimentResponse = await fetch(
      'https://apphighway.com/api/v1/sentiment-analysis',
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${Deno.env.get('APPHIGHWAY_API_KEY')}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          text: review_text,
          language: 'auto'
        })
      }
    )

    const sentiment = await sentimentResponse.json()

    // Update review in database with sentiment analysis
    const { data: review, error } = await supabase
      .from('reviews')
      .update({
        sentiment_score: sentiment.score,
        sentiment_label: sentiment.label, // positive, negative, neutral
        sentiment_confidence: sentiment.confidence,
        processed_at: new Date().toISOString()
      })
      .eq('id', review_id)
      .eq('user_id', user.id) // Security: only update own reviews
      .select()
      .single()

    if (error) throw error

    // If negative sentiment, flag for moderation
    if (sentiment.score < -0.5) {
      await supabase.from('moderation_queue').insert({
        review_id,
        reason: 'negative_sentiment',
        severity: sentiment.score < -0.8 ? 'high' : 'medium'
      })
    }

    return new Response(
      JSON.stringify({ success: true, review, sentiment }),
      { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
    )
  } catch (error) {
    return new Response(
      JSON.stringify({ error: error.message }),
      { 
        status: 500,
        headers: { ...corsHeaders, 'Content-Type': 'application/json' }
      }
    )
  }
})

This function authenticates users, analyzes review sentiment with AppHighway, stores results, and flags negative reviews for moderation.

Client-Side Usage

// React component calling Edge Function
import { useSupabaseClient } from '@supabase/auth-helpers-react'

const ReviewForm = () => {
  const supabase = useSupabaseClient()
  const [loading, setLoading] = useState(false)

  const submitReview = async (reviewText: string, productId: string) => {
    setLoading(true)

    try {
      // Create review in database
      const { data: review } = await supabase
        .from('reviews')
        .insert({ 
          product_id: productId,
          review_text: reviewText,
          user_id: (await supabase.auth.getUser()).data.user?.id
        })
        .select()
        .single()

      // Call Edge Function to analyze sentiment
      const { data: analysisResult } = await supabase.functions.invoke(
        'analyze-review',
        {
          body: {
            review_id: review.id,
            review_text: reviewText,
            product_id: productId
          }
        }
      )

      console.log('Sentiment:', analysisResult.sentiment)
      
      // Show success message based on sentiment
      if (analysisResult.sentiment.label === 'positive') {
        toast.success('Thank you for your positive review!')
      }
    } catch (error) {
      toast.error('Failed to submit review')
    } finally {
      setLoading(false)
    }
  }

  return (
    <form onSubmit={(e) => {
      e.preventDefault()
      submitReview(e.target.review.value, productId)
    }}>
      <textarea name="review" required />
      <button type="submit" disabled={loading}>
        {loading ? 'Analyzing...' : 'Submit Review'}
      </button>
    </form>
  )
}

Client creates review, calls Edge Function for sentiment analysis, displays results to user.

Database Trigger

-- Trigger to moderate comments on insert
CREATE OR REPLACE FUNCTION moderate_comment()
RETURNS TRIGGER AS $$
BEGIN
  PERFORM net.http_post(
    url := ''https://your-project.supabase.co/functions/v1/moderate-content'',
    headers := jsonb_build_object(
      ''Content-Type'', ''application/json'',
      ''Authorization'', ''Bearer '' || current_setting(''app.edge_function_key'')
    ),
    body := jsonb_build_object(
      ''comment_id'', NEW.id,
      ''content'', NEW.content,
      ''post_id'', NEW.post_id
    )
  );
  
  RETURN NEW;
END;
$$ LANGUAGE plpgsql SECURITY DEFINER;

CREATE TRIGGER on_comment_created
  AFTER INSERT ON comments
  FOR EACH ROW
  EXECUTE FUNCTION moderate_comment();

Edge Function

// supabase/functions/moderate-content/index.ts
import { serve } from 'https://deno.land/std@0.168.0/http/server.ts'
import { createClient } from 'https://esm.sh/@supabase/supabase-js@2'

serve(async (req) => {
  try {
    const { comment_id, content, post_id } = await req.json()

    // Call AppHighway Content Moderation tool
    const moderationResponse = await fetch(
      'https://apphighway.com/api/v1/content-moderation',
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${Deno.env.get('APPHIGHWAY_API_KEY')}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          text: content,
          categories: ['toxicity', 'profanity', 'spam']
        })
      }
    )

    const moderation = await moderationResponse.json()

    // Update comment with moderation results
    const supabase = createClient(
      Deno.env.get('SUPABASE_URL')!,
      Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')!
    )

    await supabase
      .from('comments')
      .update({
        is_flagged: moderation.flagged,
        toxicity_score: moderation.scores.toxicity,
        profanity_score: moderation.scores.profanity,
        spam_score: moderation.scores.spam,
        moderation_status: moderation.flagged ? 'pending_review' : 'approved',
        moderated_at: new Date().toISOString()
      })
      .eq('id', comment_id)

    return new Response(
      JSON.stringify({ success: true, moderation }),
      { headers: { 'Content-Type': 'application/json' } }
    )
  } catch (error) {
    return new Response(
      JSON.stringify({ error: error.message }),
      { status: 500, headers: { 'Content-Type': 'application/json' } }
    )
  }
})

Client Real-Time Subscription

// React component with real-time moderation
import { useSupabaseClient } from '@supabase/auth-helpers-react'
import { useEffect, useState } from 'react'

const CommentsList = ({ postId }: { postId: string }) => {
  const supabase = useSupabaseClient()
  const [comments, setComments] = useState<Comment[]>([])

  useEffect(() => {
    // Load initial comments
    loadComments()

    // Subscribe to new comments and moderation updates
    const subscription = supabase
      .channel(`post-${postId}-comments`)
      .on(
        'postgres_changes',
        {
          event: '*', // INSERT, UPDATE, DELETE
          schema: 'public',
          table: 'comments',
          filter: `post_id=eq.${postId}`
        },
        (payload) => {
          if (payload.eventType === 'INSERT') {
            // New comment added
            setComments(prev => [...prev, payload.new as Comment])
          } else if (payload.eventType === 'UPDATE') {
            // Comment moderated (moderation_status updated)
            setComments(prev => 
              prev.map(comment => 
                comment.id === payload.new.id 
                  ? { ...comment, ...payload.new }
                  : comment
              )
            )
          }
        }
      )
      .subscribe()

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

  const loadComments = async () => {
    const { data } = await supabase
      .from('comments')
      .select('*')
      .eq('post_id', postId)
      .order('created_at', { ascending: false })
    
    setComments(data || [])
  }

  return (
    <div>
      {comments.map(comment => (
        <div key={comment.id} className={comment.is_flagged ? 'flagged' : ''}>
          <p>{comment.content}</p>
          {comment.moderation_status === 'pending_review' && (
            <span className="badge">Pending Moderation</span>
          )}
          {comment.toxicity_score > 0.7 && (
            <span className="warning">High toxicity detected</span>
          )}
        </div>
      ))}
    </div>
  )
}

Client subscribes to comment changes, new comments are automatically moderated via trigger + Edge Function + AppHighway, UI updates in real-time with moderation status.

Signup Flow with Profile Enrichment

// Edge Function: enrich-user-profile
import { serve } from 'https://deno.land/std@0.168.0/http/server.ts'
import { createClient } from 'https://esm.sh/@supabase/supabase-js@2'

serve(async (req) => {
  try {
    // Validate JWT and get user
    const authHeader = req.headers.get('Authorization')!
    const supabase = createClient(
      Deno.env.get('SUPABASE_URL')!,
      Deno.env.get('SUPABASE_ANON_KEY')!,
      { global: { headers: { Authorization: authHeader } } }
    )

    const { data: { user }, error: authError } = await supabase.auth.getUser()
    if (authError || !user) {
      return new Response(
        JSON.stringify({ error: 'Unauthorized' }),
        { status: 401 }
      )
    }

    // Get user metadata from signup
    const { company_name, website } = await req.json()

    // Enrich company data with AppHighway tools
    const enrichmentResults = await Promise.all([
      // Validate and standardize company website
      fetch('https://apphighway.com/api/v1/url-validator', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${Deno.env.get('APPHIGHWAY_API_KEY')}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ url: website })
      }).then(r => r.json()),

      // Extract company information from website
      fetch('https://apphighway.com/api/v1/web-scraper', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${Deno.env.get('APPHIGHWAY_API_KEY')}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ 
          url: website,
          extract: ['company_description', 'industry', 'location']
        })
      }).then(r => r.json()),

      // Validate company email domain
      fetch('https://apphighway.com/api/v1/email-validator', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${Deno.env.get('APPHIGHWAY_API_KEY')}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ email: user.email })
      }).then(r => r.json())
    ])

    const [urlValidation, companyData, emailValidation] = enrichmentResults

    // Create enriched user profile
    const { error: profileError } = await supabase
      .from('user_profiles')
      .insert({
        user_id: user.id,
        email: user.email,
        company_name,
        website: urlValidation.standardized_url,
        company_description: companyData.company_description,
        industry: companyData.industry,
        location: companyData.location,
        email_verified: emailValidation.is_valid,
        email_corporate: !emailValidation.is_free_provider,
        enriched_at: new Date().toISOString()
      })

    if (profileError) throw profileError

    return new Response(
      JSON.stringify({ 
        success: true,
        profile: {
          company_name,
          industry: companyData.industry,
          verified: emailValidation.is_valid
        }
      }),
      { headers: { 'Content-Type': 'application/json' } }
    )
  } catch (error) {
    return new Response(
      JSON.stringify({ error: error.message }),
      { status: 500, headers: { 'Content-Type': 'application/json' } }
    )
  }
})

Client-Side Integration

// Signup form with profile enrichment
import { useSupabaseClient } from '@supabase/auth-helpers-react'
import { useState } from 'react'

const SignupForm = () => {
  const supabase = useSupabaseClient()
  const [loading, setLoading] = useState(false)

  const handleSignup = async (e: React.FormEvent) => {
    e.preventDefault()
    setLoading(true)

    const formData = new FormData(e.target as HTMLFormElement)
    const email = formData.get('email') as string
    const password = formData.get('password') as string
    const company_name = formData.get('company_name') as string
    const website = formData.get('website') as string

    try {
      // Step 1: Sign up user with Supabase Auth
      const { data: authData, error: authError } = await supabase.auth.signUp({
        email,
        password
      })

      if (authError) throw authError

      // Step 2: Enrich profile with AppHighway data
      const { data: profileData, error: profileError } = await supabase.functions.invoke(
        'enrich-user-profile',
        {
          body: { company_name, website }
        }
      )

      if (profileError) throw profileError

      // Step 3: Show success with enriched data
      toast.success(
        `Welcome! We've verified your ${profileData.profile.industry} company.`
      )
      
      router.push('/dashboard')
    } catch (error) {
      toast.error(error.message)
    } finally {
      setLoading(false)
    }
  }

  return (
    <form onSubmit={handleSignup}>
      <input name="email" type="email" placeholder="Email" required />
      <input name="password" type="password" placeholder="Password" required />
      <input name="company_name" placeholder="Company Name" required />
      <input name="website" type="url" placeholder="Website" required />
      <button type="submit" disabled={loading}>
        {loading ? 'Creating account...' : 'Sign Up'}
      </button>
    </form>
  )
}

Database Schema

-- Orders table
CREATE TABLE orders (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  user_id UUID REFERENCES auth.users(id),
  total_amount DECIMAL(10,2) NOT NULL,
  status TEXT DEFAULT ''pending'',
  items JSONB NOT NULL,
  created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Enable RLS
ALTER TABLE orders ENABLE ROW LEVEL SECURITY;

CREATE POLICY "Users can view own orders"
  ON orders FOR SELECT
  USING (auth.uid() = user_id);

-- Order processing trigger
CREATE OR REPLACE FUNCTION process_order()
RETURNS TRIGGER AS $$
BEGIN
  PERFORM net.http_post(
    url := ''https://your-project.supabase.co/functions/v1/process-order'',
    headers := jsonb_build_object(
      ''Content-Type'', ''application/json'',
      ''Authorization'', ''Bearer '' || current_setting(''app.edge_function_key'')
    ),
    body := jsonb_build_object(
      ''order_id'', NEW.id,
      ''user_id'', NEW.user_id,
      ''items'', NEW.items,
      ''total'', NEW.total_amount
    )
  );
  
  RETURN NEW;
END;
$$ LANGUAGE plpgsql SECURITY DEFINER;

CREATE TRIGGER on_order_created
  AFTER INSERT ON orders
  FOR EACH ROW
  EXECUTE FUNCTION process_order();

Edge Function: Complete Order Processing

// supabase/functions/process-order/index.ts
import { serve } from 'https://deno.land/std@0.168.0/http/server.ts'
import { createClient } from 'https://esm.sh/@supabase/supabase-js@2'

const APPHIGHWAY_KEY = Deno.env.get('APPHIGHWAY_API_KEY')!

serve(async (req) => {
  try {
    const { order_id, user_id, items, total } = await req.json()

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

    // Step 1: Get user details
    const { data: user } = await supabase
      .from('user_profiles')
      .select('email, name')
      .eq('user_id', user_id)
      .single()

    // Step 2: Validate inventory (parallel API calls)
    const inventoryChecks = await Promise.all(
      items.map(async (item: any) => {
        const { data: product } = await supabase
          .from('products')
          .select('stock')
          .eq('id', item.product_id)
          .single()
        
        return {
          product_id: item.product_id,
          requested: item.quantity,
          available: product.stock,
          valid: product.stock >= item.quantity
        }
      })
    )

    if (inventoryChecks.some(check => !check.valid)) {
      await supabase
        .from('orders')
        .update({ status: 'insufficient_inventory' })
        .eq('id', order_id)
      
      return new Response(
        JSON.stringify({ success: false, reason: 'insufficient_inventory' }),
        { status: 400 }
      )
    }

    // Step 3: Generate invoice PDF with AppHighway
    const invoiceResponse = await fetch(
      'https://apphighway.com/api/v1/pdf-generator',
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${APPHIGHWAY_KEY}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          template: 'invoice',
          data: {
            order_id,
            customer_name: user.name,
            customer_email: user.email,
            items: items,
            total: total,
            date: new Date().toISOString()
          }
        })
      }
    )

    const invoice = await invoiceResponse.json()

    // Step 4: Send confirmation email with AppHighway
    await fetch('https://apphighway.com/api/v1/email-sender', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${APPHIGHWAY_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        to: user.email,
        subject: `Order Confirmation #${order_id}`,
        template: 'order_confirmation',
        data: {
          customer_name: user.name,
          order_id,
          items,
          total
        },
        attachments: [
          {
            filename: `invoice-${order_id}.pdf`,
            content: invoice.pdf_base64
          }
        ]
      })
    })

    // Step 5: Update order status
    await supabase
      .from('orders')
      .update({ 
        status: 'confirmed',
        invoice_url: invoice.url,
        processed_at: new Date().toISOString()
      })
      .eq('id', order_id)

    // Step 6: Decrement inventory
    for (const item of items) {
      await supabase.rpc('decrement_stock', {
        product_id: item.product_id,
        quantity: item.quantity
      })
    }

    // Step 7: Log analytics event
    await supabase.from('analytics_events').insert({
      event_type: 'order_completed',
      user_id,
      metadata: { order_id, total, items_count: items.length }
    })

    return new Response(
      JSON.stringify({ success: true, invoice_url: invoice.url }),
      { headers: { 'Content-Type': 'application/json' } }
    )
  } catch (error) {
    return new Response(
      JSON.stringify({ error: error.message }),
      { status: 500 }
    )
  }
})