@delmaredigital/payload-puck 0.6.12 → 0.6.14

package/dist/api/createPuckApiRoutesWithId.js

@@ -1,6 +1,6 @@
 import { NextResponse } from 'next/server';
 import { getPayload } from 'payload';
-import { mapRootPropsToPayloadFields, deepMerge } from './utils/mapRootProps';
+import { mapRootPropsToPayloadFields, deepMerge } from './utils/mapRootProps.js';
 /**
  * Create API route handlers for /api/puck/pages/[id]
  *
@@ -31,36 +31,48 @@ import { mapRootPropsToPayloadFields, deepMerge } from './utils/mapRootProps';
  *   ],
  * })
  * ```
- */
-export function createPuckApiRoutesWithId(routeConfig) {
-    const { collection = 'pages', payloadConfig, auth, rootPropsMapping, onError, } = routeConfig;
+ */ export function createPuckApiRoutesWithId(routeConfig) {
+    const { collection = 'pages', payloadConfig, auth, rootPropsMapping, onError } = routeConfig;
     /**
-     * GET /api/puck/pages/[id]
-     * Fetch a single page by ID
-     */
-    async function GET(request, context) {
+   * GET /api/puck/pages/[id]
+   * Fetch a single page by ID
+   */ 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
+            });
             // Check if caller wants draft or published version
             // Default to draft=true for editor use (load latest draft)
             const url = new URL(request.url);
@@ -68,57 +80,81 @@ export function createPuckApiRoutesWithId(routeConfig) {
             const page = await payload.findByID({
                 collection,
                 id,
-                draft: wantsDraft, // Load draft version by default for editing
+                draft: wantsDraft
             });
             if (!page) {
-                return NextResponse.json({ error: 'Page not found' }, { status: 404 });
+                return NextResponse.json({
+                    error: 'Page not found'
+                }, {
+                    status: 404
+                });
             }
-            return NextResponse.json({ doc: page });
-        }
-        catch (error) {
+            return NextResponse.json({
+                doc: page
+            });
+        } catch (error) {
             const params = await context.params;
             if (onError) {
-                onError(error, { operation: 'read', request, pageId: params.id });
+                onError(error, {
+                    operation: 'read',
+                    request,
+                    pageId: params.id
+                });
             }
             console.error('Error fetching page:', error);
-            return NextResponse.json({ error: 'Failed to fetch page' }, { status: 500 });
+            return NextResponse.json({
+                error: 'Failed to fetch page'
+            }, {
+                status: 500
+            });
         }
     }
     /**
-     * PATCH /api/puck/pages/[id]
-     * Update a page with Puck data
-     *
-     * Request Body:
-     * - puckData?: PuckData - Full Puck editor data
-     * - title?: string - Override title (also synced from root.props)
-     * - slug?: string - Override slug (also synced from root.props)
-     * - status?: 'draft' | 'published' - Publishing status
-     *
-     * Root props from puckData are automatically synced to Payload fields
-     * based on the configured mappings.
-     */
-    async function PATCH(request, context) {
+   * PATCH /api/puck/pages/[id]
+   * Update a page with Puck data
+   *
+   * Request Body:
+   * - puckData?: PuckData - Full Puck editor data
+   * - title?: string - Override title (also synced from root.props)
+   * - slug?: string - Override slug (also synced from root.props)
+   * - status?: 'draft' | 'published' - Publishing status
+   *
+   * Root props from puckData are automatically synced to Payload fields
+   * based on the configured mappings.
+   */ async function PATCH(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 body = await request.json();
             const { puckData, title, slug, status, draft, isHomepage, swapHomepage, folder, pageSegment } = body;
             // Check publish permission only if explicitly publishing
             if (status === 'published') {
@@ -126,13 +162,19 @@ export function createPuckApiRoutesWithId(routeConfig) {
                 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 });
+                        return NextResponse.json({
+                            error: permission.error || 'Not authorized to publish pages'
+                        }, {
+                            status: 403
+                        });
                     }
                 }
             }
             // Get Payload instance with provided config
             const config = await payloadConfig;
-            const payload = await getPayload({ config });
+            const payload = await getPayload({
+                config
+            });
             // Handle homepage swap - if swapHomepage is true and isHomepage is being set,
             // unset the existing homepage first
             if (swapHomepage && isHomepage === true) {
@@ -140,20 +182,32 @@ export function createPuckApiRoutesWithId(routeConfig) {
                     collection,
                     where: {
                         and: [
-                            { isHomepage: { equals: true } },
-                            { id: { not_equals: id } },
-                        ],
+                            {
+                                isHomepage: {
+                                    equals: true
+                                }
+                            },
+                            {
+                                id: {
+                                    not_equals: id
+                                }
+                            }
+                        ]
                     },
                     limit: 1,
-                    depth: 0,
+                    depth: 0
                 });
                 if (existingHomepage.docs.length > 0) {
                     await payload.update({
                         collection,
                         id: existingHomepage.docs[0].id,
-                        data: { isHomepage: false },
+                        data: {
+                            isHomepage: false
+                        },
                         // Pass context to skip the uniqueness hook on this update
-                        context: { skipIsHomepageHook: true },
+                        context: {
+                            skipIsHomepageHook: true
+                        }
                     });
                 }
             }
@@ -161,7 +215,7 @@ export function createPuckApiRoutesWithId(routeConfig) {
             const rootProps = puckData?.root?.props || {};
             // Build update data starting with editorVersion
             const updateData = {
-                editorVersion: 'puck',
+                editorVersion: 'puck'
             };
             // Add puckData if provided
             if (puckData) {
@@ -200,7 +254,7 @@ export function createPuckApiRoutesWithId(routeConfig) {
             const updateOptions = {
                 collection,
                 id,
-                data: updateData,
+                data: updateData
             };
             // Only pass draft: true when explicitly saving as draft (not publishing)
             // When publishing (_status: 'published'), we omit the draft option entirely
@@ -209,12 +263,17 @@ export function createPuckApiRoutesWithId(routeConfig) {
                 updateOptions.draft = true;
             }
             const updatedPage = await payload.update(updateOptions);
-            return NextResponse.json({ doc: updatedPage });
-        }
-        catch (error) {
+            return NextResponse.json({
+                doc: updatedPage
+            });
+        } catch (error) {
             const params = await context.params;
             if (onError) {
-                onError(error, { operation: 'update', request, pageId: params.id });
+                onError(error, {
+                    operation: 'update',
+                    request,
+                    pageId: params.id
+                });
             }
             console.error('Error updating page:', error);
             // Handle Payload validation errors gracefully
@@ -222,65 +281,98 @@ export function createPuckApiRoutesWithId(routeConfig) {
                 const validationError = error;
                 const fieldErrors = validationError.data?.errors || [];
                 // Check for common validation issues and provide friendly messages
-                const slugError = fieldErrors.find((e) => e.field === 'slug');
+                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 });
+                        details: fieldErrors
+                    }, {
+                        status: 400
+                    });
                 }
                 // Generic validation error
                 return NextResponse.json({
-                    error: `Validation failed: ${fieldErrors.map((e) => e.message || e.field).join(', ')}`,
-                    details: fieldErrors,
-                }, { status: 400 });
+                    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 });
+            return NextResponse.json({
+                error: 'Failed to update page'
+            }, {
+                status: 500
+            });
         }
     }
     /**
-     * DELETE /api/puck/pages/[id]
-     * Delete a page by ID
-     */
-    async function DELETE(request, context) {
+   * DELETE /api/puck/pages/[id]
+   * Delete a page by ID
+   */ async function DELETE(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 delete permission
             if (auth.canDelete) {
                 const permission = await auth.canDelete(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
+            });
             await payload.delete({
                 collection,
-                id,
+                id
             });
-            return NextResponse.json({ success: true });
-        }
-        catch (error) {
+            return NextResponse.json({
+                success: true
+            });
+        } catch (error) {
             const params = await context.params;
             if (onError) {
-                onError(error, { operation: 'delete', request, pageId: params.id });
+                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 NextResponse.json({
+                error: 'Failed to delete page'
+            }, {
+                status: 500
+            });
         }
     }
-    return { GET, PATCH, DELETE };
+    return {
+        GET,
+        PATCH,
+        DELETE
+    };
 }
-//# sourceMappingURL=createPuckApiRoutesWithId.js.map

package/dist/api/index.d.ts

@@ -32,9 +32,8 @@
  * })
  * ```
  */
-export { createPuckApiRoutes } from './createPuckApiRoutes';
-export { createPuckApiRoutesWithId } from './createPuckApiRoutesWithId';
-export { createPuckApiRoutesVersions } from './createPuckApiRoutesVersions';
-export { mapRootPropsToPayloadFields, mapPayloadFieldsToRootProps, DEFAULT_ROOT_PROPS_MAPPINGS, setNestedValue, getNestedValue, mergeMappings, deepMerge, } from './utils/mapRootProps';
-export type { AuthenticatedUser, AuthResult, PermissionResult, PuckApiAuthHooks, RootPropsMapping, PuckApiRoutesConfig, ErrorContext, RouteHandler, RouteHandlerWithId, RouteHandlerContext, RouteHandlerWithIdContext, PuckApiRouteHandlers, PuckApiRouteWithIdHandlers, CreatePageBody, UpdatePageBody, ApiResponse, PageVersion, PuckApiVersionsRouteHandlers, } from './types';
-//# sourceMappingURL=index.d.ts.map
+export { createPuckApiRoutes } from './createPuckApiRoutes.js';
+export { createPuckApiRoutesWithId } from './createPuckApiRoutesWithId.js';
+export { createPuckApiRoutesVersions } from './createPuckApiRoutesVersions.js';
+export { mapRootPropsToPayloadFields, mapPayloadFieldsToRootProps, DEFAULT_ROOT_PROPS_MAPPINGS, setNestedValue, getNestedValue, mergeMappings, deepMerge, } from './utils/mapRootProps.js';
+export type { AuthenticatedUser, AuthResult, PermissionResult, PuckApiAuthHooks, RootPropsMapping, PuckApiRoutesConfig, ErrorContext, RouteHandler, RouteHandlerWithId, RouteHandlerContext, RouteHandlerWithIdContext, PuckApiRouteHandlers, PuckApiRouteWithIdHandlers, CreatePageBody, UpdatePageBody, ApiResponse, PageVersion, PuckApiVersionsRouteHandlers, } from './types.js';

package/dist/api/index.js

@@ -31,11 +31,9 @@
  *   },
  * })
  * ```
- */
-// Route factories
-export { createPuckApiRoutes } from './createPuckApiRoutes';
-export { createPuckApiRoutesWithId } from './createPuckApiRoutesWithId';
-export { createPuckApiRoutesVersions } from './createPuckApiRoutesVersions';
+ */ // Route factories
+export { createPuckApiRoutes } from './createPuckApiRoutes.js';
+export { createPuckApiRoutesWithId } from './createPuckApiRoutesWithId.js';
+export { createPuckApiRoutesVersions } from './createPuckApiRoutesVersions.js';
 // Utilities
-export { mapRootPropsToPayloadFields, mapPayloadFieldsToRootProps, DEFAULT_ROOT_PROPS_MAPPINGS, setNestedValue, getNestedValue, mergeMappings, deepMerge, } from './utils/mapRootProps';
-//# sourceMappingURL=index.js.map
+export { mapRootPropsToPayloadFields, mapPayloadFieldsToRootProps, DEFAULT_ROOT_PROPS_MAPPINGS, setNestedValue, getNestedValue, mergeMappings, deepMerge } from './utils/mapRootProps.js';

package/dist/api/payload-config.d.js

@@ -0,0 +1,14 @@
+/**
+ * Ambient type declaration for @payload-config
+ *
+ * This module is provided by the consuming project and resolves to their Payload config.
+ * The consuming project should have this alias configured in their tsconfig.json:
+ *
+ * {
+ *   "compilerOptions": {
+ *     "paths": {
+ *       "@payload-config": ["./src/payload.config.ts"]
+ *     }
+ *   }
+ * }
+ */ 

package/dist/api/types.d.ts

@@ -309,4 +309,3 @@ export interface PuckApiVersionsRouteHandlers {
     GET: RouteHandlerWithId;
     POST: RouteHandlerWithId;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/api/types.js

@@ -1,2 +1,3 @@
-export {};
-//# sourceMappingURL=types.js.map
+/**
+ * Route handlers returned by createPuckApiRoutesVersions
+ */ export { };

package/dist/api/utils/mapRootProps.d.ts

@@ -1,4 +1,4 @@
-import type { RootPropsMapping } from '../types';
+import type { RootPropsMapping } from '../types.js';
 /**
  * Default mappings from Puck root.props to Payload fields
  *
@@ -92,4 +92,3 @@ export declare function deepMerge(target: Record<string, unknown>, source: Recor
  * ```
  */
 export declare function mapPayloadFieldsToRootProps(doc: Record<string, unknown>, customMappings?: RootPropsMapping[]): Record<string, unknown>;
-//# sourceMappingURL=mapRootProps.d.ts.map

package/dist/api/utils/mapRootProps.js

@@ -5,27 +5,71 @@
  * to the corresponding Payload collection fields.
  *
  * SEO fields use the official @payloadcms/plugin-seo convention: meta.title, meta.description
- */
-export const DEFAULT_ROOT_PROPS_MAPPINGS = [
+ */ export const 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' },
+    {
+        from: 'title',
+        to: 'title'
+    },
+    {
+        from: 'slug',
+        to: 'slug'
+    },
+    {
+        from: 'pageLayout',
+        to: 'pageLayout'
+    },
+    {
+        from: 'pageType',
+        to: 'pageType'
+    },
+    {
+        from: 'isHomepage',
+        to: 'isHomepage'
+    },
     // Page-tree integration fields
-    { from: 'folder', to: 'folder' },
-    { from: 'pageSegment', to: 'pageSegment' },
+    {
+        from: 'folder',
+        to: 'folder'
+    },
+    {
+        from: 'pageSegment',
+        to: 'pageSegment'
+    },
     // 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' },
+    {
+        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' },
+    {
+        from: 'isConversionPage',
+        to: 'conversionTracking.isConversionPage'
+    },
+    {
+        from: 'conversionType',
+        to: 'conversionTracking.conversionType'
+    },
+    {
+        from: 'conversionValue',
+        to: 'conversionTracking.conversionValue'
+    }
 ];
 /**
  * Set a nested value in an object using dot notation path
@@ -36,11 +80,10 @@ export const DEFAULT_ROOT_PROPS_MAPPINGS = [
  * setNestedValue(obj, 'meta.title', 'My Title')
  * // Result: { meta: { title: 'My Title' } }
  * ```
- */
-export function setNestedValue(obj, path, value) {
+ */ export function setNestedValue(obj, path, value) {
     const keys = path.split('.');
     let current = obj;
-    for (let i = 0; i < keys.length - 1; i++) {
+    for(let i = 0; i < keys.length - 1; i++){
         const key = keys[i];
         if (!(key in current) || typeof current[key] !== 'object') {
             current[key] = {};
@@ -58,11 +101,10 @@ export function setNestedValue(obj, path, value) {
  * const obj = { meta: { title: 'My Title' } }
  * getNestedValue(obj, 'meta.title') // 'My Title'
  * ```
- */
-export function getNestedValue(obj, path) {
+ */ export function getNestedValue(obj, path) {
     const keys = path.split('.');
     let current = obj;
-    for (const key of keys) {
+    for (const key of keys){
         if (current === null || current === undefined) {
             return undefined;
         }
@@ -78,19 +120,18 @@ export function getNestedValue(obj, path) {
  *
  * @param customMappings - Custom mappings to merge with defaults
  * @returns Merged array of mappings with duplicates resolved (custom wins)
- */
-export function mergeMappings(customMappings) {
+ */ export function mergeMappings(customMappings) {
     if (!customMappings || customMappings.length === 0) {
         return DEFAULT_ROOT_PROPS_MAPPINGS;
     }
     // Create a map to track unique mappings by 'from' field
     const mappingMap = new Map();
     // Add defaults first
-    for (const mapping of DEFAULT_ROOT_PROPS_MAPPINGS) {
+    for (const mapping of DEFAULT_ROOT_PROPS_MAPPINGS){
         mappingMap.set(mapping.from, mapping);
     }
     // Custom mappings override defaults
-    for (const mapping of customMappings) {
+    for (const mapping of customMappings){
         mappingMap.set(mapping.from, mapping);
     }
     return Array.from(mappingMap.values());
@@ -122,11 +163,10 @@ export function mergeMappings(customMappings) {
  * //   },
  * // }
  * ```
- */
-export function mapRootPropsToPayloadFields(rootProps, customMappings) {
+ */ export function mapRootPropsToPayloadFields(rootProps, customMappings) {
     const mappings = mergeMappings(customMappings);
     const result = {};
-    for (const mapping of mappings) {
+    for (const mapping of mappings){
         const value = rootProps[mapping.from];
         // Skip undefined values to avoid overwriting existing data
         if (value === undefined) {
@@ -145,21 +185,14 @@ export function mapRootPropsToPayloadFields(rootProps, customMappings) {
  * @param target - The target object to merge into
  * @param source - The source object to merge from
  * @returns The merged object (target is modified in place)
- */
-export function deepMerge(target, source) {
-    for (const key of Object.keys(source)) {
+ */ export 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)) {
+        if (sourceValue !== null && typeof sourceValue === 'object' && !Array.isArray(sourceValue) && targetValue !== null && typeof targetValue === 'object' && !Array.isArray(targetValue)) {
             // Recursively merge nested objects
             target[key] = deepMerge(targetValue, sourceValue);
-        }
-        else {
+        } else {
             // Direct assignment for non-object values or arrays
             target[key] = sourceValue;
         }
@@ -183,11 +216,10 @@ export function deepMerge(target, source) {
  * const rootProps = mapPayloadFieldsToRootProps(page)
  * // Result: { title: 'My Page', isHomepage: true, metaTitle: 'SEO Title' }
  * ```
- */
-export function mapPayloadFieldsToRootProps(doc, customMappings) {
+ */ export function mapPayloadFieldsToRootProps(doc, customMappings) {
     const mappings = mergeMappings(customMappings);
     const result = {};
-    for (const mapping of mappings) {
+    for (const mapping of mappings){
         // Get value from Payload field (supports dot notation for nested fields)
         const value = getNestedValue(doc, mapping.to);
         // Skip undefined values
@@ -199,4 +231,3 @@ export function mapPayloadFieldsToRootProps(doc, customMappings) {
     }
     return result;
 }
-//# sourceMappingURL=mapRootProps.js.map