admin管理员组

文章数量:1202805

I am trying to figure out how to query supabase. I have an events table with a host_id attribute. it is a foreign key to the user.id in the users table.

I am trying (and failing miserably) at figuring out how to follow the instructions in [this documentation][1] to get to a point where I can query the first_name and last_name on the user table and display that on my events page.

My events.ts has:

import { createSupabaseServerClient } from '../supabaseServerClient';
import { Database } from '../types/supabase';

export type Event = Database['public']['Tables']['events']['Row'];
export type Status = { label: string };

type HostInfo = {
  first_name: string;
  last_name: string;
}

export type EventWithStatus = Omit<Event, 'status'> & {
  status: Status | null;
  status_id: string | null;
  created_at: string ;
  host?: HostInfo;  
  host_name?: string; 
  users?: { first_name: string; last_name: string } | null;  

};


export default async function getEvents(): Promise<EventWithStatus[]> {
  const supabase = await createSupabaseServerClient();
  const { data, error } = await supabase
    .from('events')
    .select(`
      id,
      title,
      comment,
      created_at,
      creator_id,
      host_id,
      date,
      linkToVirtual,
      location,
      maxGroupSize,
      time,
      virtual,
      status_id,
      status:status_id(label),
      users:host_id(first_name, last_name)
    `);
    // 
  if (error) {
    console.error('Error fetching events:', error.message);
    throw error;
  }

  return (data || []).map((event) => ({
    id: event.id,
    title: event.title,
    comment: eventment,
    created_at: event.created_at,
    creator_id: event.creator_id,
    host_id: event.host_id,
    date: event.date,
    linkToVirtual: event.linkToVirtual,
    location: event.location,
    maxGroupSize: event.maxGroupSize,
    time: event.time,
    virtual: event.virtual,
    status_id: event.status_id,
    status: event.status ? { label: event.status.label } : null,
    host_name: event.users 
    ? `${event.users.first_name} ${event.users.last_name}` 
    : 'Unknown Host',
    
  })) as EventWithStatus[];
  
}

// Client-side hooks for interacting with events
export function useEvents() {
  // Fetch all events with statuses
  const getEvents = async (): Promise<EventWithStatus[]> => {
    const supabase = await createSupabaseServerClient();
    const { data, error } = await supabase
      .from('events')
      .select(`
         id,
      title,
      comment,
      created_at,
      creator_id,
      host_id,
      date,
      linkToVirtual,
      location,
      maxGroupSize,
      time,
      virtual,
      status_id,
      status:status_id(label),
      users:host_id(first_name, last_name)
      `);
      

    if (error) {
      console.error('Error fetching events:', error.message);
      throw error;
    }

    return (data || []).map(event => ({
      id: event.id,
      title: event.title,
      comment: eventment,
      created_at: event.created_at,
      creator_id: event.creator_id,
      host_id: event.host_id,
      
      date: event.date,
      linkToVirtual: event.linkToVirtual,
      location: event.location,
      maxGroupSize: event.maxGroupSize,
      time: event.time,
      virtual: event.virtual,
      status_id: event.status_id,
      status: event.status ? { label: event.status.label } : null,
      host_name: event.users 
      ? `${event.users.first_name} ${event.users.last_name}` 
      : 'Unknown Host',
    })) as EventWithStatus[];
  };
  
  const getRecentEvents = async (): Promise<EventWithStatus[]> => {
    const supabase = await createSupabaseServerClient();
    const { data, error } = await supabase
      .from('events')
      .select(`
         id,
      title,
      comment,
      created_at,
      creator_id,
      host_id,
      date,
      linkToVirtual,
      location,
      maxGroupSize,
      time,
      virtual,
      status_id,
      status:status_id(label)
      

      `)
      
      .order('created_at', { ascending: false })
      .limit(5);
    if (error) {
      console.error('Error fetching events:', error.message);
      throw error;
    }
    // users(first_name, last_name)

    return (data || []).map(event => ({
      id: event.id,
      title: event.title,
      comment: eventment,
      created_at: event.created_at,
      creator_id: event.creator_id,
      host_id: event.host_id,
      date: event.date,
      linkToVirtual: event.linkToVirtual,
      location: event.location,
      maxGroupSize: event.maxGroupSize,
      time: event.time,
      virtual: event.virtual,
      status_id: event.status_id,
      status: event.status ? { label: event.status.label } : null,
     

    })) as EventWithStatus[];
  };
  
  // Fetch a single event by ID
  const getEventById = async (id: string): Promise<EventWithStatus | null> => {
    console.log('Fetching event with ID console log:', id); // Log the incoming id

    const supabase = await createSupabaseServerClient();
    const { data, error } = await supabase
      .from('events')
      .select(`
      id,
      title,
      comment,
      created_at,
      creator_id,
      host_id,
      date,
      linkToVirtual,
      location,
      maxGroupSize,
      time,
      virtual,
      status_id,
      status:status_id(label),
      users(first_name, last_name)

      `)
      .eq('id', id)
      .single();

    if (error) {
      console.error('Error fetching event:', error.message);
      return null;
    }
    console.log('Fetched eventid data:', data);

    
    return data ? {
      id: data.id,
      title: data.title,
      comment: datament,
      created_at: data.created_at,
      creator_id: data.creator_id,
      host_id: data.host_id,
      date: data.date,
      linkToVirtual: data.linkToVirtual,
      location: data.location,
      maxGroupSize: data.maxGroupSize,
      time: data.time,
      virtual: data.virtual,
      status_id: data.status_id,
      status: data.status ? { label: data.status.label } : null,
      host_name: data.users 
      ? `${data.users.first_name} ${data.users.last_name}` 
      : 'Unknown Host'
    } : null;
  };
  

 // Create a new event
 const createEvent = async (eventData: Omit<Event, 'id'>): Promise<Event> => {
  const supabase = await createSupabaseServerClient();
  const { data, error } = await supabase
    .from('events')
    .insert(eventData)
    .select()
    .single();

  if (error) {
    console.error('Error creating event:', error.message);
    throw error;
  }

  return data as Event;
};

// Update an existing event
const updateEvent = async (
  eventId: string,
  eventData: Partial<Event>
): Promise<Event[]> => {
  const supabase = await createSupabaseServerClient();
  const { data, error } = await supabase.from('events').update(eventData).eq('id', eventId);

  if (error) {
    console.error('Error updating event:', error.message);
    throw error;
  }

  return data ? (data as Event[]) : [];
};

// Delete an event by ID
const deleteEvent = async (eventId: string): Promise<Event[]> => {
  const supabase = await createSupabaseServerClient();
  const { data, error } = await supabase.from('events').delete().eq('id', eventId);

  if (error) {
    console.error('Error deleting event:', error.message);
    throw error;
  }

  return data ? (data as Event[]) : [];
};

return { getEvents, getEventById, getRecentEvents, createEvent, updateEvent, deleteEvent };
}

My serverEvents.ts has

import { createSupabaseServerClient } from '../supabaseServerClient';
import { EventWithStatus } from './events';

export async function getServerSideEvents(): Promise<EventWithStatus[]> {
  try {
    console.log('

                本文标签：
                Querying supabaseParserErrorltquotEmpty stringquotgtStack Overflow

                        版权声明：本文标题：Querying supabase - ParserError&lt;&quot;Empty string&quot;&gt; - Stack Overflow 内容由网友自发贡献，该文观点仅代表作者本人，
                        转载请联系作者并注明出处：http://www.betaflare.com/web/1738592882a2101616.html，
                        本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。