create-nextblock 0.2.77 → 0.8.0

package/templates/nextblock-template/lib/visual-editing/draft-content.ts

@@ -0,0 +1,380 @@
+import "server-only";
+
+import type { Json } from "@nextblock-cms/db";
+import {
+  createClient,
+  getServiceRoleSupabaseClient,
+  getSsgSupabaseClient,
+} from "@nextblock-cms/db/server";
+import type {
+  ContentDraftRow,
+  ContentDraftSnapshot,
+  DraftBlockSnapshot,
+  NextblockDocumentType,
+  VisualEditingBlockRequest,
+} from "./types";
+
+type SupabaseAny = ReturnType<typeof createClient> | ReturnType<typeof getServiceRoleSupabaseClient>;
+
+type RoleName = "ADMIN" | "WRITER" | string;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function toNumber(value: unknown): number | null {
+  const numeric = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+}
+
+function normalizeJson(value: unknown): Json {
+  if (value === undefined) {
+    return null;
+  }
+  return value as Json;
+}
+
+export function normalizeDraftBlocks(value: unknown): DraftBlockSnapshot[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  return value.flatMap((item, index): DraftBlockSnapshot[] => {
+    if (!isRecord(item)) {
+      return [];
+    }
+
+    const languageId = toNumber(item.language_id);
+    const blockType = typeof item.block_type === "string" ? item.block_type : null;
+
+    if (!languageId || !blockType) {
+      return [];
+    }
+
+    return [
+      {
+        id: toNumber(item.id) ?? undefined,
+        page_id: toNumber(item.page_id),
+        post_id: toNumber(item.post_id),
+        product_id: typeof item.product_id === "string" ? item.product_id : null,
+        language_id: languageId,
+        block_type: blockType,
+        content: normalizeJson(item.content),
+        order: toNumber(item.order) ?? index,
+        created_at: typeof item.created_at === "string" ? item.created_at : null,
+        updated_at: typeof item.updated_at === "string" ? item.updated_at : null,
+      },
+    ];
+  });
+}
+
+export function normalizeContentDraftRow(row: Record<string, unknown>): ContentDraftRow {
+  return {
+    id: Number(row.id),
+    parent_type: row.parent_type === "post" ? "post" : "page",
+    parent_id: Number(row.parent_id),
+    author_id: typeof row.author_id === "string" ? row.author_id : null,
+    base_version: Number(row.base_version ?? 1),
+    meta: isRecord(row.meta) ? (row.meta as Record<string, Json>) : {},
+    blocks: normalizeDraftBlocks(row.blocks),
+    created_at: String(row.created_at ?? ""),
+    updated_at: String(row.updated_at ?? ""),
+  };
+}
+
+export function getPublicPath(parentType: NextblockDocumentType, slug: string) {
+  return parentType === "page" ? `/${slug}` : `/article/${slug}`;
+}
+
+export async function getCurrentUserCanEdit() {
+  const supabase = createClient();
+  const {
+    data: { user },
+  } = await supabase.auth.getUser();
+
+  if (!user) {
+    return { supabase, user: null, canEdit: false };
+  }
+
+  const { data: profile } = await supabase
+    .from("profiles")
+    .select("role")
+    .eq("id", user.id)
+    .single();
+
+  const role = profile?.role as RoleName | undefined;
+  return {
+    supabase,
+    user,
+    canEdit: role === "ADMIN" || role === "WRITER",
+  };
+}
+
+async function readPageSnapshot(
+  supabase: SupabaseAny,
+  pageId: number
+): Promise<ContentDraftSnapshot & { baseVersion: number }> {
+  const client = supabase as any;
+  const { data: page, error: pageError } = await client
+    .from("pages")
+    .select("id, title, slug, language_id, status, meta_title, meta_description, feature_image_id, version, translation_group_id")
+    .eq("id", pageId)
+    .single();
+
+  if (pageError || !page) {
+    throw new Error("Page not found.");
+  }
+
+  const { data: blocks, error: blocksError } = await client
+    .from("blocks")
+    .select("id, page_id, post_id, language_id, block_type, content, order, created_at, updated_at")
+    .eq("page_id", pageId)
+    .order("order", { ascending: true });
+
+  if (blocksError) {
+    throw new Error(`Failed to read page blocks: ${blocksError.message}`);
+  }
+
+  return {
+    baseVersion: page.version ?? 1,
+    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,
+      feature_image_id: page.feature_image_id,
+      translation_group_id: page.translation_group_id,
+    } as Record<string, Json>,
+    blocks: normalizeDraftBlocks(blocks),
+  };
+}
+
+async function readPostSnapshot(
+  supabase: SupabaseAny,
+  postId: number
+): Promise<ContentDraftSnapshot & { baseVersion: number }> {
+  const client = supabase as any;
+  const { data: post, error: postError } = await client
+    .from("posts")
+    .select("id, title, slug, language_id, status, meta_title, meta_description, label, excerpt, subtitle, published_at, feature_image_id, version, translation_group_id")
+    .eq("id", postId)
+    .single();
+
+  if (postError || !post) {
+    throw new Error("Post not found.");
+  }
+
+  const { data: blocks, error: blocksError } = await client
+    .from("blocks")
+    .select("id, page_id, post_id, language_id, block_type, content, order, created_at, updated_at")
+    .eq("post_id", postId)
+    .order("order", { ascending: true });
+
+  if (blocksError) {
+    throw new Error(`Failed to read post blocks: ${blocksError.message}`);
+  }
+
+  return {
+    baseVersion: post.version ?? 1,
+    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,
+      label: post.label,
+      excerpt: post.excerpt,
+      subtitle: post.subtitle,
+      published_at: post.published_at,
+      feature_image_id: post.feature_image_id,
+      translation_group_id: post.translation_group_id,
+    } as Record<string, Json>,
+    blocks: normalizeDraftBlocks(blocks),
+  };
+}
+
+export async function readPublishedSnapshot(
+  supabase: SupabaseAny,
+  parentType: NextblockDocumentType,
+  parentId: number
+) {
+  return parentType === "page"
+    ? readPageSnapshot(supabase, parentId)
+    : readPostSnapshot(supabase, parentId);
+}
+
+export async function getContentDraft(
+  parentType: NextblockDocumentType,
+  parentId: number
+): Promise<ContentDraftRow | null> {
+  const supabase = createClient();
+  const { data, error } = await (supabase as any)
+    .from("content_drafts")
+    .select("*")
+    .eq("parent_type", parentType)
+    .eq("parent_id", parentId)
+    .maybeSingle();
+
+  if (error || !data) {
+    return null;
+  }
+
+  return normalizeContentDraftRow(data);
+}
+
+export async function getOrCreateContentDraft(
+  supabase: SupabaseAny,
+  parentType: NextblockDocumentType,
+  parentId: number,
+  authorId: string
+): Promise<ContentDraftRow> {
+  const { data: existing, error: existingError } = await (supabase as any)
+    .from("content_drafts")
+    .select("*")
+    .eq("parent_type", parentType)
+    .eq("parent_id", parentId)
+    .maybeSingle();
+
+  if (existingError) {
+    throw new Error(`Failed to read content draft: ${existingError.message}`);
+  }
+
+  if (existing) {
+    return normalizeContentDraftRow(existing);
+  }
+
+  const snapshot = await readPublishedSnapshot(supabase, parentType, parentId);
+  const { data: created, error: createError } = await (supabase as any)
+    .from("content_drafts")
+    .insert({
+      parent_type: parentType,
+      parent_id: parentId,
+      author_id: authorId,
+      base_version: snapshot.baseVersion,
+      meta: snapshot.meta,
+      blocks: snapshot.blocks,
+    })
+    .select("*")
+    .single();
+
+  if (createError || !created) {
+    throw new Error(`Failed to create content draft: ${createError?.message ?? "unknown error"}`);
+  }
+
+  return normalizeContentDraftRow(created);
+}
+
+export function findDraftBlock(
+  snapshot: ContentDraftSnapshot,
+  request: VisualEditingBlockRequest
+) {
+  const { target } = request;
+
+  if (target.kind === "top-level") {
+    return (
+      snapshot.blocks.find((block) => block.id === target.blockId) ??
+      snapshot.blocks[target.blockIndex] ??
+      null
+    );
+  }
+
+  const parent =
+    snapshot.blocks.find((block) => block.id === target.parentBlockId) ??
+    snapshot.blocks[target.parentBlockIndex] ??
+    null;
+
+  if (!parent || !isRecord(parent.content)) {
+    return null;
+  }
+
+  const columns = parent.content.column_blocks;
+  if (!Array.isArray(columns)) {
+    return null;
+  }
+
+  const column = columns[target.columnIndex];
+  if (!Array.isArray(column)) {
+    return null;
+  }
+
+  const nested = column[target.blockIndex];
+  return isRecord(nested) ? nested : null;
+}
+
+export function updateDraftBlockContent(
+  snapshot: ContentDraftSnapshot,
+  request: VisualEditingBlockRequest,
+  content: Json
+): ContentDraftSnapshot {
+  const blocks = JSON.parse(JSON.stringify(snapshot.blocks)) as DraftBlockSnapshot[];
+  const nextSnapshot = { ...snapshot, blocks };
+  const { target } = request;
+
+  if (target.kind === "top-level") {
+    const blockIndex = blocks.findIndex((block) => block.id === target.blockId);
+    const resolvedIndex = blockIndex >= 0 ? blockIndex : target.blockIndex;
+    const block = blocks[resolvedIndex];
+
+    if (!block) {
+      throw new Error("Draft block not found.");
+    }
+
+    if (block.block_type !== target.blockType) {
+      throw new Error("Draft block type mismatch.");
+    }
+
+    blocks[resolvedIndex] = {
+      ...block,
+      content,
+      updated_at: new Date().toISOString(),
+    };
+    return nextSnapshot;
+  }
+
+  const parentIndex = blocks.findIndex((block) => block.id === target.parentBlockId);
+  const resolvedParentIndex = parentIndex >= 0 ? parentIndex : target.parentBlockIndex;
+  const parent = blocks[resolvedParentIndex];
+
+  if (!parent || !isRecord(parent.content)) {
+    throw new Error("Draft parent block not found.");
+  }
+
+  if (parent.block_type !== target.parentBlockType) {
+    throw new Error("Draft parent block type mismatch.");
+  }
+
+  const parentContent = JSON.parse(JSON.stringify(parent.content)) as Record<string, unknown>;
+  const columns = parentContent.column_blocks;
+  if (!Array.isArray(columns) || !Array.isArray(columns[target.columnIndex])) {
+    throw new Error("Draft nested block column not found.");
+  }
+
+  const nested = columns[target.columnIndex][target.blockIndex];
+  if (!isRecord(nested) || nested.block_type !== target.blockType) {
+    throw new Error("Draft nested block type mismatch.");
+  }
+
+  columns[target.columnIndex][target.blockIndex] = {
+    ...nested,
+    content,
+  };
+
+  blocks[resolvedParentIndex] = {
+    ...parent,
+    content: parentContent as Json,
+    updated_at: new Date().toISOString(),
+  };
+
+  return nextSnapshot;
+}
+
+export function createVerificationClient() {
+  if (process.env.SUPABASE_SERVICE_ROLE_KEY) {
+    return getServiceRoleSupabaseClient();
+  }
+
+  return getSsgSupabaseClient() as ReturnType<typeof getServiceRoleSupabaseClient>;
+}

package/templates/nextblock-template/lib/visual-editing/draft-route.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import {
+  normalizeDraftRedirectPath,
+  resolveDraftPathTarget,
+} from "./draft-route";
+
+describe("draft-route helpers", () => {
+  it("normalizes relative draft redirect paths", () => {
+    expect(normalizeDraftRedirectPath("about")).toBe("/about");
+    expect(normalizeDraftRedirectPath("/article/post-one")).toBe("/article/post-one");
+    expect(normalizeDraftRedirectPath("/product/sku-one")).toBe("/product/sku-one");
+    expect(normalizeDraftRedirectPath("//evil.example/path")).toBeNull();
+    expect(normalizeDraftRedirectPath("https://evil.example/path")).toBeNull();
+    expect(normalizeDraftRedirectPath("/admin\\settings")).toBeNull();
+  });
+
+  it("resolves page and post targets without allowing nested open-ended paths", () => {
+    expect(resolveDraftPathTarget("/")).toEqual({
+      parentType: "page",
+      slug: "home",
+      path: "/",
+    });
+    expect(resolveDraftPathTarget("/about")).toEqual({
+      parentType: "page",
+      slug: "about",
+      path: "/about",
+    });
+    expect(resolveDraftPathTarget("/article/hello-world")).toEqual({
+      parentType: "post",
+      slug: "hello-world",
+      path: "/article/hello-world",
+    });
+    expect(resolveDraftPathTarget("/product/commerce-license")).toEqual({
+      parentType: "product",
+      slug: "commerce-license",
+      path: "/product/commerce-license",
+    });
+    expect(resolveDraftPathTarget("/nested/page")).toBeNull();
+    expect(resolveDraftPathTarget("/article/nested/post")).toBeNull();
+    expect(resolveDraftPathTarget("/product/nested/product")).toBeNull();
+  });
+});

package/templates/nextblock-template/lib/visual-editing/draft-route.ts

@@ -0,0 +1,82 @@
+import type { NextblockDocumentType } from "./types";
+
+export type DraftPathDocumentType = NextblockDocumentType | "product";
+
+export interface DraftPathTarget {
+  parentType: DraftPathDocumentType;
+  slug: string;
+  path: string;
+}
+
+export function normalizeDraftRedirectPath(rawPath: string | null): string | null {
+  const value = rawPath?.trim();
+
+  if (!value) {
+    return null;
+  }
+
+  if (/^[a-z][a-z0-9+.-]*:/i.test(value) || value.startsWith("//")) {
+    return null;
+  }
+
+  const normalized = value.startsWith("/") ? value : `/${value}`;
+
+  if (normalized.includes("\\") || normalized.includes("\0")) {
+    return null;
+  }
+
+  return normalized.replace(/\/{2,}/g, "/");
+}
+
+export function resolveDraftPathTarget(path: string): DraftPathTarget | null {
+  const trimmed = path.replace(/\/+$/, "") || "/";
+
+  if (trimmed === "/") {
+    return {
+      parentType: "page",
+      slug: "home",
+      path: "/",
+    };
+  }
+
+  const articlePrefix = "/article/";
+  if (trimmed.startsWith(articlePrefix)) {
+    const slug = decodeURIComponent(trimmed.slice(articlePrefix.length));
+
+    if (!slug || slug.includes("/")) {
+      return null;
+    }
+
+    return {
+      parentType: "post",
+      slug,
+      path: `/article/${encodeURIComponent(slug)}`,
+    };
+  }
+
+  const productPrefix = "/product/";
+  if (trimmed.startsWith(productPrefix)) {
+    const slug = decodeURIComponent(trimmed.slice(productPrefix.length));
+
+    if (!slug || slug.includes("/")) {
+      return null;
+    }
+
+    return {
+      parentType: "product",
+      slug,
+      path: `/product/${encodeURIComponent(slug)}`,
+    };
+  }
+
+  const slug = decodeURIComponent(trimmed.slice(1));
+  if (!slug || slug.includes("/")) {
+    return null;
+  }
+
+  return {
+    parentType: "page",
+    slug,
+    path: `/${encodeURIComponent(slug)}`,
+  };
+}

package/templates/nextblock-template/lib/visual-editing/edit-info.test.ts

@@ -0,0 +1,143 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("server-only", () => ({}));
+
+import { buildVisualEditAttributes } from "./edit-info";
+
+describe("buildVisualEditAttributes", () => {
+  beforeEach(() => {
+    delete process.env.NEXTBLOCK_VERCEL_PROJECT_ID;
+    delete process.env.NEXTBLOCK_VERCEL_WORKSPACE_ID;
+    delete process.env.NEXT_PUBLIC_URL;
+    delete process.env.TARGET_URL;
+  });
+
+  it("returns no attributes when visual editing is disabled", () => {
+    expect(
+      buildVisualEditAttributes(
+        {
+          enabled: false,
+          documentType: "page",
+          documentId: 12,
+          slug: "about",
+          languageId: 1,
+        },
+        {
+          kind: "top-level",
+          blockId: 99,
+          blockIndex: 0,
+          blockType: "text",
+        }
+      )
+    ).toBeUndefined();
+  });
+
+  it("builds a stringified Vercel edit-info payload with document and block metadata", () => {
+    process.env.NEXTBLOCK_VERCEL_PROJECT_ID = "prj_123";
+    process.env.NEXTBLOCK_VERCEL_WORKSPACE_ID = "team_123";
+
+    const attrs = buildVisualEditAttributes(
+      {
+        enabled: true,
+        documentType: "post",
+        documentId: 42,
+        slug: "hello-world",
+        languageId: 1,
+        draftId: 7,
+      },
+      {
+        kind: "top-level",
+        blockId: 99,
+        blockIndex: 0,
+        blockType: "heading",
+      }
+    );
+
+    expect(attrs).toBeDefined();
+    const payload = JSON.parse(attrs?.["data-vercel-edit-info"] ?? "{}");
+    const target = JSON.parse(attrs?.["data-vercel-edit-target"] ?? "{}");
+
+    expect(payload).toMatchObject({
+      origin: "localhost",
+      projectId: "prj_123",
+      workspaceId: "team_123",
+      editUrl: "http://localhost:3000/cms/posts/42/edit",
+      data: {
+        parentType: "post",
+        parentId: 42,
+        slug: "hello-world",
+        languageId: 1,
+        draftId: 7,
+      },
+    });
+    expect(target).toEqual({
+      kind: "top-level",
+      blockId: 99,
+      blockIndex: 0,
+      blockType: "heading",
+    });
+  });
+
+  it("dynamically overrides origin with NEXT_PUBLIC_URL and TARGET_URL", () => {
+    process.env.NEXT_PUBLIC_URL = "https://custom-domain.com/";
+    const attrs = buildVisualEditAttributes(
+      {
+        enabled: true,
+        documentType: "page",
+        documentId: 10,
+        slug: "home",
+        languageId: 1,
+      },
+      {
+        kind: "top-level",
+        blockId: 1,
+        blockIndex: 0,
+        blockType: "text",
+      }
+    );
+    const payload = JSON.parse(attrs?.["data-vercel-edit-info"] ?? "{}");
+    expect(payload.origin).toBe("custom-domain.com");
+
+    // Test TARGET_URL fallback if NEXT_PUBLIC_URL is empty
+    delete process.env.NEXT_PUBLIC_URL;
+    process.env.TARGET_URL = "https://another-domain.xyz/subpath/";
+    const attrsTarget = buildVisualEditAttributes(
+      {
+        enabled: true,
+        documentType: "page",
+        documentId: 10,
+        slug: "home",
+        languageId: 1,
+      },
+      {
+        kind: "top-level",
+        blockId: 1,
+        blockIndex: 0,
+        blockType: "text",
+      }
+    );
+    const payloadTarget = JSON.parse(attrsTarget?.["data-vercel-edit-info"] ?? "{}");
+    expect(payloadTarget.origin).toBe("another-domain.xyz");
+  });
+
+  it("uses pageOrigin from context if provided", () => {
+    const attrs = buildVisualEditAttributes(
+      {
+        enabled: true,
+        documentType: "page",
+        documentId: 10,
+        slug: "home",
+        languageId: 1,
+        pageOrigin: "https://my-custom-origin.dev/",
+      },
+      {
+        kind: "top-level",
+        blockId: 1,
+        blockIndex: 0,
+        blockType: "text",
+      }
+    );
+    const payload = JSON.parse(attrs?.["data-vercel-edit-info"] ?? "{}");
+    expect(payload.origin).toBe("my-custom-origin.dev");
+  });
+});