create-nextblock 0.2.78 → 0.8.0

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

@@ -0,0 +1,21 @@
+// Shared transactional email for 2FA codes. Server-only helper (not a server
+// action); callable from sign-in, the challenge page, and the security panel.
+import { sendEmail } from './email';
+
+export async function sendTwoFactorCodeEmail(
+  to: string,
+  code: string,
+  purpose = 'verify your sign-in',
+): Promise<void> {
+  await sendEmail({
+    to,
+    subject: 'Your NextBlock verification code',
+    text: `Your NextBlock verification code is ${code}. It expires in 5 minutes. If you didn't request it, you can ignore this email.`,
+    html: `
+  <div style="font-family:system-ui,-apple-system,Segoe UI,Roboto,sans-serif;max-width:480px;margin:0 auto;padding:24px;">
+    <p style="font-size:14px;color:#475569;">Use this code to ${purpose}:</p>
+    <p style="font-size:32px;font-weight:700;letter-spacing:8px;margin:16px 0;color:#0f172a;">${code}</p>
+    <p style="font-size:13px;color:#64748b;">This code expires in 5 minutes. If you didn't request it, you can safely ignore this email.</p>
+  </div>`,
+  });
+}

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

@@ -0,0 +1,179 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const draftContentMocks = vi.hoisted(() => ({
+  findDraftBlock: vi.fn(),
+  getCurrentUserCanEdit: vi.fn(),
+  getOrCreateContentDraft: vi.fn(),
+  getPublicPath: vi.fn((parentType: string, slug: string) =>
+    parentType === "page" ? `/${slug}` : `/article/${slug}`
+  ),
+  normalizeContentDraftRow: vi.fn((row) => row),
+  readPublishedSnapshot: vi.fn(),
+  updateDraftBlockContent: vi.fn(),
+}));
+
+const cacheMocks = vi.hoisted(() => ({
+  revalidatePath: vi.fn(),
+}));
+
+vi.mock("next/cache", () => cacheMocks);
+vi.mock("server-only", () => ({}));
+vi.mock("../cms/revisions/utils", () => ({
+  getFullPageContent: vi.fn(),
+  getFullPostContent: vi.fn(),
+}));
+vi.mock("../cms/revisions/service", () => ({
+  createPageRevision: vi.fn(),
+  createPostRevision: vi.fn(),
+}));
+vi.mock("../../lib/visual-editing/draft-content", () => draftContentMocks);
+vi.mock("../../lib/visual-editing/product-drafts", () => ({
+  discardProductVisualEditingDraft: vi.fn(),
+  loadProductVisualEditingField: vi.fn(),
+  publishProductVisualEditingDraft: vi.fn(),
+}));
+
+import {
+  discardVisualEditingDraft,
+  publishVisualEditingDraft,
+  saveVisualEditingBlockDraft,
+} from "./visualEditingActions";
+
+const baseDraft = {
+  id: 1,
+  parent_type: "page",
+  parent_id: 2,
+  author_id: "user-1",
+  base_version: 1,
+  meta: { slug: "about" },
+  blocks: [
+    {
+      id: 10,
+      page_id: 2,
+      post_id: null,
+      language_id: 1,
+      block_type: "text",
+      content: { html_content: "<p>Old</p>" },
+      order: 0,
+    },
+  ],
+  created_at: "2026-01-01T00:00:00.000Z",
+  updated_at: "2026-01-01T00:00:00.000Z",
+};
+
+const request = {
+  parentType: "page" as const,
+  parentId: 2,
+  target: {
+    kind: "top-level" as const,
+    blockId: 10,
+    blockIndex: 0,
+    blockType: "text",
+  },
+};
+
+describe("visual editing server actions", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("saves block edits to content_drafts and revalidates the draft path", async () => {
+    const savedDraft = {
+      ...baseDraft,
+      blocks: [
+        {
+          ...baseDraft.blocks[0],
+          content: { html_content: "<p>New</p>" },
+        },
+      ],
+    };
+    const single = vi.fn().mockResolvedValue({ data: savedDraft, error: null });
+    const select = vi.fn(() => ({ single }));
+    const eq = vi.fn(() => ({ select }));
+    const update = vi.fn(() => ({ eq }));
+    const from = vi.fn(() => ({ update }));
+
+    draftContentMocks.getCurrentUserCanEdit.mockResolvedValue({
+      user: { id: "user-1" },
+      canEdit: true,
+      supabase: { from },
+    });
+    draftContentMocks.getOrCreateContentDraft.mockResolvedValue(baseDraft);
+    draftContentMocks.updateDraftBlockContent.mockReturnValue(savedDraft);
+
+    const result = await saveVisualEditingBlockDraft(request, {
+      html_content: "<p>New</p>",
+    });
+
+    expect(result).toMatchObject({ success: true });
+    expect(from).toHaveBeenCalledWith("content_drafts");
+    expect(update).toHaveBeenCalledWith({
+      author_id: "user-1",
+      blocks: savedDraft.blocks,
+    });
+    expect(cacheMocks.revalidatePath).toHaveBeenCalledWith("/about");
+  });
+
+  it("returns setup guidance when draft storage is missing", async () => {
+    draftContentMocks.getCurrentUserCanEdit.mockResolvedValue({
+      user: { id: "user-1" },
+      canEdit: true,
+      supabase: {},
+    });
+    draftContentMocks.getOrCreateContentDraft.mockRejectedValue(
+      new Error(
+        "Failed to read content draft: Could not find the table 'public.content_drafts' in the schema cache"
+      )
+    );
+
+    const result = await saveVisualEditingBlockDraft(request, {
+      html_content: "<p>New</p>",
+    });
+
+    expect(result).toEqual({
+      error:
+        "Draft storage is not set up in this database. Apply the content_drafts migration: libs/db/src/supabase/migrations/00000000000014_setup_content_drafts.sql.",
+    });
+  });
+
+  it("discards a draft snapshot", async () => {
+    const deleteChain: any = {
+      error: null,
+      eq: vi.fn(() => deleteChain),
+    };
+    const from = vi.fn(() => ({
+      delete: vi.fn(() => deleteChain),
+    }));
+    draftContentMocks.getCurrentUserCanEdit.mockResolvedValue({
+      user: { id: "user-1" },
+      canEdit: true,
+      supabase: { from },
+    });
+
+    const result = await discardVisualEditingDraft("page", 2);
+
+    expect(result).toEqual({ success: true });
+    expect(from).toHaveBeenCalledWith("content_drafts");
+    expect(deleteChain.eq).toHaveBeenCalledWith("parent_type", "page");
+    expect(deleteChain.eq).toHaveBeenCalledWith("parent_id", 2);
+  });
+
+  it("returns an error when publishing without an existing draft", async () => {
+    const readChain: any = {
+      select: vi.fn(() => readChain),
+      eq: vi.fn(() => readChain),
+      maybeSingle: vi.fn().mockResolvedValue({ data: null, error: null }),
+    };
+    const from = vi.fn(() => readChain);
+    draftContentMocks.getCurrentUserCanEdit.mockResolvedValue({
+      user: { id: "user-1" },
+      canEdit: true,
+      supabase: { from },
+    });
+
+    const result = await publishVisualEditingDraft("page", 2);
+
+    expect(result).toEqual({ error: "No draft exists for this content." });
+    expect(from).toHaveBeenCalledWith("content_drafts");
+  });
+});

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

@@ -0,0 +1,345 @@
+"use server";
+
+import type { Json } from "@nextblock-cms/db";
+import {
+  getFullPageContent,
+  getFullPostContent,
+} from "../cms/revisions/utils";
+import {
+  createPageRevision,
+  createPostRevision,
+} from "../cms/revisions/service";
+import {
+  findDraftBlock,
+  getCurrentUserCanEdit,
+  getPublicPath,
+  normalizeContentDraftRow,
+  readPublishedSnapshot,
+} from "../../lib/visual-editing/draft-content";
+import {
+  assertValidVisualEditingRequest,
+  formatVisualEditingError,
+  requireVisualEditingEditableUser,
+  revalidateVisualEditingPath,
+  saveVisualEditingBlockDraftMutation,
+} from "../../lib/visual-editing/mutations";
+import {
+  discardProductVisualEditingDraft,
+  loadProductVisualEditingField,
+  publishProductVisualEditingDraft,
+} from "../../lib/visual-editing/product-drafts";
+import type {
+  ContentDraftRow,
+  DraftBlockSnapshot,
+  NextblockDocumentType,
+  VisualEditingBlockRequest,
+  VisualEditingProductFieldRequest,
+} from "../../lib/visual-editing/types";
+
+export async function loadVisualEditingBlockContent(request: VisualEditingBlockRequest) {
+  try {
+    assertValidVisualEditingRequest(request);
+    const auth = await requireVisualEditingEditableUser();
+
+    let snapshot: { blocks: DraftBlockSnapshot[]; meta?: Record<string, Json> } | null = null;
+    let draftId: number | null = null;
+
+    if (request.parentType === "product") {
+      const { getProductDraft, readProductSnapshot } = await import("../../lib/visual-editing/product-drafts");
+      const draft = await getProductDraft(request.parentId as string);
+      if (draft) {
+        snapshot = draft;
+        draftId = draft.id;
+      } else {
+        snapshot = await readProductSnapshot(auth.supabase, request.parentId as string);
+      }
+    } else {
+      let draft: ContentDraftRow | null = null;
+      const { data } = await (auth.supabase as any)
+        .from("content_drafts")
+        .select("*")
+        .eq("parent_type", request.parentType)
+        .eq("parent_id", request.parentId)
+        .maybeSingle();
+
+      if (data) {
+        draft = normalizeContentDraftRow(data);
+        draftId = draft.id;
+      }
+
+      snapshot = draft ?? (await readPublishedSnapshot(auth.supabase, request.parentType as NextblockDocumentType, request.parentId as number));
+    }
+
+    const block = findDraftBlock(snapshot as any, request);
+
+    if (!block) {
+      return { error: "Block not found." };
+    }
+
+    if (request.target.kind === "nested") {
+      return {
+        success: true,
+        content: (block as { content?: Json }).content ?? null,
+        draftId,
+      };
+    }
+
+    return {
+      success: true,
+      content: (block as DraftBlockSnapshot).content,
+      draftId,
+    };
+  } catch (error) {
+    return {
+      error: formatVisualEditingError(error, "Failed to load draft block."),
+    };
+  }
+}
+
+export async function saveVisualEditingBlockDraft(
+  request: VisualEditingBlockRequest,
+  content: Json
+) {
+  return saveVisualEditingBlockDraftMutation(request, content);
+}
+
+export async function loadVisualEditingProductField(
+  request: VisualEditingProductFieldRequest
+) {
+  return loadProductVisualEditingField(request);
+}
+
+function buildBlockInsertPayload(
+  block: DraftBlockSnapshot,
+  parentType: NextblockDocumentType,
+  parentId: number,
+  index: number
+) {
+  return {
+    page_id: parentType === "page" ? parentId : null,
+    post_id: parentType === "post" ? parentId : null,
+    language_id: block.language_id,
+    block_type: block.block_type,
+    content: block.content,
+    order: Number.isFinite(block.order) ? block.order : index,
+  };
+}
+
+function hasDraftMetaValue(draft: ContentDraftRow, key: string) {
+  return Object.prototype.hasOwnProperty.call(draft.meta, key);
+}
+
+function addStringMeta(
+  payload: Record<string, unknown>,
+  draft: ContentDraftRow,
+  key: string
+) {
+  const value = draft.meta[key];
+  if (typeof value === "string") {
+    payload[key] = value;
+  }
+}
+
+function addNullableStringMeta(
+  payload: Record<string, unknown>,
+  draft: ContentDraftRow,
+  key: string
+) {
+  if (!hasDraftMetaValue(draft, key)) {
+    return;
+  }
+
+  const value = draft.meta[key];
+  payload[key] = typeof value === "string" ? value : null;
+}
+
+function addNumberMeta(
+  payload: Record<string, unknown>,
+  draft: ContentDraftRow,
+  key: string
+) {
+  const value = draft.meta[key];
+  if (typeof value === "number") {
+    payload[key] = value;
+  }
+}
+
+async function publishPageDraft(draft: ContentDraftRow, authorId: string) {
+  const auth = await getCurrentUserCanEdit();
+  const supabase = auth.supabase;
+  const previousContent = await getFullPageContent(draft.parent_id);
+  const pageUpdate: Record<string, unknown> = {};
+  addStringMeta(pageUpdate, draft, "title");
+  addStringMeta(pageUpdate, draft, "slug");
+  addNumberMeta(pageUpdate, draft, "language_id");
+  addStringMeta(pageUpdate, draft, "status");
+  addNullableStringMeta(pageUpdate, draft, "meta_title");
+  addNullableStringMeta(pageUpdate, draft, "meta_description");
+  addNullableStringMeta(pageUpdate, draft, "feature_image_id");
+
+  const { error: pageError } = await supabase
+    .from("pages")
+    .update(pageUpdate as any)
+    .eq("id", draft.parent_id);
+
+  if (pageError) {
+    throw new Error(`Failed to update page: ${pageError.message}`);
+  }
+
+  const { error: deleteError } = await supabase.from("blocks").delete().eq("page_id", draft.parent_id);
+  if (deleteError) {
+    throw new Error(`Failed to clear page blocks: ${deleteError.message}`);
+  }
+
+  const blocks = draft.blocks.map((block, index) =>
+    buildBlockInsertPayload(block, "page", draft.parent_id, index)
+  );
+
+  if (blocks.length > 0) {
+    const { error: insertError } = await supabase.from("blocks").insert(blocks as any);
+    if (insertError) {
+      throw new Error(`Failed to insert page blocks: ${insertError.message}`);
+    }
+  }
+
+  const nextContent = await getFullPageContent(draft.parent_id);
+  if (previousContent && nextContent) {
+    await createPageRevision(draft.parent_id, authorId, previousContent, nextContent);
+  }
+}
+
+async function publishPostDraft(draft: ContentDraftRow, authorId: string) {
+  const auth = await getCurrentUserCanEdit();
+  const supabase = auth.supabase;
+  const previousContent = await getFullPostContent(draft.parent_id);
+  const postUpdate: Record<string, unknown> = {};
+  addStringMeta(postUpdate, draft, "title");
+  addStringMeta(postUpdate, draft, "slug");
+  addNumberMeta(postUpdate, draft, "language_id");
+  addStringMeta(postUpdate, draft, "status");
+  addNullableStringMeta(postUpdate, draft, "meta_title");
+  addNullableStringMeta(postUpdate, draft, "meta_description");
+  addNullableStringMeta(postUpdate, draft, "label");
+  addNullableStringMeta(postUpdate, draft, "excerpt");
+  addNullableStringMeta(postUpdate, draft, "subtitle");
+  addNullableStringMeta(postUpdate, draft, "published_at");
+  addNullableStringMeta(postUpdate, draft, "feature_image_id");
+
+  const { error: postError } = await supabase
+    .from("posts")
+    .update(postUpdate as any)
+    .eq("id", draft.parent_id);
+
+  if (postError) {
+    throw new Error(`Failed to update post: ${postError.message}`);
+  }
+
+  const { error: deleteError } = await supabase.from("blocks").delete().eq("post_id", draft.parent_id);
+  if (deleteError) {
+    throw new Error(`Failed to clear post blocks: ${deleteError.message}`);
+  }
+
+  const blocks = draft.blocks.map((block, index) =>
+    buildBlockInsertPayload(block, "post", draft.parent_id, index)
+  );
+
+  if (blocks.length > 0) {
+    const { error: insertError } = await supabase.from("blocks").insert(blocks as any);
+    if (insertError) {
+      throw new Error(`Failed to insert post blocks: ${insertError.message}`);
+    }
+  }
+
+  const nextContent = await getFullPostContent(draft.parent_id);
+  if (previousContent && nextContent) {
+    await createPostRevision(draft.parent_id, authorId, previousContent, nextContent);
+  }
+}
+
+export async function publishVisualEditingDraft(parentType: NextblockDocumentType, parentId: number) {
+  try {
+    const auth = await requireVisualEditingEditableUser();
+    const { data, error } = await (auth.supabase as any)
+      .from("content_drafts")
+      .select("*")
+      .eq("parent_type", parentType)
+      .eq("parent_id", parentId)
+      .maybeSingle();
+
+    if (error) {
+      return {
+        error: formatVisualEditingError(
+          new Error(`Failed to read content draft: ${error.message}`),
+          "Failed to read content draft."
+        ),
+      };
+    }
+
+    if (!data) {
+      return { error: "No draft exists for this content." };
+    }
+
+    const draft = normalizeContentDraftRow(data);
+
+    if (parentType === "page") {
+      await publishPageDraft(draft, auth.user.id);
+    } else {
+      await publishPostDraft(draft, auth.user.id);
+    }
+
+    const { error: deleteError } = await (auth.supabase as any)
+      .from("content_drafts")
+      .delete()
+      .eq("id", draft.id);
+
+    if (deleteError) {
+      return { error: `Published, but failed to remove draft: ${deleteError.message}` };
+    }
+
+    const slug = typeof draft.meta.slug === "string" ? draft.meta.slug : "";
+    if (slug) {
+      revalidateVisualEditingPath(getPublicPath(parentType, slug));
+    }
+    revalidateVisualEditingPath(parentType === "page" ? `/cms/pages/${parentId}/edit` : `/cms/posts/${parentId}/edit`);
+
+    return { success: true };
+  } catch (error) {
+    return {
+      error: formatVisualEditingError(error, "Failed to publish draft."),
+    };
+  }
+}
+
+export async function discardVisualEditingDraft(parentType: NextblockDocumentType, parentId: number) {
+  try {
+    const auth = await requireVisualEditingEditableUser();
+    const { error } = await (auth.supabase as any)
+      .from("content_drafts")
+      .delete()
+      .eq("parent_type", parentType)
+      .eq("parent_id", parentId);
+
+    if (error) {
+      return {
+        error: formatVisualEditingError(
+          new Error(`Failed to discard draft: ${error.message}`),
+          "Failed to discard draft."
+        ),
+      };
+    }
+
+    return { success: true };
+  } catch (error) {
+    return {
+      error: formatVisualEditingError(error, "Failed to discard draft."),
+    };
+  }
+}
+
+export async function publishVisualEditingProductDraft(productId: string) {
+  return publishProductVisualEditingDraft(productId);
+}
+
+export async function discardVisualEditingProductDraft(productId: string) {
+  return discardProductVisualEditingDraft(productId);
+}