@morphika/webframe 0.1.0

package/app/api/admin/custom-sections/route.ts

@@ -0,0 +1,127 @@
+import { NextRequest, NextResponse } from "next/server";
+import { client } from "../../../../lib/sanity/client";
+import { writeClient } from "../../../../lib/sanity/writeClient";
+import { allCustomSectionsQuery } from "../../../../lib/sanity/queries";
+import { isAdminAuthenticated } from "../../../../lib/auth";
+import { validateCsrf, csrfErrorResponse } from "../../../../lib/csrf";
+import { isBodyTooLarge, MAX_JSON_BODY_SIZE } from "../../../../lib/security";
+import { auditLog } from "../../../../lib/audit";
+import { logger } from "../../../../lib/logger";
+
+/**
+ * GET /api/admin/custom-sections — List all custom sections
+ */
+export async function GET() {
+  if (!(await isAdminAuthenticated())) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  try {
+    const sections = await client.fetch(allCustomSectionsQuery);
+    return NextResponse.json({ sections });
+  } catch (err) {
+    logger.error("[Admin:CustomSections]", "Failed to fetch custom sections", err);
+    return NextResponse.json(
+      { error: "Failed to fetch custom sections" },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * POST /api/admin/custom-sections — Create a new custom section
+ * Body: { title, slug, description?, section }
+ */
+export async function POST(request: NextRequest) {
+  if (!(await isAdminAuthenticated())) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+  if (!validateCsrf(request)) {
+    return csrfErrorResponse();
+  }
+  if (isBodyTooLarge(request, MAX_JSON_BODY_SIZE)) {
+    return NextResponse.json({ error: "Request body too large" }, { status: 413 });
+  }
+
+  try {
+    const body = await request.json();
+    const { title, slug, description, section } = body;
+
+    // Validate required fields
+    if (!title || !slug) {
+      return NextResponse.json(
+        { error: "Missing required fields: title, slug" },
+        { status: 400 }
+      );
+    }
+
+    // Validate title length
+    if (typeof title === "string" && title.length > 200) {
+      return NextResponse.json(
+        { error: "Title exceeds maximum length of 200 characters" },
+        { status: 400 }
+      );
+    }
+
+    // Validate slug format
+    if (typeof slug !== "string" || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug)) {
+      return NextResponse.json(
+        { error: "Slug must be lowercase alphanumeric with hyphens only" },
+        { status: 400 }
+      );
+    }
+
+    // Check for duplicate slug
+    const existing = await client.fetch(
+      `*[_type == "customSection" && slug.current == $slug][0]._id`,
+      { slug }
+    );
+    if (existing) {
+      return NextResponse.json(
+        { error: "A custom section with this slug already exists" },
+        { status: 409 }
+      );
+    }
+
+    // Build document
+    const doc = {
+      _type: "customSection",
+      title,
+      slug: { _type: "slug", current: slug },
+      ...(description ? { description } : {}),
+      section: section || {
+        _type: "pageSectionV2",
+        section_type: "empty-v2",
+        columns: [],
+        settings: {
+          preset: "full",
+          grid_columns: 12,
+          col_gap: 20,
+          row_gap: 20,
+        },
+      },
+      updated_at: new Date().toISOString(),
+    };
+
+    const created = await writeClient.create(doc);
+
+    auditLog("customSection.create", { slug, title });
+
+    return NextResponse.json(
+      {
+        section: {
+          _id: created._id,
+          title,
+          slug: { current: slug },
+        },
+      },
+      { status: 201 }
+    );
+  } catch (err) {
+    logger.error("[Admin:CustomSections]", "Failed to create custom section", err);
+    return NextResponse.json(
+      { error: "Failed to create custom section" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/admin/database/route.ts

@@ -0,0 +1,53 @@
+import { NextResponse } from "next/server";
+import { isAdminAuthenticated } from "../../../../lib/auth";
+import { client } from "../../../../lib/sanity/client";
+
+/**
+ * GET /api/admin/database — Sanity connection status & stats
+ * Returns project info, dataset, document counts, and connection health.
+ */
+export async function GET() {
+  const authenticated = await isAdminAuthenticated();
+  if (!authenticated) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  const projectId = process.env.NEXT_PUBLIC_SANITY_PROJECT_ID || "";
+  const dataset = process.env.NEXT_PUBLIC_SANITY_DATASET || "production";
+  const hasWriteToken = !!process.env.SANITY_API_TOKEN;
+
+  // Test connection + gather stats
+  try {
+    // Count documents by type — single GROQ query
+    const stats = await client.fetch(`{
+      "totalDocuments": count(*[!(_type match "system.*")]),
+      "pages": count(*[_type == "page"]),
+      "publishedPages": count(*[_type == "page" && is_published == true]),
+      "draftPages": count(*[_type == "page" && is_published != true]),
+      "projects": count(*[_type == "page" && page_type == "project"]),
+      "siteSettings": count(*[_type == "siteSettings"]),
+      "siteStyles": count(*[_type == "siteStyles"]),
+      "assetRegistry": count(*[_type == "assetRegistry"]),
+      "datasets": ["${dataset}"]
+    }`);
+
+    return NextResponse.json({
+      connected: true,
+      projectId,
+      dataset,
+      hasWriteToken,
+      stats,
+      apiVersion: "2024-01-01",
+    });
+  } catch (err) {
+    return NextResponse.json({
+      connected: false,
+      projectId,
+      dataset,
+      hasWriteToken,
+      error: "Connection failed",
+      stats: null,
+      apiVersion: "2024-01-01",
+    });
+  }
+}

package/app/api/admin/pages/[slug]/duplicate/route.ts

@@ -0,0 +1,91 @@
+import { NextRequest, NextResponse } from "next/server";
+import { revalidatePath } from "next/cache";
+import { client } from "../../../../../../lib/sanity/client";
+import { writeClient } from "../../../../../../lib/sanity/writeClient";
+import { pageBySlugQuery } from "../../../../../../lib/sanity/queries";
+import { isAdminAuthenticated } from "../../../../../../lib/auth";
+import { validateCsrf, csrfErrorResponse } from "../../../../../../lib/csrf";
+import { logger } from "../../../../../../lib/logger";
+
+/**
+ * POST /api/admin/pages/[slug]/duplicate — Duplicate a page
+ * Creates a copy with "(Copy)" appended to title and "-copy" to slug.
+ */
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ slug: string }> }
+) {
+  if (!(await isAdminAuthenticated())) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+  if (!validateCsrf(request)) {
+    return csrfErrorResponse();
+  }
+
+  try {
+    const { slug } = await params;
+    const page = await client.fetch(pageBySlugQuery, { slug });
+
+    if (!page) {
+      return NextResponse.json(
+        { error: "Resource not found" },
+        { status: 404 }
+      );
+    }
+
+    // Generate unique slug (with max iteration limit to prevent infinite loops)
+    let newSlug = `${slug}-copy`;
+    let suffix = 1;
+    const MAX_ITERATIONS = 100;
+    while (suffix <= MAX_ITERATIONS) {
+      const existing = await client.fetch(
+        `*[_type == "page" && slug.current == $slug][0]._id`,
+        { slug: newSlug }
+      );
+      if (!existing) break;
+      suffix++;
+      newSlug = `${slug}-copy-${suffix}`;
+    }
+
+    if (suffix > MAX_ITERATIONS) {
+      return NextResponse.json(
+        { error: "Unable to generate unique slug. Please try a different base slug." },
+        { status: 400 }
+      );
+    }
+
+    // Create duplicate document (never copy is_home — only one page can be home)
+    const duplicate = await writeClient.create({
+      _type: "page",
+      title: `${page.title} (Copy)`,
+      slug: { _type: "slug", current: newSlug },
+      page_type: page.page_type,
+      is_home: false,
+      content_rows: page.content_rows || [],
+      metadata: page.metadata || {},
+      draft_mode: true,
+      ...(page.thumbnail_path ? { thumbnail_path: page.thumbnail_path } : {}),
+      ...(page.page_settings ? { page_settings: page.page_settings } : {}),
+      ...(page.published_at ? { published_at: page.published_at } : {}),
+    });
+
+    // Revalidate layout so project grids/lists pick up the new page
+    revalidatePath("/", "layout");
+
+    return NextResponse.json({
+      success: true,
+      page: {
+        _id: duplicate._id,
+        title: duplicate.title,
+        slug: { current: newSlug },
+        page_type: page.page_type,
+      },
+    });
+  } catch (err) {
+    logger.error("[Admin:Pages]", "Failed to duplicate page", err);
+    return NextResponse.json(
+      { error: "Failed to duplicate page" },
+      { status: 500 }
+    );
+  }
+}