@delmaredigital/payload-puck 0.1.0

package/dist/api/index.mjs

@@ -0,0 +1,578 @@
+import { NextResponse } from 'next/server';
+import { getPayload } from 'payload';
+
+// src/api/createPuckApiRoutes.ts
+var DEFAULT_PUCK_DATA = {
+  root: {
+    props: {
+      title: ""
+    }
+  },
+  content: [],
+  zones: {}
+};
+function createPuckApiRoutes(routeConfig) {
+  const {
+    collection = "pages",
+    payloadConfig,
+    auth,
+    defaultPuckData = DEFAULT_PUCK_DATA,
+    enableDrafts = true,
+    onError
+  } = routeConfig;
+  async function GET(request, _context) {
+    try {
+      const authResult = await auth.authenticate(request);
+      if (!authResult.authenticated || !authResult.user) {
+        return NextResponse.json(
+          { error: authResult.error || "Unauthorized" },
+          { status: 401 }
+        );
+      }
+      if (auth.canList) {
+        const permission = await auth.canList(authResult.user);
+        if (!permission.allowed) {
+          return NextResponse.json(
+            { error: permission.error || "Forbidden" },
+            { status: 403 }
+          );
+        }
+      }
+      const { searchParams } = new URL(request.url);
+      const page = parseInt(searchParams.get("page") || "1", 10);
+      const limit = Math.min(parseInt(searchParams.get("limit") || "10", 10), 100);
+      const search = searchParams.get("search") || "";
+      const status = searchParams.get("status");
+      const editorVersion = searchParams.get("editorVersion");
+      const sort = searchParams.get("sort") || "-updatedAt";
+      const config = await payloadConfig;
+      const payload = await getPayload({ config });
+      const conditions = [];
+      if (search) {
+        conditions.push({ title: { contains: search } });
+      }
+      if (status && status !== "all") {
+        conditions.push({ _status: { equals: status } });
+      }
+      if (editorVersion && editorVersion !== "all") {
+        conditions.push({ editorVersion: { equals: editorVersion } });
+      }
+      const where = conditions.length > 0 ? conditions.length === 1 ? conditions[0] : { and: conditions } : void 0;
+      const result = await payload.find({
+        collection,
+        page,
+        limit,
+        sort,
+        where
+      });
+      return NextResponse.json(result);
+    } catch (error) {
+      if (onError) {
+        onError(error, { operation: "list", request });
+      }
+      console.error("Error listing pages:", error);
+      return NextResponse.json(
+        { error: "Failed to list pages" },
+        { status: 500 }
+      );
+    }
+  }
+  async function POST(request, _context) {
+    try {
+      const authResult = await auth.authenticate(request);
+      if (!authResult.authenticated || !authResult.user) {
+        return NextResponse.json(
+          { error: authResult.error || "Unauthorized" },
+          { status: 401 }
+        );
+      }
+      if (auth.canCreate) {
+        const permission = await auth.canCreate(authResult.user);
+        if (!permission.allowed) {
+          return NextResponse.json(
+            { error: permission.error || "Forbidden" },
+            { status: 403 }
+          );
+        }
+      }
+      const body = await request.json();
+      const { title, slug, puckData, status = "draft" } = body;
+      if (!title || !slug) {
+        return NextResponse.json(
+          { error: "Title and slug are required" },
+          { status: 400 }
+        );
+      }
+      const config = await payloadConfig;
+      const payload = await getPayload({ config });
+      const existing = await payload.find({
+        collection,
+        where: { slug: { equals: slug } },
+        limit: 1
+      });
+      if (existing.docs.length > 0) {
+        return NextResponse.json(
+          { error: "A page with this slug already exists" },
+          { status: 409 }
+        );
+      }
+      const initialPuckData = puckData || {
+        ...defaultPuckData,
+        root: {
+          ...defaultPuckData.root,
+          props: {
+            ...defaultPuckData.root?.props,
+            title
+          }
+        }
+      };
+      const newPage = await payload.create({
+        collection,
+        draft: enableDrafts,
+        data: {
+          title,
+          slug,
+          editorVersion: "puck",
+          puckData: initialPuckData,
+          _status: status
+        }
+      });
+      return NextResponse.json({ doc: newPage }, { status: 201 });
+    } catch (error) {
+      if (onError) {
+        onError(error, { operation: "create", request });
+      }
+      console.error("Error creating page:", error);
+      return NextResponse.json(
+        { error: "Failed to create page" },
+        { status: 500 }
+      );
+    }
+  }
+  return { GET, POST };
+}
+
+// src/api/utils/mapRootProps.ts
+var DEFAULT_ROOT_PROPS_MAPPINGS = [
+  // Core page fields
+  { from: "title", to: "title" },
+  { from: "slug", to: "slug" },
+  { from: "pageLayout", to: "pageLayout" },
+  { from: "pageType", to: "pageType" },
+  { from: "isHomepage", to: "isHomepage" },
+  // SEO/Meta fields (uses official @payloadcms/plugin-seo convention)
+  { from: "metaTitle", to: "meta.title" },
+  { from: "metaDescription", to: "meta.description" },
+  { from: "noindex", to: "meta.noindex" },
+  { from: "nofollow", to: "meta.nofollow" },
+  { from: "excludeFromSitemap", to: "meta.excludeFromSitemap" },
+  // Conversion tracking fields
+  { from: "isConversionPage", to: "conversionTracking.isConversionPage" },
+  { from: "conversionType", to: "conversionTracking.conversionType" },
+  { from: "conversionValue", to: "conversionTracking.conversionValue" }
+];
+function setNestedValue(obj, path, value) {
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  const finalKey = keys[keys.length - 1];
+  current[finalKey] = value;
+}
+function getNestedValue(obj, path) {
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    if (typeof current !== "object") {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return current;
+}
+function mergeMappings(customMappings) {
+  if (!customMappings || customMappings.length === 0) {
+    return DEFAULT_ROOT_PROPS_MAPPINGS;
+  }
+  const mappingMap = /* @__PURE__ */ new Map();
+  for (const mapping of DEFAULT_ROOT_PROPS_MAPPINGS) {
+    mappingMap.set(mapping.from, mapping);
+  }
+  for (const mapping of customMappings) {
+    mappingMap.set(mapping.from, mapping);
+  }
+  return Array.from(mappingMap.values());
+}
+function mapRootPropsToPayloadFields(rootProps, customMappings) {
+  const mappings = mergeMappings(customMappings);
+  const result = {};
+  for (const mapping of mappings) {
+    const value = rootProps[mapping.from];
+    if (value === void 0) {
+      continue;
+    }
+    const transformedValue = mapping.transform ? mapping.transform(value) : value;
+    setNestedValue(result, mapping.to, transformedValue);
+  }
+  return result;
+}
+function deepMerge(target, source) {
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    if (sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue !== null && typeof targetValue === "object" && !Array.isArray(targetValue)) {
+      target[key] = deepMerge(
+        targetValue,
+        sourceValue
+      );
+    } else {
+      target[key] = sourceValue;
+    }
+  }
+  return target;
+}
+
+// src/api/createPuckApiRoutesWithId.ts
+function createPuckApiRoutesWithId(routeConfig) {
+  const {
+    collection = "pages",
+    payloadConfig,
+    auth,
+    rootPropsMapping,
+    onError
+  } = routeConfig;
+  async function GET(request, context) {
+    try {
+      const params = await context.params;
+      const id = params.id;
+      if (!id) {
+        return NextResponse.json(
+          { error: "Page ID is required" },
+          { status: 400 }
+        );
+      }
+      const authResult = await auth.authenticate(request);
+      if (!authResult.authenticated || !authResult.user) {
+        return NextResponse.json(
+          { error: authResult.error || "Unauthorized" },
+          { status: 401 }
+        );
+      }
+      if (auth.canView) {
+        const permission = await auth.canView(authResult.user, id);
+        if (!permission.allowed) {
+          return NextResponse.json(
+            { error: permission.error || "Forbidden" },
+            { status: 403 }
+          );
+        }
+      }
+      const config = await payloadConfig;
+      const payload = await getPayload({ config });
+      const url = new URL(request.url);
+      const wantsDraft = url.searchParams.get("draft") !== "false";
+      const page = await payload.findByID({
+        collection,
+        id,
+        draft: wantsDraft
+        // Load draft version by default for editing
+      });
+      if (!page) {
+        return NextResponse.json({ error: "Page not found" }, { status: 404 });
+      }
+      return NextResponse.json({ doc: page });
+    } catch (error) {
+      const params = await context.params;
+      if (onError) {
+        onError(error, { operation: "read", request, pageId: params.id });
+      }
+      console.error("Error fetching page:", error);
+      return NextResponse.json(
+        { error: "Failed to fetch page" },
+        { status: 500 }
+      );
+    }
+  }
+  async function PATCH(request, context) {
+    try {
+      const params = await context.params;
+      const id = params.id;
+      if (!id) {
+        return NextResponse.json(
+          { error: "Page ID is required" },
+          { status: 400 }
+        );
+      }
+      const authResult = await auth.authenticate(request);
+      if (!authResult.authenticated || !authResult.user) {
+        return NextResponse.json(
+          { error: authResult.error || "Unauthorized" },
+          { status: 401 }
+        );
+      }
+      if (auth.canEdit) {
+        const permission = await auth.canEdit(authResult.user, id);
+        if (!permission.allowed) {
+          return NextResponse.json(
+            { error: permission.error || "Forbidden" },
+            { status: 403 }
+          );
+        }
+      }
+      const body = await request.json();
+      const { puckData, title, slug, status, draft } = body;
+      if (status === "published") {
+        const canPublish = auth.canPublish || auth.canEdit;
+        if (canPublish) {
+          const permission = await canPublish(authResult.user, id);
+          if (!permission.allowed) {
+            return NextResponse.json(
+              { error: permission.error || "Not authorized to publish pages" },
+              { status: 403 }
+            );
+          }
+        }
+      }
+      const config = await payloadConfig;
+      const payload = await getPayload({ config });
+      const rootProps = puckData?.root?.props || {};
+      const updateData = {
+        editorVersion: "puck"
+      };
+      if (puckData) {
+        updateData.puckData = puckData;
+      }
+      const mappedFields = mapRootPropsToPayloadFields(rootProps, rootPropsMapping);
+      deepMerge(updateData, mappedFields);
+      if (title !== void 0) {
+        updateData.title = title;
+      }
+      if (slug !== void 0) {
+        updateData.slug = slug;
+      }
+      if (status) {
+        updateData._status = status;
+      }
+      const updatedPage = await payload.update({
+        collection,
+        id,
+        data: updateData,
+        draft: draft === true
+      });
+      return NextResponse.json({ doc: updatedPage });
+    } catch (error) {
+      const params = await context.params;
+      if (onError) {
+        onError(error, { operation: "update", request, pageId: params.id });
+      }
+      console.error("Error updating page:", error);
+      if (error instanceof Error && error.name === "ValidationError") {
+        const validationError = error;
+        const fieldErrors = validationError.data?.errors || [];
+        const slugError = fieldErrors.find((e) => e.field === "slug");
+        if (slugError) {
+          return NextResponse.json(
+            {
+              error: "A page with this slug already exists. Please choose a different slug.",
+              field: "slug",
+              details: fieldErrors
+            },
+            { status: 400 }
+          );
+        }
+        return NextResponse.json(
+          {
+            error: `Validation failed: ${fieldErrors.map((e) => e.message || e.field).join(", ")}`,
+            details: fieldErrors
+          },
+          { status: 400 }
+        );
+      }
+      return NextResponse.json(
+        { error: "Failed to update page" },
+        { status: 500 }
+      );
+    }
+  }
+  async function DELETE(request, context) {
+    try {
+      const params = await context.params;
+      const id = params.id;
+      if (!id) {
+        return NextResponse.json(
+          { error: "Page ID is required" },
+          { status: 400 }
+        );
+      }
+      const authResult = await auth.authenticate(request);
+      if (!authResult.authenticated || !authResult.user) {
+        return NextResponse.json(
+          { error: authResult.error || "Unauthorized" },
+          { status: 401 }
+        );
+      }
+      if (auth.canDelete) {
+        const permission = await auth.canDelete(authResult.user, id);
+        if (!permission.allowed) {
+          return NextResponse.json(
+            { error: permission.error || "Forbidden" },
+            { status: 403 }
+          );
+        }
+      }
+      const config = await payloadConfig;
+      const payload = await getPayload({ config });
+      await payload.delete({
+        collection,
+        id
+      });
+      return NextResponse.json({ success: true });
+    } catch (error) {
+      const params = await context.params;
+      if (onError) {
+        onError(error, { operation: "delete", request, pageId: params.id });
+      }
+      console.error("Error deleting page:", error);
+      return NextResponse.json(
+        { error: "Failed to delete page" },
+        { status: 500 }
+      );
+    }
+  }
+  return { GET, PATCH, DELETE };
+}
+function createPuckApiRoutesVersions(routeConfig) {
+  const {
+    collection = "pages",
+    payloadConfig,
+    auth,
+    onError
+  } = routeConfig;
+  async function GET(request, context) {
+    try {
+      const params = await context.params;
+      const id = params.id;
+      if (!id) {
+        return NextResponse.json(
+          { error: "Page ID is required" },
+          { status: 400 }
+        );
+      }
+      const authResult = await auth.authenticate(request);
+      if (!authResult.authenticated || !authResult.user) {
+        return NextResponse.json(
+          { error: authResult.error || "Unauthorized" },
+          { status: 401 }
+        );
+      }
+      if (auth.canView) {
+        const permission = await auth.canView(authResult.user, id);
+        if (!permission.allowed) {
+          return NextResponse.json(
+            { error: permission.error || "Forbidden" },
+            { status: 403 }
+          );
+        }
+      }
+      const config = await payloadConfig;
+      const payload = await getPayload({ config });
+      const url = new URL(request.url);
+      const limit = parseInt(url.searchParams.get("limit") || "20", 10);
+      const page = parseInt(url.searchParams.get("page") || "1", 10);
+      const versions = await payload.findVersions({
+        collection,
+        where: {
+          parent: { equals: id }
+        },
+        sort: "-updatedAt",
+        limit,
+        page
+      });
+      return NextResponse.json({
+        docs: versions.docs,
+        totalDocs: versions.totalDocs,
+        totalPages: versions.totalPages,
+        page: versions.page,
+        limit: versions.limit,
+        hasPrevPage: versions.hasPrevPage,
+        hasNextPage: versions.hasNextPage
+      });
+    } catch (error) {
+      const params = await context.params;
+      if (onError) {
+        onError(error, { operation: "listVersions", request, pageId: params.id });
+      }
+      console.error("Error fetching versions:", error);
+      return NextResponse.json(
+        { error: "Failed to fetch versions" },
+        { status: 500 }
+      );
+    }
+  }
+  async function POST(request, context) {
+    try {
+      const params = await context.params;
+      const id = params.id;
+      if (!id) {
+        return NextResponse.json(
+          { error: "Page ID is required" },
+          { status: 400 }
+        );
+      }
+      const authResult = await auth.authenticate(request);
+      if (!authResult.authenticated || !authResult.user) {
+        return NextResponse.json(
+          { error: authResult.error || "Unauthorized" },
+          { status: 401 }
+        );
+      }
+      if (auth.canEdit) {
+        const permission = await auth.canEdit(authResult.user, id);
+        if (!permission.allowed) {
+          return NextResponse.json(
+            { error: permission.error || "Forbidden" },
+            { status: 403 }
+          );
+        }
+      }
+      const body = await request.json();
+      const { versionId } = body;
+      if (!versionId) {
+        return NextResponse.json(
+          { error: "Version ID is required" },
+          { status: 400 }
+        );
+      }
+      const config = await payloadConfig;
+      const payload = await getPayload({ config });
+      const restoredDoc = await payload.restoreVersion({
+        collection,
+        id: versionId
+      });
+      return NextResponse.json({ doc: restoredDoc });
+    } catch (error) {
+      const params = await context.params;
+      if (onError) {
+        onError(error, { operation: "restoreVersion", request, pageId: params.id });
+      }
+      console.error("Error restoring version:", error);
+      return NextResponse.json(
+        { error: "Failed to restore version" },
+        { status: 500 }
+      );
+    }
+  }
+  return { GET, POST };
+}
+
+export { DEFAULT_ROOT_PROPS_MAPPINGS, createPuckApiRoutes, createPuckApiRoutesVersions, createPuckApiRoutesWithId, deepMerge, getNestedValue, mapRootPropsToPayloadFields, mergeMappings, setNestedValue };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map