Collections

import { createCollection } from '@/features/collections/actions';

const result = await createCollection({
  name: 'Customer Support',
  description: 'Templates for handling customer inquiries',
});

export async function createCollection(input: CreateCollectionInput) {
  const result = createCollectionSchema.safeParse(input);
  if (!result.success) {
    return { error: "Invalid input", details: result.error.format() };
  }

  const supabase = createClient(cookieStore);
  const { data: { user } } = await supabase.auth.getUser();

  if (!user) {
    return { error: "Unauthorized" };
  }

  const { data, error } = await supabase
    .from("collections")
    .insert({
      name: input.name,
      description: input.description,
      user_id: user.id
    })
    .select()
    .single();

  if (error) {
    return { error: error.message };
  }

  revalidatePath("/prompts");
  return { data };
}

export const createCollectionSchema = z.object({
  name: z.string().min(1, "Name is required").max(50, "Name is too long"),
  description: z.string().max(200, "Description is too long").optional(),
});

import { getCollections } from '@/features/collections/actions';

const { data } = await getCollections();
// Returns array sorted by name

export async function getCollections() {
  const supabase = createClient(cookieStore);
  
  const { data, error } = await supabase
    .from("collections")
    .select("*")
    .order("name");
  
  if (error) {
    console.error("Error fetching collections:", error);
    return { data: [] };
  }

  return { data };
}

import { updateCollection } from '@/features/collections/actions';

const result = await updateCollection(collectionId, {
  name: 'Customer Support Templates',
  description: 'Updated description',
});

import { deleteCollection } from '@/features/collections/actions';

const result = await deleteCollection(collectionId);

import { addToCollection } from '@/features/collections/actions';

const result = await addToCollection(promptId, collectionId);

export async function addToCollection(
  promptId: string, 
  collectionId: string
) {
  const supabase = createClient(cookieStore);

  const { error } = await supabase
    .from("collection_prompts")
    .insert({
      prompt_id: promptId,
      collection_id: collectionId
    });

  if (error) {
    return { error: error.message };
  }

  revalidatePath("/prompts");
  return { error: null };
}

import { removeFromCollection } from '@/features/collections/actions';

const result = await removeFromCollection(promptId, collectionId);

CREATE TABLE collections (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
  name TEXT NOT NULL,
  description TEXT,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT now() NOT NULL,
  updated_at TIMESTAMP WITH TIME ZONE DEFAULT now() NOT NULL
);

CREATE TABLE collection_prompts (
  collection_id UUID NOT NULL REFERENCES collections(id) ON DELETE CASCADE,
  prompt_id UUID NOT NULL REFERENCES prompts(id) ON DELETE CASCADE,
  PRIMARY KEY (collection_id, prompt_id)
);

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

CREATE POLICY "Users can view their own collection prompts" 
  ON collection_prompts FOR SELECT 
  USING (
    EXISTS (
      SELECT 1 FROM collections 
      WHERE id = collection_id AND user_id = auth.uid()
    )
  );

import { searchPrompts } from '@/features/search/actions';

const { data } = await searchPrompts('customer', {
  collectionId: 'collection-uuid',
});

AND (filter_collection_id IS NULL OR EXISTS (
  SELECT 1 FROM collection_prompts cp 
  WHERE cp.prompt_id = p.id AND cp.collection_id = filter_collection_id
))

Collection: "Marketing Campaign Q1"
Prompts:
- Social media post generator
- Email subject lines
- Ad copy variations

Collection: "Engineering Team"
Prompts:
- Code review checklist
- Bug report template
- Technical documentation

Collection: "Claude-optimized"
Prompts:
- Prompts specifically tuned for Claude
- Examples with Claude's preferred style

Collection: "Production Ready"
Prompts:
- Tested and approved prompts
- Used in live applications

// Add multiple prompts to a collection
async function bulkAddToCollection(
  promptIds: string[], 
  collectionId: string
) {
  const results = await Promise.all(
    promptIds.map(id => addToCollection(id, collectionId))
  );
  return results;
}

const { count } = await supabase
  .from('collection_prompts')
  .select('*', { count: 'exact', head: true })
  .eq('collection_id', collectionId);

const { data } = await supabase
  .from('collections')
  .select('*')
  .order('updated_at', { ascending: false })
  .limit(10);