Claude Code: Build a SaaS with AI

git clone https://github.com/makerkit/next-supabase-turbo-saas-kit.git content-repurposer
cd content-repurposer

pnpm i
pnpm gen setup

pnpm run dev
pnpm run supabase:web:start # requires Docker to be installed and running

claude

AI Content Repurposer
Features:
- Upload blog posts → Get AI-generated social media variations
- Usage-based billing with credits
- Team collaboration for agencies
- Real-time processing with status updates

/*
 * -------------------------------------------------------
 * Section: AI Content Repurposer
 * Core schema for AI-powered content repurposing SaaS
 * -------------------------------------------------------
 */
-- Content types enumeration
CREATE TYPE public.content_type AS ENUM (
    'blog_post',
    'article',
    'social_media_post',
    'newsletter',
    'video_script',
    'podcast_script'
);
-- Content status enumeration
CREATE TYPE public.content_status AS ENUM (
    'uploaded',
    'processing',
    'completed',
    'failed'
);
-- Repurposing target platforms
CREATE TYPE public.target_platform AS ENUM (
    'twitter',
    'linkedin',
    'instagram',
    'facebook',
    'tiktok',
    'youtube',
    'blog',
    'newsletter'
);
-- Content processing priority
CREATE TYPE public.processing_priority AS ENUM (
    'low',
    'normal',
    'high',
    'urgent'
);
-- Original content table
CREATE TABLE IF NOT EXISTS public.original_content (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    account_id UUID NOT NULL REFERENCES public.accounts(id) ON DELETE CASCADE,
    
    -- Content metadata
    title TEXT NOT NULL,
    content_type public.content_type NOT NULL,
    original_text TEXT NOT NULL,
    word_count INTEGER GENERATED ALWAYS AS (array_length(string_to_array(trim(original_text), ' '), 1)) STORED,
    
    -- File storage (if uploaded)
    file_url TEXT,
    file_name TEXT,
    file_size INTEGER,
    file_type TEXT,
    
    -- Processing info
    status public.content_status NOT NULL DEFAULT 'uploaded',
    processing_started_at TIMESTAMPTZ,
    processing_completed_at TIMESTAMPTZ,
    error_message TEXT,
    
    -- Metadata
    metadata JSONB DEFAULT '{}'::JSONB,
    tags TEXT[] DEFAULT '{}',
    
    -- Audit fields
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    created_by UUID REFERENCES auth.users(id) ON DELETE SET NULL,
    
    -- Constraints
    CONSTRAINT valid_word_count CHECK (word_count > 0),
    CONSTRAINT valid_file_size CHECK (file_size IS NULL OR file_size > 0),
    CONSTRAINT valid_processing_times CHECK (
        processing_started_at IS NULL OR 
        processing_completed_at IS NULL OR 
        processing_completed_at >= processing_started_at
    )
);
-- Repurposing jobs table
CREATE TABLE IF NOT EXISTS public.repurposing_jobs (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    account_id UUID NOT NULL REFERENCES public.accounts(id) ON DELETE CASCADE,
    original_content_id UUID NOT NULL REFERENCES public.original_content(id) ON DELETE CASCADE,
    
    -- Job configuration
    target_platforms public.target_platform[] NOT NULL DEFAULT '{}',
    custom_instructions TEXT,
    tone TEXT, -- casual, professional, friendly, etc.
    priority public.processing_priority NOT NULL DEFAULT 'normal',
    
    -- Processing info
    status public.content_status NOT NULL DEFAULT 'uploaded',
    processing_started_at TIMESTAMPTZ,
    processing_completed_at TIMESTAMPTZ,
    error_message TEXT,
    
    -- AI processing metadata
    ai_model_used TEXT,
    processing_duration_ms INTEGER,
    tokens_consumed INTEGER,
    
    -- Credits and billing
    credits_cost INTEGER NOT NULL DEFAULT 1,
    
    -- Audit fields
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    created_by UUID REFERENCES auth.users(id) ON DELETE SET NULL,
    
    -- Constraints
    CONSTRAINT valid_platforms CHECK (array_length(target_platforms, 1) > 0),
    CONSTRAINT valid_credits_cost CHECK (credits_cost > 0),
    CONSTRAINT valid_processing_duration CHECK (processing_duration_ms IS NULL OR processing_duration_ms >= 0),
    CONSTRAINT valid_tokens_consumed CHECK (tokens_consumed IS NULL OR tokens_consumed >= 0)
);
-- Generated content variations table
CREATE TABLE IF NOT EXISTS public.content_variations (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    account_id UUID NOT NULL REFERENCES public.accounts(id) ON DELETE CASCADE,
    job_id UUID NOT NULL REFERENCES public.repurposing_jobs(id) ON DELETE CASCADE,
    original_content_id UUID NOT NULL REFERENCES public.original_content(id) ON DELETE CASCADE,
    
    -- Variation details
    platform public.target_platform NOT NULL,
    variation_title TEXT,
    content_text TEXT NOT NULL,
    character_count INTEGER GENERATED ALWAYS AS (length(content_text)) STORED,
    
    -- Platform-specific metadata
    hashtags TEXT[] DEFAULT '{}',
    mentions TEXT[] DEFAULT '{}',
    platform_metadata JSONB DEFAULT '{}'::JSONB, -- platform-specific fields
    
    -- Quality and approval
    ai_confidence_score DECIMAL(3,2), -- 0.00 to 1.00
    is_approved BOOLEAN DEFAULT FALSE,
    approved_by UUID REFERENCES auth.users(id) ON DELETE SET NULL,
    approved_at TIMESTAMPTZ,
    
    -- Publishing info
    is_published BOOLEAN DEFAULT FALSE,
    published_at TIMESTAMPTZ,
    external_post_id TEXT, -- ID from social platform
    external_url TEXT, -- URL to published content
    
    -- Audit fields
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    
    -- Constraints
    CONSTRAINT valid_confidence_score CHECK (ai_confidence_score IS NULL OR (ai_confidence_score >= 0 AND ai_confidence_score <= 1)),
    CONSTRAINT valid_character_count CHECK (character_count > 0),
    CONSTRAINT approval_consistency CHECK (
        (is_approved = FALSE) OR 
        (is_approved = TRUE AND approved_by IS NOT NULL AND approved_at IS NOT NULL)
    ),
    CONSTRAINT publishing_consistency CHECK (
        (is_published = FALSE) OR 
        (is_published = TRUE AND published_at IS NOT NULL)
    )
);
-- Account credits table for usage-based billing
CREATE TABLE IF NOT EXISTS public.account_credits (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    account_id UUID NOT NULL REFERENCES public.accounts(id) ON DELETE CASCADE,
    
    -- Credit balance
    total_credits INTEGER NOT NULL DEFAULT 0,
    used_credits INTEGER NOT NULL DEFAULT 0,
    remaining_credits INTEGER GENERATED ALWAYS AS (total_credits - used_credits) STORED,
    
    -- Billing period
    billing_period_start TIMESTAMPTZ NOT NULL,
    billing_period_end TIMESTAMPTZ NOT NULL,
    
    -- Metadata
    plan_name TEXT,
    auto_refill BOOLEAN DEFAULT TRUE,
    
    -- Audit fields
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    
    -- Constraints
    CONSTRAINT valid_credits CHECK (total_credits >= 0 AND used_credits >= 0 AND used_credits <= total_credits),
    CONSTRAINT valid_billing_period CHECK (billing_period_end > billing_period_start),
    
    -- Ensure one active period per account
    UNIQUE(account_id, billing_period_start)
);
-- Credit transactions table for audit trail
CREATE TABLE IF NOT EXISTS public.credit_transactions (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    account_id UUID NOT NULL REFERENCES public.accounts(id) ON DELETE CASCADE,
    account_credits_id UUID NOT NULL REFERENCES public.account_credits(id) ON DELETE CASCADE,
    
    -- Transaction details
    transaction_type TEXT NOT NULL, -- 'purchase', 'usage', 'refund', 'bonus'
    amount INTEGER NOT NULL, -- positive for additions, negative for usage
    description TEXT NOT NULL,
    
    -- Related entities
    job_id UUID REFERENCES public.repurposing_jobs(id) ON DELETE SET NULL,
    order_id TEXT, -- external billing system order ID
    
    -- Balance snapshot
    balance_before INTEGER NOT NULL,
    balance_after INTEGER NOT NULL,
    
    -- Audit fields
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    created_by UUID REFERENCES auth.users(id) ON DELETE SET NULL,
    
    -- Constraints
    CONSTRAINT valid_amount CHECK (amount != 0),
    CONSTRAINT valid_balance_calculation CHECK (balance_after = balance_before + amount),
    CONSTRAINT valid_transaction_type CHECK (transaction_type IN ('purchase', 'usage', 'refund', 'bonus'))
);
-- Content templates table for reusable configurations
CREATE TABLE IF NOT EXISTS public.content_templates (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    account_id UUID NOT NULL REFERENCES public.accounts(id) ON DELETE CASCADE,
    
    -- Template details
    name TEXT NOT NULL,
    description TEXT,
    content_type public.content_type NOT NULL,
    target_platforms public.target_platform[] NOT NULL DEFAULT '{}',
    
    -- Template configuration
    custom_instructions TEXT,
    tone TEXT,
    default_tags TEXT[] DEFAULT '{}',
    
    -- Usage tracking
    usage_count INTEGER NOT NULL DEFAULT 0,
    last_used_at TIMESTAMPTZ,
    
    -- Sharing
    is_public BOOLEAN DEFAULT FALSE,
    is_archived BOOLEAN DEFAULT FALSE,
    
    -- Audit fields
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    created_by UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
    
    -- Constraints
    CONSTRAINT valid_platforms_template CHECK (array_length(target_platforms, 1) > 0),
    CONSTRAINT valid_usage_count CHECK (usage_count >= 0)
);
-- Enable Row Level Security on all tables
ALTER TABLE public.original_content ENABLE ROW LEVEL SECURITY;
ALTER TABLE public.repurposing_jobs ENABLE ROW LEVEL SECURITY;
ALTER TABLE public.content_variations ENABLE ROW LEVEL SECURITY;
ALTER TABLE public.account_credits ENABLE ROW LEVEL SECURITY;
ALTER TABLE public.credit_transactions ENABLE ROW LEVEL SECURITY;
ALTER TABLE public.content_templates ENABLE ROW LEVEL SECURITY;
-- RLS Policies for original_content
CREATE POLICY "Users can read their account's original content"
    ON public.original_content
    FOR SELECT
    USING (public.has_role_on_account(account_id));
CREATE POLICY "Users can insert original content for their accounts"
    ON public.original_content
    FOR INSERT
    WITH CHECK (public.has_role_on_account(account_id));
CREATE POLICY "Users can update their account's original content"
    ON public.original_content
    FOR UPDATE
    USING (public.has_role_on_account(account_id))
    WITH CHECK (public.has_role_on_account(account_id));
CREATE POLICY "Users can delete their account's original content"
    ON public.original_content
    FOR DELETE
    USING (public.has_role_on_account(account_id));
-- RLS Policies for repurposing_jobs
CREATE POLICY "Users can read their account's repurposing jobs"
    ON public.repurposing_jobs
    FOR SELECT
    USING (public.has_role_on_account(account_id));
CREATE POLICY "Users can insert repurposing jobs for their accounts"
    ON public.repurposing_jobs
    FOR INSERT
    WITH CHECK (public.has_role_on_account(account_id));
CREATE POLICY "Users can update their account's repurposing jobs"
    ON public.repurposing_jobs
    FOR UPDATE
    USING (public.has_role_on_account(account_id))
    WITH CHECK (public.has_role_on_account(account_id));
CREATE POLICY "Users can delete their account's repurposing jobs"
    ON public.repurposing_jobs
    FOR DELETE
    USING (public.has_role_on_account(account_id));
-- RLS Policies for content_variations
CREATE POLICY "Users can read their account's content variations"
    ON public.content_variations
    FOR SELECT
    USING (public.has_role_on_account(account_id));
CREATE POLICY "Users can insert content variations for their accounts"
    ON public.content_variations
    FOR INSERT
    WITH CHECK (public.has_role_on_account(account_id));
CREATE POLICY "Users can update their account's content variations"
    ON public.content_variations
    FOR UPDATE
    USING (public.has_role_on_account(account_id))
    WITH CHECK (public.has_role_on_account(account_id));
CREATE POLICY "Users can delete their account's content variations"
    ON public.content_variations
    FOR DELETE
    USING (public.has_role_on_account(account_id));
-- RLS Policies for account_credits
CREATE POLICY "Users can read their account's credits"
    ON public.account_credits
    FOR SELECT
    USING (public.has_role_on_account(account_id));
CREATE POLICY "Service role can manage account credits"
    ON public.account_credits
    FOR ALL
    USING (auth.role() = 'service_role');
-- RLS Policies for credit_transactions
CREATE POLICY "Users can read their account's credit transactions"
    ON public.credit_transactions
    FOR SELECT
    USING (public.has_role_on_account(account_id));
CREATE POLICY "Service role can manage credit transactions"
    ON public.credit_transactions
    FOR ALL
    USING (auth.role() = 'service_role');
-- RLS Policies for content_templates
CREATE POLICY "Users can read their account's templates and public templates"
    ON public.content_templates
    FOR SELECT
    USING (
        public.has_role_on_account(account_id) OR 
        (is_public = TRUE AND is_archived = FALSE)
    );
CREATE POLICY "Users can insert templates for their accounts"
    ON public.content_templates
    FOR INSERT
    WITH CHECK (public.has_role_on_account(account_id));
CREATE POLICY "Users can update their account's templates"
    ON public.content_templates
    FOR UPDATE
    USING (public.has_role_on_account(account_id))
    WITH CHECK (public.has_role_on_account(account_id));
CREATE POLICY "Users can delete their account's templates"
    ON public.content_templates
    FOR DELETE
    USING (public.has_role_on_account(account_id));
-- Indexes for performance
CREATE INDEX IF NOT EXISTS idx_original_content_account_id ON public.original_content(account_id);
CREATE INDEX IF NOT EXISTS idx_original_content_status ON public.original_content(status);
CREATE INDEX IF NOT EXISTS idx_original_content_created_at ON public.original_content(created_at DESC);
CREATE INDEX IF NOT EXISTS idx_original_content_type ON public.original_content(content_type);
CREATE INDEX IF NOT EXISTS idx_repurposing_jobs_account_id ON public.repurposing_jobs(account_id);
CREATE INDEX IF NOT EXISTS idx_repurposing_jobs_original_content_id ON public.repurposing_jobs(original_content_id);
CREATE INDEX IF NOT EXISTS idx_repurposing_jobs_status ON public.repurposing_jobs(status);
CREATE INDEX IF NOT EXISTS idx_repurposing_jobs_priority ON public.repurposing_jobs(priority);
CREATE INDEX IF NOT EXISTS idx_repurposing_jobs_created_at ON public.repurposing_jobs(created_at DESC);
CREATE INDEX IF NOT EXISTS idx_content_variations_account_id ON public.content_variations(account_id);
CREATE INDEX IF NOT EXISTS idx_content_variations_job_id ON public.content_variations(job_id);
CREATE INDEX IF NOT EXISTS idx_content_variations_platform ON public.content_variations(platform);
CREATE INDEX IF NOT EXISTS idx_content_variations_approved ON public.content_variations(is_approved);
CREATE INDEX IF NOT EXISTS idx_content_variations_published ON public.content_variations(is_published);
CREATE INDEX IF NOT EXISTS idx_account_credits_account_id ON public.account_credits(account_id);
CREATE INDEX IF NOT EXISTS idx_account_credits_billing_period ON public.account_credits(billing_period_start, billing_period_end);
CREATE INDEX IF NOT EXISTS idx_credit_transactions_account_id ON public.credit_transactions(account_id);
CREATE INDEX IF NOT EXISTS idx_credit_transactions_created_at ON public.credit_transactions(created_at DESC);
CREATE INDEX IF NOT EXISTS idx_credit_transactions_type ON public.credit_transactions(transaction_type);
CREATE INDEX IF NOT EXISTS idx_content_templates_account_id ON public.content_templates(account_id);
CREATE INDEX IF NOT EXISTS idx_content_templates_public ON public.content_templates(is_public) WHERE is_public = TRUE;
CREATE INDEX IF NOT EXISTS idx_content_templates_content_type ON public.content_templates(content_type);
-- Triggers for updated_at timestamps using Makerkit's standard function
CREATE TRIGGER set_original_content_updated_at
    BEFORE UPDATE ON public.original_content
    FOR EACH ROW
    EXECUTE FUNCTION public.trigger_set_timestamps();
CREATE TRIGGER set_repurposing_jobs_updated_at
    BEFORE UPDATE ON public.repurposing_jobs
    FOR EACH ROW
    EXECUTE FUNCTION public.trigger_set_timestamps();
CREATE TRIGGER set_content_variations_updated_at
    BEFORE UPDATE ON public.content_variations
    FOR EACH ROW
    EXECUTE FUNCTION public.trigger_set_timestamps();
CREATE TRIGGER set_account_credits_updated_at
    BEFORE UPDATE ON public.account_credits
    FOR EACH ROW
    EXECUTE FUNCTION public.trigger_set_timestamps();
CREATE TRIGGER set_content_templates_updated_at
    BEFORE UPDATE ON public.content_templates
    FOR EACH ROW
    EXECUTE FUNCTION public.trigger_set_timestamps();
-- Helper functions for credit management
CREATE OR REPLACE FUNCTION public.consume_credits(
    p_account_id UUID,
    p_amount INTEGER,
    p_job_id UUID,
    p_description TEXT DEFAULT 'Content repurposing'
)
RETURNS BOOLEAN
LANGUAGE plpgsql
SECURITY DEFINER
SET search_path TO ''
AS $$
DECLARE
    v_credits_id UUID;
    v_current_balance INTEGER;
BEGIN
    -- Security check: only allow service_role to execute this function
    IF auth.role() != 'service_role' THEN
        RAISE EXCEPTION 'Only service role can consume credits';
    END IF;
    -- Get current active credits for account
    SELECT id, remaining_credits
    INTO v_credits_id, v_current_balance
    FROM public.account_credits
    WHERE account_id = p_account_id
      AND billing_period_start <= NOW()
      AND billing_period_end > NOW()
    ORDER BY billing_period_start DESC
    LIMIT 1;
    -- Check if account has enough credits
    IF v_credits_id IS NULL OR v_current_balance < p_amount THEN
        RETURN FALSE;
    END IF;
    -- Update used credits
    UPDATE public.account_credits
    SET used_credits = used_credits + p_amount
    WHERE id = v_credits_id;
    -- Record transaction
    INSERT INTO public.credit_transactions (
        account_id,
        account_credits_id,
        transaction_type,
        amount,
        description,
        job_id,
        balance_before,
        balance_after
    ) VALUES (
        p_account_id,
        v_credits_id,
        'usage',
        -p_amount,
        p_description,
        p_job_id,
        v_current_balance,
        v_current_balance - p_amount
    );
    RETURN TRUE;
END;
$$;
-- Grant necessary permissions (service_role only)
GRANT EXECUTE ON FUNCTION public.consume_credits TO service_role;
-- Comments for documentation
COMMENT ON TABLE public.original_content IS 'Stores original content uploaded by users for repurposing';
COMMENT ON TABLE public.repurposing_jobs IS 'Tracks AI repurposing jobs with configuration and status';
COMMENT ON TABLE public.content_variations IS 'Stores AI-generated content variations for different platforms';
COMMENT ON TABLE public.account_credits IS 'Manages credit balances for usage-based billing';
COMMENT ON TABLE public.credit_transactions IS 'Audit trail for all credit-related transactions';
COMMENT ON TABLE public.content_templates IS 'Reusable templates for content repurposing configurations';
COMMENT ON FUNCTION public.consume_credits IS 'Safely consume credits for a job and record transaction';

pnpm --filter web supabase migration new content-repurposer

Created new migration at supabase/migrations/<timestamp>_content-repurposer.sql

cat apps/web/supabase/schemas/18-content-repurposer.sql > apps/web/supabase/migrations/<timestamp>_content-repurposer.sql

pnpm run supabase:web:reset

import { z } from 'zod';
export const ContentUploadSchema = z.object({
  title: z.string().min(1, 'Title is required').max(200, 'Title is too long'),
  contentType: z.enum(['blog_post', 'article', 'social_media_post', 'newsletter', 'video_script', 'podcast_script'], {
    required_error: 'Content type is required',
  }),
  
  // Either URL or file upload is required
  contentUrl: z.string().url('Please enter a valid URL').optional().or(z.literal('')),
  
  // File validation
  file: z
    .custom<File>((val) => val instanceof File, 'Please upload a file')
    .refine(
      (file) => file.size <= 5 * 1024 * 1024, // 5MB limit
      'File size must be less than 5MB'
    )
    .refine(
      (file) => ['text/markdown', 'text/plain', 'application/octet-stream'].includes(file.type) || 
                file.name.endsWith('.md') || file.name.endsWith('.txt'),
      'Only markdown (.md) and text (.txt) files are supported'
    )
    .optional(),
    
  tags: z.array(z.string()).optional().default([]),
  customInstructions: z.string().max(1000, 'Instructions are too long').optional(),
})
.refine(
  (data) => data.contentUrl || data.file,
  {
    message: 'Either provide a URL or upload a file',
    path: ['contentUrl'],
  }
);
export type ContentUploadFormData = z.infer<typeof ContentUploadSchema>;

import { use } from 'react';
import { PageBody } from '@kit/ui/page';
import { Trans } from '@kit/ui/trans';
import { createI18nServerInstance } from '~/lib/i18n/i18n.server';
import { withI18n } from '~/lib/i18n/with-i18n';
import { TeamAccountLayoutPageHeader } from '../_components/team-account-layout-page-header';
import { ContentUploadForm } from './_components/content-upload-form';
interface UploadPageProps {
  params: Promise<{ account: string }>;
}
export const generateMetadata = async () => {
  const i18n = await createI18nServerInstance();
  const title = i18n.t('upload:pageTitle', { defaultValue: 'Upload Content' });
  return {
    title,
  };
};
function UploadPage({ params }: UploadPageProps) {
  const account = use(params).account;
  return (
    <>
      <TeamAccountLayoutPageHeader
        account={account}
        title={<Trans i18nKey="upload:pageTitle" defaults="Upload Content" />}
        description={
          <Trans 
            i18nKey="upload:pageDescription" 
            defaults="Upload content from a URL or file to start repurposing it for different platforms" 
          />
        }
      />
      <PageBody>
        <div className="space-y-6">
          <div className="text-center space-y-2">
            <h2 className="text-2xl font-semibold">
              <Trans i18nKey="upload:formTitle" defaults="Add New Content" />
            </h2>
            <p className="text-muted-foreground">
              <Trans 
                i18nKey="upload:formSubtitle" 
                defaults="Share a URL or upload a file to get AI-generated variations for social media and other platforms" 
              />
            </p>
          </div>
          <ContentUploadForm />
        </div>
      </PageBody>
    </>
  );
}
export default withI18n(UploadPage);

'use client';
import { useState, useTransition } from 'react';
import { useRouter } from 'next/navigation';
import { zodResolver } from '@hookform/resolvers/zod';
import { useForm } from 'react-hook-form';
import { useTeamAccountWorkspace } from '@kit/team-accounts/hooks/use-team-account-workspace';
import { Button } from '@kit/ui/button';
import {
  Form,
  FormControl,
  FormDescription,
  FormField,
  FormItem,
  FormLabel,
  FormMessage,
} from '@kit/ui/form';
import { If } from '@kit/ui/if';
import { Input } from '@kit/ui/input';
import { Label } from '@kit/ui/label';
import {
  Select,
  SelectContent,
  SelectItem,
  SelectTrigger,
  SelectValue,
} from '@kit/ui/select';
import { Separator } from '@kit/ui/separator';
import { toast } from '@kit/ui/sonner';
import { Spinner } from '@kit/ui/spinner';
import { Textarea } from '@kit/ui/textarea';
import { Trans } from '@kit/ui/trans';
import {
  type ContentUploadFormData,
  ContentUploadSchema,
} from '../_lib/schema/content-upload.schema';
import { uploadContentAction } from '../_lib/server/server-actions';
const contentTypeOptions = [
  { value: 'blog_post', label: 'Blog Post' },
  { value: 'article', label: 'Article' },
  { value: 'social_media_post', label: 'Social Media Post' },
  { value: 'newsletter', label: 'Newsletter' },
  { value: 'video_script', label: 'Video Script' },
  { value: 'podcast_script', label: 'Podcast Script' },
] as const;
export function ContentUploadForm() {
  const [isPending, startTransition] = useTransition();
  const [uploadMode, setUploadMode] = useState<'url' | 'file'>('url');
  const router = useRouter();
  const { account } = useTeamAccountWorkspace();
  const form = useForm({
    resolver: zodResolver(ContentUploadSchema),
    defaultValues: {
      title: '',
      contentType: 'blog_post',
      contentUrl: '',
      tags: [],
      customInstructions: '',
    },
  });
  const onSubmit = (data: ContentUploadFormData) => {
    startTransition(async () => {
      const formData = new FormData();
      // Add all form fields to FormData
      formData.append('title', data.title);
      formData.append('contentType', data.contentType);
      formData.append('accountId', account.id);
      if (uploadMode === 'url' && data.contentUrl) {
        formData.append('contentUrl', data.contentUrl);
      }
      if (uploadMode === 'file' && data.file) {
        formData.append('file', data.file);
      }
      if (data.customInstructions) {
        formData.append('customInstructions', data.customInstructions);
      }
      if (data.tags && data.tags.length > 0) {
        formData.append('tags', JSON.stringify(data.tags));
      }
      const promise = uploadContentAction({
        title: data.title,
        contentType: data.contentType,
        contentUrl: uploadMode === 'url' ? data.contentUrl : '',
        file: uploadMode === 'file' ? data.file : undefined,
        customInstructions: data.customInstructions,
        tags: data.tags,
        accountId: account.id,
      });
      toast.promise(promise, {
        loading: (
          <Trans i18nKey="common:uploading" defaults="Uploading content..." />
        ),
        success: (result) => {
          if (result.success) {
            form.reset();
            router.push(`/home/${account.slug}`);
            return (
              <Trans
                i18nKey="upload:success"
                defaults="Content uploaded successfully!"
              />
            );
          }
          throw new Error(result.error);
        },
        error: (error) =>
          error.message || (
            <Trans i18nKey="upload:error" defaults="Upload failed" />
          ),
      });
    });
  };
  return (
    <div className="mx-auto max-w-2xl">
      <Form {...form}>
        <form onSubmit={form.handleSubmit(onSubmit)} className="space-y-6">
          {/* Title Field */}
          <FormField
            control={form.control}
            name="title"
            render={({ field }) => (
              <FormItem>
                <FormLabel>
                  <Trans i18nKey="upload:titleLabel" defaults="Content Title" />
                </FormLabel>
                <FormControl>
                  <Input
                    placeholder="Enter a descriptive title for your content"
                    data-test="content-title-input"
                    {...field}
                  />
                </FormControl>
                <FormDescription>
                  <Trans
                    i18nKey="upload:titleDescription"
                    defaults="Give your content a clear, descriptive title"
                  />
                </FormDescription>
                <FormMessage />
              </FormItem>
            )}
          />
          {/* Content Type Field */}
          <FormField
            control={form.control}
            name="contentType"
            render={({ field }) => (
              <FormItem>
                <FormLabel>
                  <Trans
                    i18nKey="upload:contentTypeLabel"
                    defaults="Content Type"
                  />
                </FormLabel>
                <Select
                  onValueChange={field.onChange}
                  defaultValue={field.value}
                >
                  <FormControl>
                    <SelectTrigger data-test="content-type-select">
                      <SelectValue placeholder="Select content type" />
                    </SelectTrigger>
                  </FormControl>
                  <SelectContent>
                    {contentTypeOptions.map((option) => (
                      <SelectItem key={option.value} value={option.value}>
                        {option.label}
                      </SelectItem>
                    ))}
                  </SelectContent>
                </Select>
                <FormDescription>
                  <Trans
                    i18nKey="upload:contentTypeDescription"
                    defaults="Choose the type of content you're uploading"
                  />
                </FormDescription>
                <FormMessage />
              </FormItem>
            )}
          />
          {/* Upload Mode Selection */}
          <div className="space-y-4">
            <Label>
              <Trans i18nKey="upload:sourceLabel" defaults="Content Source" />
            </Label>
            <div className="flex gap-4">
              <Button
                type="button"
                variant={uploadMode === 'url' ? 'default' : 'outline'}
                onClick={() => setUploadMode('url')}
                data-test="url-mode-button"
              >
                <Trans i18nKey="upload:fromUrl" defaults="From URL" />
              </Button>
              <Button
                type="button"
                variant={uploadMode === 'file' ? 'default' : 'outline'}
                onClick={() => setUploadMode('file')}
                data-test="file-mode-button"
              >
                <Trans i18nKey="upload:uploadFile" defaults="Upload File" />
              </Button>
            </div>
          </div>
          <Separator />
          {/* URL Input */}
          <If condition={uploadMode === 'url'}>
            <FormField
              control={form.control}
              name="contentUrl"
              render={({ field }) => (
                <FormItem>
                  <FormLabel>
                    <Trans i18nKey="upload:urlLabel" defaults="Content URL" />
                  </FormLabel>
                  <FormControl>
                    <Input
                      type="url"
                      placeholder="https://example.com/your-content"
                      data-test="content-url-input"
                      {...field}
                    />
                  </FormControl>
                  <FormDescription>
                    <Trans
                      i18nKey="upload:urlDescription"
                      defaults="Enter the URL of the content you want to repurpose"
                    />
                  </FormDescription>
                  <FormMessage />
                </FormItem>
              )}
            />
          </If>
          {/* File Upload */}
          <If condition={uploadMode === 'file'}>
            <FormField
              control={form.control}
              name="file"
              render={({ field: { onChange, value, ...field } }) => (
                <FormItem>
                  <FormLabel>
                    <Trans i18nKey="upload:fileLabel" defaults="Upload File" />
                  </FormLabel>
                  <FormControl>
                    <Input
                      type="file"
                      accept=".md,.txt,text/markdown,text/plain"
                      data-test="file-upload-input"
                      onChange={(e) => {
                        const file = e.target.files?.[0];
                        onChange(file);
                      }}
                      {...field}
                    />
                  </FormControl>
                  <FormDescription>
                    <Trans
                      i18nKey="upload:fileDescription"
                      defaults="Upload a markdown (.md) or text (.txt) file (max 5MB)"
                    />
                  </FormDescription>
                  <FormMessage />
                </FormItem>
              )}
            />
          </If>
          {/* Custom Instructions */}
          <FormField
            control={form.control}
            name="customInstructions"
            render={({ field }) => (
              <FormItem>
                <FormLabel>
                  <Trans
                    i18nKey="upload:instructionsLabel"
                    defaults="Custom Instructions"
                  />
                </FormLabel>
                <FormControl>
                  <Textarea
                    placeholder="Any specific instructions for repurposing this content..."
                    className="min-h-[100px]"
                    data-test="custom-instructions-input"
                    {...field}
                  />
                </FormControl>
                <FormDescription>
                  <Trans
                    i18nKey="upload:instructionsDescription"
                    defaults="Optional: Provide specific instructions for how you'd like this content repurposed"
                  />
                </FormDescription>
                <FormMessage />
              </FormItem>
            )}
          />
          {/* Submit Button */}
          <div className="flex justify-end gap-3">
            <Button
              type="button"
              variant="outline"
              onClick={() => router.back()}
              disabled={isPending}
            >
              <Trans i18nKey="common:cancel" defaults="Cancel" />
            </Button>
            <Button
              type="submit"
              disabled={isPending}
              data-test="upload-submit-button"
            >
              <If condition={isPending}>
                <Spinner className="mr-2 h-4 w-4" />
                <Trans i18nKey="upload:uploading" defaults="Uploading..." />
              </If>
              <If condition={!isPending}>
                <Trans
                  i18nKey="upload:uploadButton"
                  defaults="Upload Content"
                />
              </If>
            </Button>
          </div>
        </form>
      </Form>
    </div>
  );
}

'use server';
import { z } from 'zod';
import { enhanceAction } from '@kit/next/actions';
import { getSupabaseServerClient } from '@kit/supabase/server-client';
import { ContentUploadSchema } from '../schema/content-upload.schema';
export const uploadContentAction = enhanceAction(
  async function uploadContent(data, user) {
    const client = getSupabaseServerClient();
    let fileUrl: string | null = null;
    let fileName: string | null = null;
    let fileSize: number | null = null;
    let fileType: string | null = null;
    let originalText = '';
    let uploadData: any = null;
    try {
      // Get account ID from team workspace context first
      const accountId = data.accountId;
      if (!accountId) {
        throw new Error('Account ID is required');
      }
      // Verify user has access to this account
      const { data: membership } = await client
        .from('accounts_memberships')
        .select('account_id')
        .eq('account_id', accountId)
        .eq('user_id', user.id)
        .single();
      if (!membership) {
        throw new Error('You do not have access to this account');
      }
      // Handle file upload if provided
      if (data.file) {
        const file = data.file;
        fileName = file.name;
        fileSize = file.size;
        fileType = file.type;
        if (!fileName) {
          throw new Error('File name is required');
        }
        // Generate unique file path with account ID (not user ID) for proper RLS
        const fileExt = fileName.split('.').pop();
        const filePath = `content-uploads/${accountId}/${Date.now()}-${Math.random().toString(36).substring(2)}.${fileExt}`;
        // Upload file to Supabase Storage
        const uploadResult = await client.storage
          .from('content-files')
          .upload(filePath, file);
        uploadData = uploadResult.data;
        const uploadError = uploadResult.error;
        if (uploadError) {
          throw new Error(`File upload failed: ${uploadError.message}`);
        }
        // Get public URL
        const { data: urlData } = client.storage
          .from('content-files')
          .getPublicUrl(filePath);
        fileUrl = urlData.publicUrl;
        // Read file content
        const fileContent = await file.text();
        originalText = fileContent;
      }
      // Handle URL content if provided (without file)
      if (data.contentUrl && !data.file) {
        try {
          const response = await fetch(data.contentUrl);
          if (!response.ok) {
            throw new Error(
              `Failed to fetch content from URL: ${response.statusText}`,
            );
          }
          originalText = await response.text();
        } catch (error) {
          throw new Error(
            `Unable to fetch content from URL: ${error instanceof Error ? error.message : 'Unknown error'}`,
          );
        }
      }
      if (!originalText.trim()) {
        throw new Error(
          'No content found. Please provide either a valid URL or upload a file with content.',
        );
      }
      // Insert original content record
      const { data: contentRecord, error: insertError } = await client
        .from('original_content')
        .insert({
          account_id: accountId,
          title: data.title,
          content_type: data.contentType,
          original_text: originalText,
          file_url: fileUrl,
          file_name: fileName,
          file_size: fileSize,
          file_type: fileType,
          status: 'uploaded',
          metadata: {
            source: data.file ? 'file_upload' : 'url',
            original_url: data.contentUrl || null,
            custom_instructions: data.customInstructions || null,
          },
          tags: data.tags || [],
          created_by: user.id,
        })
        .select()
        .single();
      if (insertError) {
        // Clean up uploaded file if database insert fails
        if (fileUrl && uploadData?.path) {
          await client.storage.from('content-files').remove([uploadData.path]);
        }
        throw new Error(`Failed to save content: ${insertError.message}`);
      }
      return {
        success: true,
        data: {
          contentId: contentRecord.id,
          title: contentRecord.title,
          contentType: contentRecord.content_type,
          wordCount: contentRecord.word_count,
        },
      };
    } catch (error) {
      return {
        success: false,
        error: error instanceof Error ? error.message : 'Upload failed',
      };
    }
  },
  {
    auth: true,
    schema: ContentUploadSchema.and(
      z.object({
        accountId: z.string().uuid(),
      }),
    ),
  },
);

-- Content Files for AI Content RepurposerAdd commentMore actions
insert into
  storage.buckets (id, name, PUBLIC)
values
  ('content-files', 'content-files', false);
  More actions
-- Helper function to extract account ID from content file path
create or replace function kit.get_account_id_from_content_path(file_path text)
returns uuid
language plpgsql
security definer
set search_path to ''
as $$
declare
  account_uuid uuid;
begin
  -- Extract account ID from path like: content-uploads/{account_id}/{file}
  -- Split by '/' and get the second part (index 2 in array, since arrays are 1-indexed)
  select (string_to_array(file_path, '/'))[2]::uuid into account_uuid;
  
  return account_uuid;
exception
  when others then
    return null;
end;
$$;
grant execute on function kit.get_account_id_from_content_path(text) to authenticated, service_role;
-- RLS policies for storage bucket content-files using team account access control
create policy content_files_select on storage.objects for select using (
  bucket_id = 'content-files'
  and auth.role() = 'authenticated'
  and public.has_role_on_account(kit.get_account_id_from_content_path(name))
);
create policy content_files_insert on storage.objects for insert with check (
  bucket_id = 'content-files'
  and auth.role() = 'authenticated'
  and starts_with(name, 'content-uploads/')
  and public.has_role_on_account(kit.get_account_id_from_content_path(name))
);
create policy content_files_update on storage.objects for update using (
  bucket_id = 'content-files'
  and auth.role() = 'authenticated'
  and public.has_role_on_account(kit.get_account_id_from_content_path(name))
) with check (
  bucket_id = 'content-files'
  and auth.role() = 'authenticated'
  and public.has_role_on_account(kit.get_account_id_from_content_path(name))
);
create policy content_files_delete on storage.objects for delete using (
  bucket_id = 'content-files'
  and auth.role() = 'authenticated'
  and public.has_role_on_account(kit.get_account_id_from_content_path(name))
);

import Link from 'next/link';
import { Plus } from 'lucide-react';
import { Button } from '@kit/ui/button';
import { Trans } from '@kit/ui/trans';
interface ContentHeaderProps {
  accountSlug: string;
  totalCount: number;
}
export function ContentHeader({ accountSlug, totalCount }: ContentHeaderProps) {
  return (
    <div className="flex items-center justify-between">
      <div>
        <h2 className="text-2xl font-semibold tracking-tight">
          <Trans i18nKey="content:listTitle" defaults="Content Library" />
        </h2>
        <p className="text-muted-foreground">
          <Trans
            i18nKey="content:listDescription"
            values={{ count: totalCount }}
            defaults="Manage and repurpose your content"
          />
        </p>
      </div>
      <Button asChild>
        <Link href={`/home/${accountSlug}/upload`}>
          <Plus className="mr-2 h-4 w-4" />
          <Trans i18nKey="content:uploadNew" defaults="Upload Content" />
        </Link>
      </Button>
    </div>
  );
}

import Link from 'next/link';
import { formatDistanceToNow } from 'date-fns';
import { Clock, FileText, Globe, User } from 'lucide-react';
import { Badge } from '@kit/ui/badge';
import { Button } from '@kit/ui/button';
import { Card, CardContent, CardHeader, CardTitle } from '@kit/ui/card';
import { If } from '@kit/ui/if';
import { Trans } from '@kit/ui/trans';
import type { ContentItem } from '../_lib/server/content.loader';
interface ContentListProps {
  content: ContentItem[];
  accountSlug: string;
}
export function ContentList({ content, accountSlug }: ContentListProps) {
  if (content.length === 0) {
    return <EmptyState accountSlug={accountSlug} />;
  }
  return (
    <div className="grid gap-4 md:grid-cols-2 lg:grid-cols-3">
      {content.map((item) => (
        <ContentCard key={item.id} content={item} accountSlug={accountSlug} />
      ))}
    </div>
  );
}
function ContentCard({
  content,
  accountSlug,
}: {
  content: ContentItem;
  accountSlug: string;
}) {
  const isFromFile = content.metadata?.source === 'file_upload';
  const statusColor = getStatusColor(content.status);
  return (
    <Card className="group transition-all hover:shadow-md">
      <CardHeader className="pb-3">
        <div className="flex items-start justify-between">
          <div className="flex items-center gap-2">
            {isFromFile ? (
              <FileText className="text-muted-foreground h-4 w-4" />
            ) : (
              <Globe className="text-muted-foreground h-4 w-4" />
            )}
            <Badge variant="outline" className="text-xs">
              {formatContentType(content.content_type)}
            </Badge>
          </div>
          <Badge variant={statusColor} className="text-xs">
            {formatStatus(content.status)}
          </Badge>
        </div>
        <CardTitle className="line-clamp-2 text-base leading-tight">
          {content.title}
        </CardTitle>
      </CardHeader>
      <CardContent className="pt-0">
        <div className="space-y-3">
          {/* Content Info */}
          <div className="text-muted-foreground flex items-center gap-4 text-sm">
            <If condition={!!content.word_count}>
              <div className="flex items-center gap-1">
                <FileText className="h-3 w-3" />
                <span>{content.word_count} words</span>
              </div>
            </If>
            <div className="flex items-center gap-1">
              <Clock className="h-3 w-3" />
              <span>
                {formatDistanceToNow(new Date(content.created_at), {
                  addSuffix: true,
                })}
              </span>
            </div>
          </div>
          {/* File Name */}
          <If condition={!!content.file_name}>
            <div className="text-muted-foreground text-sm">
              <span className="font-medium">File:</span> {content.file_name}
            </div>
          </If>
          {/* Tags */}
          <If condition={content.tags && content.tags.length > 0}>
            <div className="flex flex-wrap gap-1">
              {content.tags.slice(0, 3).map((tag, index) => (
                <Badge key={index} variant="secondary" className="text-xs">
                  {tag}
                </Badge>
              ))}
              <If condition={content.tags.length > 3}>
                <Badge variant="secondary" className="text-xs">
                  +{content.tags.length - 3}
                </Badge>
              </If>
            </div>
          </If>
          {/* Actions */}
          <div className="flex gap-2 pt-2">
            <Button asChild variant="outline" size="sm" className="flex-1">
              <Link href={`/home/${accountSlug}/content/${content.id}`}>
                <Trans i18nKey="content:viewDetails" defaults="View Details" />
              </Link>
            </Button>
            <If condition={content.status === 'uploaded'}>
              <Button asChild size="sm" className="flex-1">
                <Link
                  href={`/home/${accountSlug}/content/${content.id}/repurpose`}
                >
                  <Trans i18nKey="content:repurpose" defaults="Repurpose" />
                </Link>
              </Button>
            </If>
          </div>
        </div>
      </CardContent>
    </Card>
  );
}
function EmptyState({ accountSlug }: { accountSlug: string }) {
  return (
    <div className="flex flex-col items-center justify-center py-12 text-center">
      <div className="bg-muted mx-auto mb-4 flex h-16 w-16 items-center justify-center rounded-full">
        <FileText className="text-muted-foreground h-8 w-8" />
      </div>
      <h3 className="mb-2 text-lg font-semibold">
        <Trans i18nKey="content:noContentTitle" defaults="No content yet" />
      </h3>
      <p className="text-muted-foreground mb-6 max-w-sm">
        <Trans
          i18nKey="content:noContentDescription"
          defaults="Upload your first piece of content to start repurposing it for different platforms."
        />
      </p>
      <Button asChild>
        <Link href={`/home/${accountSlug}/upload`}>
          <Trans i18nKey="content:uploadFirst" defaults="Upload Content" />
        </Link>
      </Button>
    </div>
  );
}
function formatContentType(type: string): string {
  const typeMap: Record<string, string> = {
    blog_post: 'Blog Post',
    article: 'Article',
    social_media_post: 'Social Post',
    newsletter: 'Newsletter',
    video_script: 'Video Script',
    podcast_script: 'Podcast Script',
  };
  return typeMap[type] || type;
}
function formatStatus(status: string): string {
  const statusMap: Record<string, string> = {
    uploaded: 'Ready',
    processing: 'Processing',
    completed: 'Completed',
    failed: 'Failed',
  };
  return statusMap[status] || status;
}
function getStatusColor(
  status: string,
): 'default' | 'secondary' | 'destructive' | 'outline' {
  const colorMap: Record<
    string,
    'default' | 'secondary' | 'destructive' | 'outline'
  > = {
    uploaded: 'secondary',
    processing: 'default',
    completed: 'outline',
    failed: 'destructive',
  };
  return colorMap[status] || 'outline';
}