@next-buildr/payload 0.0.0-stage → 2.0.0

package/dist/plugin/endpoints/templates.test.js

@@ -0,0 +1,191 @@
+import { parseDocument } from '@next-buildr/core';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { builtinLayout, resolveLayout } from '../../data/index.js';
+import { boot, title, withChild } from './endpoints.test-kit.js';
+let h;
+beforeAll(async () => {
+    h = await boot('templates', {
+        collections: {
+            pages: { context: 'page', templates: true },
+            articles: { context: 'article', templates: true },
+        },
+    }, {
+        collections: [
+            {
+                slug: 'articles',
+                admin: { useAsTitle: 'title' },
+                fields: [{ name: 'title', type: 'text' }],
+                versions: { drafts: true },
+            },
+        ],
+    });
+});
+afterAll(() => h.close());
+const layout = (text) => withChild(title(text));
+const template = (data, status = 'published') => h.payload.create({
+    collection: 'buildr-templates',
+    data: {
+        title: 'T',
+        targetCollection: 'pages',
+        layout: layout('T'),
+        ...data,
+        _status: status,
+    },
+    draft: status === 'draft',
+});
+const page = (data = {}) => h.payload.create({
+    collection: 'pages',
+    data: { title: 'P', slug: 'p', ...data },
+    draft: true,
+});
+const resolve = async (doc, options = {}) => {
+    const collection = options.collection ?? 'pages';
+    const stored = (await h.payload.findByID({
+        collection: collection,
+        id: doc.id,
+        draft: true,
+        depth: 0,
+    }));
+    return resolveLayout({
+        payload: h.payload,
+        collection,
+        doc: stored,
+        contextName: 'page',
+        ...options,
+    });
+};
+const nameOf = (resolved) => resolved.layout.nodes['child00001']?.props?.title?.value;
+describe('resolveLayout', () => {
+    it('prefers the own layout, then the chosen template, then the default, then the built-in one', async () => {
+        const chosen = await template({ title: 'Chosen', layout: layout('chosen') });
+        const isDefault = await template({
+            title: 'Default',
+            isDefault: true,
+            layout: layout('default'),
+        });
+        const own = await page({ layout: layout('own'), template: chosen.id });
+        expect(await resolve(own)).toMatchObject({ source: 'document', layoutRef: `pages:${own.id}` });
+        expect(nameOf(await resolve(own))).toBe('own');
+        const inherits = await page({ template: chosen.id });
+        const viaTemplate = await resolve(inherits);
+        expect(viaTemplate).toMatchObject({
+            source: 'template',
+            layoutRef: `buildr-templates:${chosen.id}`,
+        });
+        expect(nameOf(viaTemplate)).toBe('chosen');
+        const plain = await page();
+        const viaDefault = await resolve(plain);
+        expect(viaDefault).toMatchObject({
+            source: 'default-template',
+            layoutRef: `buildr-templates:${isDefault.id}`,
+        });
+        expect(nameOf(viaDefault)).toBe('default');
+        await h.payload.delete({ collection: 'buildr-templates', id: isDefault.id });
+        expect(await resolve(plain)).toMatchObject({ source: 'builtin', layoutRef: null });
+    });
+    it('treats an empty layout as none', async () => {
+        const chosen = await template({ title: 'Chosen', layout: layout('chosen') });
+        const empty = await page({
+            layout: {
+                schemaVersion: 1,
+                root: 'root',
+                nodes: { root: { id: 'root', type: 'buildr/page' } },
+                components: { 'buildr/page': 1 },
+            },
+            template: chosen.id,
+        });
+        expect((await resolve(empty)).source).toBe('template');
+    });
+    it('uses published templates only, unless it reads drafts', async () => {
+        const draft = await template({ title: 'Wip', layout: layout('wip') }, 'draft');
+        const doc = await page({ template: draft.id });
+        expect((await resolve(doc)).source).not.toBe('template');
+        expect((await resolve(doc, { draft: true })).source).not.toBe('template');
+        expect(await resolve(doc, { draft: true, overrideAccess: true })).toMatchObject({
+            source: 'template',
+        });
+    });
+    it('never uses a template of another collection', async () => {
+        const other = await template({
+            title: 'For articles',
+            targetCollection: 'articles',
+            layout: layout('other'),
+        });
+        const doc = await page({ template: other.id });
+        expect((await resolve(doc)).source).not.toBe('template');
+    });
+    it('answers with a built-in layout that is a valid document', () => {
+        const parsed = parseDocument(builtinLayout('post'));
+        expect(parsed.ok).toBe(true);
+        expect(JSON.stringify(builtinLayout('post'))).toContain('post.title');
+    });
+});
+describe('buildr-templates', () => {
+    it('allows one default per target collection', async () => {
+        const first = await template({ title: 'First', targetCollection: 'articles', isDefault: true });
+        await expect(template({ title: 'Second', targetCollection: 'articles', isDefault: true })).rejects.toThrow();
+        // Another collection may have its own default, and the default may be saved again.
+        await template({ title: 'Pages default', targetCollection: 'pages', isDefault: true });
+        await h.payload.update({
+            collection: 'buildr-templates',
+            id: first.id,
+            data: { title: 'First, renamed' },
+        });
+        // Unmarking the first makes room for another.
+        await h.payload.update({
+            collection: 'buildr-templates',
+            id: first.id,
+            data: { isDefault: false },
+        });
+        const second = await template({
+            title: 'Second',
+            targetCollection: 'articles',
+            isDefault: true,
+        });
+        expect(second.id).toBeDefined();
+    });
+    it('rejects an invalid layout and a target that takes no templates', async () => {
+        await expect(template({ layout: { nope: true } })).rejects.toThrow();
+        await expect(template({ targetCollection: 'users' })).rejects.toThrow();
+    });
+    it('is readable by visitors only when published, and writable only by the builder', async () => {
+        const live = await template({ title: 'Live' });
+        const wip = await template({ title: 'Wip' }, 'draft');
+        const visible = await h.payload.find({
+            collection: 'buildr-templates',
+            overrideAccess: false,
+        });
+        const ids = visible.docs.map((doc) => doc.id);
+        expect(ids).toContain(live.id);
+        expect(ids).not.toContain(wip.id);
+        await expect(h.payload.create({
+            collection: 'buildr-templates',
+            data: { title: 'x', targetCollection: 'pages' },
+            overrideAccess: false,
+        })).rejects.toThrow();
+    });
+});
+describe('GET /buildr/documents: the source of the layout', () => {
+    it('opens an inheriting document with the template, and says where it came from', async () => {
+        const chosen = await template({ title: 'Shared', layout: layout('shared') });
+        const doc = await page({ template: chosen.id });
+        const { status, body } = await h.call('GET', `/buildr/documents/pages/${doc.id}`);
+        expect(status).toBe(200);
+        expect(body.layoutSource).toBe('template');
+        expect(body.layoutRef).toBe(`buildr-templates:${chosen.id}`);
+        expect(nameOf({ layout: body.document })).toBe('shared');
+    });
+    it('opens an own layout as such, and a bare document blank with the built-in source', async () => {
+        const own = await page({ layout: layout('mine') });
+        const opened = await h.call('GET', `/buildr/documents/pages/${own.id}`);
+        expect(opened.body).toMatchObject({ layoutSource: 'document', layoutRef: `pages:${own.id}` });
+        await h.payload.delete({
+            collection: 'buildr-templates',
+            where: { isDefault: { equals: true } },
+        });
+        const bare = await page();
+        const blank = await h.call('GET', `/buildr/documents/pages/${bare.id}`);
+        expect(blank.body).toMatchObject({ layoutSource: 'builtin', layoutRef: null });
+        expect(Object.keys(blank.body.document.nodes)).toEqual(['root']);
+    });
+});

package/dist/plugin/fields.d.ts

@@ -0,0 +1,28 @@
+import type { Field, FieldHook } from 'payload';
+import { TEMPLATES_COLLECTION } from '../data/resolve-layout.ts';
+/** The Payload import-map path of the admin field (docs/payload.md). */
+export declare const LAYOUT_FIELD_COMPONENT = "@next-buildr/payload/admin#LayoutField";
+/** The collection the `template` relationship points at. */
+export { TEMPLATES_COLLECTION };
+export declare const LAYOUT = "layout";
+export declare const REVISION = "buildrRevision";
+export declare const TEMPLATE = "template";
+/** Who made the last builder write (added with `mcp.enabled`); versions keep it, so history names the agent. */
+export declare const UPDATED_BY = "buildrUpdatedBy";
+/** The names the plugin owns; a collection that already has one of them is a configuration error. */
+export declare const RESERVED_FIELDS: readonly string[];
+/** Reserved too, but only when `mcp.enabled` adds it. */
+export declare const RESERVED_MCP_FIELDS: readonly string[];
+/**
+ * The fields the plugin adds to a collection: the document (`layout`), its concurrency counter
+ * (`buildrRevision`, hidden and read-only) and, when the collection takes templates, `template`.
+ */
+export declare function buildrFields(options: {
+    readonly templates: boolean;
+    readonly editorRoute: string;
+    readonly guard: (name: string) => FieldHook;
+    readonly layoutHook: FieldHook;
+    /** The auth collections `buildrUpdatedBy` may point at; absent unless agents are enabled. */
+    readonly updatedBy?: readonly string[] | undefined;
+}): Field[];
+//# sourceMappingURL=fields.d.ts.map

package/dist/plugin/fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../../src/plugin/fields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEjE,wEAAwE;AACxE,eAAO,MAAM,sBAAsB,2CAA2C,CAAC;AAC/E,4DAA4D;AAC5D,OAAO,EAAE,oBAAoB,EAAE,CAAC;AAEhC,eAAO,MAAM,MAAM,WAAW,CAAC;AAC/B,eAAO,MAAM,QAAQ,mBAAmB,CAAC;AACzC,eAAO,MAAM,QAAQ,aAAa,CAAC;AACnC,gHAAgH;AAChH,eAAO,MAAM,UAAU,oBAAoB,CAAC;AAE5C,qGAAqG;AACrG,eAAO,MAAM,eAAe,EAAE,SAAS,MAAM,EAAiC,CAAC;AAC/E,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAAiB,CAAC;AAEnE;;;GAGG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE;IACpC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,CAAC;IAC5C,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,6FAA6F;IAC7F,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;CACpD,GAAG,KAAK,EAAE,CA2CV"}

package/dist/plugin/fields.js

@@ -0,0 +1,62 @@
+import { TEMPLATES_COLLECTION } from '../data/resolve-layout.js';
+/** The Payload import-map path of the admin field (docs/payload.md). */
+export const LAYOUT_FIELD_COMPONENT = '@next-buildr/payload/admin#LayoutField';
+/** The collection the `template` relationship points at. */
+export { TEMPLATES_COLLECTION };
+export const LAYOUT = 'layout';
+export const REVISION = 'buildrRevision';
+export const TEMPLATE = 'template';
+/** Who made the last builder write (added with `mcp.enabled`); versions keep it, so history names the agent. */
+export const UPDATED_BY = 'buildrUpdatedBy';
+/** The names the plugin owns; a collection that already has one of them is a configuration error. */
+export const RESERVED_FIELDS = [LAYOUT, REVISION, TEMPLATE];
+/** Reserved too, but only when `mcp.enabled` adds it. */
+export const RESERVED_MCP_FIELDS = [UPDATED_BY];
+/**
+ * The fields the plugin adds to a collection: the document (`layout`), its concurrency counter
+ * (`buildrRevision`, hidden and read-only) and, when the collection takes templates, `template`.
+ */
+export function buildrFields(options) {
+    const fields = [
+        {
+            name: LAYOUT,
+            type: 'json',
+            label: 'Layout',
+            hooks: { beforeChange: [options.layoutHook] },
+            admin: {
+                components: {
+                    Field: {
+                        path: LAYOUT_FIELD_COMPONENT,
+                        clientProps: { editorRoute: options.editorRoute },
+                    },
+                },
+            },
+        },
+        {
+            name: REVISION,
+            type: 'number',
+            defaultValue: 0,
+            hooks: { beforeChange: [options.guard(REVISION)] },
+            admin: { hidden: true, readOnly: true },
+        },
+    ];
+    if (options.updatedBy !== undefined) {
+        fields.push({
+            name: UPDATED_BY,
+            type: 'relationship',
+            relationTo: [...options.updatedBy],
+            hasMany: false,
+            hooks: { beforeChange: [options.guard(UPDATED_BY)] },
+            admin: { hidden: true, readOnly: true },
+        });
+    }
+    if (options.templates) {
+        fields.push({
+            name: TEMPLATE,
+            type: 'relationship',
+            relationTo: TEMPLATES_COLLECTION,
+            hasMany: false,
+        });
+    }
+    return fields;
+}

package/dist/plugin/forms/forms.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=forms.test.d.ts.map

package/dist/plugin/forms/forms.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forms.test.d.ts","sourceRoot":"","sources":["../../../src/plugin/forms/forms.test.ts"],"names":[],"mappings":""}

package/dist/plugin/forms/forms.test.js

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'vitest';
+import { isAllowedRecipient } from './notify.js';
+import { createMemoryRateLimiter } from './rate-limit.js';
+import { validateSubmission } from './validate.js';
+const schema = (fields) => ({ formId: 'form000001', fields });
+const field = (name, valueType, extra = {}) => ({ nodeId: 'field00001', name, valueType, required: false, ...extra });
+describe('validateSubmission', () => {
+    it('checks every value type', () => {
+        const result = validateSubmission(schema([
+            field('n', 'number'),
+            field('u', 'url'),
+            field('t', 'tel'),
+            field('b', 'boolean'),
+            field('e', 'enum', { options: ['a', 'b'] }),
+        ]), { n: '4.5', u: 'https://example.com/x', t: '+48 600 100 200', b: 'off', e: 'a' });
+        expect(result).toEqual({
+            ok: true,
+            data: { n: 4.5, u: 'https://example.com/x', t: '+48 600 100 200', b: false, e: 'a' },
+        });
+        const bad = validateSubmission(schema([
+            field('n', 'number'),
+            field('u', 'url'),
+            field('t', 'tel'),
+            field('e', 'enum', { options: ['a'] }),
+        ]), { n: 'abc', u: 'javascript:alert(1)', t: 'call me', e: ['a'] });
+        expect(bad).toEqual({
+            ok: false,
+            errors: [
+                { field: 'n', code: 'invalid' },
+                { field: 'u', code: 'invalid' },
+                { field: 't', code: 'invalid' },
+                { field: 'e', code: 'invalid' },
+            ],
+        });
+    });
+    it('omits an empty optional field and requires a required one', () => {
+        const fields = [field('a', 'string'), field('b', 'string', { required: true })];
+        expect(validateSubmission(schema(fields), { a: '  ', b: ' x ' })).toEqual({
+            ok: true,
+            data: { b: 'x' },
+        });
+        expect(validateSubmission(schema(fields), { a: 'x' })).toEqual({
+            ok: false,
+            errors: [{ field: 'b', code: 'required' }],
+        });
+    });
+    it('requires a required checkbox to be ticked', () => {
+        const fields = [field('c', 'boolean', { required: true })];
+        expect(validateSubmission(schema(fields), {}).ok).toBe(false);
+        expect(validateSubmission(schema(fields), { c: 'on' }).ok).toBe(true);
+        expect(validateSubmission(schema(fields), { c: 'maybe' }).ok).toBe(false);
+    });
+    it('does not read inherited properties as values', () => {
+        const result = validateSubmission(schema([field('toString', 'string', { required: true })]), {});
+        expect(result.ok).toBe(false);
+    });
+    it('limits an unlimited text field', () => {
+        expect(validateSubmission(schema([field('a', 'string')]), { a: 'x'.repeat(5001) }).ok).toBe(false);
+    });
+});
+describe('createMemoryRateLimiter', () => {
+    it('allows the limit per window, then refuses until the window ends', () => {
+        let now = 0;
+        const limiter = createMemoryRateLimiter({ limit: 2, windowMs: 1000, now: () => now });
+        expect(limiter.hit('a')).toEqual({ allowed: true });
+        expect(limiter.hit('a')).toEqual({ allowed: true });
+        expect(limiter.hit('a')).toEqual({ allowed: false, retryAfterSeconds: 1 });
+        expect(limiter.hit('b')).toEqual({ allowed: true });
+        now = 1000;
+        expect(limiter.hit('a')).toEqual({ allowed: true });
+    });
+    it('keeps no state between limiters', () => {
+        const one = createMemoryRateLimiter({ limit: 1, windowMs: 1000 });
+        const two = createMemoryRateLimiter({ limit: 1, windowMs: 1000 });
+        one.hit('k');
+        expect(two.hit('k')).toEqual({ allowed: true });
+    });
+});
+describe('isAllowedRecipient', () => {
+    it('matches exact addresses and domains, ignoring case', () => {
+        const list = ['ops@example.com', '@team.example'];
+        expect(isAllowedRecipient('OPS@example.com', list)).toBe(true);
+        expect(isAllowedRecipient('anyone@team.example', list)).toBe(true);
+        expect(isAllowedRecipient('other@example.com', list)).toBe(false);
+        expect(isAllowedRecipient('x@evil-team.example', list)).toBe(false);
+        expect(isAllowedRecipient('a@team.example, b@evil.example', list)).toBe(false);
+    });
+});

package/dist/plugin/forms/notify.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Whether `address` is one the site may send notifications to: an allowlist entry is an exact
+ * address (`ops@example.com`) or a domain (`@example.com`). Comparison ignores case.
+ */
+export declare function isAllowedRecipient(address: string, allowlist: readonly string[]): boolean;
+//# sourceMappingURL=notify.d.ts.map

package/dist/plugin/forms/notify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notify.d.ts","sourceRoot":"","sources":["../../../src/plugin/forms/notify.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAOzF"}

package/dist/plugin/forms/notify.js

@@ -0,0 +1,13 @@
+/**
+ * Whether `address` is one the site may send notifications to: an allowlist entry is an exact
+ * address (`ops@example.com`) or a domain (`@example.com`). Comparison ignores case.
+ */
+export function isAllowedRecipient(address, allowlist) {
+    const value = address.trim().toLowerCase();
+    if (!/^[^\s@,;<>]+@[^\s@,;<>]+$/.test(value))
+        return false;
+    return allowlist.some((entry) => {
+        const allowed = entry.trim().toLowerCase();
+        return allowed.startsWith('@') ? value.endsWith(allowed) : value === allowed;
+    });
+}

package/dist/plugin/forms/rate-limit.d.ts

@@ -0,0 +1,24 @@
+export type RateLimitResult = {
+    readonly allowed: true;
+} | {
+    readonly allowed: false;
+    readonly retryAfterSeconds: number;
+};
+/**
+ * Counts attempts per key. `hit` records one attempt and says whether it may go on. The bundled
+ * implementation lives in one process's memory; behind several serverless instances supply one
+ * backed by a shared store (Redis, ...) through the `forms.rateLimiter` option.
+ */
+export interface RateLimiter {
+    hit(key: string): RateLimitResult | Promise<RateLimitResult>;
+}
+export interface MemoryRateLimiterOptions {
+    /** Attempts allowed per window. */
+    readonly limit: number;
+    readonly windowMs: number;
+    /** Replaceable clock, for tests. */
+    readonly now?: () => number;
+}
+/** A fixed-window counter in memory. Each call creates an independent limiter (no shared state). */
+export declare function createMemoryRateLimiter(options: MemoryRateLimiterOptions): RateLimiter;
+//# sourceMappingURL=rate-limit.d.ts.map

package/dist/plugin/forms/rate-limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.d.ts","sourceRoot":"","sources":["../../../src/plugin/forms/rate-limit.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GACvB;IAAE,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAA;CAAE,GAC1B;IAAE,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpE;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;CAC9D;AAED,MAAM,WAAW,wBAAwB;IACvC,mCAAmC;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,oCAAoC;IACpC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CAC7B;AAKD,oGAAoG;AACpG,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,wBAAwB,GAAG,WAAW,CA6BtF"}

package/dist/plugin/forms/rate-limit.js

@@ -0,0 +1,36 @@
+/** Entries kept at most: a flood of distinct keys cannot grow the map without bound. */
+const MAX_KEYS = 10_000;
+/** A fixed-window counter in memory. Each call creates an independent limiter (no shared state). */
+export function createMemoryRateLimiter(options) {
+    const now = options.now ?? Date.now;
+    const windows = new Map();
+    return {
+        hit(key) {
+            const at = now();
+            if (windows.size >= MAX_KEYS) {
+                for (const [candidate, window] of windows) {
+                    if (window.resetAt <= at)
+                        windows.delete(candidate);
+                }
+                // Still full of live windows: drop the oldest ones.
+                for (const candidate of windows.keys()) {
+                    if (windows.size < MAX_KEYS)
+                        break;
+                    windows.delete(candidate);
+                }
+            }
+            const current = windows.get(key);
+            if (current === undefined || current.resetAt <= at) {
+                windows.set(key, { count: 1, resetAt: at + options.windowMs });
+                return { allowed: true };
+            }
+            current.count += 1;
+            if (current.count <= options.limit)
+                return { allowed: true };
+            return {
+                allowed: false,
+                retryAfterSeconds: Math.max(1, Math.ceil((current.resetAt - at) / 1000)),
+            };
+        },
+    };
+}

package/dist/plugin/forms/validate.d.ts

@@ -0,0 +1,22 @@
+import type { FormSchema } from '@next-buildr/core';
+export type SubmissionErrorCode = 'unknown' | 'required' | 'invalid' | 'too-long';
+export interface SubmissionError {
+    readonly field: string;
+    readonly code: SubmissionErrorCode;
+}
+export type Submission = {
+    readonly ok: true;
+    readonly data: Record<string, string | number | boolean>;
+} | {
+    readonly ok: false;
+    readonly errors: readonly SubmissionError[];
+};
+/** A field without an author-set limit still has one: nobody stores megabytes in a text field. */
+export declare const DEFAULT_MAX_LENGTH = 5000;
+/**
+ * Checks a submission against the schema derived from the published document. The schema is the
+ * only thing that decides: a name it does not contain is an error (`unknown`), never ignored, and
+ * every value is checked against the type, length and options of its field. Never throws.
+ */
+export declare function validateSubmission(schema: FormSchema, input: Readonly<Record<string, unknown>>): Submission;
+//# sourceMappingURL=validate.d.ts.map

package/dist/plugin/forms/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/plugin/forms/validate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAErE,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,UAAU,CAAC;AAElF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;CACpC;AAED,MAAM,MAAM,UAAU,GAClB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAA;CAAE,GAC/E;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAA;CAAE,CAAC;AAExE,kGAAkG;AAClG,eAAO,MAAM,kBAAkB,OAAO,CAAC;AA2DvC;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,UAAU,CAcZ"}

package/dist/plugin/forms/validate.js

@@ -0,0 +1,79 @@
+/** A field without an author-set limit still has one: nobody stores megabytes in a text field. */
+export const DEFAULT_MAX_LENGTH = 5000;
+const EMAIL_MAX = 254;
+const EMAIL = /^[^\s@]+@[^\s@.]+(\.[^\s@.]+)+$/;
+const TEL = /^\+?[0-9()\s.-]{3,32}$/;
+const TRUE = new Set(['true', 'on', '1', 'yes']);
+const FALSE = new Set(['false', 'off', '0', 'no']);
+const isEmpty = (value) => value === undefined || value === null || (typeof value === 'string' && value.trim() === '');
+const bad = (code) => ({ ok: false, code });
+function checkField(field, raw) {
+    if (field.valueType === 'boolean') {
+        let on = false;
+        if (typeof raw === 'boolean')
+            on = raw;
+        else if (typeof raw === 'string' && TRUE.has(raw.toLowerCase()))
+            on = true;
+        else if (raw !== undefined && !(typeof raw === 'string' && FALSE.has(raw.toLowerCase()))) {
+            return bad('invalid');
+        }
+        if (field.required && !on)
+            return bad('required');
+        return { ok: true, value: on };
+    }
+    if (isEmpty(raw))
+        return field.required ? bad('required') : { ok: true, value: undefined };
+    if (field.valueType === 'number') {
+        const parsed = typeof raw === 'number' ? raw : typeof raw === 'string' ? Number(raw.trim()) : Number.NaN;
+        return Number.isFinite(parsed) ? { ok: true, value: parsed } : bad('invalid');
+    }
+    if (typeof raw !== 'string')
+        return bad('invalid');
+    const value = raw.trim();
+    if (value.length > (field.maxLength ?? DEFAULT_MAX_LENGTH))
+        return bad('too-long');
+    switch (field.valueType) {
+        case 'email':
+            return value.length <= EMAIL_MAX && EMAIL.test(value) ? { ok: true, value } : bad('invalid');
+        case 'tel':
+            return TEL.test(value) ? { ok: true, value } : bad('invalid');
+        case 'url': {
+            try {
+                const url = new URL(value);
+                return url.protocol === 'http:' || url.protocol === 'https:'
+                    ? { ok: true, value }
+                    : bad('invalid');
+            }
+            catch {
+                return bad('invalid');
+            }
+        }
+        case 'enum':
+            return field.options?.includes(value) === true ? { ok: true, value } : bad('invalid');
+        default:
+            return { ok: true, value };
+    }
+}
+/**
+ * Checks a submission against the schema derived from the published document. The schema is the
+ * only thing that decides: a name it does not contain is an error (`unknown`), never ignored, and
+ * every value is checked against the type, length and options of its field. Never throws.
+ */
+export function validateSubmission(schema, input) {
+    const errors = [];
+    const known = new Set(schema.fields.map((field) => field.name));
+    for (const name of Object.keys(input)) {
+        if (!known.has(name))
+            errors.push({ field: name, code: 'unknown' });
+    }
+    const data = {};
+    for (const field of schema.fields) {
+        const raw = Object.hasOwn(input, field.name) ? input[field.name] : undefined;
+        const checked = checkField(field, raw);
+        if (!checked.ok)
+            errors.push({ field: field.name, code: checked.code });
+        else if (checked.value !== undefined)
+            data[field.name] = checked.value;
+    }
+    return errors.length > 0 ? { ok: false, errors } : { ok: true, data };
+}

package/dist/plugin/hooks/layout-hook.d.ts

@@ -0,0 +1,9 @@
+import { type FieldHook } from 'payload';
+import type { ResolvedOptions } from '../options.ts';
+/**
+ * The `beforeChange` hook of the `layout` field: the write-guard first (a write that is not the
+ * builder keeps the stored value, which is not re-validated), then `processLayout` for the writes
+ * that are allowed to change it. Invalid documents are rejected with a field error the admin shows.
+ */
+export declare const layoutHook: (options: Pick<ResolvedOptions, 'registry' | 'limits'>) => FieldHook;
+//# sourceMappingURL=layout-hook.d.ts.map

package/dist/plugin/hooks/layout-hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-hook.d.ts","sourceRoot":"","sources":["../../../src/plugin/hooks/layout-hook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAmB,MAAM,SAAS,CAAC;AAE1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAIrD;;;;GAIG;AACH,eAAO,MAAM,UAAU,YACX,IAAI,CAAC,eAAe,EAAE,UAAU,GAAG,QAAQ,CAAC,KAAG,SAsBxD,CAAC"}

package/dist/plugin/hooks/layout-hook.js

@@ -0,0 +1,33 @@
+import { ValidationError } from 'payload';
+import { configuredLocales } from '../locales.js';
+import { BUILDR_WRITE, writeGuard } from '../write-guard.js';
+import { describeDiagnostics, processLayout } from './process-layout.js';
+/**
+ * The `beforeChange` hook of the `layout` field: the write-guard first (a write that is not the
+ * builder keeps the stored value, which is not re-validated), then `processLayout` for the writes
+ * that are allowed to change it. Invalid documents are rejected with a field error the admin shows.
+ */
+export const layoutHook = (options) => (args) => {
+    const guarded = writeGuard('layout')(args);
+    const accepted = args.operation === 'create' || args.req.context[BUILDR_WRITE] === true;
+    if (!accepted)
+        return guarded;
+    // An update that does not carry a layout (a publish, a title edit) leaves it as it is.
+    if (args.operation === 'update' && guarded === undefined)
+        return undefined;
+    const result = processLayout(guarded, {
+        ...options,
+        locales: configuredLocales(args.req.payload.config),
+    });
+    if (!result.ok) {
+        throw new ValidationError({
+            ...(args.collection == null ? {} : { collection: args.collection.slug }),
+            errors: [{ path: 'layout', message: describeDiagnostics(result.diagnostics) }],
+            req: args.req,
+        });
+    }
+    for (const warning of result.warnings) {
+        args.req.payload.logger.warn({ code: warning.code, path: warning.path }, warning.message);
+    }
+    return result.doc;
+};

package/dist/plugin/hooks/layout-hook.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=layout-hook.test.d.ts.map

package/dist/plugin/hooks/layout-hook.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-hook.test.d.ts","sourceRoot":"","sources":["../../../src/plugin/hooks/layout-hook.test.ts"],"names":[],"mappings":""}