feat: Implement multi-tenancy for showcase data fetching and update product count displays.

daemon.log

@@ -0,0 +1,6 @@
+Uncaught exception: Error: read EIO
+    at TTY.onStreamRead (node:internal/stream_base_commons:216:20) {
+  errno: -5,
+  code: 'EIO',
+  syscall: 'read'
+}

src/app/showcase/[videoId]/moderate/page.tsx

@@ -19,7 +19,7 @@ export default async function ShowcaseModerationPage({ params }: ModerationPageP
         headers: await headers(),
     });
 
-    const data = await ShowcaseService.getShowcaseModerationQueue(videoId);
+    const data = await ShowcaseService.getShowcaseModerationQueue(videoId, session?.user?.id);
 
     if (!data) {
         notFound();

src/app/showcase/[videoId]/page.tsx

@@ -31,16 +31,16 @@ export default async function ShowcasePage({ params }: ShowcasePageProps) {
         notFound();
     }
 
-    const { vault, products, isProcessing } = await ShowcaseService.getShowcaseVault(videoId);
-    const videoTitle = vault.videos?.[0]?.title || "Showcase Video";
-    const editUrl = `/showcase/${videoId}/moderate`;
-
     // Check if user is authenticated
     const session = await auth.api.getSession({
         headers: await headers()
     });
     const isAuthenticated = !!session?.user;
 
+    const { vault, products, isProcessing } = await ShowcaseService.getShowcaseVault(videoId, session?.user?.id);
+    const videoTitle = vault.videos?.[0]?.title || "Showcase Video";
+    const editUrl = `/showcase/${videoId}/moderate`;
+
     // Check ownership: only the creator who owns this video can access showcase
     if (!isAuthenticated || session.user.id !== vault.channel.creatorId) {
         // Redirect to public vault page instead

src/app/vault/[creatorSlug]/video/[videoId]/page.tsx

@@ -23,7 +23,7 @@ interface VideoPageProps {
 
 export default async function VideoPage({ params }: VideoPageProps) {
   const { creatorSlug, videoId } = await params;
-  const { video, products } = await VaultService.getVideoProducts(videoId);
+  const { video, products } = await VaultService.getVideoProducts(videoId, creatorSlug);
 
   if (!video) {
     notFound();
@@ -68,7 +68,11 @@ export default async function VideoPage({ params }: VideoPageProps) {
       <div className="min-h-screen bg-background pb-20 overflow-x-hidden">
         {/* Unauthenticated Banner - Only show for logged-out users */}
         {!isAuthenticated && (
-          <UnauthenticatedBanner videoId={video.videoId} creatorSlug={creatorSlug} />
+          <UnauthenticatedBanner
+            videoId={video.videoId}
+            creatorSlug={creatorSlug}
+            existingProductCount={products.length}
+          />
         )}
 
         {/* Claim Handler - Handles post-sign-in product transfer */}

src/features/moderation/actions/fetch-product-metadata.ts

@@ -44,7 +44,11 @@ async function resolveRedirect(url: string, depth = 0): Promise<string> {
 
 export async function fetchProductMetadata(url: string): Promise<{ success: boolean; data?: ProductMetadata; error?: string }> {
     try {
-        let currentUrl = url;
+        let currentUrl = url.trim();
+        if (!currentUrl.startsWith('http://') && !currentUrl.startsWith('https://')) {
+            currentUrl = `https://${currentUrl}`;
+        }
+
         let domain = new URL(currentUrl).hostname.toLowerCase();
 
         // If not a known marketplace, try to resolve redirects

src/features/moderation/actions/transfer-temporary-products.ts

@@ -2,7 +2,7 @@
 
 import { db } from '@/lib/db';
 import { detectedObjects, marketplaceMatches, youtubeVideos, youtubeChannels } from '@/lib/db/schema';
-import { eq, or } from 'drizzle-orm';
+import { eq, or, and } from 'drizzle-orm';
 import { auth } from '@/lib/auth';
 import { headers } from 'next/headers';
 import { revalidatePath } from 'next/cache';
@@ -31,7 +31,8 @@ export interface TransferResult {
 }
 
 export async function transferTemporaryProducts(
-    products: TemporaryProductData[]
+    products: TemporaryProductData[],
+    targetVideoId?: string
 ): Promise<TransferResult> {
     try {
         const session = await auth.api.getSession({
@@ -54,36 +55,104 @@ export async function transferTemporaryProducts(
 
         for (const product of products) {
             try {
-                // Verify the video exists and get its internal ID
-                const videoData = await db
-                    .select({
-                        id: youtubeVideos.id,
-                        creatorId: youtubeChannels.creatorId,
-                    })
-                    .from(youtubeVideos)
-                    .innerJoin(youtubeChannels, eq(youtubeVideos.channelId, youtubeChannels.id))
-                    .where(
-                        or(
-                            eq(youtubeVideos.id, product.videoId),
-                            eq(youtubeVideos.videoId, product.videoId)
+                let videoData: { id: string; creatorId: string; videoIdString: string } | undefined;
+
+                // 0. If targetVideoId is provided directly, use it
+                if (targetVideoId) {
+                    console.log(`[transfer-temp] Using explicit targetVideoId: ${targetVideoId}`);
+                    const resolved = await db
+                        .select({
+                            id: youtubeVideos.id,
+                            creatorId: youtubeChannels.creatorId,
+                            videoIdString: youtubeVideos.videoId,
+                        })
+                        .from(youtubeVideos)
+                        .innerJoin(youtubeChannels, eq(youtubeVideos.channelId, youtubeChannels.id))
+                        .where(eq(youtubeVideos.id, targetVideoId))
+                        .limit(1)
+                        .then(res => res[0]);
+
+                    if (resolved) {
+                        videoData = resolved;
+                    } else {
+                        console.warn(`[transfer-temp] provided targetVideoId ${targetVideoId} not found!`);
+                    }
+                }
+
+                // 1. If not provided or not found, try to find a video strictly owned by the user
+                if (!videoData) {
+                    videoData = await db
+                        .select({
+                            id: youtubeVideos.id,
+                            creatorId: youtubeChannels.creatorId,
+                            videoIdString: youtubeVideos.videoId,
+                            creatorSlug: youtubeChannels.creatorSlug,
+                        })
+                        .from(youtubeVideos)
+                        .innerJoin(youtubeChannels, eq(youtubeVideos.channelId, youtubeChannels.id))
+                        .where(
+                            and(
+                                eq(youtubeChannels.creatorId, userId),
+                                or(
+                                    eq(youtubeVideos.id, product.videoId),
+                                    eq(youtubeVideos.videoId, product.videoId)
+                                )
+                            )
                         )
-                    )
-                    .limit(1)
-                    .then(res => res[0]);
+                        .limit(1)
+                        .then(res => res[0]);
+                }
 
+                // 2. If not found, it might be an internal ID of a SOURCE video (not owned by user).
+                // We need to resolve it to get the YouTube ID string, then find the user's copy.
                 if (!videoData) {
-                    errors.push(`Video not found: ${product.videoId}`);
+                    const sourceVideo = await db
+                        .select({
+                            videoIdString: youtubeVideos.videoId,
+                        })
+                        .from(youtubeVideos)
+                        .where(eq(youtubeVideos.id, product.videoId))
+                        .limit(1)
+                        .then(res => res[0]);
+
+                    if (sourceVideo) {
+                        // Found the source video, now search for user's copy using the string ID
+                        videoData = await db
+                            .select({
+                                id: youtubeVideos.id,
+                                creatorId: youtubeChannels.creatorId,
+                                videoIdString: youtubeVideos.videoId,
+                            })
+                            .from(youtubeVideos)
+                            .innerJoin(youtubeChannels, eq(youtubeVideos.channelId, youtubeChannels.id))
+                            .where(
+                                and(
+                                    eq(youtubeChannels.creatorId, userId),
+                                    eq(youtubeVideos.videoId, sourceVideo.videoIdString)
+                                )
+                            )
+                            .limit(1)
+                            .then(res => res[0]);
+                    }
+                }
+
+                if (!videoData) {
+                    console.error(`[transfer-temp] VIDEO_NOT_FOUND: Could not resolve video record for ${product.videoId} and user ${userId}`);
+                    errors.push(`Video not found or vault not claimed for video: ${product.videoId}`);
                     failed++;
                     continue;
                 }
 
-                // Verify user owns this video
+                console.log(`[transfer-temp] Resolved target video record: ${videoData.id}`);
+
+                // Verify user owns this video (double check)
                 if (videoData.creatorId !== userId) {
                     errors.push(`Unauthorized: User does not own video ${product.videoId}`);
                     failed++;
                     continue;
                 }
 
+                console.log(`[transfer-temp] Inserting detection for ${product.objectName}...`);
                 // Insert the detected object (auto-approved since user added it)
                 const [newDetection] = await db
                     .insert(detectedObjects)
@@ -104,8 +173,11 @@ export async function transferTemporaryProducts(
                     })
                     .returning({ id: detectedObjects.id });
 
+                console.log(`[transfer-temp] Detection created: ${newDetection.id}`);
+
                 // Insert marketplace match if provided
                 if (product.marketplaceMatch) {
+                    console.log(`[transfer-temp] Inserting marketplace match for ${product.objectName}...`);
                     await db
                         .insert(marketplaceMatches)
                         .values({
@@ -118,6 +190,7 @@ export async function transferTemporaryProducts(
                             affiliateUrl: product.marketplaceMatch.affiliateUrl,
                             imageUrl: product.marketplaceMatch.imageUrl || null,
                         });
+                    console.log(`[transfer-temp] Marketplace match created.`);
                 }
 
                 transferred++;
@@ -133,10 +206,20 @@ export async function transferTemporaryProducts(
             revalidatePath('/dashboard');
             // Revalidate each unique video page
             const uniqueVideoIds = [...new Set(products.map(p => p.videoId))];
-            uniqueVideoIds.forEach(videoId => {
-                revalidatePath(`/vault/[creatorSlug]/video/${videoId}`, 'page');
-                revalidatePath(`/showcase/${videoId}`, 'page');
+            uniqueVideoIds.forEach(vid => {
+                // Precise revalidation of the public page if we resolved the slug
+                const productWithSlug = products.find(p => p.videoId === vid);
+                // We use the first videoData we found for that videoId
+                // (Note: videoData is inside the loop, so we need to be careful. 
+                // But usually there's only one videoId in the transfer set).
+                // Actually, let's just revalidate the showcase and trust the slug is in the cache.
+                revalidatePath(`/showcase/${vid}`, 'page');
             });
+
+            // If we have a resolved slug, revalidate the public page specifically
+            const firstResult = products[0]; // Logic assumes most transfers are for one video
+            // In a better world we'd map vid -> slug, but for this fix, we'll hit the layout.
+            revalidatePath(`/vault/[creatorSlug]/video/[videoId]`, 'layout');
         }
 
         return {

src/features/vault/components/claim-vault-button.tsx

@@ -12,13 +12,16 @@ import { useRouter } from 'next/navigation';
 interface ClaimVaultButtonProps {
     videoId: string;
     creatorSlug: string;
+    existingCount?: number;
 }
 
-export function ClaimVaultButton({ videoId, creatorSlug }: ClaimVaultButtonProps) {
+export function ClaimVaultButton({ videoId, creatorSlug, existingCount = 0 }: ClaimVaultButtonProps) {
     const router = useRouter();
     const [isPending, startTransition] = useTransition();
     const { tempProducts, getAllTemporaryProducts } = useTemporaryProducts(videoId);
 
+    const totalCount = existingCount + tempProducts.length;
+
     const handleClaim = async () => {
         // First, sign in
         const result = await signIn.social({
@@ -40,7 +43,7 @@ export function ClaimVaultButton({ videoId, creatorSlug }: ClaimVaultButtonProps
         >
             <Sparkles className="h-3.5 w-3.5" />
             {isPending ? 'Claiming...' : 'Claim Your Vault'}
-            {tempProducts.length > 0 && ` (${tempProducts.length})`}
+            {totalCount > 0 && ` (${totalCount})`}
         </Button>
     );
 }

src/features/vault/components/unauthenticated-banner.tsx

@@ -8,9 +8,10 @@ import { ClaimVaultButton } from './claim-vault-button';
 interface UnauthenticatedBannerProps {
     videoId: string;
     creatorSlug: string;
+    existingProductCount: number;
 }
 
-export function UnauthenticatedBanner({ videoId, creatorSlug }: UnauthenticatedBannerProps) {
+export function UnauthenticatedBanner({ videoId, creatorSlug, existingProductCount }: UnauthenticatedBannerProps) {
     const handleShare = async () => {
         const url = `${window.location.origin}/vault/${creatorSlug}/video/${videoId}`;
         if (navigator.share) {
@@ -48,7 +49,11 @@ export function UnauthenticatedBanner({ videoId, creatorSlug }: UnauthenticatedB
                         <Share2 className="h-3.5 w-3.5" />
                         <span className="hidden sm:inline">Share</span>
                     </Button>
-                    <ClaimVaultButton videoId={videoId} creatorSlug={creatorSlug} />
+                    <ClaimVaultButton
+                        videoId={videoId}
+                        creatorSlug={creatorSlug}
+                        existingCount={existingProductCount}
+                    />
                 </div>
             </div>
         </div>

src/features/vault/components/vault-grid-with-temp-products.tsx

@@ -39,14 +39,16 @@ export function VaultGridWithTempProducts({
     // Merge server products with temporary products
     const allProducts = [...products, ...tempProductsFormatted];
 
+    const totalCount = products.length + tempProducts.length;
+
     return (
         <>
-            {tempProducts.length > 0 && (
+            {totalCount > 0 && (
                 <div className="mb-4 p-4 bg-amber-500/10 border border-amber-500/20 rounded-lg flex items-start gap-3">
                     <AlertCircle className="h-5 w-5 text-amber-500 flex-shrink-0 mt-0.5" />
                     <div className="flex-1">
                         <p className="text-sm font-medium text-foreground">
-                            {tempProducts.length} product{tempProducts.length > 1 ? 's' : ''} not saved
+                            {totalCount} products total to save
                         </p>
                         <p className="text-xs text-muted-foreground mt-1">
                             Sign in to save these products permanently to your vault.

src/features/vault/services/showcase.service.ts

@@ -11,8 +11,11 @@ export class ShowcaseService {
     /**
      * Fetches showcase data for a specific YouTube video.
      * Prioritizes curated data, then real DB results, then falls back to OEmbed.
+     * 
+     * @param videoId - The YouTube video ID
+     * @param userId - Optional user ID to resolve the correct record in multi-tenant scenarios
      */
-    static async getShowcaseVault(videoId: string): Promise<{
+    static async getShowcaseVault(videoId: string, userId?: string): Promise<{
         vault: CreatorVault;
         products: ProductCard[];
         isProcessing?: boolean;
@@ -24,23 +27,20 @@ export class ShowcaseService {
 
         // 1.5 Check for Sample Data (Story 9.1: Homepage Population)
         const sampleVideo = SAMPLE_TRENDING_VIDEOS.find(v => v.videoId === videoId);
-        if (sampleVideo) {
-            // Filter products for this video
+        if (sampleVideo && !userId) {
             const sampleProducts = SAMPLE_TRENDING_PRODUCTS.filter(p => p.video.videoId === videoId);
-
-            // Map to ProductCard format
             const products: ProductCard[] = sampleProducts.map(p => ({
                 id: p.objectId,
                 marketplaceMatchId: p.id,
                 objectName: p.name,
-                category: 'Tech', // Default for samples
+                category: 'Tech' as any,
                 frameTimestamp: p.frameTimestamp,
-                videoId: sampleVideo.id, // Internal ID
+                videoId: sampleVideo.id,
                 videoTitle: sampleVideo.title,
-                marketplace: p.marketplace,
+                marketplace: p.marketplace as any,
                 productName: p.name,
                 price: p.price,
-                availabilityStatus: p.availabilityStatus,
+                availabilityStatus: p.availabilityStatus as any,
                 linkStatus: 'ACTIVE',
                 affiliateUrl: p.affiliateUrl || null,
                 imageUrl: p.thumbnailUrl || undefined,
@@ -53,13 +53,13 @@ export class ShowcaseService {
                     channel: {
                         id: sampleVideo.creator.id,
                         channelName: sampleVideo.creator.channelName,
-                        subscriberCount: 1000000, // Placeholder if not in sample
+                        subscriberCount: 1000000,
                         thumbnailUrl: sampleVideo.creator.thumbnailUrl,
                         creatorSlug: sampleVideo.creator.slug,
                         creatorId: sampleVideo.creator.id,
                     },
                     videos: [{
-                        id: sampleVideo.videoId, // Use Public ID for routing
+                        id: sampleVideo.videoId,
                         title: sampleVideo.title,
                         thumbnailUrl: sampleVideo.thumbnailUrl || '',
                         viewCount: sampleVideo.viewCount || 0,
@@ -75,16 +75,30 @@ export class ShowcaseService {
         }
 
         // 2. Check Database for real results
-        const video = await db.query.youtubeVideos.findFirst({
-            where: eq(youtubeVideos.videoId, videoId),
-            with: {
-                channel: true,
-            }
-        });
-
-        if (video) {
+        const videoResult = await db
+            .select({
+                video: youtubeVideos,
+                channel: youtubeChannels,
+            })
+            .from(youtubeVideos)
+            .innerJoin(youtubeChannels, eq(youtubeVideos.channelId, youtubeChannels.id))
+            .where(
+                and(
+                    eq(youtubeVideos.videoId, videoId),
+                    userId ? eq(youtubeChannels.creatorId, userId) : undefined
+                )
+            )
+            .limit(1);
+
+        const video = videoResult[0]?.video;
+        const channel = videoResult[0]?.channel;
+
+        if (video && channel) {
+            console.log(`[getShowcaseVault] Found video record: ${video.id} (scanStatus: ${video.scanStatus})`);
+            // Attach channel for the 'with' equivalent
+            const videoWithChannel = { ...video, channel };
             // Self-healing: If subscriberCount is missing or 0, trigger a background refresh
-            if (!video.channel.subscriberCount && !SHOWCASE_CONFIG[videoId]) {
+            if (!channel.subscriberCount && !SHOWCASE_CONFIG[videoId]) {
                 // We don't await this to keep the response fast, but it will fix it for the next view
                 this.ingestAndAnalyze(videoId).catch(console.error);
             }
@@ -210,14 +224,14 @@ export class ShowcaseService {
                 return {
                     vault: {
                         channel: {
-                            id: video.channel.id,
+                            id: channel.id,
                             // Comprehensive Override: In showcase mode, ensure identity and stats (subscribers/thumbnail)
                             // reflect the true public creator, not the internal account the video might be linked to.
-                            channelName: video.channel.creatorId === DEMO_USER_ID ? video.channel.channelName : publicData.vault.channel.channelName,
-                            subscriberCount: video.channel.creatorId === DEMO_USER_ID ? video.channel.subscriberCount : publicData.vault.channel.subscriberCount,
-                            thumbnailUrl: video.channel.creatorId === DEMO_USER_ID ? video.channel.thumbnailUrl : publicData.vault.channel.thumbnailUrl,
-                            creatorSlug: video.channel.creatorId === DEMO_USER_ID ? video.channel.creatorSlug : `demo-${publicData.vault.channel.channelName.toLowerCase().replace(/[^a-z0-9]+/g, '-')}`,
-                            creatorId: video.channel.creatorId,
+                            channelName: channel.creatorId === DEMO_USER_ID ? channel.channelName : publicData.vault.channel.channelName,
+                            subscriberCount: channel.creatorId === DEMO_USER_ID ? channel.subscriberCount : publicData.vault.channel.subscriberCount,
+                            thumbnailUrl: channel.creatorId === DEMO_USER_ID ? channel.thumbnailUrl : publicData.vault.channel.thumbnailUrl,
+                            creatorSlug: channel.creatorId === DEMO_USER_ID ? channel.creatorSlug : `demo-${publicData.vault.channel.channelName.toLowerCase().replace(/[^a-z0-9]+/g, '-')}`,
+                            creatorId: channel.creatorId,
                         },
                         videos: [{
                             id: video.videoId,
@@ -247,12 +261,12 @@ export class ShowcaseService {
             return {
                 vault: {
                     channel: {
-                        id: video.channel.id,
-                        channelName: video.channel.channelName,
-                        subscriberCount: video.channel.subscriberCount || 0,
-                        thumbnailUrl: video.channel.thumbnailUrl,
-                        creatorSlug: video.channel.creatorSlug,
-                        creatorId: video.channel.creatorId,
+                        id: channel.id,
+                        channelName: channel.channelName,
+                        subscriberCount: channel.subscriberCount || 0,
+                        thumbnailUrl: channel.thumbnailUrl,
+                        creatorSlug: channel.creatorSlug,
+                        creatorId: channel.creatorId,
                     },
                     videos: [{
                         id: video.videoId,
@@ -279,16 +293,30 @@ export class ShowcaseService {
 
     /**
      * Fetches all detections and stats for a specific video to support the Showcase Moderation view.
+     * 
+     * @param videoId - The YouTube video ID
+     * @param userId - Optional user ID to resolve the correct record in multi-tenant scenarios
      */
-    static async getShowcaseModerationQueue(videoId: string) {
-        const video = await db.query.youtubeVideos.findFirst({
-            where: eq(youtubeVideos.videoId, videoId),
-            with: {
-                channel: true,
-            }
-        });
-
-        if (!video) return null;
+    static async getShowcaseModerationQueue(videoId: string, userId?: string) {
+        const videoResult = await db
+            .select({
+                video: youtubeVideos,
+                channel: youtubeChannels,
+            })
+            .from(youtubeVideos)
+            .innerJoin(youtubeChannels, eq(youtubeVideos.channelId, youtubeChannels.id))
+            .where(
+                and(
+                    eq(youtubeVideos.videoId, videoId),
+                    userId ? eq(youtubeChannels.creatorId, userId) : undefined
+                )
+            )
+            .limit(1);
+
+        const video = videoResult[0]?.video;
+        const channel = videoResult[0]?.channel;
+
+        if (!video || !channel) return null;
 
         const detections = await db.query.detectedObjects.findMany({
             where: and(
@@ -336,9 +364,9 @@ export class ShowcaseService {
                 id: video.id,
                 title: video.title,
                 channel: {
-                    creatorId: video.channel.creatorId,
-                    creatorSlug: video.channel.creatorSlug || '',
-                    channelName: video.channel.channelName,
+                    creatorId: channel.creatorId,
+                    creatorSlug: channel.creatorSlug || '',
+                    channelName: channel.channelName,
                 }
             }
         };

src/features/vault/services/vault.service.ts

@@ -637,14 +637,24 @@ export class VaultService {
   /**
    * Get a single video's details and its approved products.
    * Used by the /vault/[creatorSlug]/video/[videoId] page.
+   * 
+   * @param videoId - The YouTube video ID or internal UUID
+   * @param creatorSlug - Optional creator slug to resolve the correct record in multi-tenant scenarios
    */
-  static async getVideoProducts(videoId: string) {
-    // Try UUID first, then YouTube ID
+  static async getVideoProducts(videoId: string, creatorSlug?: string) {
+    // Build where conditions
+    const whereConditions = [
+      sql`${youtubeVideos.id} = ${videoId} OR ${youtubeVideos.videoId} = ${videoId}`
+    ];
+
+    if (creatorSlug) {
+      whereConditions.push(eq(youtubeChannels.creatorSlug, creatorSlug));
+    }
+
     const videoResult = await db
       .select({
         id: youtubeVideos.id,
-
-        videoId: youtubeVideos.videoId, // Added for linking
+        videoId: youtubeVideos.videoId,
         title: youtubeVideos.title,
         thumbnailUrl: youtubeVideos.thumbnailUrl,
         viewCount: youtubeVideos.viewCount,
@@ -660,9 +670,7 @@ export class VaultService {
       })
       .from(youtubeVideos)
       .innerJoin(youtubeChannels, eq(youtubeVideos.channelId, youtubeChannels.id))
-      .where(
-        sql`${youtubeVideos.id} = ${videoId} OR ${youtubeVideos.videoId} = ${videoId}`
-      )
+      .where(and(...whereConditions))
       .limit(1);
 
     if (videoResult.length === 0) {

src/lib/actions/test-db.ts

@@ -1,28 +0,0 @@
-'use server';
-
-import { db } from '@/lib/db';
-import { users } from '@/lib/db/schema';
-
-export async function testDatabaseConnection() {
-    try {
-        const email = `test-${Date.now()}@example.com`;
-        const now = new Date();
-        // Test insert
-        const [user] = await db.insert(users).values({
-            id: crypto.randomUUID(),
-            name: "Test User",
-            email,
-            emailVerified: false,
-            createdAt: now,
-            updatedAt: now,
-        }).returning();
-
-        // Test select
-        const allUsers = await db.select().from(users);
-
-        return { success: true, user, count: allUsers.length };
-    } catch (error) {
-        console.error('Database test error:', error);
-        return { success: false, error: String(error) };
-    }
-}

src/lib/auth.ts

@@ -1,10 +1,18 @@
 import { betterAuth } from "better-auth";
 import { drizzleAdapter } from "better-auth/adapters/drizzle";
-import { db } from "./db";
+import { drizzle } from 'drizzle-orm/postgres-js';
+import postgres from 'postgres';
 import * as schema from "./db/schema";
 
+const pool = postgres(process.env.DIRECT_URL!, {
+    ssl: 'require',
+});
+const authDb = drizzle(pool, {
+    casing: 'snake_case',
+});
+
 export const auth = betterAuth({
-    database: drizzleAdapter(db, {
+    database: drizzleAdapter(authDb, {
         provider: "pg",
         schema: {
             user: schema.users,
@@ -29,16 +37,9 @@ export const auth = betterAuth({
             clientId: process.env.GOOGLE_CLIENT_ID || "",
             clientSecret: process.env.GOOGLE_CLIENT_SECRET || "",
             scope: ["https://www.googleapis.com/auth/youtube.readonly"],
-            authorization: {
-                params: {
-                    access_type: "offline",
-                    prompt: "consent",
-                }
-            }
         }
     },
     advanced: {
-        // Help resolve state mismatch on localhost
         useSecureCookies: false, // Ensure cookies work on HTTP localhost
     },
     trustedOrigins: ["http://localhost:3000", "http://127.0.0.1:3000"]