Skip to content

An open-source, self-hostable PaaS alternative to Vercel, Heroku & Netlify that lets you easily deploy static sites, databases, full-stack applications and 360+ one-click services on your own servers.

67.4 KB
Raw Blame
# documentation: https://supabase.io
# slogan: The open source Firebase alternative.
# category: backend
# tags: firebase, alternative, open-source
# minversion: 4.0.0-beta.228
# logo: svgs/supabase.svg
# port: 8000

services:
  supabase-kong:
    image: kong/kong:3.9.1
    entrypoint: /home/kong/kong-entrypoint.sh
    depends_on:
      supabase-analytics:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "kong", "health"]
      interval: 5s
      timeout: 5s
      retries: 5
    environment:
      - SERVICE_URL_SUPABASEKONG_8000
      - KONG_PORT_MAPS=443:8000
      - JWT_SECRET=${SERVICE_PASSWORD_JWT}
      - KONG_DATABASE=off
      - KONG_DECLARATIVE_CONFIG=/usr/local/kong/kong.yml
      # https://github.com/supabase/cli/issues/14
      - KONG_DNS_ORDER=LAST,A,CNAME
      - KONG_DNS_NOT_FOUND_TTL=1
      - KONG_PLUGINS=request-transformer,cors,key-auth,acl,basic-auth,request-termination,ip-restriction,post-function
      - KONG_NGINX_PROXY_PROXY_BUFFER_SIZE=160k
      - KONG_NGINX_PROXY_PROXY_BUFFERS=64 160k
      - 'KONG_PROXY_ACCESS_LOG=/dev/stdout combined'
      - SUPABASE_ANON_KEY=${SERVICE_SUPABASEANON_KEY}
      - SUPABASE_SERVICE_KEY=${SERVICE_SUPABASESERVICE_KEY}
      - SUPABASE_PUBLISHABLE_KEY=${SUPABASE_PUBLISHABLE_KEY:-}
      - SUPABASE_SECRET_KEY=${SUPABASE_SECRET_KEY:-}
      - ANON_KEY_ASYMMETRIC=${ANON_KEY_ASYMMETRIC:-}
      - SERVICE_ROLE_KEY_ASYMMETRIC=${SERVICE_ROLE_KEY_ASYMMETRIC:-}
      - DASHBOARD_USERNAME=${SERVICE_USER_ADMIN}
      - DASHBOARD_PASSWORD=${SERVICE_PASSWORD_ADMIN}
      - 'KONG_STORAGE_CONNECT_TIMEOUT=${KONG_STORAGE_CONNECT_TIMEOUT:-60}'
      - 'KONG_STORAGE_WRITE_TIMEOUT=${KONG_STORAGE_WRITE_TIMEOUT:-3600}'
      - 'KONG_STORAGE_READ_TIMEOUT=${KONG_STORAGE_READ_TIMEOUT:-3600}'
      - 'KONG_STORAGE_REQUEST_BUFFERING=${KONG_STORAGE_REQUEST_BUFFERING:-false}'
      - 'KONG_STORAGE_RESPONSE_BUFFERING=${KONG_STORAGE_RESPONSE_BUFFERING:-false}'
    volumes:
      - type: bind
        source: ./volumes/api/kong-entrypoint.sh
        target: /home/kong/kong-entrypoint.sh
        content: |
          #!/bin/bash
          # Custom entrypoint for Kong that builds Lua expressions for request-transformer
          # and performs environment variable substitution in the declarative config.

          if [ -n "$SUPABASE_SECRET_KEY" ] && [ -n "$SUPABASE_PUBLISHABLE_KEY" ]; then
              export LUA_AUTH_EXPR="\$((headers.authorization ~= nil and headers.authorization:sub(1, 10) ~= 'Bearer sb_' and headers.authorization) or (headers.apikey == '$SUPABASE_SECRET_KEY' and 'Bearer $SERVICE_ROLE_KEY_ASYMMETRIC') or (headers.apikey == '$SUPABASE_PUBLISHABLE_KEY' and 'Bearer $ANON_KEY_ASYMMETRIC') or headers.apikey)"
              export LUA_RT_WS_EXPR="\$((query_params.apikey == '$SUPABASE_SECRET_KEY' and '$SERVICE_ROLE_KEY_ASYMMETRIC') or (query_params.apikey == '$SUPABASE_PUBLISHABLE_KEY' and '$ANON_KEY_ASYMMETRIC') or query_params.apikey)"
          else
              export LUA_AUTH_EXPR="\$((headers.authorization ~= nil and headers.authorization:sub(1, 10) ~= 'Bearer sb_' and headers.authorization) or headers.apikey)"
              export LUA_RT_WS_EXPR="\$(query_params.apikey)"
          fi

          awk '{
            result = ""
            rest = $0
            while (match(rest, /\$[A-Za-z_][A-Za-z_0-9]*/)) {
              varname = substr(rest, RSTART + 1, RLENGTH - 1)
              if (varname in ENVIRON) {
                result = result substr(rest, 1, RSTART - 1) ENVIRON[varname]
              } else {
                result = result substr(rest, 1, RSTART + RLENGTH - 1)
              }
              rest = substr(rest, RSTART + RLENGTH)
            }
            print result rest
          }' /home/kong/temp.yml > "$KONG_DECLARATIVE_CONFIG"

          sed -i '/^[[:space:]]*- key:[[:space:]]*$/d' "$KONG_DECLARATIVE_CONFIG"

          exec /entrypoint.sh kong docker-start
      # https://github.com/supabase/supabase/issues/12661
      - type: bind
        source: ./volumes/api/kong.yml
        target: /home/kong/temp.yml
        content: |
          _format_version: '2.1'
          _transform: true

          ###
          ### Consumers / Users
          ###
          consumers:
            - username: DASHBOARD
            - username: anon
              keyauth_credentials:
                - key: $SUPABASE_ANON_KEY
                - key: $SUPABASE_PUBLISHABLE_KEY
            - username: service_role
              keyauth_credentials:
                - key: $SUPABASE_SERVICE_KEY
                - key: $SUPABASE_SECRET_KEY

          ###
          ### Access Control List
          ###
          acls:
            - consumer: anon
              group: anon
            - consumer: service_role
              group: admin

          ###
          ### Dashboard credentials
          ###
          basicauth_credentials:
          - consumer: DASHBOARD
            username: '$DASHBOARD_USERNAME'
            password: '$DASHBOARD_PASSWORD'


          ###
          ### API Routes
          ###
          services:

            ## Open Auth routes
            - name: auth-v1-open
              url: http://supabase-auth:9999/verify
              routes:
                - name: auth-v1-open
                  strip_path: true
                  paths:
                    - /auth/v1/verify
              plugins:
                - name: cors
            - name: auth-v1-open-callback
              url: http://supabase-auth:9999/callback
              routes:
                - name: auth-v1-open-callback
                  strip_path: true
                  paths:
                    - /auth/v1/callback
              plugins:
                - name: cors
            - name: auth-v1-open-authorize
              url: http://supabase-auth:9999/authorize
              routes:
                - name: auth-v1-open-authorize
                  strip_path: true
                  paths:
                    - /auth/v1/authorize
              plugins:
                - name: cors
            - name: auth-v1-open-jwks
              _comment: 'Auth: /auth/v1/.well-known/jwks.json -> http://supabase-auth:9999/.well-known/jwks.json'
              url: http://supabase-auth:9999/.well-known/jwks.json
              routes:
                - name: auth-v1-open-jwks
                  strip_path: true
                  paths:
                    - /auth/v1/.well-known/jwks.json
              plugins:
                - name: cors

            - name: auth-v1-open-sso-acs
              url: "http://supabase-auth:9999/sso/saml/acs"
              routes:
                - name: auth-v1-open-sso-acs
                  strip_path: true
                  paths:
                  - /sso/saml/acs
              plugins:
                - name: cors

            - name: auth-v1-open-sso-metadata
              url: "http://supabase-auth:9999/sso/saml/metadata"
              routes:
                - name: auth-v1-open-sso-metadata
                  strip_path: true
                  paths:
                  - /sso/saml/metadata
              plugins:
                - name: cors

            ## Secure Auth routes
            - name: auth-v1
              _comment: 'GoTrue: /auth/v1/* -> http://supabase-auth:9999/*'
              url: http://supabase-auth:9999/
              routes:
                - name: auth-v1-all
                  strip_path: true
                  paths:
                    - /auth/v1/
              plugins:
                - name: cors
                - name: key-auth
                  config:
                    hide_credentials: false
                - name: request-transformer
                  config:
                    add:
                      headers:
                        - "Authorization: $LUA_AUTH_EXPR"
                    replace:
                      headers:
                        - "Authorization: $LUA_AUTH_EXPR"
                - name: acl
                  config:
                    hide_groups_header: true
                    allow:
                      - admin
                      - anon

            ## Secure REST routes
            - name: rest-v1
              _comment: 'PostgREST: /rest/v1/* -> http://supabase-rest:3000/*'
              url: http://supabase-rest:3000/
              routes:
                - name: rest-v1-all
                  strip_path: true
                  paths:
                    - /rest/v1/
              plugins:
                - name: cors
                - name: key-auth
                  config:
                    hide_credentials: false
                - name: request-transformer
                  config:
                    add:
                      headers:
                        - "Authorization: $LUA_AUTH_EXPR"
                    replace:
                      headers:
                        - "Authorization: $LUA_AUTH_EXPR"
                - name: acl
                  config:
                    hide_groups_header: true
                    allow:
                      - admin
                      - anon

            ## Secure GraphQL routes
            - name: graphql-v1
              _comment: 'PostgREST: /graphql/v1/* -> http://supabase-rest:3000/rpc/graphql'
              url: http://supabase-rest:3000/rpc/graphql
              routes:
                - name: graphql-v1-all
                  strip_path: true
                  paths:
                    - /graphql/v1
              plugins:
                - name: cors
                - name: key-auth
                  config:
                    hide_credentials: false
                - name: request-transformer
                  config:
                    add:
                      headers:
                        - "Content-Profile: graphql_public"
                        - "Authorization: $LUA_AUTH_EXPR"
                    replace:
                      headers:
                        - "Content-Profile: graphql_public"
                        - "Authorization: $LUA_AUTH_EXPR"
                - name: acl
                  config:
                    hide_groups_header: true
                    allow:
                      - admin
                      - anon

            ## Secure Realtime routes
            - name: realtime-v1-ws
              _comment: 'Realtime: /realtime/v1/* -> ws://realtime:4000/socket/*'
              url: http://realtime-dev:4000/socket
              protocol: ws
              routes:
                - name: realtime-v1-ws
                  strip_path: true
                  paths:
                    - /realtime/v1/
              plugins:
                - name: cors
                - name: key-auth
                  config:
                    hide_credentials: false
                - name: request-transformer
                  config:
                    add:
                      querystring:
                        - "apikey: $LUA_RT_WS_EXPR"
                    replace:
                      querystring:
                        - "apikey: $LUA_RT_WS_EXPR"
                - name: acl
                  config:
                    hide_groups_header: true
                    allow:
                      - admin
                      - anon
            - name: realtime-v1-rest
              _comment: 'Realtime: /realtime/v1/api/* -> http://realtime:4000/api/*'
              url: http://realtime-dev:4000/api
              protocol: http
              routes:
                - name: realtime-v1-rest
                  strip_path: true
                  paths:
                    - /realtime/v1/api
              plugins:
                - name: cors
                - name: key-auth
                  config:
                    hide_credentials: false
                - name: request-transformer
                  config:
                    add:
                      headers:
                        - "Authorization: $LUA_AUTH_EXPR"
                    replace:
                      headers:
                        - "Authorization: $LUA_AUTH_EXPR"
                - name: acl
                  config:
                    hide_groups_header: true
                    allow:
                      - admin
                      - anon

            ## Storage API endpoint
            ## No key-auth - S3 protocol requests don't carry an apikey header.
            - name: storage-v1
              _comment: 'Storage: /storage/v1/* -> http://supabase-storage:5000/*'
              connect_timeout: $KONG_STORAGE_CONNECT_TIMEOUT
              write_timeout: $KONG_STORAGE_WRITE_TIMEOUT
              read_timeout: $KONG_STORAGE_READ_TIMEOUT
              url: http://supabase-storage:5000/
              routes:
                - name: storage-v1-all
                  strip_path: true
                  paths:
                    - /storage/v1/
                  request_buffering: $KONG_STORAGE_REQUEST_BUFFERING
                  response_buffering: $KONG_STORAGE_RESPONSE_BUFFERING
              plugins:
                - name: cors
                - name: post-function
                  config:
                    access:
                      - |
                        local auth = kong.request.get_header("authorization")
                        if auth == nil or auth == "" or auth:find("^%s*$") then
                          kong.service.request.clear_header("authorization")
                        end

            ## Edge Functions routes
            - name: functions-v1
              _comment: 'Edge Functions: /functions/v1/* -> http://supabase-edge-functions:9000/*'
              url: http://supabase-edge-functions:9000/
              read_timeout: 150000
              routes:
                - name: functions-v1-all
                  strip_path: true
                  paths:
                    - /functions/v1/
              plugins:
                - name: cors

            ## OAuth 2.0 Authorization Server Metadata (RFC 8414)
            - name: well-known-oauth
              _comment: 'Auth: /.well-known/oauth-authorization-server -> http://supabase-auth:9999/.well-known/oauth-authorization-server'
              url: http://supabase-auth:9999/.well-known/oauth-authorization-server
              routes:
                - name: well-known-oauth
                  strip_path: true
                  paths:
                    - /.well-known/oauth-authorization-server
              plugins:
                - name: cors

            ## Analytics routes
            ## Not used - Studio and Vector talk directly to analytics via Docker networking.
            # - name: analytics-v1
            #   _comment: 'Analytics: /analytics/v1/* -> http://logflare:4000/*'
            #   url: http://supabase-analytics:4000/
            #   routes:
            #     - name: analytics-v1-all
            #       strip_path: true
            #       paths:
            #         - /analytics/v1/

            ## Secure Database routes
            - name: meta
              _comment: 'pg-meta: /pg/* -> http://supabase-meta:8080/*'
              url: http://supabase-meta:8080/
              routes:
                - name: meta-all
                  strip_path: true
                  paths:
                    - /pg/
              plugins:
                - name: key-auth
                  config:
                    hide_credentials: false
                - name: acl
                  config:
                    hide_groups_header: true
                    allow:
                      - admin

            ## Block access to /api/mcp
            - name: mcp-blocker
              _comment: 'Block direct access to /api/mcp'
              url: http://supabase-studio:3000/api/mcp
              routes:
                - name: mcp-blocker-route
                  strip_path: true
                  paths:
                    - /api/mcp
              plugins:
                - name: request-termination
                  config:
                    status_code: 403
                    message: "Access is forbidden."

            ## MCP endpoint - local access
            - name: mcp
              _comment: 'MCP: /mcp -> http://supabase-studio:3000/api/mcp (local access)'
              url: http://supabase-studio:3000/api/mcp
              routes:
                - name: mcp
                  strip_path: true
                  paths:
                    - /mcp
              plugins:
                # Block access to /mcp by default
                - name: request-termination
                  config:
                    status_code: 403
                    message: "Access is forbidden."
                # Enable local access (danger zone!)
                # 1. Comment out the 'request-termination' section above
                # 2. Uncomment the entire section below, including 'deny'
                # 3. Add your local IPs to the 'allow' list
                #- name: cors
                #- name: ip-restriction
                #  config:
                #    allow:
                #      - 127.0.0.1
                #      - ::1
                #    deny: []

            ## Protected Dashboard - catch all remaining routes
            - name: dashboard
              _comment: 'Studio: /* -> http://studio:3000/*'
              url: http://supabase-studio:3000/
              routes:
                - name: dashboard-all
                  strip_path: true
                  paths:
                    - /
              plugins:
                - name: cors
                - name: basic-auth
                  config:
                    hide_credentials: true
  supabase-studio:
    image: supabase/studio:2026.03.16-sha-5528817
    healthcheck:
      test:
        [
          "CMD",
          "node",
          "-e",
          "fetch('http://127.0.0.1:3000/api/platform/profile').then((r) => {if (r.status !== 200) throw new Error(r.status)})"
        ]
      timeout: 5s
      interval: 5s
      retries: 3
    depends_on:
      supabase-analytics:
        condition: service_healthy
    environment:
      - HOSTNAME=0.0.0.0
      - STUDIO_PG_META_URL=http://supabase-meta:8080
      - POSTGRES_PASSWORD=${SERVICE_PASSWORD_POSTGRES}
      - POSTGRES_HOST=${POSTGRES_HOST:-supabase-db}
      - POSTGRES_PORT=${POSTGRES_PORT:-5432}
      - POSTGRES_DB=${POSTGRES_DB:-postgres}
      - 'PGRST_DB_SCHEMAS=${PGRST_DB_SCHEMAS:-public,storage,graphql_public}'
      - PGRST_DB_MAX_ROWS=${PGRST_DB_MAX_ROWS:-1000}
      - PGRST_DB_EXTRA_SEARCH_PATH=${PGRST_DB_EXTRA_SEARCH_PATH:-public}

      - DEFAULT_ORGANIZATION_NAME=${STUDIO_DEFAULT_ORGANIZATION:-Default Organization}
      - DEFAULT_PROJECT_NAME=${STUDIO_DEFAULT_PROJECT:-Default Project}

      - 'SUPABASE_URL=http://supabase-kong:8000'
      - SUPABASE_PUBLIC_URL=${SERVICE_URL_SUPABASEKONG}
      - SUPABASE_ANON_KEY=${SERVICE_SUPABASEANON_KEY}
      - SUPABASE_SERVICE_KEY=${SERVICE_SUPABASESERVICE_KEY}
      - AUTH_JWT_SECRET=${SERVICE_PASSWORD_JWT}
      - PG_META_CRYPTO_KEY=${SERVICE_PASSWORD_PGMETACRYPTO}

      - LOGFLARE_API_KEY=${SERVICE_PASSWORD_LOGFLARE}
      - LOGFLARE_PUBLIC_ACCESS_TOKEN=${SERVICE_PASSWORD_LOGFLARE}
      - LOGFLARE_PRIVATE_ACCESS_TOKEN=${SERVICE_PASSWORD_LOGFLAREPRIVATE}
      - LOGFLARE_URL=http://supabase-analytics:4000
      # Next.js client-side environment variables (required for browser access)
      - 'NEXT_PUBLIC_SUPABASE_URL=${SERVICE_URL_SUPABASEKONG}'
      - NEXT_PUBLIC_SUPABASE_ANON_KEY=${SERVICE_SUPABASEANON_KEY}
      - NEXT_PUBLIC_ENABLE_LOGS=true
      # Comment to use Big Query backend for analytics
      - NEXT_ANALYTICS_BACKEND_PROVIDER=postgres
      # Uncomment to use Big Query backend for analytics
      # NEXT_ANALYTICS_BACKEND_PROVIDER=bigquery
      - 'OPENAI_API_KEY=${OPENAI_API_KEY}'
      - SNIPPETS_MANAGEMENT_FOLDER=/app/snippets
      - EDGE_FUNCTIONS_MANAGEMENT_FOLDER=/app/edge-functions
    volumes:
      - ./volumes/snippets:/app/snippets
      - ./volumes/functions:/app/edge-functions
  supabase-db:
    image: supabase/postgres:15.8.1.085
    healthcheck:
      test: pg_isready -U postgres -h 127.0.0.1
      interval: 5s
      timeout: 5s
      retries: 10
    depends_on:
      supabase-vector:
        condition: service_healthy
    command:
      - postgres
      - -c
      - config_file=/etc/postgresql/postgresql.conf
      - -c
      - log_min_messages=fatal
    environment:
      - POSTGRES_HOST=/var/run/postgresql
      - PGPORT=${POSTGRES_PORT:-5432}
      - POSTGRES_PORT=${POSTGRES_PORT:-5432}
      - PGPASSWORD=${SERVICE_PASSWORD_POSTGRES}
      - POSTGRES_PASSWORD=${SERVICE_PASSWORD_POSTGRES}
      - PGDATABASE=${POSTGRES_DB:-postgres}
      - POSTGRES_DB=${POSTGRES_DB:-postgres}
      - JWT_SECRET=${SERVICE_PASSWORD_JWT}
      - JWT_EXP=${JWT_EXPIRY:-3600}
    volumes:
      - supabase-db-data:/var/lib/postgresql/data
      - type: bind
        source: ./volumes/db/realtime.sql
        target: /docker-entrypoint-initdb.d/migrations/99-realtime.sql
        content: |
          \set pguser `echo "$POSTGRES_USER"`

          create schema if not exists _realtime;
          alter schema _realtime owner to :pguser;
      - type: bind
        source: ./volumes/db/_supabase.sql
        target: /docker-entrypoint-initdb.d/migrations/97-_supabase.sql
        content: |
          \set pguser `echo "$POSTGRES_USER"`

          CREATE DATABASE _supabase WITH OWNER :pguser;
      - type: bind
        source: ./volumes/db/pooler.sql
        target: /docker-entrypoint-initdb.d/migrations/99-pooler.sql
        content: |
          \set pguser `echo "$POSTGRES_USER"`
          \c _supabase
          create schema if not exists _supavisor;
          alter schema _supavisor owner to :pguser;
          \c postgres
      - type: bind
        source: ./volumes/db/webhooks.sql
        target: /docker-entrypoint-initdb.d/init-scripts/98-webhooks.sql
        content: |
          BEGIN;
          -- Create pg_net extension
          CREATE EXTENSION IF NOT EXISTS pg_net SCHEMA extensions;
          -- Create supabase_functions schema
          CREATE SCHEMA supabase_functions AUTHORIZATION supabase_admin;
          GRANT USAGE ON SCHEMA supabase_functions TO postgres, anon, authenticated, service_role;
          ALTER DEFAULT PRIVILEGES IN SCHEMA supabase_functions GRANT ALL ON TABLES TO postgres, anon, authenticated, service_role;
          ALTER DEFAULT PRIVILEGES IN SCHEMA supabase_functions GRANT ALL ON FUNCTIONS TO postgres, anon, authenticated, service_role;
          ALTER DEFAULT PRIVILEGES IN SCHEMA supabase_functions GRANT ALL ON SEQUENCES TO postgres, anon, authenticated, service_role;
          -- supabase_functions.migrations definition
          CREATE TABLE supabase_functions.migrations (
            version text PRIMARY KEY,
            inserted_at timestamptz NOT NULL DEFAULT NOW()
          );
          -- Initial supabase_functions migration
          INSERT INTO supabase_functions.migrations (version) VALUES ('initial');
          -- supabase_functions.hooks definition
          CREATE TABLE supabase_functions.hooks (
            id bigserial PRIMARY KEY,
            hook_table_id integer NOT NULL,
            hook_name text NOT NULL,
            created_at timestamptz NOT NULL DEFAULT NOW(),
            request_id bigint
          );
          CREATE INDEX supabase_functions_hooks_request_id_idx ON supabase_functions.hooks USING btree (request_id);
          CREATE INDEX supabase_functions_hooks_h_table_id_h_name_idx ON supabase_functions.hooks USING btree (hook_table_id, hook_name);
          COMMENT ON TABLE supabase_functions.hooks IS 'Supabase Functions Hooks: Audit trail for triggered hooks.';
          CREATE FUNCTION supabase_functions.http_request()
            RETURNS trigger
            LANGUAGE plpgsql
            AS $function$
            DECLARE
              request_id bigint;
              payload jsonb;
              url text := TG_ARGV[0]::text;
              method text := TG_ARGV[1]::text;
              headers jsonb DEFAULT '{}'::jsonb;
              params jsonb DEFAULT '{}'::jsonb;
              timeout_ms integer DEFAULT 1000;
            BEGIN
              IF url IS NULL OR url = 'null' THEN
                RAISE EXCEPTION 'url argument is missing';
              END IF;

              IF method IS NULL OR method = 'null' THEN
                RAISE EXCEPTION 'method argument is missing';
              END IF;

              IF TG_ARGV[2] IS NULL OR TG_ARGV[2] = 'null' THEN
                headers = '{"Content-Type": "application/json"}'::jsonb;
              ELSE
                headers = TG_ARGV[2]::jsonb;
              END IF;

              IF TG_ARGV[3] IS NULL OR TG_ARGV[3] = 'null' THEN
                params = '{}'::jsonb;
              ELSE
                params = TG_ARGV[3]::jsonb;
              END IF;

              IF TG_ARGV[4] IS NULL OR TG_ARGV[4] = 'null' THEN
                timeout_ms = 1000;
              ELSE
                timeout_ms = TG_ARGV[4]::integer;
              END IF;

              CASE
                WHEN method = 'GET' THEN
                  SELECT http_get INTO request_id FROM net.http_get(
                    url,
                    params,
                    headers,
                    timeout_ms
                  );
                WHEN method = 'POST' THEN
                  payload = jsonb_build_object(
                    'old_record', OLD,
                    'record', NEW,
                    'type', TG_OP,
                    'table', TG_TABLE_NAME,
                    'schema', TG_TABLE_SCHEMA
                  );

                  SELECT http_post INTO request_id FROM net.http_post(
                    url,
                    payload,
                    params,
                    headers,
                    timeout_ms
                  );
                ELSE
                  RAISE EXCEPTION 'method argument % is invalid', method;
              END CASE;

              INSERT INTO supabase_functions.hooks
                (hook_table_id, hook_name, request_id)
              VALUES
                (TG_RELID, TG_NAME, request_id);

              RETURN NEW;
            END
          $function$;
          -- Supabase super admin
          DO
          $$
          BEGIN
            IF NOT EXISTS (
              SELECT 1
              FROM pg_roles
              WHERE rolname = 'supabase_functions_admin'
            )
            THEN
              CREATE USER supabase_functions_admin NOINHERIT CREATEROLE LOGIN NOREPLICATION;
            END IF;
          END
          $$;
          GRANT ALL PRIVILEGES ON SCHEMA supabase_functions TO supabase_functions_admin;
          GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA supabase_functions TO supabase_functions_admin;
          GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA supabase_functions TO supabase_functions_admin;
          ALTER USER supabase_functions_admin SET search_path = "supabase_functions";
          ALTER table "supabase_functions".migrations OWNER TO supabase_functions_admin;
          ALTER table "supabase_functions".hooks OWNER TO supabase_functions_admin;
          ALTER function "supabase_functions".http_request() OWNER TO supabase_functions_admin;
          GRANT supabase_functions_admin TO postgres;
          -- Remove unused supabase_pg_net_admin role
          DO
          $$
          BEGIN
            IF EXISTS (
              SELECT 1
              FROM pg_roles
              WHERE rolname = 'supabase_pg_net_admin'
            )
            THEN
              REASSIGN OWNED BY supabase_pg_net_admin TO supabase_admin;
              DROP OWNED BY supabase_pg_net_admin;
              DROP ROLE supabase_pg_net_admin;
            END IF;
          END
          $$;
          -- pg_net grants when extension is already enabled
          DO
          $$
          BEGIN
            IF EXISTS (
              SELECT 1
              FROM pg_extension
              WHERE extname = 'pg_net'
            )
            THEN
              GRANT USAGE ON SCHEMA net TO supabase_functions_admin, postgres, anon, authenticated, service_role;
              ALTER function net.http_get(url text, params jsonb, headers jsonb, timeout_milliseconds integer) SECURITY DEFINER;
              ALTER function net.http_post(url text, body jsonb, params jsonb, headers jsonb, timeout_milliseconds integer) SECURITY DEFINER;
              ALTER function net.http_get(url text, params jsonb, headers jsonb, timeout_milliseconds integer) SET search_path = net;
              ALTER function net.http_post(url text, body jsonb, params jsonb, headers jsonb, timeout_milliseconds integer) SET search_path = net;
              REVOKE ALL ON FUNCTION net.http_get(url text, params jsonb, headers jsonb, timeout_milliseconds integer) FROM PUBLIC;
              REVOKE ALL ON FUNCTION net.http_post(url text, body jsonb, params jsonb, headers jsonb, timeout_milliseconds integer) FROM PUBLIC;
              GRANT EXECUTE ON FUNCTION net.http_get(url text, params jsonb, headers jsonb, timeout_milliseconds integer) TO supabase_functions_admin, postgres, anon, authenticated, service_role;
              GRANT EXECUTE ON FUNCTION net.http_post(url text, body jsonb, params jsonb, headers jsonb, timeout_milliseconds integer) TO supabase_functions_admin, postgres, anon, authenticated, service_role;
            END IF;
          END
          $$;
          -- Event trigger for pg_net
          CREATE OR REPLACE FUNCTION extensions.grant_pg_net_access()
          RETURNS event_trigger
          LANGUAGE plpgsql
          AS $$
          BEGIN
            IF EXISTS (
              SELECT 1
              FROM pg_event_trigger_ddl_commands() AS ev
              JOIN pg_extension AS ext
              ON ev.objid = ext.oid
              WHERE ext.extname = 'pg_net'
            )
            THEN
              GRANT USAGE ON SCHEMA net TO supabase_functions_admin, postgres, anon, authenticated, service_role;
              ALTER function net.http_get(url text, params jsonb, headers jsonb, timeout_milliseconds integer) SECURITY DEFINER;
              ALTER function net.http_post(url text, body jsonb, params jsonb, headers jsonb, timeout_milliseconds integer) SECURITY DEFINER;
              ALTER function net.http_get(url text, params jsonb, headers jsonb, timeout_milliseconds integer) SET search_path = net;
              ALTER function net.http_post(url text, body jsonb, params jsonb, headers jsonb, timeout_milliseconds integer) SET search_path = net;
              REVOKE ALL ON FUNCTION net.http_get(url text, params jsonb, headers jsonb, timeout_milliseconds integer) FROM PUBLIC;
              REVOKE ALL ON FUNCTION net.http_post(url text, body jsonb, params jsonb, headers jsonb, timeout_milliseconds integer) FROM PUBLIC;
              GRANT EXECUTE ON FUNCTION net.http_get(url text, params jsonb, headers jsonb, timeout_milliseconds integer) TO supabase_functions_admin, postgres, anon, authenticated, service_role;
              GRANT EXECUTE ON FUNCTION net.http_post(url text, body jsonb, params jsonb, headers jsonb, timeout_milliseconds integer) TO supabase_functions_admin, postgres, anon, authenticated, service_role;
            END IF;
          END;
          $$;
          COMMENT ON FUNCTION extensions.grant_pg_net_access IS 'Grants access to pg_net';
          DO
          $$
          BEGIN
            IF NOT EXISTS (
              SELECT 1
              FROM pg_event_trigger
              WHERE evtname = 'issue_pg_net_access'
            ) THEN
              CREATE EVENT TRIGGER issue_pg_net_access ON ddl_command_end WHEN TAG IN ('CREATE EXTENSION')
              EXECUTE PROCEDURE extensions.grant_pg_net_access();
            END IF;
          END
          $$;
          INSERT INTO supabase_functions.migrations (version) VALUES ('20210809183423_update_grants');
          ALTER function supabase_functions.http_request() SECURITY DEFINER;
          ALTER function supabase_functions.http_request() SET search_path = supabase_functions;
          REVOKE ALL ON FUNCTION supabase_functions.http_request() FROM PUBLIC;
          GRANT EXECUTE ON FUNCTION supabase_functions.http_request() TO postgres, anon, authenticated, service_role;
          COMMIT;
      - type: bind
        source: ./volumes/db/roles.sql
        target: /docker-entrypoint-initdb.d/init-scripts/99-roles.sql
        content: |
          -- NOTE: change to your own passwords for production environments
           \set pgpass `echo "$POSTGRES_PASSWORD"`

           ALTER USER authenticator WITH PASSWORD :'pgpass';
           ALTER USER pgbouncer WITH PASSWORD :'pgpass';
           ALTER USER supabase_auth_admin WITH PASSWORD :'pgpass';
           ALTER USER supabase_functions_admin WITH PASSWORD :'pgpass';
           ALTER USER supabase_storage_admin WITH PASSWORD :'pgpass';
      - type: bind
        source: ./volumes/db/jwt.sql
        target: /docker-entrypoint-initdb.d/init-scripts/99-jwt.sql
        content: |
          \set jwt_secret `echo "$JWT_SECRET"`
          \set jwt_exp `echo "$JWT_EXP"`
          \set db_name `echo "${POSTGRES_DB:-postgres}"`

          ALTER DATABASE :db_name SET "app.settings.jwt_secret" TO :'jwt_secret';
          ALTER DATABASE :db_name SET "app.settings.jwt_exp" TO :'jwt_exp';

      - type: bind
        source: ./volumes/db/logs.sql
        target: /docker-entrypoint-initdb.d/migrations/99-logs.sql
        content: |
          \set pguser `echo "$POSTGRES_USER"`
          \c _supabase
          create schema if not exists _analytics;
          alter schema _analytics owner to :pguser;
          \c postgres
      # Use named volume to persist pgsodium decryption key between restarts
      - supabase-db-config:/etc/postgresql-custom

  supabase-analytics:
    image: supabase/logflare:1.31.2
    healthcheck:
      test: ["CMD", "curl", "http://127.0.0.1:4000/health"]
      timeout: 5s
      interval: 5s
      retries: 10
    depends_on:
      supabase-db:
        condition: service_healthy
    # volumes:
    #   - type: bind
    #     source: ./volumes/gcloud.json
    #     target: /opt/app/rel/logflare/bin/gcloud.json
    #     read_only: true
    environment:
      - LOGFLARE_NODE_HOST=127.0.0.1
      - DB_USERNAME=supabase_admin
      - DB_DATABASE=_supabase
      - DB_HOSTNAME=${POSTGRES_HOSTNAME:-supabase-db}
      - DB_PORT=${POSTGRES_PORT:-5432}
      - DB_PASSWORD=${SERVICE_PASSWORD_POSTGRES}
      - DB_SCHEMA=_analytics
      - LOGFLARE_PUBLIC_ACCESS_TOKEN=${SERVICE_PASSWORD_LOGFLARE}
      - LOGFLARE_PRIVATE_ACCESS_TOKEN=${SERVICE_PASSWORD_LOGFLAREPRIVATE}
      - LOGFLARE_SINGLE_TENANT=true
      - LOGFLARE_SUPABASE_MODE=true

      # Comment variables to use Big Query backend for analytics
      - POSTGRES_BACKEND_URL=postgresql://supabase_admin:${SERVICE_PASSWORD_POSTGRES}@${POSTGRES_HOSTNAME:-supabase-db}:${POSTGRES_PORT:-5432}/_supabase
      - POSTGRES_BACKEND_SCHEMA=_analytics
      - LOGFLARE_FEATURE_FLAG_OVERRIDE=multibackend=true

      # Uncomment to use Big Query backend for analytics
      # GOOGLE_PROJECT_ID=${GOOGLE_PROJECT_ID}
      # GOOGLE_PROJECT_NUMBER=${GOOGLE_PROJECT_NUMBER}
  supabase-vector:
    image: timberio/vector:0.53.0-alpine
    healthcheck:
      test:
        [
          "CMD",
          "wget",
          "--no-verbose",
          "--tries=1",
          "--spider",
          "http://supabase-vector:9001/health",
        ]
      timeout: 5s
      interval: 5s
      retries: 3
    volumes:
      - type: bind
        source: ./volumes/logs/vector.yml
        target: /etc/vector/vector.yml
        read_only: true
        content: |
          api:
            enabled: true
            address: 0.0.0.0:9001

          sources:
            docker_host:
              type: docker_logs
              exclude_containers:
                - supabase-vector

          transforms:
            project_logs:
              type: remap
              inputs:
                - docker_host
              source: |-
                .project = "default"
                .event_message = del(.message)
                .appname = del(.container_name)
                del(.container_created_at)
                del(.container_id)
                del(.source_type)
                del(.stream)
                del(.label)
                del(.image)
                del(.host)
                del(.stream)
            router:
              type: route
              inputs:
                - project_logs
              route:
                kong: 'contains(string!(.appname), "supabase-kong")'
                auth: 'contains(string!(.appname), "supabase-auth")'
                rest: 'contains(string!(.appname), "supabase-rest")'
                realtime: 'contains(string!(.appname), "realtime-dev")'
                storage: 'contains(string!(.appname), "supabase-storage")'
                functions: 'contains(string!(.appname), "supabase-edge-functions")'
                db: 'contains(string!(.appname), "supabase-db")'
            # Ignores non nginx errors since they are related with kong booting up
            kong_logs:
              type: remap
              inputs:
                - router.kong
              source: |-
                req, err = parse_nginx_log(.event_message, "combined")
                if err == null {
                    .timestamp = req.timestamp
                    .metadata.request.headers.referer = req.referer
                    .metadata.request.headers.user_agent = req.agent
                    .metadata.request.headers.cf_connecting_ip = req.client
                    .metadata.response.status_code = req.status
                    url, split_err = split(req.request, " ")
                    if split_err == null {
                        .metadata.request.method = url[0]
                        .metadata.request.path = url[1]
                        .metadata.request.protocol = url[2]
                    }
                }
                if err != null {
                  abort
                }
            # Ignores non nginx errors since they are related with kong booting up
            kong_err:
              type: remap
              inputs:
                - router.kong
              source: |-
                .metadata.request.method = "GET"
                .metadata.response.status_code = 200
                parsed, err = parse_nginx_log(.event_message, "error")
                if err == null {
                    .timestamp = parsed.timestamp
                    .severity = parsed.severity
                    .metadata.request.host = parsed.host
                    .metadata.request.headers.cf_connecting_ip = parsed.client
                    url, err = split(parsed.request, " ")
                    if err == null {
                        .metadata.request.method = url[0]
                        .metadata.request.path = url[1]
                        .metadata.request.protocol = url[2]
                    }
                }
                if err != null {
                  abort
                }
            # Gotrue logs are structured json strings which frontend parses directly. But we keep metadata for consistency.
            auth_logs:
              type: remap
              inputs:
                - router.auth
              source: |-
                parsed, err = parse_json(.event_message)
                if err == null {
                    .metadata.timestamp = parsed.time
                    .metadata = merge!(.metadata, parsed)
                }
            # PostgREST logs are structured so we separate timestamp from message using regex
            rest_logs:
              type: remap
              inputs:
                - router.rest
              source: |-
                parsed, err = parse_regex(.event_message, r'^(?P<time>.*): (?P<msg>.*)$')
                if err == null {
                    .event_message = parsed.msg
                    .timestamp = parse_timestamp!(value: parsed.time, format: "%d/%b/%Y:%H:%M:%S %z")
                    .metadata.host = .project
                }
            # Filter out healthcheck logs from Realtime
            realtime_logs_filtered:
              type: filter
              inputs:
                - router.realtime
              condition: '!contains(string!(.event_message), "/health")'
            # Realtime logs are structured so we parse the severity level using regex (ignore time because it has no date)
            realtime_logs:
              type: remap
              inputs:
                - realtime_logs_filtered
              source: |-
                .metadata.project = del(.project)
                .metadata.external_id = .metadata.project
                parsed, err = parse_regex(.event_message, r'^(?P<time>\d+:\d+:\d+\.\d+) \[(?P<level>\w+)\] (?P<msg>.*)$')
                if err == null {
                    .event_message = parsed.msg
                    .metadata.level = parsed.level
                }
            # Storage logs may contain json objects so we parse them for completeness
            storage_logs:
              type: remap
              inputs:
                - router.storage
              source: |-
                .metadata.project = del(.project)
                .metadata.tenantId = .metadata.project
                parsed, err = parse_json(.event_message)
                if err == null {
                    .event_message = parsed.msg
                    .metadata.level = parsed.level
                    .metadata.timestamp = parsed.time
                    .metadata.context[0].host = parsed.hostname
                    .metadata.context[0].pid = parsed.pid
                }
            # Function logs are unstructured messages on stderr
            functions_logs:
              type: remap
              inputs:
                - router.functions
              source: |-
                .metadata.project_ref = del(.project)
            # Postgres logs some messages to stderr which we map to warning severity level
            db_logs:
              type: remap
              inputs:
                - router.db
              source: |-
                .metadata.host = "db-default"
                .metadata.parsed.timestamp = .timestamp

                parsed, err = parse_regex(.event_message, r'.*(?P<level>INFO|NOTICE|WARNING|ERROR|LOG|FATAL|PANIC?):.*', numeric_groups: true)

                if err != null || parsed == null {
                  .metadata.parsed.error_severity = "info"
                }
                if parsed.level != null {
                 .metadata.parsed.error_severity = parsed.level
                }
                if .metadata.parsed.error_severity == "info" {
                    .metadata.parsed.error_severity = "log"
                }
                .metadata.parsed.error_severity = upcase!(.metadata.parsed.error_severity)

          sinks:
            logflare_auth:
              type: 'http'
              inputs:
                - auth_logs
              encoding:
                codec: 'json'
              method: 'post'
              request:
                retry_max_duration_secs: 30
                retry_initial_backoff_secs: 1
                headers:
                  x-api-key: '${LOGFLARE_PUBLIC_ACCESS_TOKEN?LOGFLARE_PUBLIC_ACCESS_TOKEN is required}'
              uri: 'http://supabase-analytics:4000/api/logs?source_name=gotrue.logs.prod'
            logflare_realtime:
              type: 'http'
              inputs:
                - realtime_logs
              encoding:
                codec: 'json'
              method: 'post'
              request:
                retry_max_duration_secs: 30
                retry_initial_backoff_secs: 1
                headers:
                  x-api-key: '${LOGFLARE_PUBLIC_ACCESS_TOKEN?LOGFLARE_PUBLIC_ACCESS_TOKEN is required}'
              uri: 'http://supabase-analytics:4000/api/logs?source_name=realtime.logs.prod'
            logflare_rest:
              type: 'http'
              inputs:
                - rest_logs
              encoding:
                codec: 'json'
              method: 'post'
              request:
                retry_max_duration_secs: 30
                retry_initial_backoff_secs: 1
                headers:
                  x-api-key: '${LOGFLARE_PUBLIC_ACCESS_TOKEN?LOGFLARE_PUBLIC_ACCESS_TOKEN is required}'
              uri: 'http://supabase-analytics:4000/api/logs?source_name=postgREST.logs.prod'
            logflare_db:
              type: 'http'
              inputs:
                - db_logs
              encoding:
                codec: 'json'
              method: 'post'
              request:
                retry_max_duration_secs: 30
                retry_initial_backoff_secs: 1
                headers:
                  x-api-key: '${LOGFLARE_PUBLIC_ACCESS_TOKEN?LOGFLARE_PUBLIC_ACCESS_TOKEN is required}'
              uri: 'http://supabase-analytics:4000/api/logs?source_name=postgres.logs'
            logflare_functions:
              type: 'http'
              inputs:
                - functions_logs
              encoding:
                codec: 'json'
              method: 'post'
              request:
                retry_max_duration_secs: 30
                retry_initial_backoff_secs: 1
                headers:
                  x-api-key: '${LOGFLARE_PUBLIC_ACCESS_TOKEN?LOGFLARE_PUBLIC_ACCESS_TOKEN is required}'
              uri: 'http://supabase-analytics:4000/api/logs?source_name=deno-relay-logs'
            logflare_storage:
              type: 'http'
              inputs:
                - storage_logs
              encoding:
                codec: 'json'
              method: 'post'
              request:
                retry_max_duration_secs: 30
                retry_initial_backoff_secs: 1
                headers:
                  x-api-key: '${LOGFLARE_PUBLIC_ACCESS_TOKEN?LOGFLARE_PUBLIC_ACCESS_TOKEN is required}'
              uri: 'http://supabase-analytics:4000/api/logs?source_name=storage.logs.prod.2'
            logflare_kong:
              type: 'http'
              inputs:
                - kong_logs
                - kong_err
              encoding:
                codec: 'json'
              method: 'post'
              request:
                retry_max_duration_secs: 30
                retry_initial_backoff_secs: 1
                headers:
                  x-api-key: '${LOGFLARE_PUBLIC_ACCESS_TOKEN?LOGFLARE_PUBLIC_ACCESS_TOKEN is required}'
              uri: 'http://supabase-analytics:4000/api/logs?source_name=cloudflare.logs.prod'

      - /var/run/docker.sock:/var/run/docker.sock:ro
    environment:
      - LOGFLARE_PUBLIC_ACCESS_TOKEN=${SERVICE_PASSWORD_LOGFLARE}
    command: ["--config", "/etc/vector/vector.yml"]

  supabase-rest:
    image: postgrest/postgrest:v14.6
    depends_on:
      supabase-db:
        # Disable this if you are using an external Postgres database
        condition: service_healthy
      supabase-analytics:
        condition: service_healthy
    environment:
      - PGRST_DB_URI=postgres://authenticator:${SERVICE_PASSWORD_POSTGRES}@${POSTGRES_HOSTNAME:-supabase-db}:${POSTGRES_PORT:-5432}/${POSTGRES_DB:-postgres}
      - 'PGRST_DB_SCHEMAS=${PGRST_DB_SCHEMAS:-public,storage,graphql_public}'
      - PGRST_DB_MAX_ROWS=${PGRST_DB_MAX_ROWS:-1000}
      - PGRST_DB_EXTRA_SEARCH_PATH=${PGRST_DB_EXTRA_SEARCH_PATH:-public}
      - PGRST_DB_ANON_ROLE=anon
      - PGRST_JWT_SECRET=${SERVICE_PASSWORD_JWT}
      - PGRST_DB_USE_LEGACY_GUCS=false
      - PGRST_APP_SETTINGS_JWT_SECRET=${SERVICE_PASSWORD_JWT}
      - PGRST_APP_SETTINGS_JWT_EXP=${JWT_EXPIRY:-3600}
    command: "postgrest"
    exclude_from_hc: true
  supabase-auth:
    image: supabase/gotrue:v2.186.0
    depends_on:
      supabase-db:
        # Disable this if you are using an external Postgres database
        condition: service_healthy
      supabase-analytics:
        condition: service_healthy
    healthcheck:
      test:
        [
          "CMD",
          "wget",
          "--no-verbose",
          "--tries=1",
          "--spider",
          "http://127.0.0.1:9999/health",
        ]
      timeout: 5s
      interval: 5s
      retries: 3
    environment:
      - GOTRUE_API_HOST=0.0.0.0
      - GOTRUE_API_PORT=9999
      - API_EXTERNAL_URL=${API_EXTERNAL_URL:-http://supabase-kong:8000}

      - GOTRUE_DB_DRIVER=postgres
      - GOTRUE_DB_DATABASE_URL=postgres://supabase_auth_admin:${SERVICE_PASSWORD_POSTGRES}@${POSTGRES_HOSTNAME:-supabase-db}:${POSTGRES_PORT:-5432}/${POSTGRES_DB:-postgres}
      # The base URL your site is located at. Currently used in combination with other settings to construct URLs used in emails.
      - GOTRUE_SITE_URL=${GOTRUE_SITE_URL:-${SERVICE_URL_SUPABASEKONG}}
      # A comma separated list of URIs (e.g. "https://foo.example.com,https://*.foo.example.com,https://bar.example.com") which are permitted as valid redirect_to destinations.
      - GOTRUE_URI_ALLOW_LIST=${ADDITIONAL_REDIRECT_URLS}
      - GOTRUE_DISABLE_SIGNUP=${DISABLE_SIGNUP:-false}

      - GOTRUE_JWT_ADMIN_ROLES=service_role
      - GOTRUE_JWT_AUD=authenticated
      - GOTRUE_JWT_DEFAULT_GROUP_NAME=authenticated
      - GOTRUE_JWT_EXP=${JWT_EXPIRY:-3600}
      - GOTRUE_JWT_SECRET=${SERVICE_PASSWORD_JWT}

      - GOTRUE_EXTERNAL_EMAIL_ENABLED=${ENABLE_EMAIL_SIGNUP:-true}
      - GOTRUE_EXTERNAL_ANONYMOUS_USERS_ENABLED=${ENABLE_ANONYMOUS_USERS:-false}
      - GOTRUE_MAILER_AUTOCONFIRM=${ENABLE_EMAIL_AUTOCONFIRM:-false}
      # GOTRUE_MAILER_SECURE_EMAIL_CHANGE_ENABLED=true
      # GOTRUE_SMTP_MAX_FREQUENCY=1s
      - GOTRUE_SMTP_ADMIN_EMAIL=${SMTP_ADMIN_EMAIL}
      - GOTRUE_SMTP_HOST=${SMTP_HOST}
      - GOTRUE_SMTP_PORT=${SMTP_PORT:-587}
      - GOTRUE_SMTP_USER=${SMTP_USER}
      - GOTRUE_SMTP_PASS=${SMTP_PASS}
      - GOTRUE_SMTP_SENDER_NAME=${SMTP_SENDER_NAME}
      - GOTRUE_MAILER_URLPATHS_INVITE=${MAILER_URLPATHS_INVITE:-/auth/v1/verify}
      - GOTRUE_MAILER_URLPATHS_CONFIRMATION=${MAILER_URLPATHS_CONFIRMATION:-/auth/v1/verify}
      - GOTRUE_MAILER_URLPATHS_RECOVERY=${MAILER_URLPATHS_RECOVERY:-/auth/v1/verify}
      - GOTRUE_MAILER_URLPATHS_EMAIL_CHANGE=${MAILER_URLPATHS_EMAIL_CHANGE:-/auth/v1/verify}
      - GOTRUE_MAILER_TEMPLATES_INVITE=${MAILER_TEMPLATES_INVITE}
      - GOTRUE_MAILER_TEMPLATES_CONFIRMATION=${MAILER_TEMPLATES_CONFIRMATION}
      - GOTRUE_MAILER_TEMPLATES_RECOVERY=${MAILER_TEMPLATES_RECOVERY}
      - GOTRUE_MAILER_TEMPLATES_MAGIC_LINK=${MAILER_TEMPLATES_MAGIC_LINK}
      - GOTRUE_MAILER_TEMPLATES_EMAIL_CHANGE=${MAILER_TEMPLATES_EMAIL_CHANGE}

      - GOTRUE_MAILER_SUBJECTS_CONFIRMATION=${MAILER_SUBJECTS_CONFIRMATION}
      - GOTRUE_MAILER_SUBJECTS_RECOVERY=${MAILER_SUBJECTS_RECOVERY}
      - GOTRUE_MAILER_SUBJECTS_MAGIC_LINK=${MAILER_SUBJECTS_MAGIC_LINK}
      - GOTRUE_MAILER_SUBJECTS_EMAIL_CHANGE=${MAILER_SUBJECTS_EMAIL_CHANGE}
      - GOTRUE_MAILER_SUBJECTS_INVITE=${MAILER_SUBJECTS_INVITE}

      - GOTRUE_EXTERNAL_PHONE_ENABLED=${ENABLE_PHONE_SIGNUP:-true}
      - GOTRUE_SMS_AUTOCONFIRM=${ENABLE_PHONE_AUTOCONFIRM:-true}
      # Uncomment to enable custom access token hook. You'll need to create a public.custom_access_token_hook function and grant necessary permissions.
      # See: https://supabase.com/docs/guides/auth/auth-hooks#hook-custom-access-token for details
      # GOTRUE_HOOK_CUSTOM_ACCESS_TOKEN_ENABLED="true"
      # GOTRUE_HOOK_CUSTOM_ACCESS_TOKEN_URI="pg-functions://postgres/public/custom_access_token_hook"

      # GOTRUE_HOOK_MFA_VERIFICATION_ATTEMPT_ENABLED="true"
      # GOTRUE_HOOK_MFA_VERIFICATION_ATTEMPT_URI="pg-functions://postgres/public/mfa_verification_attempt"

      # GOTRUE_HOOK_PASSWORD_VERIFICATION_ATTEMPT_ENABLED="true"
      # GOTRUE_HOOK_PASSWORD_VERIFICATION_ATTEMPT_URI="pg-functions://postgres/public/password_verification_attempt"

      # Uncomment to enable common OAuth Variables
      #- 'GOTRUE_EXTERNAL_GITHUB_CLIENT_ID=${GOTRUE_EXTERNAL_GITHUB_CLIENT_ID}'
      #- 'GOTRUE_EXTERNAL_GITHUB_ENABLED=${GOTRUE_EXTERNAL_GITHUB_ENABLED}'
      #- 'GOTRUE_EXTERNAL_GITHUB_REDIRECT_URI=${GOTRUE_EXTERNAL_GITHUB_REDIRECT_URI}'
      #- 'GOTRUE_EXTERNAL_GITHUB_SECRET=${GOTRUE_EXTERNAL_GITHUB_SECRET}'
      #- 'GOTRUE_EXTERNAL_GOOGLE_CLIENT_ID=${GOTRUE_EXTERNAL_GOOGLE_CLIENT_ID}'
      #- 'GOTRUE_EXTERNAL_GOOGLE_ENABLED=${GOTRUE_EXTERNAL_GOOGLE_ENABLED}'
      #- 'GOTRUE_EXTERNAL_GOOGLE_REDIRECT_URI=${GOTRUE_EXTERNAL_GOOGLE_REDIRECT_URI}'
      #- 'GOTRUE_EXTERNAL_GOOGLE_SECRET=${GOTRUE_EXTERNAL_GOOGLE_SECRET}'

  realtime-dev:
    # This container name looks inconsistent but is correct because realtime constructs tenant id by parsing the subdomain
    image: supabase/realtime:v2.76.5
    container_name: realtime-dev.supabase-realtime
    depends_on:
      supabase-db:
        # Disable this if you are using an external Postgres database
        condition: service_healthy
      supabase-analytics:
        condition: service_healthy
    healthcheck:
      test:
        [
          "CMD",
          "curl",
          "-sSfL",
          "--head",
          "-o",
          "/dev/null",
          "-H",
          "Authorization: Bearer ${SERVICE_SUPABASEANON_KEY}",
          "http://127.0.0.1:4000/api/tenants/realtime-dev/health",
        ]
      timeout: 5s
      interval: 5s
      retries: 3
      start_period: 10s
    environment:
      - PORT=4000
      - DB_HOST=${POSTGRES_HOSTNAME:-supabase-db}
      - DB_PORT=${POSTGRES_PORT:-5432}
      - DB_USER=supabase_admin
      - DB_PASSWORD=${SERVICE_PASSWORD_POSTGRES}
      - DB_NAME=${POSTGRES_DB:-postgres}
      - DB_AFTER_CONNECT_QUERY=SET search_path TO _realtime
      - DB_ENC_KEY=supabaserealtime
      - API_JWT_SECRET=${SERVICE_PASSWORD_JWT}
      - SECRET_KEY_BASE=${SERVICE_PASSWORD_64_REALTIME}
      - METRICS_JWT_SECRET=${SERVICE_PASSWORD_JWT}
      - ERL_AFLAGS=-proto_dist inet_tcp
      - DNS_NODES=''
      - RLIMIT_NOFILE=10000
      - APP_NAME=realtime
      - SEED_SELF_HOST=true
      - LOG_LEVEL=error
      - RUN_JANITOR=true
      - JANITOR_INTERVAL=60000
      - DISABLE_HEALTHCHECK_LOGGING=true
    command: >
      sh -c "/app/bin/migrate && /app/bin/realtime eval 'Realtime.Release.seeds(Realtime.Repo)' && /app/bin/server"
  supabase-minio:
    image: pgsty/silo:RELEASE.2026-10-15T00-00-00Z # Released on 15 October 2026
    environment:
      - MINIO_ROOT_USER=${SERVICE_USER_MINIO}
      - MINIO_ROOT_PASSWORD=${SERVICE_PASSWORD_MINIO}
    command: server --console-address ":9001" /data
    healthcheck:
      test: ["CMD", "mc", "ready", "local"]
      interval: 5s
      timeout: 20s
      retries: 10
    volumes:
      - ./volumes/storage:/data

  minio-createbucket:
    image: pgsty/silo:RELEASE.2026-10-15T00-00-00Z
    restart: "no"
    environment:
      - MINIO_ROOT_USER=${SERVICE_USER_MINIO}
      - MINIO_ROOT_PASSWORD=${SERVICE_PASSWORD_MINIO}
    depends_on:
      supabase-minio:
        condition: service_healthy
    entrypoint: ["/entrypoint.sh"]
    volumes:
      - type: bind
        source: ./entrypoint.sh
        target: /entrypoint.sh
        content: |
          #!/bin/sh
          /usr/bin/mc alias set supabase-minio http://supabase-minio:9000 ${MINIO_ROOT_USER} ${MINIO_ROOT_PASSWORD};
          /usr/bin/mc mb --ignore-existing supabase-minio/stub;
          exit 0

  supabase-storage:
    image: supabase/storage-api:v1.44.2
    depends_on:
      supabase-db:
        # Disable this if you are using an external Postgres database
        condition: service_healthy
      supabase-rest:
        condition: service_started
      imgproxy:
        condition: service_started
    healthcheck:
      test:
        [
          "CMD",
          "wget",
          "--no-verbose",
          "--tries=1",
          "--spider",
          "http://127.0.0.1:5000/status",
        ]
      timeout: 5s
      interval: 5s
      retries: 3
    environment:
      - SERVER_PORT=5000
      - SERVER_REGION=local
      - MULTI_TENANT=false
      - AUTH_JWT_SECRET=${SERVICE_PASSWORD_JWT}
      - DATABASE_URL=postgres://supabase_storage_admin:${SERVICE_PASSWORD_POSTGRES}@${POSTGRES_HOSTNAME:-supabase-db}:${POSTGRES_PORT:-5432}/${POSTGRES_DB:-postgres}
      - DB_INSTALL_ROLES=false
      - STORAGE_BACKEND=s3
      - STORAGE_S3_BUCKET=stub
      - STORAGE_S3_ENDPOINT=http://supabase-minio:9000
      - STORAGE_S3_FORCE_PATH_STYLE=true
      - STORAGE_S3_REGION=us-east-1
      - AWS_ACCESS_KEY_ID=${SERVICE_USER_MINIO}
      - AWS_SECRET_ACCESS_KEY=${SERVICE_PASSWORD_MINIO}
      - UPLOAD_FILE_SIZE_LIMIT=524288000
      - UPLOAD_FILE_SIZE_LIMIT_STANDARD=524288000
      - UPLOAD_SIGNED_URL_EXPIRATION_TIME=120
      - TUS_URL_PATH=/upload/resumable
      - TUS_MAX_SIZE=3600000
      - ENABLE_IMAGE_TRANSFORMATION=true
      - IMGPROXY_URL=http://imgproxy:8080
      - IMGPROXY_REQUEST_TIMEOUT=15
      - DATABASE_SEARCH_PATH=storage
      - NODE_ENV=production
      - REQUEST_ALLOW_X_FORWARDED_PATH=true
      - ANON_KEY=${SERVICE_SUPABASEANON_KEY}
      - SERVICE_KEY=${SERVICE_SUPABASESERVICE_KEY}
      - POSTGREST_URL=http://supabase-rest:3000
      - PGRST_JWT_SECRET=${SERVICE_PASSWORD_JWT}
      - STORAGE_PUBLIC_URL=${SERVICE_URL_SUPABASEKONG}
      - TENANT_ID=${STORAGE_TENANT_ID:-storage-single-tenant}
    volumes:
      - ./volumes/storage:/var/lib/storage
  imgproxy:
    image: darthsim/imgproxy:v3.30.1
    healthcheck:
      test: ["CMD", "imgproxy", "health"]
      timeout: 5s
      interval: 5s
      retries: 3
    environment:
      - IMGPROXY_BIND=:8080
      - IMGPROXY_LOCAL_FILESYSTEM_ROOT=/
      - IMGPROXY_USE_ETAG=true
      - IMGPROXY_AUTO_WEBP=${IMGPROXY_AUTO_WEBP:-true}
      - IMGPROXY_MAX_SRC_RESOLUTION=16.8
    volumes:
      - ./volumes/storage:/var/lib/storage

  supabase-meta:
    image: supabase/postgres-meta:v0.95.2
    depends_on:
      supabase-db:
        # Disable this if you are using an external Postgres database
        condition: service_healthy
      supabase-analytics:
        condition: service_healthy
    environment:
      - PG_META_PORT=8080
      - PG_META_DB_HOST=${POSTGRES_HOSTNAME:-supabase-db}
      - PG_META_DB_PORT=${POSTGRES_PORT:-5432}
      - PG_META_DB_NAME=${POSTGRES_DB:-postgres}
      - PG_META_DB_USER=supabase_admin
      - PG_META_DB_PASSWORD=${SERVICE_PASSWORD_POSTGRES}
      - CRYPTO_KEY=${SERVICE_PASSWORD_PGMETACRYPTO}

  supabase-edge-functions:
    image: supabase/edge-runtime:v1.71.2
    depends_on:
      supabase-analytics:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "echo", "Edge Functions is healthy"]
      timeout: 5s
      interval: 5s
      retries: 3
    environment:
      - JWT_SECRET=${SERVICE_PASSWORD_JWT}
      - SUPABASE_URL=http://supabase-kong:8000
      - SUPABASE_PUBLIC_URL=${SERVICE_URL_SUPABASEKONG}
      - SUPABASE_ANON_KEY=${SERVICE_SUPABASEANON_KEY}
      - SUPABASE_SERVICE_ROLE_KEY=${SERVICE_SUPABASESERVICE_KEY}
      - SUPABASE_DB_URL=postgresql://postgres:${SERVICE_PASSWORD_POSTGRES}@${POSTGRES_HOSTNAME:-supabase-db}:${POSTGRES_PORT:-5432}/${POSTGRES_DB:-postgres}
      # TODO: Allow configuring VERIFY_JWT per function.
      - VERIFY_JWT=${FUNCTIONS_VERIFY_JWT:-false}
    volumes:
      - ./volumes/functions:/home/deno/functions
      - deno-cache:/root/.cache/deno
      - type: bind
        source: ./volumes/functions/main/index.ts
        target: /home/deno/functions/main/index.ts
        content: |
          import * as jose from 'https://deno.land/x/[email protected]/index.ts'

          console.log('main function started')

          const JWT_SECRET = Deno.env.get('JWT_SECRET')
          const SUPABASE_URL = Deno.env.get('SUPABASE_URL')
          const VERIFY_JWT = Deno.env.get('VERIFY_JWT') === 'true'

          // Create JWKS for ES256/RS256 tokens (newer tokens)
          let SUPABASE_JWT_KEYS: ReturnType<typeof jose.createRemoteJWKSet> | null = null
          if (SUPABASE_URL) {
            try {
              SUPABASE_JWT_KEYS = jose.createRemoteJWKSet(
                new URL('/auth/v1/.well-known/jwks.json', SUPABASE_URL)
              )
            } catch (e) {
              console.error('Failed to fetch JWKS from SUPABASE_URL:', e)
            }
          }

          function getAuthToken(req: Request) {
            const authHeader = req.headers.get('authorization')
            if (!authHeader) {
              throw new Error('Missing authorization header')
            }
            const [bearer, token] = authHeader.split(' ')
            if (bearer !== 'Bearer') {
              throw new Error(`Auth header is not 'Bearer {token}'`)
            }
            return token
          }

          async function isValidLegacyJWT(jwt: string): Promise<boolean> {
            if (!JWT_SECRET) {
              console.error('JWT_SECRET not available for HS256 token verification')
              return false
            }

            const encoder = new TextEncoder();
            const secretKey = encoder.encode(JWT_SECRET)

            try {
              await jose.jwtVerify(jwt, secretKey);
            } catch (e) {
              console.error('Symmetric Legacy JWT verification error', e);
              return false;
            }
            return true;
          }

          async function isValidJWT(jwt: string): Promise<boolean> {
            if (!SUPABASE_JWT_KEYS) {
              console.error('JWKS not available for ES256/RS256 token verification')
              return false
            }

            try {
              await jose.jwtVerify(jwt, SUPABASE_JWT_KEYS)
            } catch (e) {
              console.error('Asymmetric JWT verification error', e);
              return false
            }

            return true;
          }

          async function isValidHybridJWT(jwt: string): Promise<boolean> {
            const { alg: jwtAlgorithm } = jose.decodeProtectedHeader(jwt)

            if (jwtAlgorithm === 'HS256') {
              console.log(`Legacy token type detected, attempting ${jwtAlgorithm} verification.`)

              return await isValidLegacyJWT(jwt)
            }

            if (jwtAlgorithm === 'ES256' || jwtAlgorithm === 'RS256') {
              return await isValidJWT(jwt)
            }

            return false;
          }

          Deno.serve(async (req: Request) => {
            if (req.method !== 'OPTIONS' && VERIFY_JWT) {
              try {
                const token = getAuthToken(req)
                const isValidJWT = await isValidHybridJWT(token);

                if (!isValidJWT) {
                  return new Response(JSON.stringify({ msg: 'Invalid JWT' }), {
                    status: 401,
                    headers: { 'Content-Type': 'application/json' },
                  })
                }
              } catch (e) {
                console.error(e)
                return new Response(JSON.stringify({ msg: e.toString() }), {
                  status: 401,
                  headers: { 'Content-Type': 'application/json' },
                })
              }
            }

            const url = new URL(req.url)
            const { pathname } = url
            const path_parts = pathname.split('/')
            const service_name = path_parts[1]

            if (!service_name || service_name === '') {
              const error = { msg: 'missing function name in request' }
              return new Response(JSON.stringify(error), {
                status: 400,
                headers: { 'Content-Type': 'application/json' },
              })
            }

            const servicePath = `/home/deno/functions/${service_name}`
            console.error(`serving the request with ${servicePath}`)

            const memoryLimitMb = 150
            const workerTimeoutMs = 1 * 60 * 1000
            const noModuleCache = false
            const importMapPath = null
            const envVarsObj = Deno.env.toObject()
            const envVars = Object.keys(envVarsObj).map((k) => [k, envVarsObj[k]])

            try {
              const worker = await EdgeRuntime.userWorkers.create({
                servicePath,
                memoryLimitMb,
                workerTimeoutMs,
                noModuleCache,
                importMapPath,
                envVars,
              })
              return await worker.fetch(req)
            } catch (e) {
              const error = { msg: e.toString() }
              return new Response(JSON.stringify(error), {
                status: 500,
                headers: { 'Content-Type': 'application/json' },
              })
            }
          })
      - type: bind
        source: ./volumes/functions/hello/index.ts
        target: /home/deno/functions/hello/index.ts
        content: |
          // Follow this setup guide to integrate the Deno language server with your editor:
          // https://deno.land/manual/getting_started/setup_your_environment
          // This enables autocomplete, go to definition, etc.

          Deno.serve(async () => {
            return new Response(
              `"Hello from Edge Functions!"`,
              { headers: { "Content-Type": "application/json" } },
            )
          })

          // To invoke:
          // curl 'http://localhost:<KONG_HTTP_PORT>/functions/v1/hello' \
          //   --header 'Authorization: Bearer <anon/service_role API key>'

    command:
      - start
      - --main-service
      - /home/deno/functions/main

  supabase-supavisor:
    image: 'supabase/supavisor:2.7.4'
    healthcheck:
      test:
        - CMD
        - curl
        - "-sSfL"
        - "-o"
        - /dev/null
        - "http://127.0.0.1:4000/api/health"
      timeout: 5s
      interval: 5s
      retries: 10
      start_period: 30s
    depends_on:
      supabase-db:
        condition: service_healthy
      supabase-analytics:
        condition: service_healthy
    environment:
      - POOLER_TENANT_ID=${POOLER_TENANT_ID:-dev_tenant}
      - POOLER_POOL_MODE=transaction
      - POOLER_DEFAULT_POOL_SIZE=${POOLER_DEFAULT_POOL_SIZE:-20}
      - POOLER_MAX_CLIENT_CONN=${POOLER_MAX_CLIENT_CONN:-100}
      - PORT=4000
      - 'POSTGRES_PORT=${POSTGRES_PORT:-5432}'
      - 'POSTGRES_HOSTNAME=${POSTGRES_HOSTNAME:-supabase-db}'
      - 'POSTGRES_DB=${POSTGRES_DB:-postgres}'
      - 'POSTGRES_PASSWORD=${SERVICE_PASSWORD_POSTGRES}'
      - 'DATABASE_URL=ecto://supabase_admin:${SERVICE_PASSWORD_POSTGRES}@${POSTGRES_HOSTNAME:-supabase-db}:${POSTGRES_PORT:-5432}/_supabase'
      - CLUSTER_POSTGRES=true
      - 'SECRET_KEY_BASE=${SERVICE_PASSWORD_SUPAVISORSECRET}'
      - 'VAULT_ENC_KEY=${SERVICE_PASSWORD_VAULTENC}'
      - 'API_JWT_SECRET=${SERVICE_PASSWORD_JWT}'
      - 'METRICS_JWT_SECRET=${SERVICE_PASSWORD_JWT}'
      - REGION=local
      - 'ERL_AFLAGS=-proto_dist inet_tcp'
      - 'DB_POOL_SIZE=${POOLER_DB_POOL_SIZE:-5}'
      # TLS for downstream connections (fixes Supabase CLI TLS requirement)
      - GLOBAL_DOWNSTREAM_CERT_PATH=/etc/ssl/server.crt
      - GLOBAL_DOWNSTREAM_KEY_PATH=/etc/ssl/server.key
    command:
      - /bin/sh
      - "-c"
      - |
        if [ ! -f /etc/ssl/server.crt ]; then
          openssl req -x509 -nodes -days 3650 -newkey rsa:2048 \
            -keyout /etc/ssl/server.key -out /etc/ssl/server.crt \
            -subj "/CN=supabase-pooler"
        fi
        /app/bin/migrate && /app/bin/supavisor eval "$$(cat /etc/pooler/pooler.exs)" && /app/bin/server
    volumes:
      - type: bind
        source: ./volumes/pooler/pooler.exs
        target: /etc/pooler/pooler.exs
        content: |
          {:ok, _} = Application.ensure_all_started(:supavisor)
          {:ok, version} =
              case Supavisor.Repo.query!("select version()") do
              %{rows: [[ver]]} -> Supavisor.Helpers.parse_pg_version(ver)
              _ -> nil
              end
          params = %{
              "external_id" => System.get_env("POOLER_TENANT_ID"),
              "db_host" => System.get_env("POSTGRES_HOSTNAME"),
              "db_port" => System.get_env("POSTGRES_PORT") |> String.to_integer(),
              "db_database" => System.get_env("POSTGRES_DB"),
              "require_user" => false,
              "auth_query" => "SELECT * FROM pgbouncer.get_auth($1)",
              "default_max_clients" => System.get_env("POOLER_MAX_CLIENT_CONN"),
              "default_pool_size" => System.get_env("POOLER_DEFAULT_POOL_SIZE"),
              "default_parameter_status" => %{"server_version" => version},
              "users" => [%{
              "db_user" => "pgbouncer",
              "db_password" => System.get_env("POSTGRES_PASSWORD"),
              "mode_type" => System.get_env("POOLER_POOL_MODE"),
              "pool_size" => System.get_env("POOLER_DEFAULT_POOL_SIZE"),
              "is_manager" => true
              }]
          }

          tenant = Supavisor.Tenants.get_tenant_by_external_id(params["external_id"])

          if tenant do
            {:ok, _} = Supavisor.Tenants.update_tenant(tenant, params)
          else
            {:ok, _} = Supavisor.Tenants.create_tenant(params)
          end