create-nextblock 0.2.58 → 0.2.61

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

@@ -4,6 +4,7 @@
 import { createClient } from "@nextblock-cms/db/server";
 import { restorePageToVersion, restorePostToVersion, reconstructPageVersionContent, reconstructPostVersionContent } from './service';
 import { getFullPageContent, getFullPostContent } from './utils';
+import { compare } from 'fast-json-patch';
 
 type RevisionListItem = {
   id: number;
@@ -14,30 +15,230 @@ type RevisionListItem = {
   author?: { full_name?: string | null; username?: string | null } | null;
 };
 
-export async function listPageRevisions(pageId: number) {
+const REVISIONS_PER_PAGE = 10; // Reduced to 10 as requested
+
+export async function listPageRevisions(pageId: number, page = 1, startDate?: string, endDate?: string) {
   const supabase = createClient();
-  const { data, error } = await supabase
+
+  let query = supabase
     .from('page_revisions')
-    .select('id, page_id, author_id, version, revision_type, created_at, author:profiles(full_name, username)')
+    .select('id, page_id, author_id, version, revision_type, created_at, content, author:profiles(full_name, username)', { count: 'exact' })
     .eq('page_id', pageId)
-    .order('version', { ascending: false });
+    .order('version', { ascending: false })
+    .limit(1000); // Fetch up to 1000 recent revisions to allow dense pagination after filtering
+
+  if (startDate) {
+    query = query.gte('created_at', `${startDate}T00:00:00.000Z`);
+  }
+  if (endDate) {
+    query = query.lte('created_at', `${endDate}T23:59:59.999Z`);
+  }
+
+  const { data, error } = await query; // count is less useful now as we filter
+
   if (error) return { error: error.message } as const;
-  const { data: pageRow } = await supabase.from('pages').select('version').eq('id', pageId).single();
+  
+  const { data: pageRow } = await supabase.from('pages').select('version, created_at').eq('id', pageId).single();
   const currentVersion = pageRow?.version ?? null;
-  return { success: true as const, revisions: data as RevisionListItem[], currentVersion };
+  const currentContent = await getFullPageContent(pageId);
+
+  // Map data to include useful flags instead of filtering
+  const allRevisions = (data || []).map((r: any) => {
+    let has_changes = true;
+
+    // 1. Check Diffs
+    if (r.revision_type === 'diff') {
+      let ops = r.content;
+      if (typeof ops === 'string') {
+          try { ops = JSON.parse(ops); } catch { ops = []; }
+      }
+      
+      // Strict check: Diff must be a non-empty array of operations
+      if (!Array.isArray(ops) || ops.length === 0) {
+          has_changes = false;
+      } else {
+        // Check metadata/variant
+        const ignoredSuffixes = ['/updated_at', '/created_at', '/last_modified', '/modified_at', '/version', '/id', '/published_at', '/author_id', '/variant'];
+        const usefulOps = ops.filter((op: any) => {
+            if (!op.path) return true;
+            return !ignoredSuffixes.some(suffix => op.path.endsWith(suffix));
+        });
+        if (usefulOps.length === 0) has_changes = false;
+      }
+    }
+
+    // 2. Check Snapshots
+    if (r.revision_type === 'snapshot' && currentContent && r.version !== currentVersion) {
+        let snapshotContent = r.content;
+        if (typeof snapshotContent === 'string') {
+            try { snapshotContent = JSON.parse(snapshotContent); } catch { /* default true */ }
+        }
+        
+        const ops = compare(currentContent, snapshotContent);
+        
+        const ignoredSuffixes = ['/updated_at', '/created_at', '/last_modified', '/modified_at', '/version', '/id', '/published_at', '/author_id', '/variant'];
+        const usefulOps = ops.filter((op: any) => {
+             if (!op.path) return true;
+             return !ignoredSuffixes.some(suffix => op.path.endsWith(suffix));
+        });
+
+        if (usefulOps.length === 0) has_changes = false;
+    }
+
+    return { ...r, has_changes };
+  }) as (RevisionListItem & { has_changes: boolean; content: any })[];
+
+  // Append Synthetic V1
+  const hasVersion1 = allRevisions.some(r => r.version === 1);
+  const pageCreatedAt = pageRow?.created_at;
+  
+  let matchesDate = true;
+  if (pageCreatedAt) {
+      if (startDate && pageCreatedAt < `${startDate}T00:00:00.000Z`) matchesDate = false;
+      if (endDate && pageCreatedAt > `${endDate}T23:59:59.999Z`) matchesDate = false;
+  }
+  
+  if (!hasVersion1 && (currentVersion ?? 0) > 1 && matchesDate) {
+   allRevisions.push({
+     id: -1,
+     version: 1,
+     revision_type: 'snapshot',
+     created_at: pageCreatedAt ?? new Date().toISOString(),
+     author_id: null,
+     author: { full_name: 'System (Initial)', username: 'system' },
+     has_changes: true, // V1 always counts
+     content: null
+   });
+  }
+  
+  allRevisions.sort((a, b) => b.version - a.version);
+
+  const totalFiltered = allRevisions.length;
+  const totalPages = Math.ceil(totalFiltered / REVISIONS_PER_PAGE);
+  
+  const fromIndex = (page - 1) * REVISIONS_PER_PAGE;
+  // Use map to strip heavy content if not needed, but keep flags
+  const slicedRevisions = allRevisions
+    .slice(fromIndex, fromIndex + REVISIONS_PER_PAGE)
+    .map(({ content, ...rest }) => rest);
+
+  return { 
+      success: true as const, 
+      revisions: slicedRevisions, 
+      currentVersion, 
+      count: totalFiltered, 
+      totalPages, 
+      hasMore: (page * REVISIONS_PER_PAGE) < totalFiltered 
+  };
 }
 
-export async function listPostRevisions(postId: number) {
+export async function listPostRevisions(postId: number, page = 1, startDate?: string, endDate?: string) {
   const supabase = createClient();
-  const { data, error } = await supabase
+
+
+
+  let query = supabase
     .from('post_revisions')
-    .select('id, post_id, author_id, version, revision_type, created_at, author:profiles(full_name, username)')
+    .select('id, post_id, author_id, version, revision_type, created_at, content, author:profiles(full_name, username)', { count: 'exact' })
     .eq('post_id', postId)
-    .order('version', { ascending: false });
+    .order('version', { ascending: false })
+    .limit(1000);
+
+  if (startDate) {
+    query = query.gte('created_at', `${startDate}T00:00:00.000Z`);
+  }
+  if (endDate) {
+    query = query.lte('created_at', `${endDate}T23:59:59.999Z`);
+  }
+
+  const { data, error } = await query;
+
   if (error) return { error: error.message } as const;
-  const { data: postRow } = await supabase.from('posts').select('version').eq('id', postId).single();
+
+  const { data: postRow } = await supabase.from('posts').select('version, created_at').eq('id', postId).single();
   const currentVersion = postRow?.version ?? null;
-  return { success: true as const, revisions: data as RevisionListItem[], currentVersion };
+  const currentContent = await getFullPostContent(postId);
+
+  const allRevisions = (data || []).map((r: any) => {
+    let has_changes = true;
+
+    // 1. Check Diffs
+    if (r.revision_type === 'diff') {
+      let ops = r.content;
+      if (typeof ops === 'string') {
+          try { ops = JSON.parse(ops); } catch { ops = []; }
+      }
+      
+      // Strict check: Diff must be a non-empty array of operations
+      if (!Array.isArray(ops) || ops.length === 0) {
+          has_changes = false;
+      } else {
+        // Check metadata/variant
+        const ignoredSuffixes = ['/updated_at', '/created_at', '/last_modified', '/modified_at', '/version', '/id', '/published_at', '/author_id', '/variant'];
+        const usefulOps = ops.filter((op: any) => {
+            if (!op.path) return true;
+            return !ignoredSuffixes.some(suffix => op.path.endsWith(suffix));
+        });
+        if (usefulOps.length === 0) has_changes = false;
+      }
+    }
+    
+    // 2. Check Snapshots
+    if (r.revision_type === 'snapshot' && currentContent && r.version !== currentVersion) {
+        let snapshotContent = r.content;
+        if (typeof snapshotContent === 'string') {
+            try { snapshotContent = JSON.parse(snapshotContent); } catch { /* default true */ }
+        }
+        
+        const ops = compare(currentContent, snapshotContent);
+        
+        const ignoredSuffixes = ['/updated_at', '/created_at', '/last_modified', '/modified_at', '/version', '/id', '/published_at', '/author_id', '/variant'];
+        const usefulOps = ops.filter((op: any) => {
+             if (!op.path) return true;
+             return !ignoredSuffixes.some(suffix => op.path.endsWith(suffix));
+        });
+
+        if (usefulOps.length === 0) has_changes = false;
+    }
+
+    return { ...r, has_changes };
+  }) as (RevisionListItem & { has_changes: boolean; content: any })[];
+
+  // Synthetic V1
+  const hasVersion1 = allRevisions.some(r => r.version === 1);
+  const postCreatedAt = postRow?.created_at;
+  
+  let matchesDate = true;
+  if (postCreatedAt) {
+      if (startDate && postCreatedAt < `${startDate}T00:00:00.000Z`) matchesDate = false;
+      if (endDate && postCreatedAt > `${endDate}T23:59:59.999Z`) matchesDate = false;
+  }
+
+  if (!hasVersion1 && (currentVersion ?? 0) > 1 && matchesDate) {
+   allRevisions.push({
+     id: -1,
+     version: 1,
+     revision_type: 'snapshot',
+     created_at: postCreatedAt ?? new Date().toISOString(),
+     author_id: null,
+     author: { full_name: 'System (Initial)', username: 'system' },
+     has_changes: true,
+     content: null
+   });
+  }
+
+  allRevisions.sort((a, b) => b.version - a.version);
+
+  const totalFiltered = allRevisions.length;
+  const totalPages = Math.ceil(totalFiltered / REVISIONS_PER_PAGE);
+  
+  const fromIndex = (page - 1) * REVISIONS_PER_PAGE;
+  // Use map to strip heavy content if not needed, but keep flags
+  const slicedRevisions = allRevisions
+    .slice(fromIndex, fromIndex + REVISIONS_PER_PAGE)
+    .map(({ content, ...rest }) => rest);
+
+  return { success: true as const, revisions: slicedRevisions, currentVersion, count: totalFiltered, totalPages, hasMore: (page * REVISIONS_PER_PAGE) < totalFiltered };
 }
 
 export async function restorePageVersion(pageId: number, targetVersion: number) {

package/templates/nextblock-template/app/cms/revisions/service.ts

@@ -28,12 +28,31 @@ export async function createPageRevision(
     .single();
   if (pageError || !page) return { error: 'Page not found' } as const;
 
-  const nextVersion = (page.version ?? 1) + 1;
-  const makeSnapshot = shouldCreateSnapshot(page.version ?? 1) || nextVersion === 2; // ensure early snapshot cadence
+  const currentVersion = page.version ?? 1;
+  const nextVersion = currentVersion + 1;
+
+  // If we are moving to version 2, it means Version 1 was never saved (it was the initial state).
+  // We should save Version 1 now so we have a history base.
+  if (nextVersion === 2) {
+    await supabase.from('page_revisions').insert({
+      page_id: pageId,
+      author_id: authorId, // Can be current author or null
+      version: 1,
+      revision_type: 'snapshot',
+      content: previousContent as unknown as Json,
+    });
+  }
+
+  const makeSnapshot = shouldCreateSnapshot(currentVersion) || nextVersion === 2; // ensure early snapshot cadence
 
   const revisionType: 'snapshot' | 'diff' = makeSnapshot ? 'snapshot' : 'diff';
   const content: Json = makeSnapshot ? (newContent as unknown as Json) : (compare(previousContent, newContent) as unknown as Json);
 
+  // If it's a diff and there are no changes, skip creating revision
+  if (revisionType === 'diff' && Array.isArray(content) && content.length === 0) {
+    return { success: true as const, version: currentVersion }; // Return current version as we didn't bump
+  }
+
   const { error: insertError } = await supabase.from('page_revisions').insert({
     page_id: pageId,
     author_id: authorId,
@@ -67,12 +86,28 @@ export async function createPostRevision(
     .single();
   if (postError || !post) return { error: 'Post not found' } as const;
 
-  const nextVersion = (post.version ?? 1) + 1;
-  const makeSnapshot = shouldCreateSnapshot(post.version ?? 1) || nextVersion === 2;
+  const currentVersion = post.version ?? 1;
+  const nextVersion = currentVersion + 1;
+
+  if (nextVersion === 2) {
+    await supabase.from('post_revisions').insert({
+      post_id: postId,
+      author_id: authorId,
+      version: 1,
+      revision_type: 'snapshot',
+      content: previousContent as unknown as Json,
+    });
+  }
+
+  const makeSnapshot = shouldCreateSnapshot(currentVersion) || nextVersion === 2;
 
   const revisionType: 'snapshot' | 'diff' = makeSnapshot ? 'snapshot' : 'diff';
   const content: Json = makeSnapshot ? (newContent as unknown as Json) : (compare(previousContent, newContent) as unknown as Json);
 
+  if (revisionType === 'diff' && Array.isArray(content) && content.length === 0) {
+    return { success: true as const, version: currentVersion };
+  }
+
   const { error: insertError } = await supabase.from('post_revisions').insert({
     post_id: postId,
     author_id: authorId,
@@ -104,27 +139,50 @@ export async function restorePageToVersion(pageId: number, targetVersion: number
     .order('version', { ascending: false })
     .limit(1)
     .maybeSingle();
-  if (snapshotError || !snapshot) return { error: 'No snapshot found at or before target version.' } as const;
-
-  let content = snapshot.content as unknown as FullPageContent;
 
-  // 2. Fetch diffs up to target and apply
-  const { data: diffs, error: diffsError } = await supabase
-    .from('page_revisions')
-    .select('version, content, revision_type')
-    .eq('page_id', pageId)
-    .gt('version', snapshot.version)
-    .lte('version', targetVersion)
-    .order('version', { ascending: true });
-  if (diffsError) return { error: `Failed to fetch diffs: ${diffsError.message}` } as const;
+  let content: FullPageContent;
+  let baseVersion = 0;
+
+  if (snapshot) {
+    content = snapshot.content as unknown as FullPageContent;
+    baseVersion = snapshot.version;
+  } else if (targetVersion === 1) {
+    // Fallback for missing Version 1: use empty content with current meta
+    const { data: pageMeta } = await supabase
+      .from('pages')
+      .select('title, slug, language_id, status, meta_title, meta_description')
+      .eq('id', pageId)
+      .single();
+    if (!pageMeta) return { error: 'Page not found.' } as const;
+    content = {
+      meta: pageMeta,
+      blocks: [],
+    };
+    baseVersion = 1;
+  } else {
+    if (snapshotError) return { error: `Snapshot error: ${snapshotError.message}` } as const;
+    return { error: 'No snapshot found at or before target version.' } as const;
+  }
 
-  for (const r of diffs || []) {
-    if (r.revision_type === 'diff') {
-      const ops = r.content as any[];
-      const result = applyPatch(content as any, ops, /*validate*/ false, /*mutateDocument*/ true);
-      content = result.newDocument as unknown as FullPageContent;
-    } else {
-      content = r.content as unknown as FullPageContent;
+  // 2. Fetch diffs up to target and apply (only if we are not already at target)
+  if (baseVersion < targetVersion) {
+    const { data: diffs, error: diffsError } = await supabase
+      .from('page_revisions')
+      .select('version, content, revision_type')
+      .eq('page_id', pageId)
+      .gt('version', baseVersion)
+      .lte('version', targetVersion)
+      .order('version', { ascending: true });
+    if (diffsError) return { error: `Failed to fetch diffs: ${diffsError.message}` } as const;
+
+    for (const r of diffs || []) {
+      if (r.revision_type === 'diff') {
+        const ops = r.content as any[];
+        const result = applyPatch(content as any, ops, /*validate*/ false, /*mutateDocument*/ true);
+        content = result.newDocument as unknown as FullPageContent;
+      } else {
+        content = r.content as unknown as FullPageContent;
+      }
     }
   }
 
@@ -193,17 +251,38 @@ export async function restorePostToVersion(postId: number, targetVersion: number
     .order('version', { ascending: false })
     .limit(1)
     .maybeSingle();
-  if (snapshotError || !snapshot) return { error: 'No snapshot found at or before target version.' } as const;
 
-  let content = snapshot.content as unknown as FullPostContent;
+  let content: FullPostContent;
+  let baseVersion = 0;
+
+  if (snapshot) {
+    content = snapshot.content as unknown as FullPostContent;
+    baseVersion = snapshot.version;
+  } else if (targetVersion === 1) {
+    const { data: postMeta } = await supabase
+      .from('posts')
+      .select('title, slug, language_id, status, meta_title, meta_description, excerpt, published_at, feature_image_id')
+      .eq('id', postId)
+      .single();
+    if (!postMeta) return { error: 'Post not found.' } as const;
+    content = {
+      meta: postMeta,
+      blocks: [],
+    };
+    baseVersion = 1;
+  } else {
+    if (snapshotError) return { error: `Snapshot error: ${snapshotError.message}` } as const;
+    return { error: 'No snapshot found at or before target version.' } as const;
+  }
 
-  const { data: diffs, error: diffsError } = await supabase
-    .from('post_revisions')
-    .select('version, content, revision_type')
-    .eq('post_id', postId)
-    .gt('version', snapshot.version)
-    .lte('version', targetVersion)
-    .order('version', { ascending: true });
+  if (baseVersion < targetVersion) {
+    const { data: diffs, error: diffsError } = await supabase
+      .from('post_revisions')
+      .select('version, content, revision_type')
+      .eq('post_id', postId)
+      .gt('version', baseVersion)
+      .lte('version', targetVersion)
+      .order('version', { ascending: true });
   if (diffsError) return { error: `Failed to fetch diffs: ${diffsError.message}` } as const;
 
   for (const r of diffs || []) {
@@ -214,6 +293,7 @@ export async function restorePostToVersion(postId: number, targetVersion: number
     } else {
       content = r.content as unknown as FullPostContent;
     }
+    }
   }
 
   // Determine next version for post
@@ -281,17 +361,38 @@ export async function reconstructPageVersionContent(pageId: number, targetVersio
     .order('version', { ascending: false })
     .limit(1)
     .maybeSingle();
-  if (snapshotError || !snapshot) return { error: 'No snapshot found at or before target version.' } as const;
 
-  let content = snapshot.content as unknown as FullPageContent;
+  let content: FullPageContent;
+  let baseVersion = 0;
+
+  if (snapshot) {
+    content = snapshot.content as unknown as FullPageContent;
+    baseVersion = snapshot.version;
+  } else if (targetVersion === 1) {
+    const { data: pageMeta } = await supabase
+      .from('pages')
+      .select('title, slug, language_id, status, meta_title, meta_description')
+      .eq('id', pageId)
+      .single();
+    if (!pageMeta) return { error: 'Page not found.' } as const;
+    content = {
+      meta: pageMeta,
+      blocks: [],
+    };
+    baseVersion = 1;
+  } else {
+    if (snapshotError) return { error: `Snapshot error: ${snapshotError.message}` } as const;
+    return { error: 'No snapshot found at or before target version.' } as const;
+  }
 
-  const { data: diffs, error: diffsError } = await supabase
-    .from('page_revisions')
-    .select('version, content, revision_type')
-    .eq('page_id', pageId)
-    .gt('version', snapshot.version)
-    .lte('version', targetVersion)
-    .order('version', { ascending: true });
+  if (baseVersion < targetVersion) {
+    const { data: diffs, error: diffsError } = await supabase
+      .from('page_revisions')
+      .select('version, content, revision_type')
+      .eq('page_id', pageId)
+      .gt('version', baseVersion)
+      .lte('version', targetVersion)
+      .order('version', { ascending: true });
   if (diffsError) return { error: `Failed to fetch diffs: ${diffsError.message}` } as const;
 
   for (const r of diffs || []) {
@@ -303,6 +404,7 @@ export async function reconstructPageVersionContent(pageId: number, targetVersio
       content = r.content as unknown as FullPageContent;
     }
   }
+  }
   return { success: true as const, content };
 }
 
@@ -318,17 +420,38 @@ export async function reconstructPostVersionContent(postId: number, targetVersio
     .order('version', { ascending: false })
     .limit(1)
     .maybeSingle();
-  if (snapshotError || !snapshot) return { error: 'No snapshot found at or before target version.' } as const;
 
-  let content = snapshot.content as unknown as FullPostContent;
+  let content: FullPostContent;
+  let baseVersion = 0;
+
+  if (snapshot) {
+    content = snapshot.content as unknown as FullPostContent;
+    baseVersion = snapshot.version;
+  } else if (targetVersion === 1) {
+    const { data: postMeta } = await supabase
+      .from('posts')
+      .select('title, slug, language_id, status, meta_title, meta_description, excerpt, published_at, feature_image_id')
+      .eq('id', postId)
+      .single();
+    if (!postMeta) return { error: 'Post not found.' } as const;
+    content = {
+      meta: postMeta,
+      blocks: [],
+    };
+    baseVersion = 1;
+  } else {
+    if (snapshotError) return { error: `Snapshot error: ${snapshotError.message}` } as const;
+    return { error: 'No snapshot found at or before target version.' } as const;
+  }
 
-  const { data: diffs, error: diffsError } = await supabase
-    .from('post_revisions')
-    .select('version, content, revision_type')
-    .eq('post_id', postId)
-    .gt('version', snapshot.version)
-    .lte('version', targetVersion)
-    .order('version', { ascending: true });
+  if (baseVersion < targetVersion) {
+    const { data: diffs, error: diffsError } = await supabase
+      .from('post_revisions')
+      .select('version, content, revision_type')
+      .eq('post_id', postId)
+      .gt('version', baseVersion)
+      .lte('version', targetVersion)
+      .order('version', { ascending: true });
   if (diffsError) return { error: `Failed to fetch diffs: ${diffsError.message}` } as const;
 
   for (const r of diffs || []) {
@@ -340,5 +463,6 @@ export async function reconstructPostVersionContent(postId: number, targetVersio
       content = r.content as unknown as FullPostContent;
     }
   }
+  }
   return { success: true as const, content };
 }

package/templates/nextblock-template/app/layout.tsx

@@ -17,9 +17,7 @@ import { getTranslations } from '@/app/cms/settings/extra-translations/actions';
 import type { Database } from '@nextblock-cms/db';
 import { headers, cookies } from 'next/headers';
 
-const defaultUrl = process.env.NEXT_PUBLIC_URL
-  ? `https://${process.env.NEXT_PUBLIC_URL}`
-  : "http://localhost:3000";
+const defaultUrl = process.env.NEXT_PUBLIC_URL || "http://localhost:3000";
 
 const DEFAULT_LOCALE_FOR_LAYOUT = 'en';
 
@@ -106,6 +104,28 @@ export const metadata: Metadata = {
   metadataBase: new URL(defaultUrl),
   title: 'Nextblock CMS',
   description: 'Nextblock CMS pairs a visual block editor with a blazing-fast Next.js + Supabase architecture.',
+  openGraph: {
+    title: 'Nextblock CMS',
+    description: 'Nextblock CMS pairs a visual block editor with a blazing-fast Next.js + Supabase architecture.',
+    url: defaultUrl,
+    siteName: 'Nextblock CMS',
+    images: [
+      {
+        url: '/images/metadata_image.webp',
+        width: 1200,
+        height: 630,
+        alt: 'Nextblock CMS',
+      },
+    ],
+    locale: 'en_US',
+    type: 'website',
+  },
+  twitter: {
+    card: 'summary_large_image',
+    title: 'Nextblock CMS',
+    description: 'Nextblock CMS pairs a visual block editor with a blazing-fast Next.js + Supabase architecture.',
+    images: ['/images/metadata_image.webp'],
+  },
   icons: {
     icon: [
       { url: '/favicon/favicon.ico' },

package/templates/nextblock-template/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextblock-cms/template",
-  "version": "0.2.36",
+  "version": "0.2.39",
   "private": true,
   "scripts": {
     "dev": "next dev",

package/templates/nextblock-template/proxy.ts

@@ -189,14 +189,37 @@ export default async function proxy(request: NextRequest) {
   if (process.env.NODE_ENV === 'production') {
     const nonceValue = requestHeaders.get('x-nonce');
     if (nonceValue) {
+      const supabaseHostname = new URL(supabaseUrl).hostname;
+      
+      const r2BaseUrl = process.env.NEXT_PUBLIC_R2_BASE_URL;
+      const r2PublicUrl = process.env.NEXT_PUBLIC_R2_PUBLIC_URL;
+      const r2BucketName = process.env.R2_BUCKET_NAME;
+
+      let r2Hostnames = '';
+      if (r2BaseUrl) {
+         try {
+           r2Hostnames += ` https://${new URL(r2BaseUrl).hostname}`;
+         } catch (e) {
+           console.error('Invalid NEXT_PUBLIC_R2_BASE_URL', e);
+         }
+      }
+      if (r2PublicUrl && r2BucketName) {
+         try {
+           const publicHostname = new URL(r2PublicUrl).hostname;
+           r2Hostnames += ` https://${r2BucketName}.${publicHostname}`;
+         } catch (e) {
+            console.error('Invalid NEXT_PUBLIC_R2_PUBLIC_URL', e);
+         }
+      }
+
       const csp = [
         "default-src 'self'",
         `script-src 'self' blob: data: 'nonce-${nonceValue}'`,
         "style-src 'self' 'unsafe-inline'",
-        "img-src 'self' data: blob: https://nrh-next-cms.e260676f72b0b18314b868f136ed72ae.r2.cloudflarestorage.com https://pub-a31e3f1a87d144898aeb489a8221f92e.r2.dev",
+        `img-src 'self' data: blob:${r2Hostnames}`,
         "font-src 'self'",
         "object-src 'none'",
-        "connect-src 'self' https://ppcppwsfnrptznvbxnsz.supabase.co wss://ppcppwsfnrptznvbxnsz.supabase.co https://nrh-next-cms.e260676f72b0b18314b868f136ed72ae.r2.cloudflarestorage.com https://pub-a31e3f1a87d144898aeb489a8221f92e.r2.dev",
+        `connect-src 'self' https://${supabaseHostname} wss://${supabaseHostname}${r2Hostnames}`,
         "frame-src 'self' blob: data: https://www.youtube.com",
         "form-action 'self'",
         "base-uri 'self'",

package/templates/nextblock-template/tsconfig.json

@@ -37,7 +37,6 @@
     "**/*.jsx",
     "next-env.d.ts",
     ".next/types/**/*.ts",
-    "../../dist/apps/nextblock/.next/types/**/*.ts",
     "../../libs/ui/tailwind.config.js"
   ],
   "exclude": [