@delmaredigital/payload-experiments 0.1.0-rc.7 → 0.2.0-rc.2

package/dist/admin/views/ExperimentsRootView.js

@@ -0,0 +1,175 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { formatAdminURL } from 'payload/shared';
+import { notFound, redirect } from 'next/navigation.js';
+import { RenderServerComponent } from '@payloadcms/ui/elements/RenderServerComponent';
+import { serializeAttributeKeys, serializeFlagPoints, serializeMetricSources } from '../../collections/serialize.js';
+import { puckCollections } from '../../options.js';
+import { xpOptionsFromReq } from '../../options/fromReq.js';
+import { XP_TESTS_SURFACE } from '../paths.js';
+import { SURFACE_COPY } from '../copy/surface.js';
+import { routeAccess } from './access.model.js';
+export async function ExperimentsRootView({ initPageResult, params, searchParams }) {
+    const { req } = initPageResult;
+    const adminRoute = req.payload.config.routes.admin;
+    const segments = (await params)?.segments;
+    const path = Array.isArray(segments) ? segments : [];
+    const tail = path[0] === 'experiments' ? path.slice(1) : path;
+    let route;
+    let id;
+    if (tail.length === 0) route = 'home';
+    else if (tail.length === 1 && tail[0] === 'new') route = 'new';
+    else if (tail.length === 1) {
+        route = 'test';
+        id = tail[0];
+    } else if (tail.length === 2 && tail[1] === 'results') {
+        route = 'results';
+        id = tail[0];
+    } else return notFound();
+    if (!req.user) {
+        const { login } = req.payload.config.admin.routes;
+        const query = new URLSearchParams();
+        for (const [key, value] of Object.entries(await searchParams ?? {})){
+            if (Array.isArray(value)) value.forEach((item)=>query.append(key, item));
+            else if (value !== undefined) query.set(key, String(value));
+        }
+        const currentPath = formatAdminURL({
+            adminRoute,
+            path: `/experiments${tail.length ? `/${tail.map(encodeURIComponent).join('/')}` : ''}${query.size ? `?${query}` : ''}`
+        });
+        return redirect(formatAdminURL({
+            adminRoute,
+            path: `${login}?redirect=${encodeURIComponent(currentPath)}`
+        }));
+    }
+    const options = xpOptionsFromReq(req);
+    async function permits(access) {
+        try {
+            return await access({
+                req
+            }) === true;
+        } catch  {
+            return false;
+        }
+    }
+    const canManage = await permits(options.access.manage);
+    const isAdmin = options.access.admin ? await permits(options.access.admin) : false;
+    const canReadResults = options.access.readResults ? await permits(options.access.readResults) : canManage;
+    if (routeAccess({
+        route,
+        hasUser: true,
+        canManage,
+        canReadResults
+    }) !== 'ok') {
+        return /*#__PURE__*/ _jsx("div", {
+            style: {
+                padding: 'var(--base)',
+                color: 'var(--theme-text)',
+                background: 'var(--theme-bg)'
+            },
+            children: SURFACE_COPY.noAccess
+        });
+    }
+    const flagPoints = serializeFlagPoints(options);
+    // xp-state is manager-readable only. Results-only readers do not edit settings.
+    if (canManage && flagPoints.length) {
+        const state = await req.payload.findGlobal({
+            slug: 'xp-state',
+            req,
+            overrideAccess: false,
+            depth: 0
+        });
+        const defaults = state.flagDefaults;
+        for (const point of flagPoints)point.effectiveDefaults = defaults?.[point.id]?.params ?? point.defaultParams;
+    }
+    const registrations = puckCollections(options);
+    const pages = route === 'new' && canManage && options.puck?.enabled && registrations.length ? (await Promise.all(registrations.map(async ({ slug: collection })=>{
+        try {
+            const config = req.payload.config.collections.find((item)=>item.slug === collection);
+            const useAsTitle = config?.admin.useAsTitle ?? 'id';
+            const label = config?.labels.plural;
+            // Keep /rsc dependency-safe: translations is not a declared runtime dependency,
+            // so a per-language label picks the request language, then English, then any string.
+            const byLanguage = label && typeof label === 'object' ? label : {};
+            const collectionLabel = typeof label === 'string' ? label : [
+                byLanguage[req.i18n?.language ?? 'en'],
+                byLanguage.en,
+                ...Object.values(byLanguage)
+            ].find((value)=>typeof value === 'string') ?? collection;
+            const result = await req.payload.find({
+                collection,
+                req,
+                overrideAccess: false,
+                depth: 0,
+                limit: 50,
+                sort: '-updatedAt',
+                draft: true,
+                select: {
+                    [useAsTitle]: true
+                }
+            });
+            return result.docs.map((doc)=>{
+                const id = doc.id;
+                const customUrl = options.admin?.editorUrl?.({
+                    collection,
+                    id,
+                    draft: true
+                });
+                const title = doc[useAsTitle];
+                return {
+                    collection,
+                    collectionLabel,
+                    id,
+                    title: typeof title === 'string' || typeof title === 'number' ? String(title) : String(id),
+                    editorUrl: typeof customUrl === 'string' ? customUrl : formatAdminURL({
+                        adminRoute,
+                        path: `/collections/${collection}/${encodeURIComponent(String(id))}`
+                    })
+                };
+            });
+        } catch  {
+            return [];
+        }
+    }))).flat() : undefined;
+    const descriptions = options.admin?.descriptions;
+    const clientProps = {
+        route,
+        ...id === undefined ? {} : {
+            id
+        },
+        adminRoute,
+        apiRoute: req.payload.config.routes.api,
+        canManage,
+        canReadResults,
+        isAdmin,
+        flagPoints,
+        ...pages === undefined ? {} : {
+            pages
+        },
+        attributeKeys: serializeAttributeKeys(options),
+        metricSources: serializeMetricSources(options),
+        ...descriptions ? {
+            admin: {
+                descriptions: {
+                    ...descriptions
+                }
+            }
+        } : {}
+    };
+    return RenderServerComponent({
+        Component: XP_TESTS_SURFACE,
+        Fallback: TestsSurfaceFallback,
+        importMap: req.payload.importMap,
+        clientProps
+    });
+}
+function TestsSurfaceFallback() {
+    return /*#__PURE__*/ _jsx("div", {
+        role: "alert",
+        style: {
+            padding: 'var(--base)',
+            color: 'var(--theme-text)',
+            background: 'var(--theme-bg)'
+        },
+        children: SURFACE_COPY.notInstalled
+    });
+}

package/dist/admin/views/access.model.d.ts

@@ -0,0 +1,7 @@
+import type { TestsRoute } from '../../types/surface.js';
+export declare function routeAccess({ route, hasUser, canManage, canReadResults }: {
+    route: TestsRoute;
+    hasUser: boolean;
+    canManage: unknown;
+    canReadResults?: unknown;
+}): 'login' | 'unauthorized' | 'ok';

package/dist/admin/views/access.model.js

@@ -0,0 +1,5 @@
+export function routeAccess({ route, hasUser, canManage, canReadResults }) {
+    if (!hasUser) return 'login';
+    const allowed = route === 'results' ? canReadResults ?? canManage : canManage;
+    return allowed === true ? 'ok' : 'unauthorized';
+}

package/dist/collections/experiments/config.js

@@ -1,5 +1,4 @@
 import * as paths from '../../admin/paths.js';
-import { TAB_DESCRIPTIONS } from '../../admin/copy/tabs.js';
 import { managedAccess } from '../access.js';
 import { serializeAttributeKeys, serializeFlagPoints } from '../serialize.js';
 import { TARGETING_OPS, isOpValid } from '../../targeting/ops.js';
@@ -9,17 +8,6 @@ import { lockHook } from './lockHook.js';
 import { deleteGuard, deleteGuardAfter } from './deleteGuard.js';
 import { checkArms } from './armInvariants.js';
 import { XpNotImplemented } from '../../errors.js';
-const locked = (field, admin = {})=>({
-        ...admin,
-        custom: {
-            ...admin.custom,
-            field
-        },
-        components: {
-            ...admin.components,
-            Description: paths.XP_LOCKED_NOTICE
-        }
-    });
 const positiveInteger = (value)=>value != null && Number.isInteger(value) && value > 0 || 'Enter a positive whole number.';
 export function experimentsCollection(options) {
     const flagPoints = serializeFlagPoints(options);
@@ -43,7 +31,8 @@ export function experimentsCollection(options) {
         graphQL: false,
         disableDuplicate: true,
         versions: {
-            drafts: false
+            drafts: false,
+            maxPerDoc: 50
         },
         access: {
             ...managedAccess(options),
@@ -59,19 +48,26 @@ export function experimentsCollection(options) {
                 } : false
         },
         admin: {
+            // group:false hides navigation while keeping custom view routes reachable (hidden causes 404s).
+            group: false,
             useAsTitle: 'name',
             defaultColumns: [
                 'name',
                 'status',
                 'kind',
-                'flagPoint',
-                'listSummary'
+                'flagPoint'
             ],
             components: {
                 views: {
+                    list: {
+                        Component: paths.XP_TESTS_LIST_REDIRECT
+                    },
                     edit: {
+                        default: {
+                            Component: paths.XP_TEST_EDIT_REDIRECT
+                        },
                         results: {
-                            Component: paths.XP_RESULTS_VIEW,
+                            Component: paths.XP_TEST_EDIT_REDIRECT,
                             path: '/results',
                             tab: {
                                 label: 'Results',
@@ -98,16 +94,6 @@ export function experimentsCollection(options) {
             ]
         },
         fields: [
-            {
-                name: 'actions',
-                type: 'ui',
-                admin: {
-                    position: 'sidebar',
-                    components: {
-                        Field: paths.XP_ACTIONS
-                    }
-                }
-            },
             {
                 name: 'status',
                 type: 'select',
@@ -122,30 +108,7 @@ export function experimentsCollection(options) {
                 ],
                 admin: {
                     position: 'sidebar',
-                    readOnly: true,
-                    components: {
-                        Cell: paths.XP_STATUS_CELL
-                    }
-                }
-            },
-            {
-                name: 'listSummary',
-                type: 'ui',
-                admin: {
-                    condition: ()=>false,
-                    components: {
-                        Cell: paths.XP_SUMMARY_CELL
-                    }
-                }
-            },
-            {
-                name: 'phaseHistory',
-                type: 'ui',
-                admin: {
-                    position: 'sidebar',
-                    components: {
-                        Field: paths.XP_PHASE_HISTORY
-                    }
+                    readOnly: true
                 }
             },
             {
@@ -153,13 +116,11 @@ export function experimentsCollection(options) {
                 tabs: [
                     {
                         label: 'What',
-                        description: TAB_DESCRIPTIONS.What,
                         fields: [
                             {
                                 name: 'name',
                                 type: 'text',
-                                required: true,
-                                admin: locked('name')
+                                required: true
                             },
                             {
                                 name: 'slug',
@@ -169,8 +130,7 @@ export function experimentsCollection(options) {
                             },
                             {
                                 name: 'hypothesis',
-                                type: 'textarea',
-                                admin: locked('hypothesis')
+                                type: 'textarea'
                             },
                             {
                                 name: 'kind',
@@ -189,14 +149,6 @@ export function experimentsCollection(options) {
                             {
                                 name: 'flagPoint',
                                 type: 'text',
-                                admin: locked('flagPoint', {
-                                    components: {
-                                        Field: paths.XP_FLAG_POINT_SELECT
-                                    },
-                                    custom: {
-                                        flagPoints
-                                    }
-                                }),
                                 validate: (value, { data })=>!value && data?.kind !== 'flag' || flagPoints.some((point)=>point.id === value) || 'Choose a registered flag point.'
                             },
                             {
@@ -209,7 +161,6 @@ export function experimentsCollection(options) {
                                     'pageview',
                                     'manual'
                                 ],
-                                admin: locked('exposurePolicy'),
                                 validate: (value, { data })=>{
                                     const allowed = data?.kind === 'block' ? [
                                         'render',
@@ -226,7 +177,6 @@ export function experimentsCollection(options) {
                     },
                     {
                         label: 'Who',
-                        description: TAB_DESCRIPTIONS.Who,
                         fields: [
                             {
                                 name: 'unitType',
@@ -246,12 +196,7 @@ export function experimentsCollection(options) {
                                 defaultValue: 100,
                                 min: 1,
                                 max: 100,
-                                validate: (value)=>positiveInteger(value) === true && value <= 100 || 'Enter a whole percentage from 1 to 100.',
-                                admin: locked('allocation', {
-                                    components: {
-                                        Field: paths.XP_ALLOCATION_FIELD
-                                    }
-                                })
+                                validate: (value)=>positiveInteger(value) === true && value <= 100 || 'Enter a whole percentage from 1 to 100.'
                             },
                             {
                                 name: 'layer',
@@ -261,21 +206,12 @@ export function experimentsCollection(options) {
                             {
                                 name: 'targeting',
                                 type: 'array',
-                                admin: locked('targeting'),
                                 fields: [
                                     {
                                         name: 'attribute',
                                         type: 'text',
                                         required: true,
-                                        validate: (value)=>typeof value === 'string' && Object.hasOwn(attributeKeys, value) || 'Choose a registered attribute.',
-                                        admin: {
-                                            components: {
-                                                Field: paths.XP_TARGETING_ATTRIBUTE
-                                            },
-                                            custom: {
-                                                attributeKeys
-                                            }
-                                        }
+                                        validate: (value)=>typeof value === 'string' && Object.hasOwn(attributeKeys, value) || 'Choose a registered attribute.'
                                     },
                                     {
                                         name: 'op',
@@ -284,15 +220,7 @@ export function experimentsCollection(options) {
                                         options: [
                                             ...new Set(Object.values(TARGETING_OPS).flat())
                                         ],
-                                        validate: (value, { siblingData })=>isOpValid(attributeKeys[siblingData?.attribute ?? '']?.type ?? '', value) || 'Choose an operator supported by this attribute.',
-                                        admin: {
-                                            components: {
-                                                Field: paths.XP_TARGETING_OP
-                                            },
-                                            custom: {
-                                                attributeKeys
-                                            }
-                                        }
+                                        validate: (value, { siblingData })=>isOpValid(attributeKeys[siblingData?.attribute ?? '']?.type ?? '', value) || 'Choose an operator supported by this attribute.'
                                     },
                                     {
                                         name: 'value',
@@ -305,14 +233,6 @@ export function experimentsCollection(options) {
                                             const valid = type === 'string' && (op === 'in' || op === 'nin') ? Array.isArray(value) && value.length > 0 && value.every((item)=>typeof item === 'string') : typeof value === type && (type !== 'number' || Number.isFinite(value));
                                             if (!valid && type === 'string' && (op === 'in' || op === 'nin') && Array.isArray(value) && value.length === 0) return 'Add at least one value; an empty list matches nobody.';
                                             return valid || 'Enter a value of the type required by this attribute and operator.';
-                                        },
-                                        admin: {
-                                            components: {
-                                                Field: paths.XP_TARGETING_VALUE
-                                            },
-                                            custom: {
-                                                attributeKeys
-                                            }
                                         }
                                     }
                                 ]
@@ -321,7 +241,6 @@ export function experimentsCollection(options) {
                     },
                     {
                         label: 'Groups',
-                        description: TAB_DESCRIPTIONS.Groups,
                         fields: [
                             {
                                 name: 'arms',
@@ -337,14 +256,6 @@ export function experimentsCollection(options) {
                                         throw error;
                                     }
                                 },
-                                admin: locked('arms', {
-                                    components: {
-                                        Field: paths.XP_ARMS_FIELD
-                                    },
-                                    custom: {
-                                        flagPoints
-                                    }
-                                }),
                                 fields: [
                                     {
                                         name: 'key',
@@ -405,12 +316,10 @@ export function experimentsCollection(options) {
                     },
                     {
                         label: 'Metrics',
-                        description: TAB_DESCRIPTIONS.Metrics,
                         fields: [
                             {
                                 name: 'metrics',
                                 type: 'group',
-                                admin: locked('metrics'),
                                 fields: [
                                     metric('primary'),
                                     metric('secondary', true),
@@ -420,7 +329,6 @@ export function experimentsCollection(options) {
                             {
                                 name: 'analysis',
                                 type: 'group',
-                                admin: locked('analysis'),
                                 fields: [
                                     {
                                         name: 'method',
@@ -475,21 +383,6 @@ export function experimentsCollection(options) {
                                 ]
                             }
                         ]
-                    },
-                    {
-                        label: 'Review',
-                        description: TAB_DESCRIPTIONS.Review,
-                        fields: [
-                            {
-                                name: 'review',
-                                type: 'ui',
-                                admin: {
-                                    components: {
-                                        Field: paths.XP_REVIEW_PANEL
-                                    }
-                                }
-                            }
-                        ]
                     }
                 ]
             },

package/dist/collections/experiments/createDefaults.js

@@ -3,5 +3,11 @@ export const createDefaults = ({ data, operation })=>{
     if (operation === 'create' && data && (!data.arms || Array.isArray(data.arms) && data.arms.length === 0)) {
         data.arms = defaultArms(data.kind);
     }
+    if (operation === 'create' && data && data.analysis?.plannedDurationDays == null) {
+        data.analysis = {
+            ...data.analysis,
+            plannedDurationDays: 28
+        };
+    }
     return data;
 };

package/dist/collections/layers.js

@@ -2,57 +2,88 @@ import { XpRefusal } from '../errors.js';
 import { XP_LAYER_USAGE } from '../admin/paths.js';
 import { managedAccess } from './access.js';
 export function layersCollection(options) {
+    const usageAdmin = {
+        description: 'See which tests use this group and how much room is left.',
+        components: {
+            Field: XP_LAYER_USAGE
+        }
+    };
     return {
         slug: 'xp-layers',
         graphQL: false,
         disableDuplicate: true,
+        // group:false hides navigation while keeping collection routes reachable (hidden causes 404s).
+        labels: {
+            singular: 'Test group',
+            plural: 'Test groups (advanced)'
+        },
         admin: {
+            group: false,
             useAsTitle: 'name'
         },
         access: managedAccess(options),
         fields: [
             {
                 name: 'name',
+                label: 'Name',
                 type: 'text',
-                required: true
+                required: true,
+                admin: {
+                    description: 'Give this test group a name people will recognize.'
+                }
             },
             {
                 name: 'slug',
+                label: 'Short name (used in code)',
                 type: 'text',
                 unique: true,
                 required: true,
+                admin: {
+                    description: 'Use a unique short name for code that refers to this group.'
+                },
                 validate: (value, { operation, previousValue })=>{
                     if (operation === 'update' && value === undefined) return true;
-                    if (typeof value !== 'string' || !value.length) return 'Enter a slug.';
-                    return operation !== 'update' || value === previousValue || 'slug is set when the layer is created.';
+                    if (typeof value !== 'string' || !value.length) return 'Enter a short name.';
+                    return operation !== 'update' || value === previousValue || "The short name can't change after the group is created.";
                 }
             },
             {
                 name: 'unitType',
+                label: 'Counts',
                 type: 'select',
                 required: true,
                 options: [
-                    'visitor',
-                    'user'
+                    {
+                        label: 'Visitors',
+                        value: 'visitor'
+                    },
+                    {
+                        label: 'Signed-in users',
+                        value: 'user'
+                    }
                 ],
+                admin: {
+                    description: 'Choose whether tests in this group count visitors or signed-in users.'
+                },
                 validate: (value, { operation, previousValue })=>{
                     if (operation === 'update' && value === undefined) return true;
                     if (value !== 'visitor' && value !== 'user') return 'Choose visitors or signed-in users.';
-                    return operation !== 'update' || value === previousValue || 'unitType is set when the layer is created.';
+                    return operation !== 'update' || value === previousValue || "Who it counts can't change after the group is created.";
                 }
             },
             {
                 name: 'description',
-                type: 'textarea'
+                label: 'Notes',
+                type: 'textarea',
+                admin: {
+                    description: 'Explain when people should use this test group.'
+                }
             },
             {
                 name: 'usage',
+                label: 'Tests in this group',
                 type: 'ui',
-                admin: {
-                    components: {
-                        Field: XP_LAYER_USAGE
-                    }
-                }
+                admin: usageAdmin
             }
         ],
         hooks: {