const form = formidable({ multiples: true });
    const client = await serverSupabaseClient(event);

    const response = await new Promise((resolve, reject) => {
        form.parse(event.req, (err, fields, files) => {
            if (err) {
                reject(err);
            }
            resolve({ fields, files });
        });
    });
    const { fields, files } = response;

const fileName = encodeURIComponent(
        files.avatar.originalFilename.replace(/\s/g, '-')
    );

// upload the file to supabase storage
    const { data, error } = await client.storage
        .from('site')
        .upload('public/' + Date.now() + '-' + fileName, files.avatar);
    return data;

select

.select(
        `
        ${PROPS},
        ${DATABASE}!${FOREIGN_KEY.parent} (
          ${PROPS}
        ),
        ${vendorService.DATABASE}!${FOREIGN_KEY.vendor} (${vendorService.PROPS})

recipes

const {error, data} = await supabase.from('google_reviews').update({ name: 'Nepal' }).select().eq('id', 1)

sql
(
  (household_auth_for_heatpump(serial_number) AND has_permission(ARRAY['heatpumps.select.household'::text])) OR
  (team_auth_for_heatpump(serial_number) AND has_permission(ARRAY['heaptumps.select.team'::text])) OR
  (installer_company_auth_for_heatpump(serial_number) AND has_permission(ARRAY['heatpumps.select.company'::text]))
)

INFO: Deploy to supabase/test-reports
ERROR: not found ACTIONS_DEPLOY_KEY, PERSONAL_TOKEN, or GITHUB_TOKEN

import { createClient } from 'https://deno.land/x/supabase/mod.ts';

const supabase = createClient(
  MY_SUPABASE_URL,
  MY_SUPABASE_SERVICE_ROLE,
);

Serving supabase/functions/supaconnect
2022/10/26 21:16:13 Sent Header: Host [docker]
2022/10/26 21:16:13 Sent Header: User-Agent [Go-http-client/1.1]
2022/10/26 21:16:13 Sent Header: Content-Length [736]
2022/10/26 21:16:13 Sent Header: Content-Type [application/json]
2022/10/26 21:16:13 Send Done
2022/10/26 21:16:13 Recv First Byte
Watcher Process started.
error: Uncaught TypeError: Cannot read properties of undefined (reading 'href')
  if (!url) url = window.location.href
                                  ^
    at getParameterByName (https://deno.land/x/gotrue@3.0.0/src/lib/helpers.ts:17:35)
    at new GoTrueClient (https://deno.land/x/gotrue@3.0.0/src/GoTrueClient.ts:94:57)
    at new SupabaseAuthClient (https://deno.land/x/supabase@1.3.1/src/lib/SupabaseAuthClient.ts:6:5)
    at SupabaseClient._initSupabaseAuthClient (https://deno.land/x/supabase@1.3.1/src/SupabaseClient.ts:166:12)
    at new SupabaseClient (https://deno.land/x/supabase@1.3.1/src/SupabaseClient.ts:69:22)
    at createClient (https://deno.land/x/supabase@1.3.1/src/index.ts:11:10)
    at file:///home/deno/functions/newhello/index.ts:4:18

bash
supabase db diff -f "add_functions" --debug > l
Error: Error starting shadow database: ERROR:  syntax error at or near "COMMIT"
LINE 6: COMMIT;

const { data, error } = await supabase
        .from(LISTINGS_TABLE)
        .select("*, comments:listingComments(count), likes:listingLikes(count)", { count: "estimated" })

listing?.comments[0]?.count

listing?.likes[0]?.count

listing?.likes?.count

listing?.likes

auth.uid() = user_id

create trigger index_products_to_search
  after insert on products
  for each row execute procedure 
  public.send_to_webhook( 'http://172.17.0.1:54321/functions/v1/hello' );

create extension http with schema extensions;

create or replace function send_to_webhook() returns trigger AS $trigger$
declare
  rec RECORD;
  payload TEXT;
  column_name TEXT;
  column_value TEXT;
  payload_items JSONB;
begin
  -- Set record row depending on operation
  CASE TG_OP
  WHEN 'INSERT', 'UPDATE' THEN
     rec := new;
  WHEN 'DELETE' THEN
     rec := old;
  ELSE
     RAISE EXCEPTION 'Unknown TG_OP: "%". Should not occur!', TG_OP;
  END CASE;
 
  payload_items := coalesce(row_to_json(rec),'{}')::jsonb;
  
  -- Build the payload
  payload := json_build_object(
    'timestamp',CURRENT_TIMESTAMP,
    'operation',TG_OP,
    'schema',TG_TABLE_SCHEMA,
    'table',TG_TABLE_NAME,
    'data',payload_items
  );

  -- Notify the webhook
  perform extensions.http((
    'POST',
    TG_ARGV[0]::varchar,
    ARRAY[http_header('Authorization','Bearer ANON_KEY')],
    'application/json',
    payload::varchar
  )::http_request);

  return rec;
end;
$trigger$ language plpgsql;

import { serve } from "https://deno.land/std@0.131.0/http/server.ts";
import { adminSupabaseClient } from "../_shared/supabase.ts";

serve(async (req) => {
  try {
    const payload = await req.json();
    const { data } = payload;

    const product = await adminSupabaseClient
      .from("products")
      .select("id")
      .eq("id", data.id)
      .single();

    // data.id is the ID of the return rec from the function, but trying to select it returns no results.  

    if (!product.data) {
      throw new Error(`No Product Found for ${data.id}`); // This error throws and it has the id from data
    }

    return new Response(JSON.stringify(data), { headers: { "Content-Type": "application/json" } });
  } catch (e) {
    throw new Error(e);
  }
});

> supabase@1.11.2 preinstall /Users/.../node_modules/supabase
> node scripts/preinstall.js

internal/process/esm_loader.js:74
    internalBinding('errors').triggerUncaughtException(

https://github.com/supabase/cli/releases/download/v0.0.0-automated/supabase_0.0.0-automated_darwin_amd64.tar.gz

export const handleUpdateUsername = async (id: string, username: string) => {
  const { data, error } = await supabase
    .from('profiles')
    .update({ username: username })
    .match({ id: id })
    .single();

  if (error) {
    console.log('error', error);
    return error;
  } else {
    console.log('data', data);
    return data;
  }
};

prividers={["google"]}

false

loading

images:profile_id=eq.${profileId}

public:images:profile_id=eq.${profileId}

select 
 ST_X(location) AS x1, 
 ST_Y(location) as y1,
  location as loc
 from properties 
 where id = 1;

Failed to run sql query: function st_x(geography) does not exist

supabase db remote set "..."

supabase db push

db push

supabase link