@delmaredigital/payload-puck 0.6.12 → 0.6.14

package/dist/api/createPuckApiRoutes.js

@@ -2,15 +2,14 @@ import { NextResponse } from 'next/server';
 import { getPayload } from 'payload';
 /**
  * Default Puck data for new pages
- */
-const DEFAULT_PUCK_DATA = {
+ */ const DEFAULT_PUCK_DATA = {
     root: {
         props: {
-            title: '',
-        },
+            title: ''
+        }
     },
     content: [],
-    zones: {},
+    zones: {}
 };
 /**
  * Create API route handlers for /api/puck/pages
@@ -39,33 +38,39 @@ const DEFAULT_PUCK_DATA = {
  *   },
  * })
  * ```
- */
-export function createPuckApiRoutes(routeConfig) {
-    const { collection = 'pages', payloadConfig, auth, defaultPuckData = DEFAULT_PUCK_DATA, enableDrafts = true, onError, } = routeConfig;
+ */ export function createPuckApiRoutes(routeConfig) {
+    const { collection = 'pages', payloadConfig, auth, defaultPuckData = DEFAULT_PUCK_DATA, enableDrafts = true, onError } = routeConfig;
     /**
-     * GET /api/puck/pages
-     * List all pages with optional filtering
-     *
-     * Query Parameters:
-     * - page: Page number (default: 1)
-     * - limit: Items per page (default: 10)
-     * - search: Search in title field
-     * - status: Filter by _status ('draft', 'published', 'all')
-     * - editorVersion: Filter by editorVersion field
-     * - sort: Sort field (default: '-updatedAt')
-     */
-    async function GET(request, _context) {
+   * GET /api/puck/pages
+   * List all pages with optional filtering
+   *
+   * Query Parameters:
+   * - page: Page number (default: 1)
+   * - limit: Items per page (default: 10)
+   * - search: Search in title field
+   * - status: Filter by _status ('draft', 'published', 'all')
+   * - editorVersion: Filter by editorVersion field
+   * - sort: Sort field (default: '-updatedAt')
+   */ async function GET(request, _context) {
         try {
             // Authenticate
             const authResult = await auth.authenticate(request);
             if (!authResult.authenticated || !authResult.user) {
-                return NextResponse.json({ error: authResult.error || 'Unauthorized' }, { status: 401 });
+                return NextResponse.json({
+                    error: authResult.error || 'Unauthorized'
+                }, {
+                    status: 401
+                });
             }
             // Check list permission
             if (auth.canList) {
                 const permission = await auth.canList(authResult.user);
                 if (!permission.allowed) {
-                    return NextResponse.json({ error: permission.error || 'Forbidden' }, { status: 403 });
+                    return NextResponse.json({
+                        error: permission.error || 'Forbidden'
+                    }, {
+                        status: 403
+                    });
                 }
             }
             // Parse query parameters
@@ -78,82 +83,121 @@ export function createPuckApiRoutes(routeConfig) {
             const sort = searchParams.get('sort') || '-updatedAt';
             // Get Payload instance with provided config
             const config = await payloadConfig;
-            const payload = await getPayload({ config });
+            const payload = await getPayload({
+                config
+            });
             // Build where clause
             const conditions = [];
             if (search) {
-                conditions.push({ title: { contains: search } });
+                conditions.push({
+                    title: {
+                        contains: search
+                    }
+                });
             }
             if (status && status !== 'all') {
-                conditions.push({ _status: { equals: status } });
+                conditions.push({
+                    _status: {
+                        equals: status
+                    }
+                });
             }
             if (editorVersion && editorVersion !== 'all') {
-                conditions.push({ editorVersion: { equals: editorVersion } });
+                conditions.push({
+                    editorVersion: {
+                        equals: editorVersion
+                    }
+                });
             }
-            const where = conditions.length > 0
-                ? conditions.length === 1
-                    ? conditions[0]
-                    : { and: conditions }
-                : undefined;
+            const where = conditions.length > 0 ? conditions.length === 1 ? conditions[0] : {
+                and: conditions
+            } : undefined;
             const result = await payload.find({
                 collection,
                 page,
                 limit,
                 sort,
-                where,
+                where
             });
             return NextResponse.json(result);
-        }
-        catch (error) {
+        } catch (error) {
             if (onError) {
-                onError(error, { operation: 'list', request });
+                onError(error, {
+                    operation: 'list',
+                    request
+                });
             }
             console.error('Error listing pages:', error);
-            return NextResponse.json({ error: 'Failed to list pages' }, { status: 500 });
+            return NextResponse.json({
+                error: 'Failed to list pages'
+            }, {
+                status: 500
+            });
         }
     }
     /**
-     * POST /api/puck/pages
-     * Create a new page with Puck data
-     *
-     * Request Body:
-     * - title: string (required)
-     * - slug: string (required)
-     * - puckData?: PuckData (optional, uses default if not provided)
-     * - status?: 'draft' | 'published' (default: 'draft')
-     */
-    async function POST(request, _context) {
+   * POST /api/puck/pages
+   * Create a new page with Puck data
+   *
+   * Request Body:
+   * - title: string (required)
+   * - slug: string (required)
+   * - puckData?: PuckData (optional, uses default if not provided)
+   * - status?: 'draft' | 'published' (default: 'draft')
+   */ async function POST(request, _context) {
         try {
             // Authenticate
             const authResult = await auth.authenticate(request);
             if (!authResult.authenticated || !authResult.user) {
-                return NextResponse.json({ error: authResult.error || 'Unauthorized' }, { status: 401 });
+                return NextResponse.json({
+                    error: authResult.error || 'Unauthorized'
+                }, {
+                    status: 401
+                });
             }
             // Check create permission
             if (auth.canCreate) {
                 const permission = await auth.canCreate(authResult.user);
                 if (!permission.allowed) {
-                    return NextResponse.json({ error: permission.error || 'Forbidden' }, { status: 403 });
+                    return NextResponse.json({
+                        error: permission.error || 'Forbidden'
+                    }, {
+                        status: 403
+                    });
                 }
             }
             // Parse request body
-            const body = (await request.json());
+            const body = await request.json();
             const { title, slug, puckData, status = 'draft' } = body;
             // Validate required fields
             if (!title || !slug) {
-                return NextResponse.json({ error: 'Title and slug are required' }, { status: 400 });
+                return NextResponse.json({
+                    error: 'Title and slug are required'
+                }, {
+                    status: 400
+                });
             }
             // Get Payload instance with provided config
             const config = await payloadConfig;
-            const payload = await getPayload({ config });
+            const payload = await getPayload({
+                config
+            });
             // Check if slug already exists
             const existing = await payload.find({
                 collection,
-                where: { slug: { equals: slug } },
-                limit: 1,
+                where: {
+                    slug: {
+                        equals: slug
+                    }
+                },
+                limit: 1
             });
             if (existing.docs.length > 0) {
-                return NextResponse.json({ error: 'A page with this slug already exists' }, { status: 409 });
+                return NextResponse.json({
+                    error: 'A page with this slug already exists'
+                }, {
+                    status: 409
+                });
             }
             // Prepare initial Puck data with title in root.props
             const initialPuckData = puckData || {
@@ -162,9 +206,9 @@ export function createPuckApiRoutes(routeConfig) {
                     ...defaultPuckData.root,
                     props: {
                         ...defaultPuckData.root?.props,
-                        title,
-                    },
-                },
+                        title
+                    }
+                }
             };
             // Create the page
             const newPage = await payload.create({
@@ -175,19 +219,31 @@ export function createPuckApiRoutes(routeConfig) {
                     slug,
                     editorVersion: 'puck',
                     puckData: initialPuckData,
-                    _status: status,
-                },
+                    _status: status
+                }
             });
-            return NextResponse.json({ doc: newPage }, { status: 201 });
-        }
-        catch (error) {
+            return NextResponse.json({
+                doc: newPage
+            }, {
+                status: 201
+            });
+        } catch (error) {
             if (onError) {
-                onError(error, { operation: 'create', request });
+                onError(error, {
+                    operation: 'create',
+                    request
+                });
             }
             console.error('Error creating page:', error);
-            return NextResponse.json({ error: 'Failed to create page' }, { status: 500 });
+            return NextResponse.json({
+                error: 'Failed to create page'
+            }, {
+                status: 500
+            });
         }
     }
-    return { GET, POST };
+    return {
+        GET,
+        POST
+    };
 }
-//# sourceMappingURL=createPuckApiRoutes.js.map

package/dist/api/createPuckApiRoutesVersions.d.ts

@@ -1,4 +1,4 @@
-import type { PuckApiRoutesConfig, PuckApiVersionsRouteHandlers } from './types';
+import type { PuckApiRoutesConfig, PuckApiVersionsRouteHandlers } from './types.js';
 /**
  * Create API route handlers for /api/puck/pages/[id]/versions
  *
@@ -25,4 +25,3 @@ import type { PuckApiRoutesConfig, PuckApiVersionsRouteHandlers } from './types'
  * ```
  */
 export declare function createPuckApiRoutesVersions(routeConfig: PuckApiRoutesConfig): PuckApiVersionsRouteHandlers;
-//# sourceMappingURL=createPuckApiRoutesVersions.d.ts.map

package/dist/api/createPuckApiRoutesVersions.js

@@ -24,36 +24,48 @@ import { getPayload } from 'payload';
  *   },
  * })
  * ```
- */
-export function createPuckApiRoutesVersions(routeConfig) {
-    const { collection = 'pages', payloadConfig, auth, onError, } = routeConfig;
+ */ export function createPuckApiRoutesVersions(routeConfig) {
+    const { collection = 'pages', payloadConfig, auth, onError } = routeConfig;
     /**
-     * GET /api/puck/pages/[id]/versions
-     * Fetch version history for a page
-     */
-    async function GET(request, context) {
+   * GET /api/puck/pages/[id]/versions
+   * Fetch version history for a page
+   */ async function GET(request, context) {
         try {
             // Get page ID from params
             const params = await context.params;
             const id = params.id;
             if (!id) {
-                return NextResponse.json({ error: 'Page ID is required' }, { status: 400 });
+                return NextResponse.json({
+                    error: 'Page ID is required'
+                }, {
+                    status: 400
+                });
             }
             // Authenticate
             const authResult = await auth.authenticate(request);
             if (!authResult.authenticated || !authResult.user) {
-                return NextResponse.json({ error: authResult.error || 'Unauthorized' }, { status: 401 });
+                return NextResponse.json({
+                    error: authResult.error || 'Unauthorized'
+                }, {
+                    status: 401
+                });
             }
             // Check view permission
             if (auth.canView) {
                 const permission = await auth.canView(authResult.user, id);
                 if (!permission.allowed) {
-                    return NextResponse.json({ error: permission.error || 'Forbidden' }, { status: 403 });
+                    return NextResponse.json({
+                        error: permission.error || 'Forbidden'
+                    }, {
+                        status: 403
+                    });
                 }
             }
             // Get Payload instance with provided config
             const config = await payloadConfig;
-            const payload = await getPayload({ config });
+            const payload = await getPayload({
+                config
+            });
             // Parse query params for pagination
             const url = new URL(request.url);
             const limit = parseInt(url.searchParams.get('limit') || '20', 10);
@@ -62,11 +74,13 @@ export function createPuckApiRoutesVersions(routeConfig) {
             const versions = await payload.findVersions({
                 collection,
                 where: {
-                    parent: { equals: id },
+                    parent: {
+                        equals: id
+                    }
                 },
                 sort: '-updatedAt',
                 limit,
-                page,
+                page
             });
             return NextResponse.json({
                 docs: versions.docs,
@@ -75,70 +89,105 @@ export function createPuckApiRoutesVersions(routeConfig) {
                 page: versions.page,
                 limit: versions.limit,
                 hasPrevPage: versions.hasPrevPage,
-                hasNextPage: versions.hasNextPage,
+                hasNextPage: versions.hasNextPage
             });
-        }
-        catch (error) {
+        } catch (error) {
             const params = await context.params;
             if (onError) {
-                onError(error, { operation: 'listVersions', request, pageId: params.id });
+                onError(error, {
+                    operation: 'listVersions',
+                    request,
+                    pageId: params.id
+                });
             }
             console.error('Error fetching versions:', error);
-            return NextResponse.json({ error: 'Failed to fetch versions' }, { status: 500 });
+            return NextResponse.json({
+                error: 'Failed to fetch versions'
+            }, {
+                status: 500
+            });
         }
     }
     /**
-     * POST /api/puck/pages/[id]/versions
-     * Restore a specific version
-     *
-     * Request Body:
-     * - versionId: string - The version ID to restore
-     */
-    async function POST(request, context) {
+   * POST /api/puck/pages/[id]/versions
+   * Restore a specific version
+   *
+   * Request Body:
+   * - versionId: string - The version ID to restore
+   */ async function POST(request, context) {
         try {
             // Get page ID from params
             const params = await context.params;
             const id = params.id;
             if (!id) {
-                return NextResponse.json({ error: 'Page ID is required' }, { status: 400 });
+                return NextResponse.json({
+                    error: 'Page ID is required'
+                }, {
+                    status: 400
+                });
             }
             // Authenticate
             const authResult = await auth.authenticate(request);
             if (!authResult.authenticated || !authResult.user) {
-                return NextResponse.json({ error: authResult.error || 'Unauthorized' }, { status: 401 });
+                return NextResponse.json({
+                    error: authResult.error || 'Unauthorized'
+                }, {
+                    status: 401
+                });
             }
             // Check edit permission
             if (auth.canEdit) {
                 const permission = await auth.canEdit(authResult.user, id);
                 if (!permission.allowed) {
-                    return NextResponse.json({ error: permission.error || 'Forbidden' }, { status: 403 });
+                    return NextResponse.json({
+                        error: permission.error || 'Forbidden'
+                    }, {
+                        status: 403
+                    });
                 }
             }
             // Parse request body
             const body = await request.json();
             const { versionId } = body;
             if (!versionId) {
-                return NextResponse.json({ error: 'Version ID is required' }, { status: 400 });
+                return NextResponse.json({
+                    error: 'Version ID is required'
+                }, {
+                    status: 400
+                });
             }
             // Get Payload instance with provided config
             const config = await payloadConfig;
-            const payload = await getPayload({ config });
+            const payload = await getPayload({
+                config
+            });
             // Restore the version
             const restoredDoc = await payload.restoreVersion({
                 collection,
-                id: versionId,
+                id: versionId
             });
-            return NextResponse.json({ doc: restoredDoc });
-        }
-        catch (error) {
+            return NextResponse.json({
+                doc: restoredDoc
+            });
+        } catch (error) {
             const params = await context.params;
             if (onError) {
-                onError(error, { operation: 'restoreVersion', request, pageId: params.id });
+                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 NextResponse.json({
+                error: 'Failed to restore version'
+            }, {
+                status: 500
+            });
         }
     }
-    return { GET, POST };
+    return {
+        GET,
+        POST
+    };
 }
-//# sourceMappingURL=createPuckApiRoutesVersions.js.map

package/dist/api/createPuckApiRoutesWithId.d.ts

@@ -1,4 +1,4 @@
-import type { PuckApiRoutesConfig, PuckApiRouteWithIdHandlers } from './types';
+import type { PuckApiRoutesConfig, PuckApiRouteWithIdHandlers } from './types.js';
 /**
  * Create API route handlers for /api/puck/pages/[id]
  *
@@ -31,4 +31,3 @@ import type { PuckApiRoutesConfig, PuckApiRouteWithIdHandlers } from './types';
  * ```
  */
 export declare function createPuckApiRoutesWithId(routeConfig: PuckApiRoutesConfig): PuckApiRouteWithIdHandlers;
-//# sourceMappingURL=createPuckApiRoutesWithId.d.ts.map