⬡ Dev Tools/2026-03-28Advanced

Rork Max × Supabase Edge Functions & Row Level Security — Complete Secure API Design Guide

Learn how to design and implement secure, scalable APIs for Rork Max apps using Supabase Edge Functions and Row Level Security (RLS). From authorization patterns to production deployment.

Rork Max²²⁹ Supabase³³ Edge Functions² Row Level Security API Design Security⁸ Backend⁴

✦ Premium Article

Setup and context — Why Edge Functions × RLS Matters

As you build more sophisticated apps with Rork Max, you'll inevitably hit scenarios where client-side logic alone isn't enough. Integrating with external APIs, processing payments, aggregating analytics data, sending emails — these server-side operations need to be handled securely and efficiently. That's where Supabase Edge Functions come in.

On the data access side, controlling exactly who can read and write which rows in your database is the job of Row Level Security (RLS). Because RLS operates at the database layer, it prevents unauthorized data access even when clients query Supabase directly.

Combining these two capabilities gives your Rork Max app a backend that's both lightweight and rock-solid. In this guide, we'll walk through the complete architecture of secure API design using Edge Functions and RLS, with production-ready implementation code.

This article is aimed at intermediate-to-advanced developers who want to ship production-grade Rork Max apps. If you need a refresher on Supabase basics (authentication, CRUD operations), check out Rork × Supabase Auth & Realtime Implementation Guide first.

Supabase Edge Functions Architecture

What Are Edge Functions?

Supabase Edge Functions are serverless functions running on the Deno runtime. Because they execute within Supabase's infrastructure, they have fast database connectivity and minimal cold-start times.

Key characteristics include the following.

Deno Runtime: Native TypeScript support with a secure sandbox environment
Global Edge Delivery: Responses served from the closest region to the user for low latency
Built-in Supabase Client: supabase-js is available within the execution environment
Secrets Management: API keys and tokens stored securely as environment variables

Directory Structure

supabase/
├── functions/
│   ├── process-payment/
│   │   └── index.ts        # Payment processing
│   ├── send-notification/
│   │   └── index.ts        # Push notification dispatch
│   ├── aggregate-analytics/
│   │   └── index.ts        # Analytics aggregation
│   └── _shared/
│       ├── cors.ts          # CORS helper
│       ├── auth.ts          # Auth helper
│       └── response.ts      # Response helper
└── config.toml

Placing common utilities in the _shared/ directory keeps your Edge Function code DRY (Don't Repeat Yourself).

Minimal Edge Function

Here's a simple Edge Function that returns an authenticated user's profile.

// supabase/functions/get-profile/index.ts
import { serve } from "https://deno.land/std@0.177.0/http/server.ts";
import { createClient } from "https://esm.sh/@supabase/supabase-js@2";
 
// CORS headers
const corsHeaders = {
  "Access-Control-Allow-Origin": "*",
  "Access-Control-Allow-Headers":
    "authorization, x-client-info, apikey, content-type",
};
 
serve(async (req: Request) => {
  // Handle preflight requests
  if (req.method === "OPTIONS") {
    return new Response("ok", { headers: corsHeaders });
  }
 
  try {
    // Extract JWT from the request header
    const authHeader = req.headers.get("Authorization");
    if (!authHeader) {
      return new Response(
        JSON.stringify({ error: "Authentication required" }),
        { status: 401, headers: { ...corsHeaders, "Content-Type": "application/json" } }
      );
    }
 
    // Initialize the Supabase client with the user's JWT
    const supabase = createClient(
      Deno.env.get("SUPABASE_URL") ?? "",
      Deno.env.get("SUPABASE_ANON_KEY") ?? "",
      { global: { headers: { Authorization: authHeader } } }
    );
 
    // Retrieve the authenticated user
    const { data: { user }, error: userError } = await supabase.auth.getUser();
    if (userError || !user) {
      return new Response(
        JSON.stringify({ error: "Invalid token" }),
        { status: 401, headers: { ...corsHeaders, "Content-Type": "application/json" } }
      );
    }
 
    // Fetch profile with RLS applied
    const { data: profile, error } = await supabase
      .from("profiles")
      .select("*")
      .eq("id", user.id)
      .single();
 
    if (error) throw error;
 
    return new Response(
      JSON.stringify({ profile }),
      { status: 200, headers: { ...corsHeaders, "Content-Type": "application/json" } }
    );
  } catch (err) {
    return new Response(
      JSON.stringify({ error: err.message }),
      { status: 500, headers: { ...corsHeaders, "Content-Type": "application/json" } }
    );
  }
});
// Expected output:
// { "profile": { "id": "uuid-xxx", "display_name": "Masaki", "avatar_url": "https://..." } }

The key insight here is that passing the Authorization header to the Supabase client causes RLS policies to be evaluated in the user's context.

✦

Thank you for reading this far.

Continue Reading

What follows includes implementation code, benchmarks, and practical content we hope you'll find useful. This site runs without ads — server and development costs are supported entirely by members like you. If it's been helpful, we'd be truly grateful for your support.

WHAT YOU'LL LEARN

✦Understand the design patterns of Supabase Edge Functions and how to invoke them from Rork Max

✦Implement multi-tenant authorization using Row Level Security (RLS)

✦Master debugging, performance optimization, and monitoring techniques for Edge Functions in production

Secure payment via Stripe · Cancel anytime

✦

Unlock This Article

Get full access to the rest of this article. Buy once, read anytime. This site is ad-free — your support goes directly toward keeping it running.

Unlock all articles with Membership →

Row Level Security (RLS) Design Patterns

How RLS Works

RLS is a native PostgreSQL feature that lets you define access policies for individual rows in a table. In Supabase, RLS is enabled by default, meaning tables without policies are inaccessible to everyone.

RLS policies can be defined for four operations.

SELECT: Reading data
INSERT: Creating new rows
UPDATE: Modifying existing rows
DELETE: Removing rows

Pattern 1: Protecting User-Owned Data

The most fundamental pattern ensures users can only interact with their own data.

-- RLS policies for the profiles table
-- Users can only view their own profile
CREATE POLICY "Users can view own profile"
  ON profiles FOR SELECT
  USING (auth.uid() = id);
 
-- Users can only update their own profile
CREATE POLICY "Users can update own profile"
  ON profiles FOR UPDATE
  USING (auth.uid() = id)
  WITH CHECK (auth.uid() = id);
 
-- Users can only create a profile with their own ID
CREATE POLICY "Users can insert own profile"
  ON profiles FOR INSERT
  WITH CHECK (auth.uid() = id);

auth.uid() is a Supabase-provided function that automatically extracts the user ID from the current JWT token.

Pattern 2: Multi-Tenant Access Control

SaaS apps and team-based features require a pattern where only members of the same organization can share data.

-- Organization membership table
CREATE TABLE org_members (
  org_id UUID REFERENCES organizations(id),
  user_id UUID REFERENCES auth.users(id),
  role TEXT CHECK (role IN ('owner', 'admin', 'member', 'viewer')),
  PRIMARY KEY (org_id, user_id)
);
 
-- RLS for the projects table
-- Only org members can view projects
CREATE POLICY "Org members can view projects"
  ON projects FOR SELECT
  USING (
    org_id IN (
      SELECT org_id FROM org_members
      WHERE user_id = auth.uid()
    )
  );
 
-- Only admins and above can create or update projects
CREATE POLICY "Admins can manage projects"
  ON projects FOR ALL
  USING (
    org_id IN (
      SELECT org_id FROM org_members
      WHERE user_id = auth.uid()
      AND role IN ('owner', 'admin')
    )
  );

Pattern 3: Public vs. Private Content

For apps like blogs or portfolios where published content is public but drafts are private.

-- RLS for the posts table
-- Published posts are visible to everyone
CREATE POLICY "Anyone can view published posts"
  ON posts FOR SELECT
  USING (status = 'published');
 
-- Drafts are visible only to the author
CREATE POLICY "Authors can view own drafts"
  ON posts FOR SELECT
  USING (author_id = auth.uid() AND status = 'draft');
 
-- Only the author can create and update
CREATE POLICY "Authors can manage own posts"
  ON posts FOR INSERT
  WITH CHECK (author_id = auth.uid());
 
CREATE POLICY "Authors can update own posts"
  ON posts FOR UPDATE
  USING (author_id = auth.uid())
  WITH CHECK (author_id = auth.uid());

Optimizing RLS Performance

Complex subqueries in RLS policies can degrade query performance. Use security definer functions for better efficiency.

-- ❌ Bad: Subquery runs for every row
CREATE POLICY "slow_policy" ON items FOR SELECT
USING (
  owner_id IN (
    SELECT user_id FROM team_members
    WHERE team_id IN (
      SELECT team_id FROM user_teams WHERE user_id = auth.uid()
    )
  )
);
 
-- ✅ Good: Security definer function with caching
CREATE OR REPLACE FUNCTION auth.user_team_ids()
RETURNS SETOF UUID
LANGUAGE sql
SECURITY DEFINER
STABLE  -- Results cached within the same transaction
AS $$
  SELECT team_id FROM user_teams WHERE user_id = auth.uid();
$$;
 
CREATE POLICY "fast_policy" ON items FOR SELECT
USING (team_id IN (SELECT auth.user_team_ids()));

The STABLE marker tells PostgreSQL to cache this function's results within the same transaction — highly effective when the same condition is used across multiple tables.

Calling Edge Functions from Rork Max

Basic Invocation Pattern

To call an Edge Function from your Rork Max app, use the functions.invoke() method from supabase-js.

// Calling an Edge Function from within a Rork Max app
import { supabase } from "./lib/supabase";
 
// Delegating payment processing to an Edge Function
async function processPayment(amount: number, currency: string) {
  try {
    const { data, error } = await supabase.functions.invoke(
      "process-payment",
      {
        body: {
          amount,
          currency,
          // Never store card details on the client
          // Use Stripe PaymentIntents instead
          payment_method_id: "pm_xxx",
        },
      }
    );
 
    if (error) throw error;
 
    return data;
  } catch (err) {
    console.error("Payment error:", err.message);
    throw err;
  }
}
// Expected output:
// { "success": true, "payment_intent_id": "pi_xxx", "status": "succeeded" }

Automatic Token Forwarding

supabase.functions.invoke() automatically includes the current session's JWT token in the Authorization header. This means the Edge Function can identify the user via auth.uid() without any additional configuration.

Error Handling Best Practices

Here's a robust pattern for handling Edge Function errors in your Rork Max app.

// lib/edge-functions.ts — Shared invocation wrapper
import { supabase } from "./supabase";
 
type EdgeFunctionResult<T> = {
  data: T | null;
  error: string | null;
  status: number;
};
 
export async function callEdgeFunction<T>(
  functionName: string,
  body?: Record<string, unknown>
): Promise<EdgeFunctionResult<T>> {
  try {
    const { data, error } = await supabase.functions.invoke(functionName, {
      body: body ?? {},
    });
 
    if (error) {
      // FunctionsHttpError: Edge Function returned 4xx/5xx
      // FunctionsRelayError: Network error
      // FunctionsFetchError: Fetch itself failed
      return {
        data: null,
        error: error.message,
        status: error.context?.status ?? 500,
      };
    }
 
    return { data: data as T, error: null, status: 200 };
  } catch (err) {
    return {
      data: null,
      error: err instanceof Error ? err.message : "Unknown error",
      status: 500,
    };
  }
}
 
// Usage example
const result = await callEdgeFunction<{ profile: Profile }>("get-profile");
if (result.error) {
  showToast(`Error: ${result.error}`);
} else {
  setProfile(result.data?.profile);
}

Hands-On: Building a Multi-Tenant Task Management API

Let's walk through a comprehensive, real-world implementation. We'll build the API for a team-based task management app using Edge Functions and RLS.

Database Schema

-- Organizations table
CREATE TABLE organizations (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  name TEXT NOT NULL,
  slug TEXT UNIQUE NOT NULL,
  created_at TIMESTAMPTZ DEFAULT now()
);
 
-- Memberships table
CREATE TABLE memberships (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  org_id UUID REFERENCES organizations(id) ON DELETE CASCADE,
  user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE,
  role TEXT NOT NULL CHECK (role IN ('owner', 'admin', 'member')),
  created_at TIMESTAMPTZ DEFAULT now(),
  UNIQUE(org_id, user_id)
);
 
-- Tasks table
CREATE TABLE tasks (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  org_id UUID REFERENCES organizations(id) ON DELETE CASCADE,
  title TEXT NOT NULL,
  description TEXT,
  status TEXT DEFAULT 'todo' CHECK (status IN ('todo', 'in_progress', 'done')),
  priority INTEGER DEFAULT 0,
  assignee_id UUID REFERENCES auth.users(id),
  created_by UUID REFERENCES auth.users(id) NOT NULL,
  due_date DATE,
  created_at TIMESTAMPTZ DEFAULT now(),
  updated_at TIMESTAMPTZ DEFAULT now()
);
 
-- Enable RLS
ALTER TABLE organizations ENABLE ROW LEVEL SECURITY;
ALTER TABLE memberships ENABLE ROW LEVEL SECURITY;
ALTER TABLE tasks ENABLE ROW LEVEL SECURITY;
 
-- Organizations: only members can view
CREATE POLICY "Members can view org"
  ON organizations FOR SELECT
  USING (id IN (SELECT org_id FROM memberships WHERE user_id = auth.uid()));
 
-- Memberships: visible to fellow org members
CREATE POLICY "Members can view memberships"
  ON memberships FOR SELECT
  USING (org_id IN (SELECT org_id FROM memberships WHERE user_id = auth.uid()));
 
-- Tasks: full CRUD for org members
CREATE POLICY "Members can view tasks"
  ON tasks FOR SELECT
  USING (org_id IN (SELECT org_id FROM memberships WHERE user_id = auth.uid()));
 
CREATE POLICY "Members can create tasks"
  ON tasks FOR INSERT
  WITH CHECK (
    org_id IN (SELECT org_id FROM memberships WHERE user_id = auth.uid())
    AND created_by = auth.uid()
  );
 
CREATE POLICY "Members can update tasks"
  ON tasks FOR UPDATE
  USING (org_id IN (SELECT org_id FROM memberships WHERE user_id = auth.uid()));
 
-- Only admins and above can delete
CREATE POLICY "Admins can delete tasks"
  ON tasks FOR DELETE
  USING (
    org_id IN (
      SELECT org_id FROM memberships
      WHERE user_id = auth.uid() AND role IN ('owner', 'admin')
    )
  );

Edge Function: Task Summary API

// supabase/functions/task-summary/index.ts
import { serve } from "https://deno.land/std@0.177.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: Request) => {
  if (req.method === "OPTIONS") {
    return new Response("ok", { headers: corsHeaders });
  }
 
  try {
    const authHeader = req.headers.get("Authorization");
    if (!authHeader) {
      return new Response(
        JSON.stringify({ error: "Unauthorized" }),
        { status: 401, headers: { ...corsHeaders, "Content-Type": "application/json" } }
      );
    }
 
    const { org_id } = await req.json();
    if (!org_id) {
      return new Response(
        JSON.stringify({ error: "org_id is required" }),
        { status: 400, headers: { ...corsHeaders, "Content-Type": "application/json" } }
      );
    }
 
    // Initialize with the user's JWT — RLS is enforced
    const supabase = createClient(
      Deno.env.get("SUPABASE_URL") ?? "",
      Deno.env.get("SUPABASE_ANON_KEY") ?? "",
      { global: { headers: { Authorization: authHeader } } }
    );
 
    // Aggregate task status
    const { data: tasks, error } = await supabase
      .from("tasks")
      .select("status, priority, assignee_id, due_date")
      .eq("org_id", org_id);
 
    if (error) throw error;
 
    const summary = {
      total: tasks.length,
      by_status: {
        todo: tasks.filter((t) => t.status === "todo").length,
        in_progress: tasks.filter((t) => t.status === "in_progress").length,
        done: tasks.filter((t) => t.status === "done").length,
      },
      overdue: tasks.filter(
        (t) => t.due_date && new Date(t.due_date) < new Date() && t.status !== "done"
      ).length,
      high_priority: tasks.filter((t) => t.priority >= 3).length,
      completion_rate:
        tasks.length > 0
          ? Math.round(
              (tasks.filter((t) => t.status === "done").length / tasks.length) * 100
            )
          : 0,
    };
 
    return new Response(
      JSON.stringify({ summary }),
      { status: 200, headers: { ...corsHeaders, "Content-Type": "application/json" } }
    );
  } catch (err) {
    return new Response(
      JSON.stringify({ error: err.message }),
      { status: 500, headers: { ...corsHeaders, "Content-Type": "application/json" } }
    );
  }
});
// Expected output:
// {
//   "summary": {
//     "total": 42,
//     "by_status": { "todo": 15, "in_progress": 12, "done": 15 },
//     "overdue": 3,
//     "high_priority": 8,
//     "completion_rate": 36
//   }
// }

Security Best Practices for Edge Functions

1. Service Role Key Usage

Two types of client initialization are available inside Edge Functions. Misusing them can lead to serious security incidents where RLS is bypassed entirely.

// ✅ User context (RLS enforced)
// → Use for all user-facing data operations
const userClient = createClient(
  Deno.env.get("SUPABASE_URL")!,
  Deno.env.get("SUPABASE_ANON_KEY")!,
  { global: { headers: { Authorization: authHeader } } }
);
 
// ⚠️ Service Role (bypasses RLS)
// → Use ONLY for admin operations (analytics, batch jobs)
// → Never pass user input directly
const adminClient = createClient(
  Deno.env.get("SUPABASE_URL")!,
  Deno.env.get("SUPABASE_SERVICE_ROLE_KEY")!
);

As a rule, always use the user context (ANON_KEY + JWT) for data operations triggered by user requests. Reserve the Service Role for administrative batch operations and system-level tasks that cannot run under a user context.

2. Input Validation

Inputs sent to Edge Functions can be freely tampered with by clients. Always validate on the server side.

// Input validation using Zod
import { z } from "https://deno.land/x/zod@v3.22.4/mod.ts";
 
const CreateTaskSchema = z.object({
  org_id: z.string().uuid(),
  title: z.string().min(1).max(200),
  description: z.string().max(5000).optional(),
  priority: z.number().int().min(0).max(5).default(0),
  assignee_id: z.string().uuid().optional(),
  due_date: z.string().datetime().optional(),
});
 
// Usage inside the Edge Function
const body = await req.json();
const parsed = CreateTaskSchema.safeParse(body);
 
if (!parsed.success) {
  return new Response(
    JSON.stringify({
      error: "Validation error",
      details: parsed.error.flatten(),
    }),
    { status: 400, headers: { ...corsHeaders, "Content-Type": "application/json" } }
  );
}
 
// parsed.data is fully type-safe
const { org_id, title, description, priority } = parsed.data;

3. Rate Limiting Implementation

Edge Functions don't include built-in rate limiting, but you can implement a lightweight solution using a Supabase table.

// _shared/rate-limit.ts
import { SupabaseClient } from "https://esm.sh/@supabase/supabase-js@2";
 
export async function checkRateLimit(
  adminClient: SupabaseClient,
  userId: string,
  action: string,
  maxRequests: number,
  windowMinutes: number
): Promise<boolean> {
  const windowStart = new Date(
    Date.now() - windowMinutes * 60 * 1000
  ).toISOString();
 
  // Count recent requests
  const { count } = await adminClient
    .from("rate_limits")
    .select("*", { count: "exact", head: true })
    .eq("user_id", userId)
    .eq("action", action)
    .gte("created_at", windowStart);
 
  if ((count ?? 0) >= maxRequests) {
    return false; // Rate limit exceeded
  }
 
  // Record the request
  await adminClient
    .from("rate_limits")
    .insert({ user_id: userId, action });
 
  return true;
}
 
// Usage in an Edge Function
const allowed = await checkRateLimit(adminClient, user.id, "create-task", 100, 60);
if (!allowed) {
  return new Response(
    JSON.stringify({ error: "Too many requests. Please try again later." }),
    { status: 429, headers: corsHeaders }
  );
}

Debugging and Deploying Edge Functions

Local Development

# Start the local Supabase server
supabase start
 
# Serve the Edge Function locally
supabase functions serve --env-file .env.local
 
# Test from another terminal
curl -i --location --request POST \
  "http://localhost:54321/functions/v1/task-summary" \
  --header "Authorization: Bearer YOUR_ANON_KEY" \
  --header "Content-Type: application/json" \
  --data '{"org_id": "test-org-id"}'

Production Deployment

# Deploy a specific function
supabase functions deploy task-summary
 
# Deploy all functions at once
supabase functions deploy
 
# Set secrets
supabase secrets set STRIPE_SECRET_KEY=YOUR_API_KEY
supabase secrets set SENDGRID_API_KEY=YOUR_API_KEY

Logs and Monitoring

# Real-time logs (great for debugging)
supabase functions logs task-summary --tail
 
# Error logs from the past 24 hours
supabase functions logs task-summary --status error

The Supabase dashboard's Edge Functions section provides graphs of invocation counts, average latency, and error rates. Monitoring performance as your app grows is essential.

Performance Optimization Techniques

1. Connection Pooling

Since Edge Functions are short-lived per-request executions, optimizing database connections matters.

// The Supabase client is created per request,
// but connection pooling is handled internally.
// When connecting directly to PostgreSQL, use the pooler.
 
const supabase = createClient(
  // Use the pooler URL (port 6543)
  Deno.env.get("SUPABASE_URL")!.replace(":5432", ":6543"),
  Deno.env.get("SUPABASE_ANON_KEY")!
);

2. Response Caching

For data that doesn't change frequently, leverage Cache-Control headers.

// Allow caching for 5 minutes
return new Response(JSON.stringify({ data }), {
  status: 200,
  headers: {
    ...corsHeaders,
    "Content-Type": "application/json",
    "Cache-Control": "public, max-age=300, s-maxage=300",
  },
});

3. Parallel Queries

When you need to fetch multiple datasets, use Promise.all() for concurrent execution.

// ❌ Sequential execution (slow)
const tasks = await supabase.from("tasks").select("*").eq("org_id", orgId);
const members = await supabase.from("memberships").select("*").eq("org_id", orgId);
 
// ✅ Parallel execution (fast)
const [tasksResult, membersResult] = await Promise.all([
  supabase.from("tasks").select("*").eq("org_id", orgId),
  supabase.from("memberships").select("*, profiles(display_name, avatar_url)").eq("org_id", orgId),
]);

Summary

Combining Supabase Edge Functions with Row Level Security enables you to build simple yet robust backends for your Rork Max apps. Here's a recap of what we covered.

Edge Functions are Deno-based serverless functions ideal for external API integration and complex logic
RLS enforces authorization at the database layer, preventing unauthorized data access from clients
Correctly distinguishing between user context and Service Role is the cornerstone of security
Input validation, rate limiting, and log monitoring together deliver a production-quality backend

For more on security fundamentals, also check out Rork Max Security Best Practices. If you're interested in implementing semantic search with AI, take a look at Rork × Supabase pgvector Semantic Search App Development Guide.

To dive even deeper into these topics,

Thank You for Reading

Rork Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.