create-nextblock 0.0.1

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

@@ -0,0 +1,344 @@
+// apps/nextblock/app/cms/revisions/service.ts
+"use server";
+
+import { createClient } from "@nextblock-cms/db/server";
+import type { Json } from "@nextblock-cms/db";
+import { compare, applyPatch } from 'fast-json-patch';
+import type { FullPageContent, FullPostContent } from './utils';
+
+
+function shouldCreateSnapshot(currentVersion: number): boolean {
+  // Create a snapshot every 20 revisions
+  return currentVersion % 20 === 0;
+}
+
+export async function createPageRevision(
+  pageId: number,
+  authorId: string,
+  previousContent: FullPageContent,
+  newContent: FullPageContent
+) {
+  const supabase = createClient();
+
+  // Get current version
+  const { data: page, error: pageError } = await supabase
+    .from('pages')
+    .select('version')
+    .eq('id', pageId)
+    .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 revisionType: 'snapshot' | 'diff' = makeSnapshot ? 'snapshot' : 'diff';
+  const content: Json = makeSnapshot ? (newContent as unknown as Json) : (compare(previousContent, newContent) as unknown as Json);
+
+  const { error: insertError } = await supabase.from('page_revisions').insert({
+    page_id: pageId,
+    author_id: authorId,
+    version: nextVersion,
+    revision_type: revisionType,
+    content,
+  });
+  if (insertError) return { error: `Failed to insert page revision: ${insertError.message}` } as const;
+
+  const { error: updateVersionError } = await supabase
+    .from('pages')
+    .update({ version: nextVersion })
+    .eq('id', pageId);
+  if (updateVersionError) return { error: `Failed to bump page version: ${updateVersionError.message}` } as const;
+
+  return { success: true as const, version: nextVersion };
+}
+
+export async function createPostRevision(
+  postId: number,
+  authorId: string,
+  previousContent: FullPostContent,
+  newContent: FullPostContent
+) {
+  const supabase = createClient();
+
+  const { data: post, error: postError } = await supabase
+    .from('posts')
+    .select('version')
+    .eq('id', postId)
+    .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 revisionType: 'snapshot' | 'diff' = makeSnapshot ? 'snapshot' : 'diff';
+  const content: Json = makeSnapshot ? (newContent as unknown as Json) : (compare(previousContent, newContent) as unknown as Json);
+
+  const { error: insertError } = await supabase.from('post_revisions').insert({
+    post_id: postId,
+    author_id: authorId,
+    version: nextVersion,
+    revision_type: revisionType,
+    content,
+  });
+  if (insertError) return { error: `Failed to insert post revision: ${insertError.message}` } as const;
+
+  const { error: updateVersionError } = await supabase
+    .from('posts')
+    .update({ version: nextVersion })
+    .eq('id', postId);
+  if (updateVersionError) return { error: `Failed to bump post version: ${updateVersionError.message}` } as const;
+
+  return { success: true as const, version: nextVersion };
+}
+
+export async function restorePageToVersion(pageId: number, targetVersion: number, authorId: string) {
+  const supabase = createClient();
+
+  // 1. Find latest snapshot at or before target
+  const { data: snapshot, error: snapshotError } = await supabase
+    .from('page_revisions')
+    .select('version, content, revision_type')
+    .eq('page_id', pageId)
+    .lte('version', targetVersion)
+    .eq('revision_type', 'snapshot')
+    .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;
+
+  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;
+    }
+  }
+
+  // Determine next version number (append a new revision for restored state)
+  const { data: pageRow } = await supabase
+    .from('pages')
+    .select('version')
+    .eq('id', pageId)
+    .single();
+  const newVersion = ((pageRow?.version as number | null) ?? 1) + 1;
+
+  // 3. Apply to DB: update page meta and replace blocks; bump to newVersion
+  const { error: updatePageError } = await supabase
+    .from('pages')
+    .update({
+      title: content.meta.title,
+      slug: content.meta.slug,
+      language_id: content.meta.language_id,
+      status: content.meta.status,
+      meta_title: content.meta.meta_title,
+      meta_description: content.meta.meta_description,
+      version: newVersion,
+    })
+    .eq('id', pageId);
+  if (updatePageError) return { error: `Failed to update page: ${updatePageError.message}` } as const;
+
+  // delete all existing blocks for this page then reinsert
+  const { error: deleteError } = await supabase.from('blocks').delete().eq('page_id', pageId);
+  if (deleteError) return { error: `Failed to clear blocks: ${deleteError.message}` } as const;
+
+  if (content.blocks.length > 0) {
+    const toInsert = content.blocks.map(b => ({
+      page_id: pageId,
+      post_id: null,
+      language_id: b.language_id,
+      block_type: b.block_type,
+      content: b.content,
+      order: b.order,
+    }));
+    const { error: insertError } = await supabase.from('blocks').insert(toInsert);
+    if (insertError) return { error: `Failed to insert blocks: ${insertError.message}` } as const;
+  }
+
+  // 4. Record a new snapshot revision representing the restored state at newVersion
+  const { error: revErr } = await supabase.from('page_revisions').insert({
+    page_id: pageId,
+    author_id: authorId,
+    version: newVersion,
+    revision_type: 'snapshot',
+    content: content as unknown as Json,
+  });
+  if (revErr) return { error: `Failed to write restored revision: ${revErr.message}` } as const;
+
+  return { success: true as const };
+}
+
+export async function restorePostToVersion(postId: number, targetVersion: number, authorId: string) {
+  const supabase = createClient();
+
+  const { data: snapshot, error: snapshotError } = await supabase
+    .from('post_revisions')
+    .select('version, content, revision_type')
+    .eq('post_id', postId)
+    .lte('version', targetVersion)
+    .eq('revision_type', 'snapshot')
+    .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;
+
+  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 (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 FullPostContent;
+    } else {
+      content = r.content as unknown as FullPostContent;
+    }
+  }
+
+  // Determine next version for post
+  const { data: postRow } = await supabase
+    .from('posts')
+    .select('version')
+    .eq('id', postId)
+    .single();
+  const newVersion = ((postRow?.version as number | null) ?? 1) + 1;
+
+  const { error: updatePostError } = await supabase
+    .from('posts')
+    .update({
+      title: content.meta.title,
+      slug: content.meta.slug,
+      language_id: content.meta.language_id,
+      status: content.meta.status,
+      meta_title: content.meta.meta_title,
+      meta_description: content.meta.meta_description,
+      excerpt: content.meta.excerpt,
+      published_at: content.meta.published_at,
+      feature_image_id: content.meta.feature_image_id,
+      version: newVersion,
+    })
+    .eq('id', postId);
+  if (updatePostError) return { error: `Failed to update post: ${updatePostError.message}` } as const;
+
+  const { error: deleteError } = await supabase.from('blocks').delete().eq('post_id', postId);
+  if (deleteError) return { error: `Failed to clear blocks: ${deleteError.message}` } as const;
+
+  if (content.blocks.length > 0) {
+    const toInsert = content.blocks.map(b => ({
+      page_id: null,
+      post_id: postId,
+      language_id: b.language_id,
+      block_type: b.block_type,
+      content: b.content,
+      order: b.order,
+    }));
+    const { error: insertError } = await supabase.from('blocks').insert(toInsert);
+    if (insertError) return { error: `Failed to insert blocks: ${insertError.message}` } as const;
+  }
+
+  const { error: revErr } = await supabase.from('post_revisions').insert({
+    post_id: postId,
+    author_id: authorId,
+    version: newVersion,
+    revision_type: 'snapshot',
+    content: content as unknown as Json,
+  });
+  if (revErr) return { error: `Failed to write restored revision: ${revErr.message}` } as const;
+
+  return { success: true as const };
+}
+
+export async function reconstructPageVersionContent(pageId: number, targetVersion: number) {
+  const supabase = createClient();
+
+  const { data: snapshot, error: snapshotError } = await supabase
+    .from('page_revisions')
+    .select('version, content, revision_type')
+    .eq('page_id', pageId)
+    .lte('version', targetVersion)
+    .eq('revision_type', 'snapshot')
+    .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;
+
+  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;
+
+  for (const r of diffs || []) {
+    if (r.revision_type === 'diff') {
+      const ops = r.content as any[];
+      const result = applyPatch(content as any, ops, false, true);
+      content = result.newDocument as unknown as FullPageContent;
+    } else {
+      content = r.content as unknown as FullPageContent;
+    }
+  }
+  return { success: true as const, content };
+}
+
+export async function reconstructPostVersionContent(postId: number, targetVersion: number) {
+  const supabase = createClient();
+
+  const { data: snapshot, error: snapshotError } = await supabase
+    .from('post_revisions')
+    .select('version, content, revision_type')
+    .eq('post_id', postId)
+    .lte('version', targetVersion)
+    .eq('revision_type', 'snapshot')
+    .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;
+
+  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 (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, false, true);
+      content = result.newDocument as unknown as FullPostContent;
+    } else {
+      content = r.content as unknown as FullPostContent;
+    }
+  }
+  return { success: true as const, content };
+}

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

@@ -0,0 +1,127 @@
+// apps/nextblock/app/cms/revisions/utils.ts
+import { createClient } from "@nextblock-cms/db/server";
+import type { Database, Json } from "@nextblock-cms/db";
+
+type BlockRow = Database['public']['Tables']['blocks']['Row'];
+
+export interface PageMetaContent {
+  title: string;
+  slug: string;
+  language_id: number;
+  status: Database['public']['Enums']['page_status'];
+  meta_title: string | null;
+  meta_description: string | null;
+}
+
+export interface PostMetaContent extends PageMetaContent {
+  excerpt: string | null;
+  published_at: string | null;
+  feature_image_id: string | null;
+}
+
+export interface SimpleBlockContent {
+  language_id: number;
+  block_type: BlockRow['block_type'];
+  content: Json;
+  order: number;
+}
+
+export interface FullPageContent {
+  meta: PageMetaContent;
+  blocks: SimpleBlockContent[];
+}
+
+export interface FullPostContent {
+  meta: PostMetaContent;
+  blocks: SimpleBlockContent[];
+}
+
+export async function getFullPageContent(
+  pageId: number,
+  opts?: { overrideBlockId?: number; overrideBlockContent?: unknown; excludeDeletedBlockId?: number }
+): Promise<FullPageContent | null> {
+  const supabase = createClient();
+  const { data: page, error: pageError } = await supabase
+    .from('pages')
+    .select('id, title, slug, language_id, status, meta_title, meta_description')
+    .eq('id', pageId)
+    .single();
+  if (pageError || !page) return null;
+
+  const { data: blocks, error: blocksError } = await supabase
+    .from('blocks')
+    .select('id, language_id, block_type, content, order, page_id, post_id')
+    .eq('page_id', pageId)
+    .order('order', { ascending: true });
+  if (blocksError) return null;
+
+  const processed = (blocks || [])
+    .filter(b => opts?.excludeDeletedBlockId ? b.id !== opts.excludeDeletedBlockId : true)
+    .map(b => ({
+      language_id: b.language_id,
+      block_type: b.block_type,
+      content: (opts?.overrideBlockId && b.id === opts.overrideBlockId)
+        ? (opts.overrideBlockContent as Json)
+        : (b.content as Json),
+      order: b.order,
+    } satisfies SimpleBlockContent));
+
+  return {
+    meta: {
+      title: page.title,
+      slug: page.slug,
+      language_id: page.language_id,
+      status: page.status,
+      meta_title: page.meta_title,
+      meta_description: page.meta_description,
+    },
+    blocks: processed,
+  };
+}
+
+export async function getFullPostContent(
+  postId: number,
+  opts?: { overrideBlockId?: number; overrideBlockContent?: unknown; excludeDeletedBlockId?: number }
+): Promise<FullPostContent | null> {
+  const supabase = createClient();
+  const { data: post, error: postError } = await supabase
+    .from('posts')
+    .select('id, title, slug, language_id, status, meta_title, meta_description, excerpt, published_at, feature_image_id')
+    .eq('id', postId)
+    .single();
+  if (postError || !post) return null;
+
+  const { data: blocks, error: blocksError } = await supabase
+    .from('blocks')
+    .select('id, language_id, block_type, content, order, page_id, post_id')
+    .eq('post_id', postId)
+    .order('order', { ascending: true });
+  if (blocksError) return null;
+
+  const processed = (blocks || [])
+    .filter(b => opts?.excludeDeletedBlockId ? b.id !== opts.excludeDeletedBlockId : true)
+    .map(b => ({
+      language_id: b.language_id,
+      block_type: b.block_type,
+      content: (opts?.overrideBlockId && b.id === opts.overrideBlockId)
+        ? (opts.overrideBlockContent as Json)
+        : (b.content as Json),
+      order: b.order,
+    } satisfies SimpleBlockContent));
+
+  return {
+    meta: {
+      title: post.title,
+      slug: post.slug,
+      language_id: post.language_id,
+      status: post.status,
+      meta_title: post.meta_title,
+      meta_description: post.meta_description,
+      excerpt: post.excerpt,
+      published_at: post.published_at ? new Date(post.published_at).toISOString() : null,
+      feature_image_id: post.feature_image_id ?? null,
+    },
+    blocks: processed,
+  };
+}
+

package/templates/nextblock-template/app/cms/settings/copyright/actions.ts

@@ -0,0 +1,68 @@
+// app/cms/settings/copyright/actions.ts
+'use server';
+
+import { createClient } from '@nextblock-cms/db/server';
+import { revalidatePath } from 'next/cache';
+
+export type CopyrightSettings = {
+  [key: string]: string;
+};
+
+export async function getCopyrightSettings(): Promise<CopyrightSettings> {
+  const supabase = createClient();
+  const { data, error } = await supabase
+    .from('site_settings')
+    .select('value')
+    .eq('key', 'footer_copyright')
+    .single();
+
+  if (error || !data) {
+    // If you want to handle the "not found" case gracefully,
+    // you could return a default value instead of throwing an error.
+    console.error('Copyright settings not found:', error);
+    return { en: '© {year} Default Copyright. All rights reserved.' };
+  }
+
+  return data.value as CopyrightSettings;
+}
+
+export async function updateCopyrightSettings(formData: FormData) {
+  const supabase = createClient();
+
+  // Check if user is an admin
+  const { data: { user } } = await supabase.auth.getUser();
+  if (!user) {
+    throw new Error('You must be logged in to update settings.');
+  }
+  const { data: profile, error: profileError } = await supabase
+    .from('profiles')
+    .select('role')
+    .eq('id', user.id)
+    .single();
+
+  if (profileError || !profile || !['ADMIN', 'WRITER'].includes(profile.role)) {
+    throw new Error('You do not have permission to perform this action.');
+  }
+
+  const newSettings: CopyrightSettings = {};
+  formData.forEach((value, key) => {
+    if (key.startsWith('copyright_')) {
+      const langCode = key.replace('copyright_', '');
+      newSettings[langCode] = value as string;
+    }
+  });
+
+  const { error } = await supabase
+    .from('site_settings')
+    .upsert({ key: 'footer_copyright', value: newSettings });
+
+  if (error) {
+    console.error('Error updating copyright settings:', error);
+    throw new Error('Failed to update copyright settings.');
+  }
+
+  // Revalidate the root layout to reflect changes immediately across the site.
+  revalidatePath('/', 'layout');
+
+  return { success: true, message: 'Copyright settings updated successfully.' };
+}

package/templates/nextblock-template/app/cms/settings/copyright/components/CopyrightForm.tsx

@@ -0,0 +1,78 @@
+'use client';
+
+import { useState, useTransition } from 'react';
+import type { Database } from '@nextblock-cms/db';
+
+type Language = Database['public']['Tables']['languages']['Row'];
+import { CopyrightSettings, updateCopyrightSettings } from '../actions';
+import { Label } from '@nextblock-cms/ui';
+import { Input } from '@nextblock-cms/ui';
+import { Button } from '@nextblock-cms/ui';
+import { FormMessage, type Message } from '@/components/form-message';
+
+interface CopyrightFormProps {
+  languages: Language[];
+  initialSettings: CopyrightSettings;
+}
+
+export default function CopyrightForm({ languages, initialSettings }: CopyrightFormProps) {
+  const [isPending, startTransition] = useTransition();
+  const [message, setMessage] = useState<Message | null>(null);
+  const [settings, setSettings] = useState<CopyrightSettings>(initialSettings);
+
+  const handleInputChange = (langCode: string, value: string) => {
+    setSettings(prev => ({ ...prev, [langCode]: value }));
+  };
+
+  const handleSubmit = async (event: React.FormEvent<HTMLFormElement>) => {
+    event.preventDefault();
+    setMessage(null);
+
+    const formData = new FormData();
+    for (const lang of languages) {
+        const value = settings[lang.code] || '';
+        formData.append(`copyright_${lang.code}`, value);
+    }
+
+    startTransition(async () => {
+      try {
+        const result = await updateCopyrightSettings(formData);
+        if (result.success) {
+          setMessage({ success: result.message });
+        } else {
+          setMessage({ error: 'An unexpected error occurred.' });
+        }
+      } catch (error) {
+        setMessage({ error: error instanceof Error ? error.message : 'An unknown error occurred.' });
+      }
+    });
+  };
+
+  return (
+    <form onSubmit={handleSubmit} className="space-y-6">
+      <div className="space-y-4">
+        {languages.map(lang => (
+          <div key={lang.id} className="space-y-2">
+            <Label htmlFor={`copyright_${lang.code}`}>
+              {lang.name} ({lang.code})
+            </Label>
+            <Input
+              id={`copyright_${lang.code}`}
+              name={`copyright_${lang.code}`}
+              value={settings[lang.code] || ''}
+              onChange={(e) => handleInputChange(lang.code, e.target.value)}
+              placeholder="e.g., © {year} Copyright"
+            />
+          </div>
+        ))}
+      </div>
+
+      <div className="flex items-center gap-4">
+        <Button type="submit" disabled={isPending}>
+          {isPending ? 'Saving...' : 'Save Settings'}
+        </Button>
+        {message && <FormMessage message={message} />}
+      </div>
+    </form>
+  );
+}

package/templates/nextblock-template/app/cms/settings/copyright/page.tsx

@@ -0,0 +1,32 @@
+// app/cms/settings/copyright/page.tsx
+import { getActiveLanguagesServerSide } from '@/app/cms/settings/languages/actions';
+import { getCopyrightSettings } from './actions';
+import CopyrightForm from './components/CopyrightForm';
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@nextblock-cms/ui';
+
+export default async function CopyrightSettingsPage() {
+  const languages = await getActiveLanguagesServerSide();
+  const copyrightSettings = await getCopyrightSettings();
+
+  const year = new Date().getFullYear();
+
+  return (
+    <div className="max-w-4xl mx-auto">
+        <Card>
+            <CardHeader>
+                <CardTitle>Footer Copyright Settings</CardTitle>
+                <CardDescription>
+                    Manage the copyright text displayed in the site footer for each language.
+                    Use &quot;{year}&quot; as a placeholder for the current year.
+                </CardDescription>
+            </CardHeader>
+            <CardContent>
+                <CopyrightForm
+                    languages={languages}
+                    initialSettings={copyrightSettings}
+                />
+            </CardContent>
+        </Card>
+    </div>
+  );
+}