create-nextblock 0.2.59 → 0.2.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-nextblock",
-  "version": "0.2.59",
+  "version": "0.2.61",
   "description": "",
   "main": "index.js",
   "bin": {

package/templates/nextblock-template/app/cms/revisions/RevisionHistoryButton.tsx

@@ -1,8 +1,9 @@
 // apps/nextblock/app/cms/revisions/RevisionHistoryButton.tsx
 "use client";
 
-import { useEffect, useState, useTransition } from 'react';
+import { useEffect, useState, useTransition, Fragment } from 'react';
 import { Button } from "@nextblock-cms/ui";
+import { cn } from "@nextblock-cms/utils";
 import { Spinner, Alert, AlertDescription } from "@nextblock-cms/ui";
 import {
   Dialog,
@@ -33,49 +34,91 @@ type RevisionItem = {
   author?: { full_name?: string | null; username?: string | null } | null;
 };
 
+import { Input } from "@nextblock-cms/ui";
+
 export default function RevisionHistoryButton({ parentType, parentId }: RevisionHistoryButtonProps) {
   const [open, setOpen] = useState(false);
   const [loading, setLoading] = useState(false);
-  const [revisions, setRevisions] = useState<RevisionItem[] | null>(null);
+  const [revisions, setRevisions] = useState<RevisionItem[]>([]);
   const [currentVersion, setCurrentVersion] = useState<number | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [message, setMessage] = useState<string | null>(null);
   const [isPending, startTransition] = useTransition();
+  const [page, setPage] = useState(1);
+  const [startDate, setStartDate] = useState('');
+  const [endDate, setEndDate] = useState('');
+  
+  const [totalPages, setTotalPages] = useState(0);
+  
   const router = useRouter();
-
   const [compareLoading, setCompareLoading] = useState(false);
   const [activeCompareVersion, setActiveCompareVersion] = useState<number | null>(null);
   const [leftText, setLeftText] = useState<string | null>(null);
   const [rightText, setRightText] = useState<string | null>(null);
-  useEffect(() => {
-    if (!open) return;
+
+  const loadRevisions = async (pageToLoad: number, start?: string, end?: string) => {
     setLoading(true);
     setError(null);
-    (async () => {
-      try {
-        if (parentType === 'page') {
-          const res = await listPageRevisions(parentId);
-        if ('error' in res) {
-          setError(res.error ?? 'Unknown error');
-          setRevisions(null);
-          setCurrentVersion(null);
-        } else {
-          setRevisions(res.revisions as unknown as RevisionItem[]);
-          setCurrentVersion((res as any).currentVersion ?? null);
-        }
-        } else {
-          const res = await listPostRevisions(parentId);
-          if ('error' in res) { setError(res.error ?? 'Unknown error'); setRevisions(null); setCurrentVersion(null); }
-          else { setRevisions(res.revisions as unknown as RevisionItem[]); setCurrentVersion((res as any).currentVersion ?? null); }
-        }
-      } catch (e: unknown) {
-        setError(e instanceof Error ? e.message : 'Failed to load revisions');
-      } finally {
-        setLoading(false);
+    try {
+      let res;
+      // Pass date range to actions
+      if (parentType === 'page') {
+        res = await listPageRevisions(parentId, pageToLoad, start, end);
+      } else {
+        res = await listPostRevisions(parentId, pageToLoad, start, end);
       }
-    })();
+
+      if ('error' in res) {
+        setError(res.error ?? 'Unknown error');
+        setRevisions([]);
+      } else {
+        const newRevisions = res.revisions as unknown as RevisionItem[];
+        setRevisions(newRevisions);
+        setCurrentVersion((res as any).currentVersion ?? null);
+        setTotalPages((res as any).totalPages ?? 0);
+      }
+    } catch (e: unknown) {
+      setError(e instanceof Error ? e.message : 'Failed to load revisions');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    if (!open) return;
+    setRevisions([]);
+    setPage(1);
+    setStartDate('');
+    setEndDate('');
+    loadRevisions(1, '', '');
   }, [open, parentId, parentType]);
 
+  const handlePageChange = (newPage: number) => {
+    setPage(newPage);
+    loadRevisions(newPage, startDate, endDate);
+  };
+
+  const handleStartDateChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const newVal = e.target.value;
+    setStartDate(newVal);
+    setPage(1);
+    loadRevisions(1, newVal, endDate);
+  };
+
+  const handleEndDateChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const newVal = e.target.value;
+    setEndDate(newVal);
+    setPage(1);
+    loadRevisions(1, startDate, newVal);
+  };
+
+  const handleClearDates = () => {
+    setStartDate('');
+    setEndDate('');
+    setPage(1);
+    loadRevisions(1, '', '');
+  };
+
   const handleRestore = (version: number) => {
     setMessage(null);
     setError(null);
@@ -91,9 +134,7 @@ export default function RevisionHistoryButton({ parentType, parentId }: Revision
         }
         setMessage('Version restored successfully.');
         toast.success('Version restored successfully');
-        // refresh current page to fetch restored content
         router.refresh();
-        // Close the dialog after a short delay
         setTimeout(() => setOpen(false), 800);
       } catch (e: unknown) {
         setError(e instanceof Error ? e.message : 'Failed to restore version');
@@ -132,19 +173,41 @@ export default function RevisionHistoryButton({ parentType, parentId }: Revision
   return (
     <Dialog open={open} onOpenChange={setOpen}>
       <Button variant="outline" onClick={() => setOpen(true)}>Revision History</Button>
-      <DialogContent className="max-w-2xl h-[95vh] overflow-y-auto">
+      <DialogContent 
+        className="max-w-2xl h-[95vh] overflow-y-auto flex flex-col"
+        onOpenAutoFocus={(e) => e.preventDefault()}
+      >
         <DialogHeader>
-          <DialogTitle>Revision History</DialogTitle>
+          <div className="flex items-center justify-between mr-8">
+            <DialogTitle>Revision History</DialogTitle>
+            <div className="flex items-center gap-2">
+                 <span className="text-sm text-muted-foreground whitespace-nowrap">From:</span>
+                 <Input 
+                    type="date" 
+                    className="w-auto h-8 text-sm px-2" 
+                    value={startDate} 
+                    onChange={handleStartDateChange} 
+                 />
+                 <span className="text-sm text-muted-foreground whitespace-nowrap">To:</span>
+                 <Input 
+                    type="date" 
+                    className="w-auto h-8 text-sm px-2" 
+                    value={endDate} 
+                    onChange={handleEndDateChange} 
+                 />
+                 {(startDate || endDate) && (
+                   <Button variant="ghost" size="sm" onClick={handleClearDates} className="h-8 px-2 text-xs text-muted-foreground hover:text-foreground">
+                     Clear
+                   </Button>
+                 )}
+            </div>
+          </div>
           <DialogDescription>
             Browse and restore previous versions.
           </DialogDescription>
         </DialogHeader>
-        <div className="space-y-3">
-          {loading && (
-             <div className="flex items-center justify-center py-4">
-                <Spinner size="lg" />
-             </div>
-          )}
+        
+        <div className="flex-1 overflow-y-auto space-y-3 p-1">
           {error && (
             <Alert variant="destructive">
                <AlertDescription>{error}</AlertDescription>
@@ -156,55 +219,146 @@ export default function RevisionHistoryButton({ parentType, parentId }: Revision
             </Alert>
           )}
 
-          {(!loading && revisions && revisions.length === 0) && (
-            <div className="text-sm text-muted-foreground">No revisions yet.</div>
-          )}
-
-              {revisions && revisions.length > 0 && (
-                <div className="divide-y rounded border">
-                  {revisions.map((rev: RevisionItem) => {
+          {revisions && revisions.length > 0 ? (
+            <div className="rounded border divide-y">
+              {revisions.map((rev: RevisionItem, idx) => {
                 const when = rev.created_at ? formatDistanceToNow(new Date(rev.created_at), { addSuffix: true }) : '';
-                const who = rev.author?.full_name || rev.author?.username || rev.author_id || 'Unknown';
+                const authorName = rev.author?.full_name || rev.author?.username;
+                const isCurrent = currentVersion != null && rev.version === currentVersion;
+                const isInitial = rev.version === 1;
+
                 return (
-                  <div key={rev.id} className="flex items-center justify-between gap-4 p-3">
-                    <div className="min-w-0">
-                      <div className="font-medium flex items-center gap-2">
-                        <span>Version {rev.version}</span>
-                        <span className="text-xs text-muted-foreground">({rev.revision_type})</span>
-                        {currentVersion != null && rev.version === currentVersion && (
-                          <span className="text-[10px] px-1.5 py-0.5 rounded bg-blue-50 text-blue-700 border border-blue-200">Current</span>
-                        )}
-                      </div>
-                      <div className="text-xs text-muted-foreground truncate">{when} • {who}</div>
-                    </div>
+                  <Fragment key={`${rev.id}-${idx}`}>
+                    <div className={cn("flex items-center justify-between gap-3 p-3 text-sm", activeCompareVersion === rev.version && "bg-muted/50")}>
+                     <div className="flex flex-col gap-0.5">
+                        <div className="flex items-center gap-2">
+                           <span className="font-semibold text-gray-900">
+                              {isCurrent ? 'Current Version' : (isInitial ? 'Initial Version' : `Version ${rev.version}`)}
+                           </span>
+                           <span className="text-muted-foreground text-xs">• {when}</span>
+                           {authorName && <span className="text-muted-foreground text-xs">• by {authorName}</span>}
+                           {!isCurrent && (
+                              <span className="text-[10px] text-muted-foreground bg-gray-100 px-1 rounded uppercase tracking-wider">{rev.revision_type}</span>
+                           )}
+                           {isInitial && !isCurrent && <span className="text-[10px] px-1.5 py-0.5 rounded bg-gray-100 text-gray-600 border border-gray-200">v1</span>}
+                        </div>
+                     </div>
+
                     <div className="flex gap-2">
-                      <Button variant="secondary" size="sm" onClick={() => handleCompare(rev.version)} disabled={compareLoading && activeCompareVersion === rev.version}>
-                        {compareLoading && activeCompareVersion === rev.version ? <><Spinner className="mr-2 h-3 w-3" /> Loading</> : 'Compare'}
-                      </Button>
-                      <Button size="sm" onClick={() => handleRestore(rev.version)} disabled={isPending}>
-                        {isPending ? <><Spinner className="mr-2 h-3 w-3" /> Restoring</> : 'Restore'}
-                      </Button>
+                      {!isCurrent && (
+                        <>
+                          <Button 
+                            variant="outline" 
+                            size="sm" 
+                            onClick={() => handleCompare(rev.version)} 
+                            disabled={compareLoading && activeCompareVersion === rev.version || (rev as any).has_changes === false} 
+                            className={cn("h-8 px-2 text-xs text-blue-600 border-blue-200 hover:bg-blue-50 hover:text-blue-700", (rev as any).has_changes === false && "invisible pointer-events-none")}
+                          >
+                            {compareLoading && activeCompareVersion === rev.version ? <><Spinner className="mr-1 h-3 w-3" /> compare</> : 'Compare'}
+                          </Button>
+                          <Button 
+                            variant="destructive" 
+                            size="sm" 
+                            onClick={() => handleRestore(rev.version)} 
+                            disabled={isPending || (rev as any).has_changes === false} 
+                            className={cn("h-8 px-2 text-xs", (rev as any).has_changes === false && "invisible pointer-events-none")}
+                          >
+                            {isPending ? <Spinner className="h-3 w-3" /> : 'Restore'}
+                          </Button>
+                        </>
+                      )}
+                      {isCurrent && <span className="text-xs text-muted-foreground italic px-2 self-center">Active</span>}
                     </div>
                   </div>
+                  
+                  {activeCompareVersion === rev.version && (
+                    <div className="p-3 bg-slate-50 border-b relative">
+                      <div className="mb-2 flex items-center justify-between">
+                        <div className="font-semibold text-sm">Comparing Version {activeCompareVersion} to Current</div>
+                        <Button variant="outline" size="sm" onClick={() => { setActiveCompareVersion(null); setLeftText(null); setRightText(null); }} className="h-7 text-xs">Close Compare</Button>
+                      </div>
+                      {compareLoading && <div className="text-sm text-muted-foreground py-4 text-center">Preparing diff…</div>}
+                      {!compareLoading && leftText && rightText && (
+                        <div className="max-h-[50vh] overflow-y-auto border rounded bg-white">
+                           <div className="p-2">
+                              <JsonDiffView
+                                oldValue={leftText}
+                                newValue={rightText}
+                                leftTitle="Current (Now)"
+                                rightTitle={`Version ${activeCompareVersion}`}
+                              />
+                           </div>
+                        </div>
+                      )}
+                    </div>
+                  )}
+                  </Fragment>
                 );
               })}
             </div>
+          ) : (!loading && <div className="text-sm text-muted-foreground text-center py-4">No revisions found for this selection.</div>)}
+
+          {loading && (
+             <div className="flex items-center justify-center py-2">
+                <Spinner size="lg" />
+             </div>
           )}
-          {(activeCompareVersion !== null) && (
-            <div className="mt-4">
-              <div className="mb-2 flex items-center justify-between">
-                <div className="font-semibold">Comparing Version {activeCompareVersion} to Current</div>
-                <Button variant="outline" size="sm" onClick={() => { setActiveCompareVersion(null); setLeftText(null); setRightText(null); }}>Close Compare</Button>
-              </div>
-              {compareLoading && <div className="text-sm text-muted-foreground">Preparing diff…</div>}
-              {!compareLoading && leftText && rightText && (
-                <JsonDiffView
-                  oldValue={leftText}
-                  newValue={rightText}
-                  leftTitle="Current (Now)"
-                  rightTitle={`Version ${activeCompareVersion}`}
-                />
-              )}
+
+          {!loading && (revisions.length > 0 || page > 1) && (
+            <div className="flex items-center justify-center gap-2 py-2 flex-wrap">
+               <Button 
+                 variant="outline" 
+                 size="sm" 
+                 onClick={() => handlePageChange(page - 1)} 
+                 disabled={page <= 1}
+                 className="h-8 px-2"
+               >
+                 Previous
+               </Button>
+               
+               {totalPages > 0 && Array.from({ length: totalPages }, (_, i) => i + 1).map((p) => {
+                  // Show limited pages if too many
+                  if (totalPages > 10) {
+                      if (p === 1 || p === totalPages || (p >= page - 2 && p <= page + 2)) {
+                          return (
+                            <Button
+                                key={p}
+                                variant={p === page ? "default" : "outline"}
+                                size="sm"
+                                onClick={() => handlePageChange(p)}
+                                className="h-8 w-8 p-0"
+                            >
+                                {p}
+                            </Button>
+                          );
+                      } else if (p === page - 3 || p === page + 3) {
+                          return <span key={p} className="text-muted-foreground px-1">...</span>;
+                      }
+                      return null;
+                  }
+                  
+                  return (
+                    <Button
+                        key={p}
+                        variant={p === page ? "default" : "outline"}
+                        size="sm"
+                        onClick={() => handlePageChange(p)}
+                        className="h-8 w-8 p-0"
+                    >
+                        {p}
+                    </Button>
+                  );
+               })}
+
+               <Button 
+                 variant="outline" 
+                 size="sm" 
+                 onClick={() => handlePageChange(page + 1)} 
+                 disabled={page >= totalPages}
+                 className="h-8 px-2"
+               >
+                 Next
+               </Button>
             </div>
           )}
         </div>

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/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/dev/types/routes.d.ts";
+import "./.next/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/templates/nextblock-template/package.json

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