create-nextblock 0.2.78 → 0.8.0

package/templates/nextblock-template/app/actions/formActions.ts

@@ -2,23 +2,142 @@
 "use server";
 
 import { sendEmail } from './email';
+import { getServiceRoleSupabaseClient } from '@nextblock-cms/db/server';
 
-interface FormSubmissionResult {
-  success: boolean;
-  message: string;
-}
+interface FormSubmissionResult {
+  success: boolean;
+  message: string;
+}
+
+type BotProtectionProvider = 'none' | 'turnstile' | 'recaptcha';
+
+type FormSubmissionConfig = {
+  recipient: string;
+  botProtectionProvider?: BotProtectionProvider;
+};
+
+function normalizeSubmissionConfig(config: string | FormSubmissionConfig) {
+  if (typeof config === 'string') {
+    return {
+      recipient: config,
+      botProtectionProvider: undefined,
+    };
+  }
+
+  return config;
+}
+
+export async function handleFormSubmission(
+  config: string | FormSubmissionConfig,
+  prevState: unknown,
+  formData: FormData
+): Promise<FormSubmissionResult> {
+  const { recipient, botProtectionProvider } = normalizeSubmissionConfig(config);
+
+  // Phase 1: Honeypot Validation
+  const honeypot = formData.get('verification_secondary_email');
+  if (honeypot && typeof honeypot === 'string' && honeypot.length > 0) {
+    console.warn("[Bot Protection] Honeypot triggered. Discarding submission from bot.");
+    // Fool the bot by returning a fake success response immediately
+    return { success: true, message: "Submission successful!" };
+  }
+
+  // Phase 2: Advanced Captcha Verification
+  try {
+    const supabase = getServiceRoleSupabaseClient();
+    
+    // Fetch global bot protection settings
+    const { data: publicSetting } = await supabase
+      .from('site_settings')
+      .select('value')
+      .eq('key', 'bot_protection_public')
+      .maybeSingle();
+
+    const { data: secretSetting } = await supabase
+      .from('site_settings')
+      .select('value')
+      .eq('key', 'bot_protection_secret')
+      .maybeSingle();
+
+    const publicVal = (publicSetting?.value || {}) as Record<string, any>;
+    const secretVal = (secretSetting?.value || {}) as Record<string, any>;
+
+    const blockProvider =
+      botProtectionProvider === 'turnstile' || botProtectionProvider === 'recaptcha'
+        ? botProtectionProvider
+        : undefined;
+    const provider = blockProvider || publicVal.provider || 'none';
+    const secretKey = secretVal.secretKey || 
+      (provider === 'turnstile' ? process.env.TURNSTILE_SECRET_KEY : process.env.RECAPTCHA_SECRET_KEY) || 
+      '';
+
+    if (provider === 'turnstile') {
+      const token = formData.get('cf-turnstile-response') as string;
+      if (!token) {
+        return { success: false, message: "Security verification token is missing. Please try again." };
+      }
+      if (!secretKey) {
+        console.error("[Bot Protection] Turnstile secret key is not configured.");
+        return { success: false, message: "Bot protection is misconfigured. Please contact support." };
+      }
+
+      const res = await fetch('https://challenges.cloudflare.com/turnstile/v0/siteverify', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: `secret=${encodeURIComponent(secretKey)}&response=${encodeURIComponent(token)}`,
+      });
 
-export async function handleFormSubmission(
-  recipient: string,
-  prevState: unknown,
-  formData: FormData
-): Promise<FormSubmissionResult> {
+      const outcome = await res.json();
+      if (!outcome.success) {
+        console.warn("[Bot Protection] Turnstile verification failed:", outcome);
+        return { success: false, message: "Security verification failed. Please try again." };
+      }
+    } else if (provider === 'recaptcha') {
+      const token = formData.get('g-recaptcha-response') as string;
+      if (!token) {
+        return { success: false, message: "Security verification token is missing. Please try again." };
+      }
+      if (!secretKey) {
+        console.error("[Bot Protection] reCAPTCHA secret key is not configured.");
+        return { success: false, message: "Bot protection is misconfigured. Please contact support." };
+      }
+
+      const res = await fetch('https://www.google.com/recaptcha/api/siteverify', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: `secret=${encodeURIComponent(secretKey)}&response=${encodeURIComponent(token)}`,
+      });
+
+      const outcome = await res.json();
+      if (!outcome.success || outcome.score < 0.5) {
+        console.warn("[Bot Protection] reCAPTCHA verification failed:", outcome);
+        return { success: false, message: "Security verification failed. Please try again." };
+      }
+    }
+  } catch (error) {
+    console.error("[Bot Protection] Error during validation:", error);
+    // If database or fetch error occurs, we gracefully degrade or warn, but let's be secure and fail open/closed depending on preference.
+    // The requirement says: "If the API indicates a verification failure or falls below a threshold... reject the operation securely."
+    // Let's return error message.
+    return { success: false, message: "Sorry, security verification could not be completed at this time." };
+  }
 
   const data: Record<string, string | File> = {};
   let submitterEmail = 'a user'; // Default value
 
   formData.forEach((value, key) => {
-    if (typeof value === 'string' && !key.startsWith('$')) {
+    // Avoid sending internal bot protection tokens and honeypots in the notification email
+    if (
+      typeof value === 'string' && 
+      !key.startsWith('$') && 
+      key !== 'verification_secondary_email' && 
+      key !== 'g-recaptcha-response' && 
+      key !== 'cf-turnstile-response'
+    ) {
       data[key] = value;
       // Attempt to find a field that looks like an email address to use in the subject
       if (key.toLowerCase().includes('email')) {
@@ -62,4 +181,4 @@ export async function handleFormSubmission(
     console.error("Email sending failed:", error);
     return { success: false, message: "Sorry, there was an error sending your message. Please try again later." };
   }
-}
+}

package/templates/nextblock-template/app/actions/languageActions.ts

@@ -3,7 +3,7 @@
 import { createClient } from '@nextblock-cms/db';
 import { cookies } from 'next/headers';
 import { redirect } from 'next/navigation';
-import { getLanguageByCode } from '@/app/cms/settings/languages/actions';
+import { getLanguageByCode } from '../cms/settings/languages/actions';
 
 export interface Language {
   id: number;
@@ -33,43 +33,37 @@ export async function setCurrentLocaleCookie(locale: string) {
   cookieStore.set('NEXT_LOCALE', locale, { path: '/' });
 }
 
-export async function getPageTranslations(translationGroupId: string): Promise<{ slug: string, language_code: string }[]> {
+export async function getContentTranslations(translationGroupId: string, type: 'pages' | 'posts' | 'products' = 'pages'): Promise<{ slug: string, language_code: string }[]> {
   if (!translationGroupId) {
-    console.warn('getPageTranslations called without translationGroupId');
+    console.warn('getContentTranslations called without translationGroupId');
     return [];
   }
   const supabase = createClient();
 
   const { data, error } = await supabase
-    .from('pages')
-    .select('slug, status, languages(code)') // Use actual table name for join
+    .from(type)
+    .select('slug, languages(code)')
     .eq('translation_group_id', translationGroupId)
-    .eq('status', 'published');
+    .eq('status', type === 'products' ? 'active' : 'published'); // Products use 'active' or 'draft' status usually, but let's check
 
   if (error) {
-    console.error('Error fetching page translations:', error);
+    console.error(`Error fetching translations for ${type}:`, error);
     return [];
   }
 
-  interface PageWithLanguage {
-    slug: string;
-    status: string; // Or your actual status type
-    languages: { code: string } | { code: string }[] | null; // Can be object, array of objects, or null
-  }
-
   // Map the data to the expected format { slug: string, language_code: string }
   const formattedTranslations = data
-    ? (data as PageWithLanguage[]).map(page => {
+    ? (data as any[]).map(item => {
         let langCode = '';
-        if (page.languages) {
-          if (Array.isArray(page.languages)) {
-            langCode = page.languages[0]?.code || '';
-          } else { // It's an object
-            langCode = page.languages.code || '';
+        if (item.languages) {
+          if (Array.isArray(item.languages)) {
+            langCode = item.languages[0]?.code || '';
+          } else { 
+            langCode = item.languages.code || '';
           }
         }
         return {
-          slug: page.slug,
+          slug: item.slug,
           language_code: langCode,
         };
       }).filter(t => t.language_code)
@@ -78,6 +72,10 @@ export async function getPageTranslations(translationGroupId: string): Promise<{
   return formattedTranslations;
 }
 
+export async function getPageTranslations(translationGroupId: string): Promise<{ slug: string, language_code: string }[]> {
+  return getContentTranslations(translationGroupId, 'pages');
+}
+
 // Helper to get language details by code, potentially used by LanguageSwitcher or other components
 export async function getLanguageDetails(localeCode: string): Promise<Language | null> {
     const { data, error } = await getLanguageByCode(localeCode);
@@ -89,9 +87,9 @@ export async function getLanguageDetails(localeCode: string): Promise<Language |
     return data;
 }
 
-export async function getPageMetadataBySlugAndLocale(slug: string, localeCode: string): Promise<{ slug: string; translation_group_id: string | null } | null> {
+export async function getContentMetadataBySlugAndLocale(slug: string, localeCode: string, type: 'pages' | 'posts' | 'products' = 'pages'): Promise<{ slug: string; translation_group_id: string | null; type: string } | null> {
   if (!slug || !localeCode) {
-    console.warn('getPageMetadataBySlugAndLocale called without slug or localeCode');
+    console.warn('getContentMetadataBySlugAndLocale called without slug or localeCode');
     return null;
   }
   const supabase = createClient();
@@ -102,24 +100,27 @@ export async function getPageMetadataBySlugAndLocale(slug: string, localeCode: s
     return null;
   }
 
-  const { data: page, error } = await supabase
-    .from('pages')
+  const { data: item, error } = await supabase
+    .from(type)
     .select('slug, translation_group_id')
     .eq('slug', slug)
     .eq('language_id', languageData.id)
     .maybeSingle();
 
   if (error) {
-    console.error(`Error fetching page metadata for slug ${slug} and locale ${localeCode}:`, error);
+    console.error(`Error fetching metadata for ${type} slug ${slug} and locale ${localeCode}:`, error);
     return null;
   }
-  if (!page) {
-    // It's possible the slug is for a different content type (e.g. blog post) or doesn't exist.
-    // For now, we only search 'pages'. This might need to be expanded or handled gracefully.
-    console.warn(`No page found for slug ${slug} and locale ${localeCode}`);
+  if (!item) {
     return null;
   }
-  return page;
+  return { ...item, type };
+}
+
+export async function getPageMetadataBySlugAndLocale(slug: string, localeCode: string): Promise<{ slug: string; translation_group_id: string | null } | null> {
+  const metadata = await getContentMetadataBySlugAndLocale(slug, localeCode, 'pages');
+  if (!metadata) return null;
+  return { slug: metadata.slug, translation_group_id: metadata.translation_group_id };
 }
 
 export async function changeLanguage(newLocale: string, currentPath: string) {

package/templates/nextblock-template/app/actions/package-actions.ts

@@ -0,0 +1,183 @@
+'use server';
+
+import { createClient } from '@supabase/supabase-js';
+import { NEXTBLOCK_PACKAGES } from '@nextblock-cms/utils';
+import { headers } from 'next/headers';
+import { revalidatePath } from 'next/cache';
+
+// Freemius handles both Sandbox and Production keys on the same API domain.
+// The key itself determines the environment.
+const FM_API_URL = 'https://api.freemius.com/v1';
+
+// Helper to get service role client
+const getServiceRoleClient = () => {
+    const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
+    const supabaseServiceKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
+
+    if (!supabaseUrl || !supabaseServiceKey) {
+        console.error('Missing Supabase credentials');
+        throw new Error('Missing Supabase credentials (Service Key required for activation).');
+    }
+
+    if (supabaseServiceKey === process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY) {
+        console.warn('CRITICAL WARNING: SUPABASE_SERVICE_ROLE_KEY matches NEXT_PUBLIC_SUPABASE_ANON_KEY. This will likely cause Permission Denied errors as RLS cannot be bypassed.');
+    }
+
+    return createClient(supabaseUrl, supabaseServiceKey, {
+      auth: {
+        persistSession: false,
+        autoRefreshToken: false,
+        detectSessionInUrl: false,
+      },
+    });
+};
+
+export async function activatePackage(key: string) {
+  if (process.env.NEXT_PUBLIC_IS_SANDBOX === 'true') {
+    return { error: 'License activation is disabled in Sandbox mode. To purchase a real license, visit nextblock.ca' };
+  }
+
+  if (!key) {
+    return { error: 'License key is required.' };
+  }
+
+  const headerList = await headers();
+  // instance_name is usually the domain, for local dev use 'localhost' or actual host
+  const instanceName = headerList.get('host') || 'nextblock-instance';
+  
+  // Freemius requires a 32-char unique identifier for the install.
+  // We hash the instance (domain) to ensure reactivations on the same domain use the same UID.
+  const crypto = require('crypto');
+  const uid = crypto.createHash('md5').update(instanceName).digest('hex');
+
+  try {
+    let data = null;
+    let pkg = null;
+    let fmProductId = null;
+    let hasLicenseError = false;
+    let specificErrorMsg: string | null = null;
+
+    // We don't know the exact package just from the license key, so we try activating
+    // against our known Freemius Product IDs from the NEXTBLOCK_PACKAGES registry.
+    const packages = Object.values(NEXTBLOCK_PACKAGES);
+    
+    for (const p of packages) {
+      if (!p.fm_product_id) continue;
+      
+      const siteUrl = encodeURIComponent(`http://${instanceName}`);
+      const response = await fetch(`${FM_API_URL}/products/${p.fm_product_id}/licenses/activate.json?uid=${uid}&license_key=${encodeURIComponent(key)}&url=${siteUrl}`, {
+        method: 'POST',
+        headers: {
+          'Accept': 'application/json',
+          'Content-Type': 'application/json',
+        }
+      });
+
+      const responseData = await response.json();
+      
+      // Freemius returns the license object directly if successful, or an error/api_response
+      if (response.ok && responseData.install_id) {
+          data = responseData;
+          pkg = p;
+          fmProductId = p.fm_product_id;
+          break;
+      }
+      
+      const errorCode = responseData?.error?.code;
+      if (errorCode === 'not_found' || errorCode === 'invalid_license_key') {
+          hasLicenseError = true;
+      } else if (responseData?.error?.message) {
+          specificErrorMsg = responseData.error.message;
+      }
+    }
+
+    if (!data || !pkg) {
+        if (hasLicenseError && process.env.NEXT_PUBLIC_IS_SANDBOX !== 'true' && !specificErrorMsg) {
+            return { error: 'Sorry, this is a sandbox key. Please purchase the real key at nextblock.ca' };
+        }
+        return { error: specificErrorMsg || 'Activation failed. Invalid key, wrong product, or limit reached.' };
+    }
+
+    // 3. Store in DB - USE SERVICE ROLE
+    const supabase = getServiceRoleClient();
+    
+    const { error: dbError } = await supabase
+        .from('package_activations')
+        .upsert({
+            license_key: key,
+            instance_name: instanceName,
+            package_id: pkg.id,
+            status: 'active',
+            meta: {
+              ...data,
+              fm_product_id: fmProductId,
+              fm_install_id: data.install_id,
+              fm_uid: uid
+            },
+            last_validated_at: new Date().toISOString(),
+        }, { onConflict: 'license_key, package_id' });
+
+    if (dbError) {
+        console.error('DB Error activating package:', dbError);
+        return { error: 'Activation successful, but local saving failed: ' + dbError.message };
+    }
+
+    revalidatePath('/cms/settings/packages');
+    return { success: true, package: pkg.name };
+
+  } catch (err: any) {
+    console.error('Activation Action Error:', err);
+    return { error: err.message || 'An unexpected error occurred.' };
+  }
+}
+
+export async function deactivatePackage(packageId: string) {
+    if (process.env.NEXT_PUBLIC_IS_SANDBOX === 'true') {
+        return { error: 'License deactivation is disabled in Sandbox mode.' };
+    }
+
+    const supabase = getServiceRoleClient();
+    
+    // 1. Get current activation
+    const { data: activation, error: fetchError } = await supabase
+        .from('package_activations')
+        .select('id, license_key, instance_name, meta')
+        .eq('package_id', packageId)
+        .eq('status', 'active')
+        .single();
+
+    if (fetchError || !activation) {
+        return { error: 'No active license found for this package.' };
+    }
+
+    // 2. Deactivate at Freemius
+    try {
+        const fmProductId = activation.meta?.fm_product_id;
+        const uid = activation.meta?.fm_uid;
+        const installId = activation.meta?.fm_install_id;
+        
+        if (fmProductId && uid && installId) {
+          await fetch(`${FM_API_URL}/products/${fmProductId}/licenses/deactivate.json?uid=${uid}&install_id=${installId}&license_key=${encodeURIComponent(activation.license_key)}`, {
+              method: 'POST',
+              headers: {
+                  'Accept': 'application/json',
+              }
+          });
+        }
+    } catch (err) {
+        console.warn('Freemius Deactivation failed (network?), removing locally anyway.', err);
+    }
+
+    // 3. Remove/Update local DB
+    const { error: deleteError } = await supabase
+        .from('package_activations')
+        .delete()
+        .eq('id', activation.id);
+
+    if (deleteError) {
+        return { error: 'Failed to remove local activation record.' };
+    }
+
+    revalidatePath('/cms/settings/packages');
+    return { success: true };
+}

package/templates/nextblock-template/app/actions/postActions.ts

@@ -1,48 +1,147 @@
-'use server';
-
-import { cache } from 'react';
-import { createClient } from '@nextblock-cms/db/server';
-import { revalidatePath } from 'next/cache';
-import type { PostWithMediaDimensions } from '../../components/blocks/types';
-
-export async function fetchPaginatedPublishedPosts(languageId: number, page: number, limit: number): Promise<{ posts: PostWithMediaDimensions[], totalCount: number, error?: string }> {
-  const supabase = createClient();
-  const offset = (page - 1) * limit;
-
-  const { data: posts, error, count } = await supabase
-    .from('posts')
-    .select('*, media:media!feature_image_id(*)', { count: 'exact' })
-    .eq('status', 'published')
-    .eq('language_id', languageId)
-    .order('published_at', { ascending: false })
-    .range(offset, offset + limit - 1);
-
-  if (error) {
-    console.error("Error fetching paginated posts:", error);
-    return { posts: [], totalCount: 0, error: error.message };
-  }
-  
-  return { posts: posts as PostWithMediaDimensions[], totalCount: count || 0, error: undefined }; // Return error: undefined on success
-}
-
-// You could also move fetchInitialPublishedPosts here if it makes sense for organization
-export const fetchInitialPublishedPosts = cache(async (languageId: number, limit: number): Promise<{ posts: PostWithMediaDimensions[], totalCount: number, error?: string | null }> => {
-  const supabase = createClient(); // This createClient is from utils/supabase/server
-  const { data: posts, error, count } = await supabase
-    .from('posts')
-    .select('*, media:media!feature_image_id(*)', { count: 'exact' })
-    .eq('status', 'published')
-    .eq('language_id', languageId)
-    .order('published_at', { ascending: false })
-    .limit(limit);
-
-  if (error) {
-    console.error("Error fetching initial posts:", error);
-    return { posts: [], totalCount: 0, error: error.message };
-  }
-  
-  return { posts: posts as PostWithMediaDimensions[], totalCount: count || 0, error: null };
-});
+'use server';
+
+import { cache } from 'react';
+import { createClient } from '@nextblock-cms/db/server';
+import { revalidatePath } from 'next/cache';
+import type { Database } from '@nextblock-cms/db';
+import type { PostWithMediaDimensions } from '../../components/blocks/types';
+import { resolveMediaUrl } from '../../lib/media/resolveMediaUrl';
+import { estimateReadTimeMinutesFromBlocks } from '../../lib/posts/readTime';
+
+type PostRow = Database['public']['Tables']['posts']['Row'];
+type BlockRow = Database['public']['Tables']['blocks']['Row'];
+type FeatureMediaSelection = {
+  object_key: string;
+  width?: number | null;
+  height?: number | null;
+  blur_data_url?: string | null;
+};
+
+type PostQueryRow = PostRow & {
+  feature_media_object?: FeatureMediaSelection | FeatureMediaSelection[] | null;
+};
+
+type PostWithFeatureMedia = PostRow & {
+  feature_media_object?: FeatureMediaSelection | null;
+};
+
+function normalizeFeatureMediaObject(
+  mediaObject: PostQueryRow['feature_media_object']
+): FeatureMediaSelection | null {
+  if (Array.isArray(mediaObject)) {
+    return mediaObject[0] ?? null;
+  }
+
+  return mediaObject ?? null;
+}
+
+async function getEstimatedReadTimeMap(
+  supabase: ReturnType<typeof createClient>,
+  postIds: number[]
+) {
+  if (postIds.length === 0) {
+    return new Map<number, number>();
+  }
+
+  const { data: textBlocks, error } = await supabase
+    .from('blocks')
+    .select('post_id, block_type, content')
+    .in('post_id', postIds)
+    .eq('block_type', 'text')
+    .order('order', { ascending: true });
+
+  if (error) {
+    console.error('Error fetching post text blocks for read-time estimation:', error);
+    return new Map(postIds.map((postId) => [postId, 1]));
+  }
+
+  const blocksByPostId = new Map<number, Array<Pick<BlockRow, 'block_type' | 'content'>>>();
+  postIds.forEach((postId) => blocksByPostId.set(postId, []));
+
+  (textBlocks || []).forEach((block) => {
+    if (typeof block.post_id !== 'number') {
+      return;
+    }
+
+    const blocks = blocksByPostId.get(block.post_id) || [];
+    blocks.push(block as Pick<BlockRow, 'block_type' | 'content'>);
+    blocksByPostId.set(block.post_id, blocks);
+  });
+
+  return new Map(
+    postIds.map((postId) => [
+      postId,
+      estimateReadTimeMinutesFromBlocks(blocksByPostId.get(postId)),
+    ])
+  );
+}
+
+function normalizePostsForCards(
+  posts: PostWithFeatureMedia[],
+  estimatedReadTimeMap: Map<number, number>
+) {
+  return posts.map((post) => {
+    const mediaObject = post.feature_media_object || null;
+
+    return {
+      ...post,
+      feature_image_url: resolveMediaUrl(mediaObject?.object_key),
+      feature_image_width: mediaObject?.width || null,
+      feature_image_height: mediaObject?.height || null,
+      blur_data_url: mediaObject?.blur_data_url || null,
+      estimated_read_time_minutes: estimatedReadTimeMap.get(post.id) || 1,
+    } satisfies PostWithMediaDimensions;
+  });
+}
+
+async function fetchPublishedPostsPage(languageId: number, page: number, limit: number) {
+  const supabase = createClient();
+  const offset = (page - 1) * limit;
+
+  const { data: posts, error, count } = await supabase
+    .from('posts')
+    .select(
+      'id, title, slug, label, excerpt, subtitle, published_at, language_id, status, created_at, updated_at, translation_group_id, feature_image_id, version, author_id, meta_title, meta_description, feature_media_object:media!feature_image_id(object_key, width, height, blur_data_url)',
+      { count: 'exact' }
+    )
+    .eq('status', 'published')
+    .eq('language_id', languageId)
+    .order('published_at', { ascending: false })
+    .range(offset, offset + limit - 1);
+
+  if (error) {
+    console.error('Error fetching published posts:', error);
+    return { posts: [], totalCount: 0, error: error.message };
+  }
+
+  const normalizedPosts: PostWithFeatureMedia[] = ((posts as PostQueryRow[] | null) ?? []).map(
+    (post) => ({
+      ...post,
+      feature_media_object: normalizeFeatureMediaObject(post.feature_media_object),
+    })
+  );
+  const postIds = normalizedPosts.map((post) => post.id);
+  const estimatedReadTimeMap = await getEstimatedReadTimeMap(supabase, postIds);
+
+  return {
+    posts: normalizePostsForCards(normalizedPosts, estimatedReadTimeMap),
+    totalCount: count || 0,
+    error: undefined,
+  };
+}
+
+export async function fetchPaginatedPublishedPosts(languageId: number, page: number, limit: number): Promise<{ posts: PostWithMediaDimensions[], totalCount: number, error?: string }> {
+  return fetchPublishedPostsPage(languageId, page, limit);
+}
+
+export const fetchInitialPublishedPosts = cache(async (languageId: number, limit: number): Promise<{ posts: PostWithMediaDimensions[], totalCount: number, error?: string | null }> => {
+  const result = await fetchPublishedPostsPage(languageId, 1, limit);
+  return {
+    posts: result.posts,
+    totalCount: result.totalCount,
+    error: result.error ?? null,
+  };
+});
 export async function revalidateAndLog(path: string): Promise<{ success: boolean; error?: string }> {
   try {
     // Step 1: Revalidate the path
@@ -69,12 +168,11 @@ export async function revalidateAndLog(path: string): Promise<{ success: boolean
       throw new Error(`Failed to log revalidation: ${response.status} ${response.statusText} - ${errorBody.error}`);
     }
 
-    console.log(`Successfully revalidated and logged path: ${path}`);
-    return { success: true };
+    return { success: true };
 
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
     console.error(`Error in revalidateAndLog for path "${path}":`, errorMessage);
     return { success: false, error: errorMessage };
   }
-}
+}