@pro-laico/payload-seed 0.0.0

package/dist/engine/run.d.ts

@@ -0,0 +1,46 @@
+import { type Payload, type PayloadRequest } from 'payload';
+import { type ResolvedSeedOptions, type SeedPluginOptions } from '../options';
+import type { SeedDefinition } from '../types';
+import { type DeferredField } from './graph';
+export interface SeedResult {
+    /** Created doc counts keyed by collection slug. */
+    created: Record<string, number>;
+    /** The computed topological create order (doc node ids, `collection:_key`). */
+    order: string[];
+    /** Fields deferred to break a `ref` cycle: created null, then set in a second pass. */
+    deferred: DeferredField[];
+    /** Definitions skipped this run (their own `disabled`, or the collection's `custom.seedDisabled`). */
+    skipped: SkippedDefinition[];
+}
+export interface SkippedDefinition {
+    slug: string;
+    reason: string;
+}
+export interface RunSeedArgs {
+    payload: Payload;
+    req: PayloadRequest;
+    options: ResolvedSeedOptions;
+    /** Seed definitions. Falls back to `options.definitions` when omitted. */
+    definitions?: SeedDefinition[];
+}
+/**
+ * The seed engine. Takes the seed definitions, skips the disabled ones (their own `disabled`, or
+ * the collection's `custom.seedDisabled` — dropping optional refs that point at them), builds the
+ * model, validates references against the live config, topologically sorts the dependency graph,
+ * clears the seeded collections, then creates docs in order — resolving `ref` tokens to ids and
+ * delivering each doc's `_file` as a native upload (upload collections) or a source-field value
+ * (`custom.seedAsset` collections). A `ref` cycle is broken by deferring an optional field, which a
+ * second pass sets once every doc exists (a cycle with only required fields is a hard error).
+ * Globals are updated last.
+ */
+export declare function runSeed({ payload, req, options, definitions }: RunSeedArgs): Promise<SeedResult>;
+/**
+ * CLI / Local-API convenience: run the seed from a script (`payload run`) or test. Builds
+ * a local `req` if one isn't supplied and resolves the public plugin options.
+ */
+export declare function seed(args: {
+    payload: Payload;
+    req?: PayloadRequest;
+    options?: SeedPluginOptions;
+}): Promise<SeedResult>;
+//# sourceMappingURL=run.d.ts.map

package/dist/engine/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/engine/run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuC,KAAK,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,SAAS,CAAA;AAChG,OAAO,EAAkB,KAAK,mBAAmB,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAE7F,OAAO,KAAK,EAAmB,cAAc,EAAsB,MAAM,UAAU,CAAA;AACnF,OAAO,EAAyF,KAAK,aAAa,EAAE,MAAM,SAAS,CAAA;AAKnI,MAAM,WAAW,UAAU;IACzB,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,+EAA+E;IAC/E,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,uFAAuF;IACvF,QAAQ,EAAE,aAAa,EAAE,CAAA;IACzB,sGAAsG;IACtG,OAAO,EAAE,iBAAiB,EAAE,CAAA;CAC7B;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;IACnB,OAAO,EAAE,mBAAmB,CAAA;IAC5B,0EAA0E;IAC1E,WAAW,CAAC,EAAE,cAAc,EAAE,CAAA;CAC/B;AA0JD;;;;;;;;;GASG;AACH,wBAAsB,OAAO,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,WAAW,EAAE,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAkJtG;AAED;;;GAGG;AACH,wBAAsB,IAAI,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,cAAc,CAAC;IAAC,OAAO,CAAC,EAAE,iBAAiB,CAAA;CAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAG7H"}

package/dist/engine/run.js

@@ -0,0 +1,387 @@
+import { createLocalReq } from "payload";
+import { resolveOptions } from "../options.js";
+import { file, isFileToken, isRef, ref } from "../refs.js";
+import { buildGraph } from "./graph.js";
+import { resolveFilePath, readFileAsUpload, searchedDirs } from "./files.js";
+import { collectTokens, docNodeId, resolveTokens } from "./tokens.js";
+import { SeedValidationError, validateModel } from "./validate.js";
+const tokens = {
+    ref,
+    file
+};
+/** Discover asset collections from the live config: any collection whose `custom.seedAsset` is set.
+ *  A `_file` on one of these is handed to the collection's ingest hook via `sourceField` instead of
+ *  uploaded as bytes. Replaces the old `assetProviders` plugin option — declaration now lives on the
+ *  collection, so the seed plugin needs no knowledge of the owning plugins. */ function discoverAssetCollections(payload) {
+    const map = new Map();
+    for (const slug of Object.keys(payload.collections)){
+        const marker = payload.collections[slug]?.config.custom?.seedAsset;
+        if (!marker) continue;
+        const m = marker === true ? {} : marker;
+        map.set(slug, {
+            sourceField: m.sourceField ?? 'source',
+            subdir: m.subdir
+        });
+    }
+    return map;
+}
+/** Split definitions by kind and build the concrete model (records + their `_file`, and globals). */ function buildModel(definitions) {
+    const collections = [];
+    const globals = [];
+    for (const def of definitions){
+        if (def.kind === 'collection') {
+            const records = def.build(tokens).map((rec)=>{
+                const { _key, _file, ...data } = rec;
+                return {
+                    key: _key,
+                    file: isFileToken(_file) ? _file : undefined,
+                    data
+                };
+            });
+            collections.push({
+                slug: def.slug,
+                records
+            });
+        } else if (def.kind === 'global') {
+            globals.push({
+                slug: def.slug,
+                data: def.build(tokens)
+            });
+        }
+    }
+    return {
+        collections,
+        globals
+    };
+}
+/** Split definitions into runnable and skipped. A definition is skipped when its own `disabled` is
+ *  set, or when its target collection declares `custom.seedDisabled` (e.g. a plugin detecting
+ *  missing credentials at config time). Skipped definitions still shaped the generated seed-ref
+ *  types — only the run drops them, so types stay stable across environments. */ function partitionDefinitions(payload, defs) {
+    const active = [];
+    const skipped = [];
+    for (const def of defs){
+        const fromCollection = def.kind === 'collection' ? payload.collections[def.slug]?.config.custom?.seedDisabled : undefined;
+        const flag = def.disabled || fromCollection;
+        if (!flag) {
+            active.push(def);
+            continue;
+        }
+        const reason = typeof flag === 'string' ? flag : 'disabled';
+        skipped.push({
+            slug: def.slug,
+            reason
+        });
+        payload.logger.warn(`[payload-seed] skipping '${def.slug}': ${reason}`);
+    }
+    return {
+        active,
+        skipped
+    };
+}
+/** Drop every optional field whose value contains a `ref()` into a skipped collection (warning per
+ *  drop — the doc won't exist this run), and hard-error when such a ref sits on a required field.
+ *  Runs before validation, so the remaining model checks clean. */ function stripRefsToSkipped(payload, model, skipped, requiredFields) {
+    if (!skipped.length) return;
+    const reasonBySlug = new Map(skipped.map((s)=>[
+            s.slug,
+            s.reason
+        ]));
+    const issues = [];
+    const strip = (where, slug, data)=>{
+        for (const [field, value] of Object.entries(data)){
+            const hit = collectTokens(value).find((t)=>isRef(t) && reasonBySlug.has(t.collection));
+            if (!hit || !isRef(hit)) continue;
+            if (slug && requiredFields.get(slug)?.has(field)) {
+                issues.push(`${where}.${field}: required, but ref('${hit.collection}', '${hit.key}') targets a skipped definition (${reasonBySlug.get(hit.collection)}).`);
+                continue;
+            }
+            delete data[field];
+            payload.logger.warn(`[payload-seed] dropping entire field '${field}' on ${where} (contains ref('${hit.collection}', '${hit.key}') to skipped '${hit.collection}': ${reasonBySlug.get(hit.collection)}).`);
+        }
+    };
+    for (const coll of model.collections)for (const rec of coll.records)strip(docNodeId(coll.slug, rec.key), coll.slug, rec.data);
+    for (const g of model.globals)strip(`global:${g.slug}`, undefined, g.data);
+    if (issues.length) throw new SeedValidationError(issues);
+}
+async function clearCollection(payload, req, collection) {
+    const config = payload.collections[collection]?.config;
+    if (!config) return;
+    payload.logger.info(`[payload-seed] clearing ${collection}`);
+    // Delete via the Local API (firing hooks) when clearing must cascade — an upload collection (to
+    // remove stored bytes) or any collection with a before/after-delete hook (e.g. `mux-video`'s Mux
+    // cleanup, `font`'s cascade to its originals + optimized). Otherwise wipe rows directly.
+    const withHooks = Boolean(config.upload || config.hooks?.beforeDelete?.length || config.hooks?.afterDelete?.length);
+    if (withHooks) {
+        const result = await payload.delete({
+            collection: collection,
+            where: {
+                id: {
+                    exists: true
+                }
+            },
+            req,
+            overrideAccess: true,
+            context: {
+                disableRevalidate: true
+            },
+            disableTransaction: true
+        });
+        // Payload's bulk delete does NOT throw on per-doc failures — it returns them in `errors`.
+        // Retry each once, then warn LOUDLY with the underlying reasons — a silent partial wipe
+        // would leave stale docs sitting beside the fresh seed.
+        const failed = [];
+        for (const e of result?.errors ?? []){
+            if (e.id == null) continue;
+            try {
+                await payload.delete({
+                    collection: collection,
+                    id: e.id,
+                    req,
+                    overrideAccess: true,
+                    context: {
+                        disableRevalidate: true
+                    },
+                    disableTransaction: true
+                });
+            } catch (err) {
+                // Surface the DEEPEST cause: the ORM wraps the driver error ("Failed query: …"), which
+                // hides the actionable part (e.g. "NOT NULL constraint failed: projects_gallery.image_id").
+                let deepest = err instanceof Error ? err : undefined;
+                while(deepest?.cause instanceof Error)deepest = deepest.cause;
+                const reason = (deepest?.message ?? e.message ?? String(err)).replace(/\s+/g, ' ').slice(0, 300);
+                failed.push({
+                    id: e.id,
+                    reason
+                });
+            }
+        }
+        if (failed.length) {
+            const detail = failed.map((f)=>`${f.id}: ${f.reason}`).join(' | ');
+            payload.logger.warn(`[payload-seed] could not clear ${failed.length} doc(s) in '${collection}' — these STALE docs now sit beside the fresh seed; re-run the seed or delete them in the admin. Reasons: ${detail}`);
+        }
+    } else {
+        await payload.db.deleteMany({
+            collection: collection,
+            req,
+            where: {}
+        });
+    }
+    if (config.versions) await payload.db.deleteVersions({
+        collection: collection,
+        req,
+        where: {}
+    });
+}
+/**
+ * The seed engine. Takes the seed definitions, skips the disabled ones (their own `disabled`, or
+ * the collection's `custom.seedDisabled` — dropping optional refs that point at them), builds the
+ * model, validates references against the live config, topologically sorts the dependency graph,
+ * clears the seeded collections, then creates docs in order — resolving `ref` tokens to ids and
+ * delivering each doc's `_file` as a native upload (upload collections) or a source-field value
+ * (`custom.seedAsset` collections). A `ref` cycle is broken by deferring an optional field, which a
+ * second pass sets once every doc exists (a cycle with only required fields is a hard error).
+ * Globals are updated last.
+ */ export async function runSeed({ payload, req, options, definitions }) {
+    const defs = definitions ?? options.definitions ?? [];
+    if (defs.length === 0) payload.logger.warn('[payload-seed] no seed definitions: pass `definitions` to seedPlugin() or seed().');
+    // Drop disabled definitions (their own `disabled`, or the collection's `custom.seedDisabled` —
+    // e.g. payload-mux without credentials). They still shaped the generated seed-ref types.
+    const { active, skipped } = partitionDefinitions(payload, defs);
+    const model = buildModel(active);
+    const collectionSlugs = new Set(Object.keys(payload.collections));
+    const isUpload = (slug)=>Boolean(payload.collections[slug]?.config.upload);
+    const assetBySlug = discoverAssetCollections(payload);
+    // Collections a `_file` may sit on: every upload collection plus every `custom.seedAsset` collection.
+    const fileCollections = new Set([
+        ...collectionSlugs
+    ].filter(isUpload));
+    for (const slug of assetBySlug.keys())fileCollections.add(slug);
+    // Valid top-level field names per node (for unknown-field detection) plus the required ones (so a
+    // ref cycle can only be broken by deferring an optional field) — read from the live config.
+    const fieldNames = new Map();
+    const requiredFields = new Map();
+    for (const coll of model.collections){
+        const cfg = payload.collections[coll.slug]?.config;
+        if (!cfg) continue;
+        fieldNames.set(coll.slug, new Set(cfg.flattenedFields.map((f)=>f.name)));
+        requiredFields.set(coll.slug, new Set(cfg.flattenedFields.filter((f)=>f.required).map((f)=>f.name)));
+    }
+    for (const g of model.globals){
+        const cfg = payload.config.globals.find((gc)=>gc.slug === g.slug);
+        if (cfg) fieldNames.set(`global:${g.slug}`, new Set(cfg.flattenedFields.map((f)=>f.name)));
+    }
+    // Refs into a skipped definition come out of the data before validation: dropped when the field
+    // is optional (the run warns; re-seed once the skip is lifted and they fill in), fatal when it's
+    // required (the doc can't be created without it).
+    stripRefsToSkipped(payload, model, skipped, requiredFields);
+    const globalSlugs = new Set(payload.config.globals.map((g)=>g.slug));
+    validateModel({
+        model,
+        collectionSlugs,
+        globalSlugs,
+        fileCollections,
+        fieldNames
+    });
+    const isRequired = (collection, field)=>requiredFields.get(collection)?.has(field) ?? false;
+    const { order, deferred } = buildGraph(model, {
+        isRequired
+    });
+    // Fields nulled at create time (their refs point into a cycle) and set in a second pass below.
+    const deferredByNode = new Map();
+    for (const d of deferred){
+        const set = deferredByNode.get(d.node) ?? new Set();
+        set.add(d.field);
+        deferredByNode.set(d.node, set);
+    }
+    const baseArgs = {
+        depth: 0,
+        overrideAccess: true,
+        context: {
+            disableRevalidate: true
+        },
+        req
+    };
+    const docIds = new Map();
+    const recordIndex = new Map();
+    for (const coll of model.collections)for (const rec of coll.records)recordIndex.set(docNodeId(coll.slug, rec.key), {
+        slug: coll.slug,
+        record: rec
+    });
+    // Clear every seeded collection — dependents BEFORE their dependencies (the REVERSE of creation
+    // order). Clearing in creation order deletes referenced docs while the previous run's
+    // referencing rows still exist, and on SQL adapters a relationship column can make that delete
+    // FAIL outright (e.g. sqlite generates a required in-array upload as NOT NULL with an
+    // ON DELETE SET NULL foreign key — nulling it violates the constraint), stranding stale docs
+    // beside the fresh seed. `clearCollection` fires delete hooks when the collection needs a
+    // cascade (uploads / external-asset cleanup); plain collections are wiped directly.
+    const seededCollections = [
+        ...new Set(model.collections.map((c)=>c.slug))
+    ];
+    const creationOrder = [];
+    const seen = new Set();
+    for (const nodeId of order){
+        const slug = recordIndex.get(nodeId)?.slug;
+        if (slug && !seen.has(slug)) {
+            seen.add(slug);
+            creationOrder.push(slug);
+        }
+    }
+    // Definitions whose records were all skipped/empty still get cleared (after the ordered ones).
+    for (const slug of seededCollections)if (!seen.has(slug)) creationOrder.push(slug);
+    payload.logger.info('[payload-seed] clearing collections...');
+    for (const slug of [
+        ...creationOrder
+    ].reverse())await clearCollection(payload, req, slug);
+    // Create docs in dependency order, resolving ref tokens to ids and delivering each `_file`.
+    const created = {};
+    payload.logger.info('[payload-seed] seeding documents...');
+    for (const nodeId of order){
+        const entry = recordIndex.get(nodeId);
+        if (!entry) continue;
+        const { slug, record } = entry;
+        // Drop any deferred fields before resolving: their refs point into a cycle and aren't created
+        // yet. The second pass below sets them once every doc exists.
+        const deferFields = deferredByNode.get(nodeId);
+        const source = deferFields ? Object.fromEntries(Object.entries(record.data).filter(([k])=>!deferFields.has(k))) : record.data;
+        let data = resolveTokens(source, {
+            docs: docIds,
+            where: nodeId
+        });
+        let uploadFile;
+        if (record.file) {
+            // Both branches resolve the file the same way — under the per-collection subdir (a
+            // `custom.seedAsset` `subdir`, else `assetSubDirs`, else the slug), then the assets root.
+            const asset = assetBySlug.get(slug);
+            const subdir = asset?.subdir ?? options.assetSubDirs[slug] ?? slug;
+            const subdirs = [
+                subdir,
+                ''
+            ];
+            const path = await resolveFilePath(record.file.name, options.assetsDir, subdirs);
+            if (!path) {
+                const searched = searchedDirs(record.file.name, options.assetsDir, subdirs).join(', ');
+                payload.logger.warn({
+                    msg: `[payload-seed] ${nodeId}: _file '${record.file.name}' not found - skipped. Searched: ${searched}`
+                });
+            } else if (asset) {
+                // Hand the resolved path + options to the collection's ingest hook via its source field
+                // instead of uploading bytes.
+                data = {
+                    ...data,
+                    [asset.sourceField]: {
+                        file: path,
+                        ...record.file.options
+                    }
+                };
+            } else if (isUpload(slug)) {
+                uploadFile = await readFileAsUpload(path);
+            }
+        }
+        payload.logger.info(`[payload-seed] seeding '${nodeId}'`);
+        const doc = await payload.create({
+            collection: slug,
+            data: data,
+            ...uploadFile ? {
+                file: uploadFile
+            } : {},
+            ...baseArgs
+        });
+        docIds.set(nodeId, doc.id);
+        created[slug] = (created[slug] ?? 0) + 1;
+    }
+    // Second pass: now every doc exists, resolve and set the fields deferred to break cycles.
+    if (deferred.length) {
+        payload.logger.info(`[payload-seed] resolving ${deferred.length} deferred reference(s)...`);
+        for (const { node, field } of deferred){
+            const entry = recordIndex.get(node);
+            const id = docIds.get(node);
+            if (!entry || id === undefined) continue;
+            const value = resolveTokens(entry.record.data[field], {
+                docs: docIds,
+                where: `${node}.${field}`
+            });
+            await payload.update({
+                collection: entry.slug,
+                id,
+                data: {
+                    [field]: value
+                },
+                ...baseArgs
+            });
+        }
+    }
+    // Update globals after all docs exist.
+    for (const g of model.globals){
+        payload.logger.info(`[payload-seed] seeding global '${g.slug}'`);
+        const data = resolveTokens(g.data, {
+            docs: docIds,
+            where: `global:${g.slug}`
+        });
+        await payload.updateGlobal({
+            slug: g.slug,
+            data: data,
+            ...baseArgs
+        });
+    }
+    payload.logger.info('[payload-seed] seed complete.');
+    return {
+        created,
+        order,
+        deferred,
+        skipped
+    };
+}
+/**
+ * CLI / Local-API convenience: run the seed from a script (`payload run`) or test. Builds
+ * a local `req` if one isn't supplied and resolves the public plugin options.
+ */ export async function seed(args) {
+    const req = args.req ?? await createLocalReq({}, args.payload);
+    return runSeed({
+        payload: args.payload,
+        req,
+        options: resolveOptions(args.options)
+    });
+}
+
+//# sourceMappingURL=run.js.map

package/dist/engine/run.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/engine/run.ts"],"sourcesContent":["import { type CollectionSlug, createLocalReq, type Payload, type PayloadRequest } from 'payload'\nimport { resolveOptions, type ResolvedSeedOptions, type SeedPluginOptions } from '../options'\nimport { file, isFileToken, isRef, ref } from '../refs'\nimport type { SeedAssetMarker, SeedDefinition, SeedDisabledMarker } from '../types'\nimport { type BuiltCollection, type BuiltGlobal, type BuiltModel, type BuiltRecord, buildGraph, type DeferredField } from './graph'\nimport { resolveFilePath, readFileAsUpload, searchedDirs } from './files'\nimport { collectTokens, docNodeId, resolveTokens } from './tokens'\nimport { SeedValidationError, validateModel } from './validate'\n\nexport interface SeedResult {\n  /** Created doc counts keyed by collection slug. */\n  created: Record<string, number>\n  /** The computed topological create order (doc node ids, `collection:_key`). */\n  order: string[]\n  /** Fields deferred to break a `ref` cycle: created null, then set in a second pass. */\n  deferred: DeferredField[]\n  /** Definitions skipped this run (their own `disabled`, or the collection's `custom.seedDisabled`). */\n  skipped: SkippedDefinition[]\n}\n\nexport interface SkippedDefinition {\n  slug: string\n  reason: string\n}\n\nexport interface RunSeedArgs {\n  payload: Payload\n  req: PayloadRequest\n  options: ResolvedSeedOptions\n  /** Seed definitions. Falls back to `options.definitions` when omitted. */\n  definitions?: SeedDefinition[]\n}\n\nconst tokens = { ref, file }\n\n/** A `custom.seedAsset` collection, resolved to its effective source field (subdir defaults are\n *  applied at lookup, alongside `assetSubDirs`, so they match native uploads). */\ninterface AssetCollection {\n  sourceField: string\n  subdir?: string\n}\n\n/** Discover asset collections from the live config: any collection whose `custom.seedAsset` is set.\n *  A `_file` on one of these is handed to the collection's ingest hook via `sourceField` instead of\n *  uploaded as bytes. Replaces the old `assetProviders` plugin option — declaration now lives on the\n *  collection, so the seed plugin needs no knowledge of the owning plugins. */\nfunction discoverAssetCollections(payload: Payload): Map<string, AssetCollection> {\n  const map = new Map<string, AssetCollection>()\n  for (const slug of Object.keys(payload.collections)) {\n    const marker = payload.collections[slug as CollectionSlug]?.config.custom?.seedAsset as SeedAssetMarker | undefined\n    if (!marker) continue\n    const m = marker === true ? {} : marker\n    map.set(slug, { sourceField: m.sourceField ?? 'source', subdir: m.subdir })\n  }\n  return map\n}\n\n/** Split definitions by kind and build the concrete model (records + their `_file`, and globals). */\nfunction buildModel(definitions: SeedDefinition[]): BuiltModel {\n  const collections: BuiltCollection[] = []\n  const globals: BuiltGlobal[] = []\n\n  for (const def of definitions) {\n    if (def.kind === 'collection') {\n      const records: BuiltRecord[] = def.build(tokens).map((rec) => {\n        const { _key, _file, ...data } = rec as { _key: string; _file?: unknown } & Record<string, unknown>\n        return { key: _key, file: isFileToken(_file) ? _file : undefined, data }\n      })\n      collections.push({ slug: def.slug, records })\n    } else if (def.kind === 'global') {\n      globals.push({ slug: def.slug, data: def.build(tokens) as Record<string, unknown> })\n    }\n  }\n\n  return { collections, globals }\n}\n\n/** Split definitions into runnable and skipped. A definition is skipped when its own `disabled` is\n *  set, or when its target collection declares `custom.seedDisabled` (e.g. a plugin detecting\n *  missing credentials at config time). Skipped definitions still shaped the generated seed-ref\n *  types — only the run drops them, so types stay stable across environments. */\nfunction partitionDefinitions(payload: Payload, defs: SeedDefinition[]): { active: SeedDefinition[]; skipped: SkippedDefinition[] } {\n  const active: SeedDefinition[] = []\n  const skipped: SkippedDefinition[] = []\n  for (const def of defs) {\n    const fromCollection =\n      def.kind === 'collection'\n        ? (payload.collections[def.slug as CollectionSlug]?.config.custom?.seedDisabled as SeedDisabledMarker | undefined)\n        : undefined\n    const flag = def.disabled || fromCollection\n    if (!flag) {\n      active.push(def)\n      continue\n    }\n    const reason = typeof flag === 'string' ? flag : 'disabled'\n    skipped.push({ slug: def.slug, reason })\n    payload.logger.warn(`[payload-seed] skipping '${def.slug}': ${reason}`)\n  }\n  return { active, skipped }\n}\n\n/** Drop every optional field whose value contains a `ref()` into a skipped collection (warning per\n *  drop — the doc won't exist this run), and hard-error when such a ref sits on a required field.\n *  Runs before validation, so the remaining model checks clean. */\nfunction stripRefsToSkipped(payload: Payload, model: BuiltModel, skipped: SkippedDefinition[], requiredFields: Map<string, Set<string>>): void {\n  if (!skipped.length) return\n  const reasonBySlug = new Map(skipped.map((s) => [s.slug, s.reason]))\n  const issues: string[] = []\n\n  const strip = (where: string, slug: string | undefined, data: Record<string, unknown>) => {\n    for (const [field, value] of Object.entries(data)) {\n      const hit = collectTokens(value).find((t) => isRef(t) && reasonBySlug.has(t.collection))\n      if (!hit || !isRef(hit)) continue\n      if (slug && requiredFields.get(slug)?.has(field)) {\n        issues.push(\n          `${where}.${field}: required, but ref('${hit.collection}', '${hit.key}') targets a skipped definition (${reasonBySlug.get(hit.collection)}).`,\n        )\n        continue\n      }\n      delete data[field]\n      payload.logger.warn(\n        `[payload-seed] dropping entire field '${field}' on ${where} (contains ref('${hit.collection}', '${hit.key}') to skipped '${hit.collection}': ${reasonBySlug.get(hit.collection)}).`,\n      )\n    }\n  }\n\n  for (const coll of model.collections) for (const rec of coll.records) strip(docNodeId(coll.slug, rec.key), coll.slug, rec.data)\n  for (const g of model.globals) strip(`global:${g.slug}`, undefined, g.data)\n\n  if (issues.length) throw new SeedValidationError(issues)\n}\n\nasync function clearCollection(payload: Payload, req: PayloadRequest, collection: string): Promise<void> {\n  const config = payload.collections[collection as CollectionSlug]?.config\n  if (!config) return\n  payload.logger.info(`[payload-seed] clearing ${collection}`)\n  // Delete via the Local API (firing hooks) when clearing must cascade — an upload collection (to\n  // remove stored bytes) or any collection with a before/after-delete hook (e.g. `mux-video`'s Mux\n  // cleanup, `font`'s cascade to its originals + optimized). Otherwise wipe rows directly.\n  const withHooks = Boolean(config.upload || config.hooks?.beforeDelete?.length || config.hooks?.afterDelete?.length)\n  if (withHooks) {\n    const result = (await payload.delete({\n      collection: collection as CollectionSlug,\n      where: { id: { exists: true } },\n      req,\n      overrideAccess: true,\n      context: { disableRevalidate: true },\n      disableTransaction: true,\n    })) as { errors?: Array<{ id?: string | number; message?: string }> }\n    // Payload's bulk delete does NOT throw on per-doc failures — it returns them in `errors`.\n    // Retry each once, then warn LOUDLY with the underlying reasons — a silent partial wipe\n    // would leave stale docs sitting beside the fresh seed.\n    const failed: Array<{ id: string | number; reason: string }> = []\n    for (const e of result?.errors ?? []) {\n      if (e.id == null) continue\n      try {\n        await payload.delete({\n          collection: collection as CollectionSlug,\n          id: e.id,\n          req,\n          overrideAccess: true,\n          context: { disableRevalidate: true },\n          disableTransaction: true,\n        })\n      } catch (err) {\n        // Surface the DEEPEST cause: the ORM wraps the driver error (\"Failed query: …\"), which\n        // hides the actionable part (e.g. \"NOT NULL constraint failed: projects_gallery.image_id\").\n        let deepest = err instanceof Error ? err : undefined\n        while (deepest?.cause instanceof Error) deepest = deepest.cause\n        const reason = (deepest?.message ?? e.message ?? String(err)).replace(/\\s+/g, ' ').slice(0, 300)\n        failed.push({ id: e.id, reason })\n      }\n    }\n    if (failed.length) {\n      const detail = failed.map((f) => `${f.id}: ${f.reason}`).join(' | ')\n      payload.logger.warn(\n        `[payload-seed] could not clear ${failed.length} doc(s) in '${collection}' — these STALE docs now sit beside the fresh seed; re-run the seed or delete them in the admin. Reasons: ${detail}`,\n      )\n    }\n  } else {\n    await payload.db.deleteMany({ collection: collection as CollectionSlug, req, where: {} })\n  }\n  if (config.versions) await payload.db.deleteVersions({ collection: collection as CollectionSlug, req, where: {} })\n}\n\n/**\n * The seed engine. Takes the seed definitions, skips the disabled ones (their own `disabled`, or\n * the collection's `custom.seedDisabled` — dropping optional refs that point at them), builds the\n * model, validates references against the live config, topologically sorts the dependency graph,\n * clears the seeded collections, then creates docs in order — resolving `ref` tokens to ids and\n * delivering each doc's `_file` as a native upload (upload collections) or a source-field value\n * (`custom.seedAsset` collections). A `ref` cycle is broken by deferring an optional field, which a\n * second pass sets once every doc exists (a cycle with only required fields is a hard error).\n * Globals are updated last.\n */\nexport async function runSeed({ payload, req, options, definitions }: RunSeedArgs): Promise<SeedResult> {\n  const defs = definitions ?? options.definitions ?? []\n  if (defs.length === 0) payload.logger.warn('[payload-seed] no seed definitions: pass `definitions` to seedPlugin() or seed().')\n\n  // Drop disabled definitions (their own `disabled`, or the collection's `custom.seedDisabled` —\n  // e.g. payload-mux without credentials). They still shaped the generated seed-ref types.\n  const { active, skipped } = partitionDefinitions(payload, defs)\n\n  const model = buildModel(active)\n  const collectionSlugs = new Set(Object.keys(payload.collections))\n\n  const isUpload = (slug: string): boolean => Boolean(payload.collections[slug as CollectionSlug]?.config.upload)\n  const assetBySlug = discoverAssetCollections(payload)\n\n  // Collections a `_file` may sit on: every upload collection plus every `custom.seedAsset` collection.\n  const fileCollections = new Set<string>([...collectionSlugs].filter(isUpload))\n  for (const slug of assetBySlug.keys()) fileCollections.add(slug)\n\n  // Valid top-level field names per node (for unknown-field detection) plus the required ones (so a\n  // ref cycle can only be broken by deferring an optional field) — read from the live config.\n  const fieldNames = new Map<string, Set<string>>()\n  const requiredFields = new Map<string, Set<string>>()\n  for (const coll of model.collections) {\n    const cfg = payload.collections[coll.slug as CollectionSlug]?.config\n    if (!cfg) continue\n    fieldNames.set(coll.slug, new Set(cfg.flattenedFields.map((f) => f.name)))\n    requiredFields.set(coll.slug, new Set(cfg.flattenedFields.filter((f) => (f as { required?: boolean }).required).map((f) => f.name)))\n  }\n  for (const g of model.globals) {\n    const cfg = payload.config.globals.find((gc) => gc.slug === g.slug)\n    if (cfg) fieldNames.set(`global:${g.slug}`, new Set(cfg.flattenedFields.map((f) => f.name)))\n  }\n\n  // Refs into a skipped definition come out of the data before validation: dropped when the field\n  // is optional (the run warns; re-seed once the skip is lifted and they fill in), fatal when it's\n  // required (the doc can't be created without it).\n  stripRefsToSkipped(payload, model, skipped, requiredFields)\n\n  const globalSlugs = new Set(payload.config.globals.map((g) => g.slug))\n  validateModel({ model, collectionSlugs, globalSlugs, fileCollections, fieldNames })\n  const isRequired = (collection: string, field: string): boolean => requiredFields.get(collection)?.has(field) ?? false\n  const { order, deferred } = buildGraph(model, { isRequired })\n\n  // Fields nulled at create time (their refs point into a cycle) and set in a second pass below.\n  const deferredByNode = new Map<string, Set<string>>()\n  for (const d of deferred) {\n    const set = deferredByNode.get(d.node) ?? new Set<string>()\n    set.add(d.field)\n    deferredByNode.set(d.node, set)\n  }\n\n  const baseArgs = { depth: 0, overrideAccess: true, context: { disableRevalidate: true }, req } as const\n\n  const docIds = new Map<string, string | number>()\n  const recordIndex = new Map<string, { slug: string; record: BuiltRecord }>()\n  for (const coll of model.collections)\n    for (const rec of coll.records) recordIndex.set(docNodeId(coll.slug, rec.key), { slug: coll.slug, record: rec })\n\n  // Clear every seeded collection — dependents BEFORE their dependencies (the REVERSE of creation\n  // order). Clearing in creation order deletes referenced docs while the previous run's\n  // referencing rows still exist, and on SQL adapters a relationship column can make that delete\n  // FAIL outright (e.g. sqlite generates a required in-array upload as NOT NULL with an\n  // ON DELETE SET NULL foreign key — nulling it violates the constraint), stranding stale docs\n  // beside the fresh seed. `clearCollection` fires delete hooks when the collection needs a\n  // cascade (uploads / external-asset cleanup); plain collections are wiped directly.\n  const seededCollections = [...new Set(model.collections.map((c) => c.slug))]\n  const creationOrder: string[] = []\n  const seen = new Set<string>()\n  for (const nodeId of order) {\n    const slug = recordIndex.get(nodeId)?.slug\n    if (slug && !seen.has(slug)) {\n      seen.add(slug)\n      creationOrder.push(slug)\n    }\n  }\n  // Definitions whose records were all skipped/empty still get cleared (after the ordered ones).\n  for (const slug of seededCollections) if (!seen.has(slug)) creationOrder.push(slug)\n  payload.logger.info('[payload-seed] clearing collections...')\n  for (const slug of [...creationOrder].reverse()) await clearCollection(payload, req, slug)\n\n  // Create docs in dependency order, resolving ref tokens to ids and delivering each `_file`.\n  const created: Record<string, number> = {}\n\n  payload.logger.info('[payload-seed] seeding documents...')\n  for (const nodeId of order) {\n    const entry = recordIndex.get(nodeId)\n    if (!entry) continue\n    const { slug, record } = entry\n    // Drop any deferred fields before resolving: their refs point into a cycle and aren't created\n    // yet. The second pass below sets them once every doc exists.\n    const deferFields = deferredByNode.get(nodeId)\n    const source = deferFields ? Object.fromEntries(Object.entries(record.data).filter(([k]) => !deferFields.has(k))) : record.data\n    let data = resolveTokens(source, { docs: docIds, where: nodeId }) as Record<string, unknown>\n    let uploadFile: Awaited<ReturnType<typeof readFileAsUpload>> | undefined\n\n    if (record.file) {\n      // Both branches resolve the file the same way — under the per-collection subdir (a\n      // `custom.seedAsset` `subdir`, else `assetSubDirs`, else the slug), then the assets root.\n      const asset = assetBySlug.get(slug)\n      const subdir = asset?.subdir ?? options.assetSubDirs[slug] ?? slug\n      const subdirs = [subdir, '']\n      const path = await resolveFilePath(record.file.name, options.assetsDir, subdirs)\n      if (!path) {\n        const searched = searchedDirs(record.file.name, options.assetsDir, subdirs).join(', ')\n        payload.logger.warn({ msg: `[payload-seed] ${nodeId}: _file '${record.file.name}' not found - skipped. Searched: ${searched}` })\n      } else if (asset) {\n        // Hand the resolved path + options to the collection's ingest hook via its source field\n        // instead of uploading bytes.\n        data = { ...data, [asset.sourceField]: { file: path, ...record.file.options } }\n      } else if (isUpload(slug)) {\n        uploadFile = await readFileAsUpload(path)\n      }\n    }\n\n    payload.logger.info(`[payload-seed] seeding '${nodeId}'`)\n    const doc = (await payload.create({\n      collection: slug as CollectionSlug,\n      data: data as never,\n      ...(uploadFile ? { file: uploadFile } : {}),\n      ...baseArgs,\n    })) as { id: string | number }\n    docIds.set(nodeId, doc.id)\n    created[slug] = (created[slug] ?? 0) + 1\n  }\n\n  // Second pass: now every doc exists, resolve and set the fields deferred to break cycles.\n  if (deferred.length) {\n    payload.logger.info(`[payload-seed] resolving ${deferred.length} deferred reference(s)...`)\n    for (const { node, field } of deferred) {\n      const entry = recordIndex.get(node)\n      const id = docIds.get(node)\n      if (!entry || id === undefined) continue\n      const value = resolveTokens(entry.record.data[field], { docs: docIds, where: `${node}.${field}` })\n      await payload.update({ collection: entry.slug as CollectionSlug, id, data: { [field]: value } as never, ...baseArgs })\n    }\n  }\n\n  // Update globals after all docs exist.\n  for (const g of model.globals) {\n    payload.logger.info(`[payload-seed] seeding global '${g.slug}'`)\n    const data = resolveTokens(g.data, { docs: docIds, where: `global:${g.slug}` }) as Record<string, unknown>\n    await payload.updateGlobal({ slug: g.slug as never, data: data as never, ...baseArgs })\n  }\n\n  payload.logger.info('[payload-seed] seed complete.')\n  return { created, order, deferred, skipped }\n}\n\n/**\n * CLI / Local-API convenience: run the seed from a script (`payload run`) or test. Builds\n * a local `req` if one isn't supplied and resolves the public plugin options.\n */\nexport async function seed(args: { payload: Payload; req?: PayloadRequest; options?: SeedPluginOptions }): Promise<SeedResult> {\n  const req = args.req ?? (await createLocalReq({}, args.payload))\n  return runSeed({ payload: args.payload, req, options: resolveOptions(args.options) })\n}\n"],"names":["createLocalReq","resolveOptions","file","isFileToken","isRef","ref","buildGraph","resolveFilePath","readFileAsUpload","searchedDirs","collectTokens","docNodeId","resolveTokens","SeedValidationError","validateModel","tokens","discoverAssetCollections","payload","map","Map","slug","Object","keys","collections","marker","config","custom","seedAsset","m","set","sourceField","subdir","buildModel","definitions","globals","def","kind","records","build","rec","_key","_file","data","key","undefined","push","partitionDefinitions","defs","active","skipped","fromCollection","seedDisabled","flag","disabled","reason","logger","warn","stripRefsToSkipped","model","requiredFields","length","reasonBySlug","s","issues","strip","where","field","value","entries","hit","find","t","has","collection","get","coll","g","clearCollection","req","info","withHooks","Boolean","upload","hooks","beforeDelete","afterDelete","result","delete","id","exists","overrideAccess","context","disableRevalidate","disableTransaction","failed","e","errors","err","deepest","Error","cause","message","String","replace","slice","detail","f","join","db","deleteMany","versions","deleteVersions","runSeed","options","collectionSlugs","Set","isUpload","assetBySlug","fileCollections","filter","add","fieldNames","cfg","flattenedFields","name","required","gc","globalSlugs","isRequired","order","deferred","deferredByNode","d","node","baseArgs","depth","docIds","recordIndex","record","seededCollections","c","creationOrder","seen","nodeId","reverse","created","entry","deferFields","source","fromEntries","k","docs","uploadFile","asset","assetSubDirs","subdirs","path","assetsDir","searched","msg","doc","create","update","updateGlobal","seed","args"],"mappings":"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"}

package/dist/engine/tokens.d.ts

@@ -0,0 +1,16 @@
+import { type AnyRef } from '../refs';
+/** The map key for a seeded doc node: `collection:_key`. */
+export declare const docNodeId: (collection: string, key: string) => string;
+/** Walk a seed-data value and collect every ref token it contains (drives the dependency graph). */
+export declare function collectTokens(value: unknown, out?: AnyRef[]): AnyRef[];
+export interface ResolveContext {
+    /** `collection:_key` → created doc id. */
+    docs: Map<string, string | number>;
+    /** For error messages. */
+    where: string;
+}
+/** Deep-clone a seed-data value, replacing every ref token with its resolved id. Throws a
+ *  contextual error if a ref can't be resolved (should be impossible after validation +
+ *  topo-sort, but guards against engine bugs). */
+export declare function resolveTokens(value: unknown, ctx: ResolveContext): unknown;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/engine/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../src/engine/tokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAA+B,MAAM,SAAS,CAAA;AAElE,4DAA4D;AAC5D,eAAO,MAAM,SAAS,GAAI,YAAY,MAAM,EAAE,KAAK,MAAM,KAAG,MAAgC,CAAA;AAE5F,oGAAoG;AACpG,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,GAAE,MAAM,EAAO,GAAG,MAAM,EAAE,CAW1E;AAED,MAAM,WAAW,cAAc;IAC7B,0CAA0C;IAC1C,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAA;IAClC,0BAA0B;IAC1B,KAAK,EAAE,MAAM,CAAA;CACd;AAED;;kDAEkD;AAClD,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAU1E"}

package/dist/engine/tokens.js

@@ -0,0 +1,37 @@
+import { isAnyToken, isRef } from "../refs.js";
+/** The map key for a seeded doc node: `collection:_key`. */ export const docNodeId = (collection, key)=>`${collection}:${key}`;
+/** Walk a seed-data value and collect every ref token it contains (drives the dependency graph). */ export function collectTokens(value, out = []) {
+    if (isRef(value)) {
+        out.push(value);
+        return out;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)collectTokens(item, out);
+    } else if (value && typeof value === 'object') {
+        for (const v of Object.values(value))collectTokens(v, out);
+    }
+    return out;
+}
+/** Deep-clone a seed-data value, replacing every ref token with its resolved id. Throws a
+ *  contextual error if a ref can't be resolved (should be impossible after validation +
+ *  topo-sort, but guards against engine bugs). */ export function resolveTokens(value, ctx) {
+    if (isRef(value)) return resolveRef(value, ctx);
+    if (isAnyToken(value)) return value // any non-ref token passes through untouched
+    ;
+    if (Array.isArray(value)) return value.map((item)=>resolveTokens(item, ctx));
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value))out[k] = resolveTokens(v, ctx);
+        return out;
+    }
+    return value;
+}
+function resolveRef(token, ctx) {
+    const id = ctx.docs.get(docNodeId(token.collection, token.key));
+    if (id === undefined) {
+        throw new Error(`[payload-seed] ${ctx.where}: unresolved ref('${token.collection}', '${token.key}') - no seeded doc with that _key.`);
+    }
+    return id;
+}
+
+//# sourceMappingURL=tokens.js.map

package/dist/engine/tokens.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/engine/tokens.ts"],"sourcesContent":["import { type AnyRef, isAnyToken, isRef, type Ref } from '../refs'\n\n/** The map key for a seeded doc node: `collection:_key`. */\nexport const docNodeId = (collection: string, key: string): string => `${collection}:${key}`\n\n/** Walk a seed-data value and collect every ref token it contains (drives the dependency graph). */\nexport function collectTokens(value: unknown, out: AnyRef[] = []): AnyRef[] {\n  if (isRef(value)) {\n    out.push(value)\n    return out\n  }\n  if (Array.isArray(value)) {\n    for (const item of value) collectTokens(item, out)\n  } else if (value && typeof value === 'object') {\n    for (const v of Object.values(value)) collectTokens(v, out)\n  }\n  return out\n}\n\nexport interface ResolveContext {\n  /** `collection:_key` → created doc id. */\n  docs: Map<string, string | number>\n  /** For error messages. */\n  where: string\n}\n\n/** Deep-clone a seed-data value, replacing every ref token with its resolved id. Throws a\n *  contextual error if a ref can't be resolved (should be impossible after validation +\n *  topo-sort, but guards against engine bugs). */\nexport function resolveTokens(value: unknown, ctx: ResolveContext): unknown {\n  if (isRef(value)) return resolveRef(value, ctx)\n  if (isAnyToken(value)) return value // any non-ref token passes through untouched\n  if (Array.isArray(value)) return value.map((item) => resolveTokens(item, ctx))\n  if (value && typeof value === 'object') {\n    const out: Record<string, unknown> = {}\n    for (const [k, v] of Object.entries(value)) out[k] = resolveTokens(v, ctx)\n    return out\n  }\n  return value\n}\n\nfunction resolveRef(token: Ref, ctx: ResolveContext): string | number {\n  const id = ctx.docs.get(docNodeId(token.collection, token.key))\n  if (id === undefined) {\n    throw new Error(`[payload-seed] ${ctx.where}: unresolved ref('${token.collection}', '${token.key}') - no seeded doc with that _key.`)\n  }\n  return id\n}\n"],"names":["isAnyToken","isRef","docNodeId","collection","key","collectTokens","value","out","push","Array","isArray","item","v","Object","values","resolveTokens","ctx","resolveRef","map","k","entries","token","id","docs","get","undefined","Error","where"],"mappings":"AAAA,SAAsBA,UAAU,EAAEC,KAAK,QAAkB,aAAS;AAElE,0DAA0D,GAC1D,OAAO,MAAMC,YAAY,CAACC,YAAoBC,MAAwB,GAAGD,WAAW,CAAC,EAAEC,KAAK,CAAA;AAE5F,kGAAkG,GAClG,OAAO,SAASC,cAAcC,KAAc,EAAEC,MAAgB,EAAE;IAC9D,IAAIN,MAAMK,QAAQ;QAChBC,IAAIC,IAAI,CAACF;QACT,OAAOC;IACT;IACA,IAAIE,MAAMC,OAAO,CAACJ,QAAQ;QACxB,KAAK,MAAMK,QAAQL,MAAOD,cAAcM,MAAMJ;IAChD,OAAO,IAAID,SAAS,OAAOA,UAAU,UAAU;QAC7C,KAAK,MAAMM,KAAKC,OAAOC,MAAM,CAACR,OAAQD,cAAcO,GAAGL;IACzD;IACA,OAAOA;AACT;AASA;;gDAEgD,GAChD,OAAO,SAASQ,cAAcT,KAAc,EAAEU,GAAmB;IAC/D,IAAIf,MAAMK,QAAQ,OAAOW,WAAWX,OAAOU;IAC3C,IAAIhB,WAAWM,QAAQ,OAAOA,MAAM,6CAA6C;;IACjF,IAAIG,MAAMC,OAAO,CAACJ,QAAQ,OAAOA,MAAMY,GAAG,CAAC,CAACP,OAASI,cAAcJ,MAAMK;IACzE,IAAIV,SAAS,OAAOA,UAAU,UAAU;QACtC,MAAMC,MAA+B,CAAC;QACtC,KAAK,MAAM,CAACY,GAAGP,EAAE,IAAIC,OAAOO,OAAO,CAACd,OAAQC,GAAG,CAACY,EAAE,GAAGJ,cAAcH,GAAGI;QACtE,OAAOT;IACT;IACA,OAAOD;AACT;AAEA,SAASW,WAAWI,KAAU,EAAEL,GAAmB;IACjD,MAAMM,KAAKN,IAAIO,IAAI,CAACC,GAAG,CAACtB,UAAUmB,MAAMlB,UAAU,EAAEkB,MAAMjB,GAAG;IAC7D,IAAIkB,OAAOG,WAAW;QACpB,MAAM,IAAIC,MAAM,CAAC,eAAe,EAAEV,IAAIW,KAAK,CAAC,kBAAkB,EAAEN,MAAMlB,UAAU,CAAC,IAAI,EAAEkB,MAAMjB,GAAG,CAAC,kCAAkC,CAAC;IACtI;IACA,OAAOkB;AACT"}

package/dist/engine/validate.d.ts

@@ -0,0 +1,28 @@
+import type { BuiltModel } from './graph';
+export declare class SeedValidationError extends Error {
+    issues: string[];
+    constructor(issues: string[]);
+}
+export interface ValidateArgs {
+    model: BuiltModel;
+    /** Slugs of collections that actually exist in the Payload config. */
+    collectionSlugs: Set<string>;
+    /** Slugs of globals that actually exist in the Payload config. */
+    globalSlugs: Set<string>;
+    /** Slugs that can carry a `_file`: upload collections plus `custom.seedAsset` collections. */
+    fileCollections: Set<string>;
+    /** Valid top-level field names per node (`collection` slug, or `global:<slug>`), from the
+     *  live config's `flattenedFields`. When provided, unknown record fields are flagged —
+     *  the runtime counterpart to the compile-time exactness check. */
+    fieldNames?: Map<string, Set<string>>;
+}
+/**
+ * Validate the built model against the declared docs and the live config: every definition's own
+ * slug exists in the config (as a collection or global, matching its kind); every `ref()`
+ * resolves to a seeded doc and references a real collection; every `_file` sits on a collection
+ * that can take one (an upload or `custom.seedAsset` collection); no duplicate `_key` within a collection
+ * (across every definition sharing the slug); and (when `fieldNames` is supplied) every record field
+ * exists in the schema. Collects ALL issues and throws once. (Cycle detection happens in the graph topo-sort.)
+ */
+export declare function validateModel({ model, collectionSlugs, globalSlugs, fileCollections, fieldNames }: ValidateArgs): void;
+//# sourceMappingURL=validate.d.ts.map

package/dist/engine/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/engine/validate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGzC,qBAAa,mBAAoB,SAAQ,KAAK;IACzB,MAAM,EAAE,MAAM,EAAE;gBAAhB,MAAM,EAAE,MAAM,EAAE;CAIpC;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,UAAU,CAAA;IACjB,sEAAsE;IACtE,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC5B,kEAAkE;IAClE,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACxB,8FAA8F;IAC9F,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC5B;;uEAEmE;IACnE,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;CACtC;AAKD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,EAAE,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,eAAe,EAAE,UAAU,EAAE,EAAE,YAAY,GAAG,IAAI,CA+DtH"}