@pro-laico/payload-seed 0.0.0

package/dist/engine/validate.js

@@ -0,0 +1,79 @@
+import { isRef } from "../refs.js";
+import { collectTokens, docNodeId } from "./tokens.js";
+export class SeedValidationError extends Error {
+    issues;
+    constructor(issues){
+        super(`[payload-seed] seed data failed validation:\n${issues.map((i)=>`  - ${i}`).join('\n')}`), this.issues = issues;
+        this.name = 'SeedValidationError';
+    }
+}
+// Keys that are valid on a record but aren't schema fields.
+const ALLOWED_NON_FIELDS = new Set([
+    '_status'
+]);
+/**
+ * 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 function validateModel({ model, collectionSlugs, globalSlugs, fileCollections, fieldNames }) {
+    const issues = [];
+    const docIds = new Set();
+    for (const coll of model.collections)for (const rec of coll.records)docIds.add(docNodeId(coll.slug, rec.key));
+    // A definition's own slug must exist in the config, or the run would wipe collections and then die mid-create.
+    for (const coll of model.collections){
+        if (!collectionSlugs.has(coll.slug)) {
+            issues.push(`defineSeed('${coll.slug}'): no collection '${coll.slug}' in the Payload config - fix the slug or add the collection.`);
+        }
+    }
+    for (const g of model.globals){
+        if (!globalSlugs.has(g.slug)) {
+            issues.push(`defineSeed('${g.slug}'): no global '${g.slug}' in the Payload config - fix the slug or add the global.`);
+        }
+    }
+    const check = (where, data)=>{
+        for (const token of collectTokens(data)){
+            if (!isRef(token)) continue;
+            if (!collectionSlugs.has(token.collection)) {
+                issues.push(`${where}: ref('${token.collection}', '${token.key}') targets unknown collection '${token.collection}'.`);
+            } else if (!docIds.has(docNodeId(token.collection, token.key))) {
+                issues.push(`${where}: ref('${token.collection}', '${token.key}') - no seeded '${token.collection}' doc has _key '${token.key}'.`);
+            }
+        }
+    };
+    for (const coll of model.collections)for (const rec of coll.records)check(`${coll.slug}:${rec.key}`, rec.data);
+    for (const g of model.globals)check(`global:${g.slug}`, g.data);
+    // A `_file` only makes sense on an upload collection or a `custom.seedAsset` collection.
+    for (const coll of model.collections){
+        for (const rec of coll.records){
+            if (rec.file && !fileCollections.has(coll.slug)) {
+                issues.push(`${coll.slug}:${rec.key}: _file set, but '${coll.slug}' is not an upload collection or a custom.seedAsset collection.`);
+            }
+        }
+    }
+    // Unknown top-level fields (runtime counterpart to the compile-time exactness check).
+    const checkFields = (where, slug, data)=>{
+        const valid = fieldNames?.get(slug);
+        if (!valid) return;
+        for (const key of Object.keys(data)){
+            if (!valid.has(key) && !ALLOWED_NON_FIELDS.has(key)) issues.push(`${where}: unknown field '${key}' - not in the '${slug}' schema.`);
+        }
+    };
+    for (const coll of model.collections)for (const rec of coll.records)checkFields(`${coll.slug}:${rec.key}`, coll.slug, rec.data);
+    for (const g of model.globals)checkFields(`global:${g.slug}`, `global:${g.slug}`, g.data);
+    // Duplicate _key within a collection makes refs ambiguous - checked across every definition sharing the slug.
+    const seenBySlug = new Map();
+    for (const coll of model.collections){
+        const seen = seenBySlug.get(coll.slug) ?? new Set();
+        seenBySlug.set(coll.slug, seen);
+        for (const rec of coll.records){
+            if (seen.has(rec.key)) issues.push(`${coll.slug}: duplicate _key '${rec.key}'.`);
+            seen.add(rec.key);
+        }
+    }
+    if (issues.length) throw new SeedValidationError(issues);
+}
+
+//# sourceMappingURL=validate.js.map

package/dist/engine/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/engine/validate.ts"],"sourcesContent":["import { isRef } from '../refs'\nimport type { BuiltModel } from './graph'\nimport { collectTokens, docNodeId } from './tokens'\n\nexport class SeedValidationError extends Error {\n  constructor(public issues: string[]) {\n    super(`[payload-seed] seed data failed validation:\\n${issues.map((i) => `  - ${i}`).join('\\n')}`)\n    this.name = 'SeedValidationError'\n  }\n}\n\nexport interface ValidateArgs {\n  model: BuiltModel\n  /** Slugs of collections that actually exist in the Payload config. */\n  collectionSlugs: Set<string>\n  /** Slugs of globals that actually exist in the Payload config. */\n  globalSlugs: Set<string>\n  /** Slugs that can carry a `_file`: upload collections plus `custom.seedAsset` collections. */\n  fileCollections: Set<string>\n  /** Valid top-level field names per node (`collection` slug, or `global:<slug>`), from the\n   *  live config's `flattenedFields`. When provided, unknown record fields are flagged —\n   *  the runtime counterpart to the compile-time exactness check. */\n  fieldNames?: Map<string, Set<string>>\n}\n\n// Keys that are valid on a record but aren't schema fields.\nconst ALLOWED_NON_FIELDS = new Set(['_status'])\n\n/**\n * Validate the built model against the declared docs and the live config: every definition's own\n * slug exists in the config (as a collection or global, matching its kind); every `ref()`\n * resolves to a seeded doc and references a real collection; every `_file` sits on a collection\n * that can take one (an upload or `custom.seedAsset` collection); no duplicate `_key` within a collection\n * (across every definition sharing the slug); and (when `fieldNames` is supplied) every record field\n * exists in the schema. Collects ALL issues and throws once. (Cycle detection happens in the graph topo-sort.)\n */\nexport function validateModel({ model, collectionSlugs, globalSlugs, fileCollections, fieldNames }: ValidateArgs): void {\n  const issues: string[] = []\n  const docIds = new Set<string>()\n  for (const coll of model.collections) for (const rec of coll.records) docIds.add(docNodeId(coll.slug, rec.key))\n\n  // A definition's own slug must exist in the config, or the run would wipe collections and then die mid-create.\n  for (const coll of model.collections) {\n    if (!collectionSlugs.has(coll.slug)) {\n      issues.push(`defineSeed('${coll.slug}'): no collection '${coll.slug}' in the Payload config - fix the slug or add the collection.`)\n    }\n  }\n  for (const g of model.globals) {\n    if (!globalSlugs.has(g.slug)) {\n      issues.push(`defineSeed('${g.slug}'): no global '${g.slug}' in the Payload config - fix the slug or add the global.`)\n    }\n  }\n\n  const check = (where: string, data: unknown) => {\n    for (const token of collectTokens(data)) {\n      if (!isRef(token)) continue\n      if (!collectionSlugs.has(token.collection)) {\n        issues.push(`${where}: ref('${token.collection}', '${token.key}') targets unknown collection '${token.collection}'.`)\n      } else if (!docIds.has(docNodeId(token.collection, token.key))) {\n        issues.push(`${where}: ref('${token.collection}', '${token.key}') - no seeded '${token.collection}' doc has _key '${token.key}'.`)\n      }\n    }\n  }\n\n  for (const coll of model.collections) for (const rec of coll.records) check(`${coll.slug}:${rec.key}`, rec.data)\n  for (const g of model.globals) check(`global:${g.slug}`, g.data)\n\n  // A `_file` only makes sense on an upload collection or a `custom.seedAsset` collection.\n  for (const coll of model.collections) {\n    for (const rec of coll.records) {\n      if (rec.file && !fileCollections.has(coll.slug)) {\n        issues.push(`${coll.slug}:${rec.key}: _file set, but '${coll.slug}' is not an upload collection or a custom.seedAsset collection.`)\n      }\n    }\n  }\n\n  // Unknown top-level fields (runtime counterpart to the compile-time exactness check).\n  const checkFields = (where: string, slug: string, data: Record<string, unknown>) => {\n    const valid = fieldNames?.get(slug)\n    if (!valid) return\n    for (const key of Object.keys(data)) {\n      if (!valid.has(key) && !ALLOWED_NON_FIELDS.has(key)) issues.push(`${where}: unknown field '${key}' - not in the '${slug}' schema.`)\n    }\n  }\n  for (const coll of model.collections) for (const rec of coll.records) checkFields(`${coll.slug}:${rec.key}`, coll.slug, rec.data)\n  for (const g of model.globals) checkFields(`global:${g.slug}`, `global:${g.slug}`, g.data)\n\n  // Duplicate _key within a collection makes refs ambiguous - checked across every definition sharing the slug.\n  const seenBySlug = new Map<string, Set<string>>()\n  for (const coll of model.collections) {\n    const seen = seenBySlug.get(coll.slug) ?? new Set<string>()\n    seenBySlug.set(coll.slug, seen)\n    for (const rec of coll.records) {\n      if (seen.has(rec.key)) issues.push(`${coll.slug}: duplicate _key '${rec.key}'.`)\n      seen.add(rec.key)\n    }\n  }\n\n  if (issues.length) throw new SeedValidationError(issues)\n}\n"],"names":["isRef","collectTokens","docNodeId","SeedValidationError","Error","issues","map","i","join","name","ALLOWED_NON_FIELDS","Set","validateModel","model","collectionSlugs","globalSlugs","fileCollections","fieldNames","docIds","coll","collections","rec","records","add","slug","key","has","push","g","globals","check","where","data","token","collection","file","checkFields","valid","get","Object","keys","seenBySlug","Map","seen","set","length"],"mappings":"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"}

package/dist/guard.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Master kill switch for the destructive seed. Both run paths — a CLI runner and the
+ * in-app `POST /api/seed` endpoint — refuse to run unless `ENABLE_SEED` is exactly
+ * `"true"`. The seed WIPES whole collections, so it stays off by default: opt in
+ * per-environment by setting `ENABLE_SEED=true` while iterating, and never set it in
+ * production. The gate lives only on the entry points, never inside the engine, so an
+ * integration test can drive the real seed directly.
+ */
+export declare const seedingEnabled: () => boolean;
+export declare const SEED_DISABLED_MESSAGE = "Seeding is disabled. Set ENABLE_SEED=true to enable it (DESTRUCTIVE: wipes the seeded collections).";
+//# sourceMappingURL=guard.d.ts.map

package/dist/guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard.d.ts","sourceRoot":"","sources":["../src/guard.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,QAAO,OAA6C,CAAA;AAE/E,eAAO,MAAM,qBAAqB,wGAAwG,CAAA"}

package/dist/guard.js

@@ -0,0 +1,11 @@
+/**
+ * Master kill switch for the destructive seed. Both run paths — a CLI runner and the
+ * in-app `POST /api/seed` endpoint — refuse to run unless `ENABLE_SEED` is exactly
+ * `"true"`. The seed WIPES whole collections, so it stays off by default: opt in
+ * per-environment by setting `ENABLE_SEED=true` while iterating, and never set it in
+ * production. The gate lives only on the entry points, never inside the engine, so an
+ * integration test can drive the real seed directly.
+ */ export const seedingEnabled = ()=>process.env.ENABLE_SEED === 'true';
+export const SEED_DISABLED_MESSAGE = 'Seeding is disabled. Set ENABLE_SEED=true to enable it (DESTRUCTIVE: wipes the seeded collections).';
+
+//# sourceMappingURL=guard.js.map

package/dist/guard.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/guard.ts"],"sourcesContent":["/**\n * Master kill switch for the destructive seed. Both run paths — a CLI runner and the\n * in-app `POST /api/seed` endpoint — refuse to run unless `ENABLE_SEED` is exactly\n * `\"true\"`. The seed WIPES whole collections, so it stays off by default: opt in\n * per-environment by setting `ENABLE_SEED=true` while iterating, and never set it in\n * production. The gate lives only on the entry points, never inside the engine, so an\n * integration test can drive the real seed directly.\n */\nexport const seedingEnabled = (): boolean => process.env.ENABLE_SEED === 'true'\n\nexport const SEED_DISABLED_MESSAGE = 'Seeding is disabled. Set ENABLE_SEED=true to enable it (DESTRUCTIVE: wipes the seeded collections).'\n"],"names":["seedingEnabled","process","env","ENABLE_SEED","SEED_DISABLED_MESSAGE"],"mappings":"AAAA;;;;;;;CAOC,GACD,OAAO,MAAMA,iBAAiB,IAAeC,QAAQC,GAAG,CAACC,WAAW,KAAK,OAAM;AAE/E,OAAO,MAAMC,wBAAwB,sGAAqG"}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { seedPlugin } from './plugin';
+export type { SeedPluginOptions } from './options';
+export { defineSeed } from './defineSeed';
+export type { SeedRegistry } from './registry';
+export type { CollectionSeedData, GlobalSeedData, SeedTokens, WithRefs } from './types';
+export type { FileToken, Ref } from './refs';
+export { file, isFileToken, isRef, ref } from './refs';
+export { seed } from './engine/run';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AACrC,YAAY,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAKlD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAGzC,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAM9C,YAAY,EAAE,kBAAkB,EAAE,cAAc,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AACvF,YAAY,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAA;AAG5C,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAA;AAGtD,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA"}

package/dist/index.js

@@ -0,0 +1,13 @@
+// The plugin
+export { seedPlugin } from "./plugin.js";
+// Authoring: define seed data (the `ref` / `file` tokens are supplied to each builder callback —
+// `defineSeed('x', ({ ref, file }) => …)` — so they aren't imported). One helper for both:
+// `defineSeed` infers collection (array of records) vs global (single object) from the slug.
+export { defineSeed } from "./defineSeed.js";
+// The token constructors themselves, for code that builds seed data OUTSIDE a builder
+// callback — e.g. unit tests exercising a composed seed fragment directly.
+export { file, isFileToken, isRef, ref } from "./refs.js";
+// Run the seed from a script or test (the `payload seed` command and endpoint use this)
+export { seed } from "./engine/run.js";
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["// The plugin\nexport { seedPlugin } from './plugin'\nexport type { SeedPluginOptions } from './options'\n\n// Authoring: define seed data (the `ref` / `file` tokens are supplied to each builder callback —\n// `defineSeed('x', ({ ref, file }) => …)` — so they aren't imported). One helper for both:\n// `defineSeed` infers collection (array of records) vs global (single object) from the slug.\nexport { defineSeed } from './defineSeed'\n\n// The augmentable interface that generated types fill in (so `ref` keys are typed)\nexport type { SeedRegistry } from './registry'\n\n// Authoring types for seed helpers COMPOSED across files (e.g. per-block seed fragments that a\n// page definition assembles): `SeedTokens` types a helper's `{ ref, file }` parameter, `WithRefs`\n// widens a generated data type so `Ref` tokens may sit in relationship fields, and `Ref` /\n// `FileToken` are the token value types themselves.\nexport type { CollectionSeedData, GlobalSeedData, SeedTokens, WithRefs } from './types'\nexport type { FileToken, Ref } from './refs'\n// The token constructors themselves, for code that builds seed data OUTSIDE a builder\n// callback — e.g. unit tests exercising a composed seed fragment directly.\nexport { file, isFileToken, isRef, ref } from './refs'\n\n// Run the seed from a script or test (the `payload seed` command and endpoint use this)\nexport { seed } from './engine/run'\n"],"names":["seedPlugin","defineSeed","file","isFileToken","isRef","ref","seed"],"mappings":"AAAA,aAAa;AACb,SAASA,UAAU,QAAQ,cAAU;AAGrC,iGAAiG;AACjG,2FAA2F;AAC3F,6FAA6F;AAC7F,SAASC,UAAU,QAAQ,kBAAc;AAWzC,sFAAsF;AACtF,2EAA2E;AAC3E,SAASC,IAAI,EAAEC,WAAW,EAAEC,KAAK,EAAEC,GAAG,QAAQ,YAAQ;AAEtD,wFAAwF;AACxF,SAASC,IAAI,QAAQ,kBAAc"}

package/dist/options.d.ts

@@ -0,0 +1,29 @@
+import type { CollectionSlug } from 'payload';
+import type { SeedDefinition } from './types';
+export interface SeedPluginOptions {
+    /** The seed definitions (from `defineSeed`). They feed both the
+     *  seed run and the typed `SeedRegistry` injected into `payload-types.ts`. */
+    definitions?: SeedDefinition[];
+    /** The assets root where `_file` source files live, relative to the project root (default
+     *  `assets`). A file is looked up under its per-collection subdir (see {@link assetSubDirs},
+     *  defaulting to the collection slug) and then the root — the same for native uploads and
+     *  `custom.seedAsset` collections. */
+    assetsDir?: string;
+    /** Per-collection subdirectory (under `assetsDir`) for a native upload collection's `_file`
+     *  source files. Defaults to the collection slug — `media` resolves under `<assetsDir>/media/` —
+     *  so name a folder after the collection and it just works. Set an entry to use a different folder
+     *  name, e.g. `{ media: 'images' }`. A `_file` name may also include a relative subpath under the
+     *  resolved folder (`file('portraits/jane.jpg')`) to subdivide further. */
+    assetSubDirs?: Partial<Record<CollectionSlug, string>>;
+    /** Show the "Seed your database" button in the admin header. Default: false. */
+    adminButton?: boolean;
+}
+/** Options with defaults applied (internal). */
+export interface ResolvedSeedOptions {
+    definitions?: SeedDefinition[];
+    assetsDir: string;
+    assetSubDirs: Partial<Record<string, string>>;
+    adminButton: boolean;
+}
+export declare function resolveOptions(options?: SeedPluginOptions): ResolvedSeedOptions;
+//# sourceMappingURL=options.d.ts.map

package/dist/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,MAAM,WAAW,iBAAiB;IAChC;kFAC8E;IAC9E,WAAW,CAAC,EAAE,cAAc,EAAE,CAAA;IAC9B;;;0CAGsC;IACtC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;;+EAI2E;IAC3E,YAAY,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC,CAAA;IACtD,gFAAgF;IAChF,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED,gDAAgD;AAChD,MAAM,WAAW,mBAAmB;IAClC,WAAW,CAAC,EAAE,cAAc,EAAE,CAAA;IAC9B,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAC7C,WAAW,EAAE,OAAO,CAAA;CACrB;AAED,wBAAgB,cAAc,CAAC,OAAO,GAAE,iBAAsB,GAAG,mBAAmB,CAOnF"}

package/dist/options.js

@@ -0,0 +1,10 @@
+export function resolveOptions(options = {}) {
+    return {
+        definitions: options.definitions,
+        assetsDir: options.assetsDir ?? 'assets',
+        assetSubDirs: options.assetSubDirs ?? {},
+        adminButton: options.adminButton ?? false
+    };
+}
+
+//# sourceMappingURL=options.js.map

package/dist/options.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/options.ts"],"sourcesContent":["import type { CollectionSlug } from 'payload'\nimport type { SeedDefinition } from './types'\n\nexport interface SeedPluginOptions {\n  /** The seed definitions (from `defineSeed`). They feed both the\n   *  seed run and the typed `SeedRegistry` injected into `payload-types.ts`. */\n  definitions?: SeedDefinition[]\n  /** The assets root where `_file` source files live, relative to the project root (default\n   *  `assets`). A file is looked up under its per-collection subdir (see {@link assetSubDirs},\n   *  defaulting to the collection slug) and then the root — the same for native uploads and\n   *  `custom.seedAsset` collections. */\n  assetsDir?: string\n  /** Per-collection subdirectory (under `assetsDir`) for a native upload collection's `_file`\n   *  source files. Defaults to the collection slug — `media` resolves under `<assetsDir>/media/` —\n   *  so name a folder after the collection and it just works. Set an entry to use a different folder\n   *  name, e.g. `{ media: 'images' }`. A `_file` name may also include a relative subpath under the\n   *  resolved folder (`file('portraits/jane.jpg')`) to subdivide further. */\n  assetSubDirs?: Partial<Record<CollectionSlug, string>>\n  /** Show the \"Seed your database\" button in the admin header. Default: false. */\n  adminButton?: boolean\n}\n\n/** Options with defaults applied (internal). */\nexport interface ResolvedSeedOptions {\n  definitions?: SeedDefinition[]\n  assetsDir: string\n  assetSubDirs: Partial<Record<string, string>>\n  adminButton: boolean\n}\n\nexport function resolveOptions(options: SeedPluginOptions = {}): ResolvedSeedOptions {\n  return {\n    definitions: options.definitions,\n    assetsDir: options.assetsDir ?? 'assets',\n    assetSubDirs: options.assetSubDirs ?? {},\n    adminButton: options.adminButton ?? false,\n  }\n}\n"],"names":["resolveOptions","options","definitions","assetsDir","assetSubDirs","adminButton"],"mappings":"AA8BA,OAAO,SAASA,eAAeC,UAA6B,CAAC,CAAC;IAC5D,OAAO;QACLC,aAAaD,QAAQC,WAAW;QAChCC,WAAWF,QAAQE,SAAS,IAAI;QAChCC,cAAcH,QAAQG,YAAY,IAAI,CAAC;QACvCC,aAAaJ,QAAQI,WAAW,IAAI;IACtC;AACF"}

package/dist/plugin.d.ts

@@ -0,0 +1,14 @@
+import type { Plugin } from 'payload';
+import { type SeedPluginOptions } from './options';
+/**
+ * The seed plugin. Pass your seed `definitions`; it wires up the rest so a project authors
+ * no seed plumbing:
+ * - `payload seed` — runs the seed (behind the `ENABLE_SEED` guard).
+ * - `POST /api/seed` + the optional admin button — the in-app way to run it.
+ * - typed refs — injects the `SeedRegistry` into `payload-types.ts` via Payload's
+ *   `typescript.postProcess`, so `ref()` keys are checked. Rides `generate:types`.
+ *
+ *   seedPlugin({ definitions: [assets, services, posts], adminButton: true })
+ */
+export declare function seedPlugin(options?: SeedPluginOptions): Plugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAU,MAAM,EAAE,MAAM,SAAS,CAAA;AAE7C,OAAO,EAAE,KAAK,iBAAiB,EAAkB,MAAM,WAAW,CAAA;AAWlE;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,MAAM,CAkClE"}

package/dist/plugin.js

@@ -0,0 +1,73 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createSeedEndpoint } from "./endpoint.js";
+import { resolveOptions } from "./options.js";
+import { buildSeedRegistry } from "./typegen.js";
+/** Absolute path to a bundled bin script, resolving the src→dist swap from this module's
+ *  own location (so it works both in-workspace and when published). */ function binScriptPath(name) {
+    const here = fileURLToPath(import.meta.url);
+    const ext = here.endsWith('.ts') ? 'ts' : 'js';
+    return resolve(dirname(here), 'bin', `${name}.${ext}`);
+}
+/**
+ * The seed plugin. Pass your seed `definitions`; it wires up the rest so a project authors
+ * no seed plumbing:
+ * - `payload seed` — runs the seed (behind the `ENABLE_SEED` guard).
+ * - `POST /api/seed` + the optional admin button — the in-app way to run it.
+ * - typed refs — injects the `SeedRegistry` into `payload-types.ts` via Payload's
+ *   `typescript.postProcess`, so `ref()` keys are checked. Rides `generate:types`.
+ *
+ *   seedPlugin({ definitions: [assets, services, posts], adminButton: true })
+ */ export function seedPlugin(options = {}) {
+    const resolved = resolveOptions(options);
+    return (incomingConfig)=>{
+        const config = {
+            ...incomingConfig,
+            bin: [
+                ...incomingConfig.bin ?? [],
+                {
+                    key: 'seed',
+                    scriptPath: binScriptPath('seed')
+                }
+            ],
+            custom: {
+                ...incomingConfig.custom,
+                payloadSeed: {
+                    options
+                }
+            },
+            endpoints: [
+                ...incomingConfig.endpoints ?? [],
+                createSeedEndpoint(resolved)
+            ]
+        };
+        // Inject the typed ref registry into `payload-types.ts` during type generation, from the
+        // in-memory definitions. Skipped when none are passed (nothing to derive types from).
+        if (resolved.definitions?.length) {
+            const definitions = resolved.definitions;
+            config.typescript = {
+                ...config.typescript,
+                postProcess: [
+                    ...config.typescript?.postProcess ?? [],
+                    ({ compiledTypes })=>`${compiledTypes}\n\n${buildSeedRegistry(definitions)}\n`
+                ]
+            };
+        }
+        if (resolved.adminButton) {
+            const components = config.admin?.components ?? {};
+            config.admin = {
+                ...config.admin,
+                components: {
+                    ...components,
+                    actions: [
+                        ...components.actions ?? [],
+                        '@pro-laico/payload-seed/components/SeedButton#SeedButton'
+                    ]
+                }
+            };
+        }
+        return config;
+    };
+}
+
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/plugin.ts"],"sourcesContent":["import { dirname, resolve } from 'node:path'\nimport { fileURLToPath } from 'node:url'\nimport type { Config, Plugin } from 'payload'\nimport { createSeedEndpoint } from './endpoint'\nimport { type SeedPluginOptions, resolveOptions } from './options'\nimport { buildSeedRegistry } from './typegen'\n\n/** Absolute path to a bundled bin script, resolving the src→dist swap from this module's\n *  own location (so it works both in-workspace and when published). */\nfunction binScriptPath(name: string): string {\n  const here = fileURLToPath(import.meta.url)\n  const ext = here.endsWith('.ts') ? 'ts' : 'js'\n  return resolve(dirname(here), 'bin', `${name}.${ext}`)\n}\n\n/**\n * The seed plugin. Pass your seed `definitions`; it wires up the rest so a project authors\n * no seed plumbing:\n * - `payload seed` — runs the seed (behind the `ENABLE_SEED` guard).\n * - `POST /api/seed` + the optional admin button — the in-app way to run it.\n * - typed refs — injects the `SeedRegistry` into `payload-types.ts` via Payload's\n *   `typescript.postProcess`, so `ref()` keys are checked. Rides `generate:types`.\n *\n *   seedPlugin({ definitions: [assets, services, posts], adminButton: true })\n */\nexport function seedPlugin(options: SeedPluginOptions = {}): Plugin {\n  const resolved = resolveOptions(options)\n\n  return (incomingConfig: Config): Config => {\n    const config: Config = {\n      ...incomingConfig,\n      bin: [...(incomingConfig.bin ?? []), { key: 'seed', scriptPath: binScriptPath('seed') }],\n      custom: { ...incomingConfig.custom, payloadSeed: { options } },\n      endpoints: [...(incomingConfig.endpoints ?? []), createSeedEndpoint(resolved)],\n    }\n\n    // Inject the typed ref registry into `payload-types.ts` during type generation, from the\n    // in-memory definitions. Skipped when none are passed (nothing to derive types from).\n    if (resolved.definitions?.length) {\n      const definitions = resolved.definitions\n      config.typescript = {\n        ...config.typescript,\n        postProcess: [\n          ...(config.typescript?.postProcess ?? []),\n          ({ compiledTypes }) => `${compiledTypes}\\n\\n${buildSeedRegistry(definitions)}\\n`,\n        ],\n      }\n    }\n\n    if (resolved.adminButton) {\n      const components = config.admin?.components ?? {}\n      config.admin = {\n        ...config.admin,\n        components: { ...components, actions: [...(components.actions ?? []), '@pro-laico/payload-seed/components/SeedButton#SeedButton'] },\n      }\n    }\n\n    return config\n  }\n}\n"],"names":["dirname","resolve","fileURLToPath","createSeedEndpoint","resolveOptions","buildSeedRegistry","binScriptPath","name","here","url","ext","endsWith","seedPlugin","options","resolved","incomingConfig","config","bin","key","scriptPath","custom","payloadSeed","endpoints","definitions","length","typescript","postProcess","compiledTypes","adminButton","components","admin","actions"],"mappings":"AAAA,SAASA,OAAO,EAAEC,OAAO,QAAQ,YAAW;AAC5C,SAASC,aAAa,QAAQ,WAAU;AAExC,SAASC,kBAAkB,QAAQ,gBAAY;AAC/C,SAAiCC,cAAc,QAAQ,eAAW;AAClE,SAASC,iBAAiB,QAAQ,eAAW;AAE7C;qEACqE,GACrE,SAASC,cAAcC,IAAY;IACjC,MAAMC,OAAON,cAAc,YAAYO,GAAG;IAC1C,MAAMC,MAAMF,KAAKG,QAAQ,CAAC,SAAS,OAAO;IAC1C,OAAOV,QAAQD,QAAQQ,OAAO,OAAO,GAAGD,KAAK,CAAC,EAAEG,KAAK;AACvD;AAEA;;;;;;;;;CASC,GACD,OAAO,SAASE,WAAWC,UAA6B,CAAC,CAAC;IACxD,MAAMC,WAAWV,eAAeS;IAEhC,OAAO,CAACE;QACN,MAAMC,SAAiB;YACrB,GAAGD,cAAc;YACjBE,KAAK;mBAAKF,eAAeE,GAAG,IAAI,EAAE;gBAAG;oBAAEC,KAAK;oBAAQC,YAAYb,cAAc;gBAAQ;aAAE;YACxFc,QAAQ;gBAAE,GAAGL,eAAeK,MAAM;gBAAEC,aAAa;oBAAER;gBAAQ;YAAE;YAC7DS,WAAW;mBAAKP,eAAeO,SAAS,IAAI,EAAE;gBAAGnB,mBAAmBW;aAAU;QAChF;QAEA,yFAAyF;QACzF,sFAAsF;QACtF,IAAIA,SAASS,WAAW,EAAEC,QAAQ;YAChC,MAAMD,cAAcT,SAASS,WAAW;YACxCP,OAAOS,UAAU,GAAG;gBAClB,GAAGT,OAAOS,UAAU;gBACpBC,aAAa;uBACPV,OAAOS,UAAU,EAAEC,eAAe,EAAE;oBACxC,CAAC,EAAEC,aAAa,EAAE,GAAK,GAAGA,cAAc,IAAI,EAAEtB,kBAAkBkB,aAAa,EAAE,CAAC;iBACjF;YACH;QACF;QAEA,IAAIT,SAASc,WAAW,EAAE;YACxB,MAAMC,aAAab,OAAOc,KAAK,EAAED,cAAc,CAAC;YAChDb,OAAOc,KAAK,GAAG;gBACb,GAAGd,OAAOc,KAAK;gBACfD,YAAY;oBAAE,GAAGA,UAAU;oBAAEE,SAAS;2BAAKF,WAAWE,OAAO,IAAI,EAAE;wBAAG;qBAA2D;gBAAC;YACpI;QACF;QAEA,OAAOf;IACT;AACF"}

package/dist/refs.d.ts

@@ -0,0 +1,56 @@
+import type { RegistryCollectionSlug, RegistryCollections, RegistryKey } from './registry';
+/**
+ * A typed reference to another seeded document, used in place of a raw id inside seed
+ * data. The engine resolves it to the created doc's id at create time and records a
+ * dependency edge (dependent → dependency) for the topological sort and graph. A ref
+ * is the ONLY way to point at another doc — you can't fabricate an id — which is what
+ * makes the dependency graph complete and tamper-resistant.
+ */
+export interface Ref<C extends RegistryCollectionSlug = RegistryCollectionSlug> {
+    readonly __seedRef: 'doc';
+    readonly collection: C;
+    readonly key: RegistryKey<C>;
+}
+/**
+ * A file attached to a seeded upload/provider doc via its `_file` meta-key. Carries a source
+ * filename (resolved under the assets dir at seed time) plus optional provider-specific options.
+ * How the file is delivered depends on the doc's collection:
+ *  - an **upload collection** → the bytes are read and passed as the created doc's upload.
+ *  - a registered **provider collection** (e.g. Mux, fonts) → the resolved path + options are
+ *    handed to the collection's ingest hook via its source field.
+ */
+export interface FileToken {
+    readonly __seedRef: 'file';
+    /** Source filename, resolved under the assets dir (native: searched subdirs; provider: its subdir). */
+    readonly name: string;
+    /** Provider-specific ingest options (e.g. a font `weight`), merged into the provider source field.
+     *  Ignored for native uploads. */
+    readonly options: Record<string, unknown>;
+}
+/** Any edge-creating reference (drives the dependency graph). Only doc refs create edges. */
+export type AnyRef = Ref;
+/** Any seed token that may appear in record data. */
+export type AnyToken = Ref | FileToken;
+/**
+ * Reference a seeded document by collection slug and local `_key`. Type-checked against
+ * the generated {@link SeedRegistry} — once codegen has run, an unknown or removed key
+ * is a TS error at every use site.
+ *
+ *   relatedService: ref('services', 'consulting')
+ */
+export declare function ref<C extends RegistryCollectionSlug>(collection: C, key: RegistryCollections[C] & string): Ref<C>;
+/**
+ * Attach a source file to a seeded doc via its `_file` meta-key. The engine resolves the file
+ * under the assets dir and — depending on the doc's collection — either uploads the bytes
+ * (native upload collection) or hands the path to the collection's ingest hook (provider).
+ *
+ *   { _key: 'lighthouse', _file: file('lighthouse.png'), alt: 'A lighthouse' }   // native upload
+ *   { _key: 'intro', _file: file('intro.mp4'), title: 'Intro' }                   // Mux provider
+ *   { _key: 'inter', _file: file('inter.woff2', { weight: '400' }), family: 'sans' } // fonts provider
+ */
+export declare function file(name: string, options?: Record<string, unknown>): FileToken;
+export declare function isRef(value: unknown): value is Ref;
+export declare function isFileToken(value: unknown): value is FileToken;
+/** Any seed token (doc reference or file). */
+export declare function isAnyToken(value: unknown): value is AnyToken;
+//# sourceMappingURL=refs.d.ts.map

package/dist/refs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refs.d.ts","sourceRoot":"","sources":["../src/refs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE1F;;;;;;GAMG;AACH,MAAM,WAAW,GAAG,CAAC,CAAC,SAAS,sBAAsB,GAAG,sBAAsB;IAC5E,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAA;IACzB,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAA;IACtB,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,CAAA;CAC7B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,uGAAuG;IACvG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB;sCACkC;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC1C;AAED,6FAA6F;AAC7F,MAAM,MAAM,MAAM,GAAG,GAAG,CAAA;AAExB,qDAAqD;AACrD,MAAM,MAAM,QAAQ,GAAG,GAAG,GAAG,SAAS,CAAA;AAEtC;;;;;;GAMG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,sBAAsB,EAAE,UAAU,EAAE,CAAC,EAAE,GAAG,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,CAEjH;AAED;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,SAAS,CAEnF;AAED,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,GAAG,CAElD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAE9D;AAED,8CAA8C;AAC9C,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D"}

package/dist/refs.js

@@ -0,0 +1,39 @@
+/**
+ * Reference a seeded document by collection slug and local `_key`. Type-checked against
+ * the generated {@link SeedRegistry} — once codegen has run, an unknown or removed key
+ * is a TS error at every use site.
+ *
+ *   relatedService: ref('services', 'consulting')
+ */ export function ref(collection, key) {
+    return {
+        __seedRef: 'doc',
+        collection,
+        key: key
+    };
+}
+/**
+ * Attach a source file to a seeded doc via its `_file` meta-key. The engine resolves the file
+ * under the assets dir and — depending on the doc's collection — either uploads the bytes
+ * (native upload collection) or hands the path to the collection's ingest hook (provider).
+ *
+ *   { _key: 'lighthouse', _file: file('lighthouse.png'), alt: 'A lighthouse' }   // native upload
+ *   { _key: 'intro', _file: file('intro.mp4'), title: 'Intro' }                   // Mux provider
+ *   { _key: 'inter', _file: file('inter.woff2', { weight: '400' }), family: 'sans' } // fonts provider
+ */ export function file(name, options = {}) {
+    return {
+        __seedRef: 'file',
+        name,
+        options
+    };
+}
+export function isRef(value) {
+    return typeof value === 'object' && value !== null && value.__seedRef === 'doc';
+}
+export function isFileToken(value) {
+    return typeof value === 'object' && value !== null && value.__seedRef === 'file';
+}
+/** Any seed token (doc reference or file). */ export function isAnyToken(value) {
+    return isRef(value) || isFileToken(value);
+}
+
+//# sourceMappingURL=refs.js.map

package/dist/refs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/refs.ts"],"sourcesContent":["import type { RegistryCollectionSlug, RegistryCollections, RegistryKey } from './registry'\n\n/**\n * A typed reference to another seeded document, used in place of a raw id inside seed\n * data. The engine resolves it to the created doc's id at create time and records a\n * dependency edge (dependent → dependency) for the topological sort and graph. A ref\n * is the ONLY way to point at another doc — you can't fabricate an id — which is what\n * makes the dependency graph complete and tamper-resistant.\n */\nexport interface Ref<C extends RegistryCollectionSlug = RegistryCollectionSlug> {\n  readonly __seedRef: 'doc'\n  readonly collection: C\n  readonly key: RegistryKey<C>\n}\n\n/**\n * A file attached to a seeded upload/provider doc via its `_file` meta-key. Carries a source\n * filename (resolved under the assets dir at seed time) plus optional provider-specific options.\n * How the file is delivered depends on the doc's collection:\n *  - an **upload collection** → the bytes are read and passed as the created doc's upload.\n *  - a registered **provider collection** (e.g. Mux, fonts) → the resolved path + options are\n *    handed to the collection's ingest hook via its source field.\n */\nexport interface FileToken {\n  readonly __seedRef: 'file'\n  /** Source filename, resolved under the assets dir (native: searched subdirs; provider: its subdir). */\n  readonly name: string\n  /** Provider-specific ingest options (e.g. a font `weight`), merged into the provider source field.\n   *  Ignored for native uploads. */\n  readonly options: Record<string, unknown>\n}\n\n/** Any edge-creating reference (drives the dependency graph). Only doc refs create edges. */\nexport type AnyRef = Ref\n\n/** Any seed token that may appear in record data. */\nexport type AnyToken = Ref | FileToken\n\n/**\n * Reference a seeded document by collection slug and local `_key`. Type-checked against\n * the generated {@link SeedRegistry} — once codegen has run, an unknown or removed key\n * is a TS error at every use site.\n *\n *   relatedService: ref('services', 'consulting')\n */\nexport function ref<C extends RegistryCollectionSlug>(collection: C, key: RegistryCollections[C] & string): Ref<C> {\n  return { __seedRef: 'doc', collection, key: key as RegistryKey<C> }\n}\n\n/**\n * Attach a source file to a seeded doc via its `_file` meta-key. The engine resolves the file\n * under the assets dir and — depending on the doc's collection — either uploads the bytes\n * (native upload collection) or hands the path to the collection's ingest hook (provider).\n *\n *   { _key: 'lighthouse', _file: file('lighthouse.png'), alt: 'A lighthouse' }   // native upload\n *   { _key: 'intro', _file: file('intro.mp4'), title: 'Intro' }                   // Mux provider\n *   { _key: 'inter', _file: file('inter.woff2', { weight: '400' }), family: 'sans' } // fonts provider\n */\nexport function file(name: string, options: Record<string, unknown> = {}): FileToken {\n  return { __seedRef: 'file', name, options }\n}\n\nexport function isRef(value: unknown): value is Ref {\n  return typeof value === 'object' && value !== null && (value as { __seedRef?: unknown }).__seedRef === 'doc'\n}\n\nexport function isFileToken(value: unknown): value is FileToken {\n  return typeof value === 'object' && value !== null && (value as { __seedRef?: unknown }).__seedRef === 'file'\n}\n\n/** Any seed token (doc reference or file). */\nexport function isAnyToken(value: unknown): value is AnyToken {\n  return isRef(value) || isFileToken(value)\n}\n"],"names":["ref","collection","key","__seedRef","file","name","options","isRef","value","isFileToken","isAnyToken"],"mappings":"AAsCA;;;;;;CAMC,GACD,OAAO,SAASA,IAAsCC,UAAa,EAAEC,GAAoC;IACvG,OAAO;QAAEC,WAAW;QAAOF;QAAYC,KAAKA;IAAsB;AACpE;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASE,KAAKC,IAAY,EAAEC,UAAmC,CAAC,CAAC;IACtE,OAAO;QAAEH,WAAW;QAAQE;QAAMC;IAAQ;AAC5C;AAEA,OAAO,SAASC,MAAMC,KAAc;IAClC,OAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQ,AAACA,MAAkCL,SAAS,KAAK;AACzG;AAEA,OAAO,SAASM,YAAYD,KAAc;IACxC,OAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQ,AAACA,MAAkCL,SAAS,KAAK;AACzG;AAEA,4CAA4C,GAC5C,OAAO,SAASO,WAAWF,KAAc;IACvC,OAAOD,MAAMC,UAAUC,YAAYD;AACrC"}

package/dist/registry.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The cross-file type bridge. The set of valid reference keys is materialized into types by
+ * the plugin, which injects an augmentation of this interface into the project's
+ * `payload-types.ts` during `payload generate:types` (via `typescript.postProcess`):
+ *
+ *   declare module '@pro-laico/payload-seed' {
+ *     interface SeedRegistry {
+ *       collections: { services: 'consulting' | 'implementation'; posts: 'launch' }
+ *       globals: 'header' | 'footer'
+ *     }
+ *   }
+ *
+ * Once augmented, `ref()` keys are checked against these unions — remove a seeded item's
+ * `_key` and every reference to it becomes a TS error. Before types are generated (interface
+ * empty), the resolvers below fall back to permissive `string` keys, so refs are
+ * runtime-validated only. Progressive: safe without it, fully safe with it.
+ */
+export interface SeedRegistry {
+}
+/** Resolve `SeedRegistry[K]` if augmented, else the permissive default `D`. */
+type Resolve<K extends string, D> = K extends keyof SeedRegistry ? SeedRegistry[K] : D;
+/** Map of collection slug → union of that collection's declared `_key`s. */
+export type RegistryCollections = Resolve<'collections', Record<string, string>>;
+/** Slugs that have at least one seeded doc (the keys of {@link RegistryCollections}). */
+export type RegistryCollectionSlug = keyof RegistryCollections & string;
+/** Valid ref keys for a given collection slug. */
+export type RegistryKey<C extends RegistryCollectionSlug> = RegistryCollections[C] & string;
+/** Union of declared global slugs. */
+export type RegistryGlobal = Resolve<'globals', string>;
+export {};
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,YAAY;CAAG;AAEhC,+EAA+E;AAC/E,KAAK,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,IAAI,CAAC,SAAS,MAAM,YAAY,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;AAEtF,4EAA4E;AAC5E,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;AAEhF,yFAAyF;AACzF,MAAM,MAAM,sBAAsB,GAAG,MAAM,mBAAmB,GAAG,MAAM,CAAA;AAEvE,kDAAkD;AAClD,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,sBAAsB,IAAI,mBAAmB,CAAC,CAAC,CAAC,GAAG,MAAM,CAAA;AAE3F,sCAAsC;AACtC,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,SAAS,EAAE,MAAM,CAAC,CAAA"}

package/dist/registry.js

@@ -0,0 +1,20 @@
+/**
+ * The cross-file type bridge. The set of valid reference keys is materialized into types by
+ * the plugin, which injects an augmentation of this interface into the project's
+ * `payload-types.ts` during `payload generate:types` (via `typescript.postProcess`):
+ *
+ *   declare module '@pro-laico/payload-seed' {
+ *     interface SeedRegistry {
+ *       collections: { services: 'consulting' | 'implementation'; posts: 'launch' }
+ *       globals: 'header' | 'footer'
+ *     }
+ *   }
+ *
+ * Once augmented, `ref()` keys are checked against these unions — remove a seeded item's
+ * `_key` and every reference to it becomes a TS error. Before types are generated (interface
+ * empty), the resolvers below fall back to permissive `string` keys, so refs are
+ * runtime-validated only. Progressive: safe without it, fully safe with it.
+ */ // Intentionally empty — augmented in the project's payload-types.ts during generate:types.
+/** Union of declared global slugs. */ export { };
+
+//# sourceMappingURL=registry.js.map

package/dist/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/registry.ts"],"sourcesContent":["/**\n * The cross-file type bridge. The set of valid reference keys is materialized into types by\n * the plugin, which injects an augmentation of this interface into the project's\n * `payload-types.ts` during `payload generate:types` (via `typescript.postProcess`):\n *\n *   declare module '@pro-laico/payload-seed' {\n *     interface SeedRegistry {\n *       collections: { services: 'consulting' | 'implementation'; posts: 'launch' }\n *       globals: 'header' | 'footer'\n *     }\n *   }\n *\n * Once augmented, `ref()` keys are checked against these unions — remove a seeded item's\n * `_key` and every reference to it becomes a TS error. Before types are generated (interface\n * empty), the resolvers below fall back to permissive `string` keys, so refs are\n * runtime-validated only. Progressive: safe without it, fully safe with it.\n */\n// Intentionally empty — augmented in the project's payload-types.ts during generate:types.\nexport interface SeedRegistry {}\n\n/** Resolve `SeedRegistry[K]` if augmented, else the permissive default `D`. */\ntype Resolve<K extends string, D> = K extends keyof SeedRegistry ? SeedRegistry[K] : D\n\n/** Map of collection slug → union of that collection's declared `_key`s. */\nexport type RegistryCollections = Resolve<'collections', Record<string, string>>\n\n/** Slugs that have at least one seeded doc (the keys of {@link RegistryCollections}). */\nexport type RegistryCollectionSlug = keyof RegistryCollections & string\n\n/** Valid ref keys for a given collection slug. */\nexport type RegistryKey<C extends RegistryCollectionSlug> = RegistryCollections[C] & string\n\n/** Union of declared global slugs. */\nexport type RegistryGlobal = Resolve<'globals', string>\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;CAgBC,GACD,2FAA2F;AAe3F,oCAAoC,GACpC,WAAuD"}

package/dist/typegen.d.ts

@@ -0,0 +1,13 @@
+import type { SeedDefinition } from './types';
+/** Module name whose `SeedRegistry` interface the generated augmentation targets. */
+export declare const SEED_PACKAGE = "@pro-laico/payload-seed";
+/**
+ * Build the `declare module '@pro-laico/payload-seed' { interface SeedRegistry … }`
+ * augmentation from the in-memory seed definitions — collection `_key`s and global slugs. The
+ * plugin appends this to Payload's generated types via `typescript.postProcess`, so `ref()` keys
+ * are type-checked in `payload-types.ts` (rename/remove a seeded item, regenerate, and every
+ * reference errors). No filesystem access — the keys come from the same definition data the engine
+ * seeds.
+ */
+export declare function buildSeedRegistry(definitions: SeedDefinition[], packageName?: string): string;
+//# sourceMappingURL=typegen.d.ts.map

package/dist/typegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typegen.d.ts","sourceRoot":"","sources":["../src/typegen.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,qFAAqF;AACrF,eAAO,MAAM,YAAY,4BAA4B,CAAA;AAKrD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,cAAc,EAAE,EAAE,WAAW,GAAE,MAAqB,GAAG,MAAM,CAiB3G"}

package/dist/typegen.js

@@ -0,0 +1,40 @@
+import { file, ref } from "./refs.js";
+/** Module name whose `SeedRegistry` interface the generated augmentation targets. */ export const SEED_PACKAGE = '@pro-laico/payload-seed';
+const tokens = {
+    ref,
+    file
+};
+const union = (values)=>values.length ? values.map((v)=>`'${v}'`).join(' | ') : 'never';
+/**
+ * Build the `declare module '@pro-laico/payload-seed' { interface SeedRegistry … }`
+ * augmentation from the in-memory seed definitions — collection `_key`s and global slugs. The
+ * plugin appends this to Payload's generated types via `typescript.postProcess`, so `ref()` keys
+ * are type-checked in `payload-types.ts` (rename/remove a seeded item, regenerate, and every
+ * reference errors). No filesystem access — the keys come from the same definition data the engine
+ * seeds.
+ */ export function buildSeedRegistry(definitions, packageName = SEED_PACKAGE) {
+    const collections = {};
+    const globals = new Set();
+    for (const def of definitions){
+        if (def.kind === 'global') globals.add(def.slug);
+        else if (def.kind === 'collection') {
+            collections[def.slug] ??= new Set();
+            const set = collections[def.slug];
+            for (const rec of def.build(tokens))set?.add(rec._key);
+        }
+    }
+    const lines = [
+        `declare module '${packageName}' {`,
+        '  interface SeedRegistry {',
+        '    collections: {'
+    ];
+    for (const slug of Object.keys(collections).sort())lines.push(`      '${slug}': ${union([
+        ...collections[slug] ?? []
+    ].sort())}`);
+    lines.push('    }', `    globals: ${union([
+        ...globals
+    ].sort())}`, '  }', '}');
+    return lines.join('\n');
+}
+
+//# sourceMappingURL=typegen.js.map

package/dist/typegen.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/typegen.ts"],"sourcesContent":["import { file, ref } from './refs'\nimport type { SeedDefinition } from './types'\n\n/** Module name whose `SeedRegistry` interface the generated augmentation targets. */\nexport const SEED_PACKAGE = '@pro-laico/payload-seed'\n\nconst tokens = { ref, file }\nconst union = (values: string[]): string => (values.length ? values.map((v) => `'${v}'`).join(' | ') : 'never')\n\n/**\n * Build the `declare module '@pro-laico/payload-seed' { interface SeedRegistry … }`\n * augmentation from the in-memory seed definitions — collection `_key`s and global slugs. The\n * plugin appends this to Payload's generated types via `typescript.postProcess`, so `ref()` keys\n * are type-checked in `payload-types.ts` (rename/remove a seeded item, regenerate, and every\n * reference errors). No filesystem access — the keys come from the same definition data the engine\n * seeds.\n */\nexport function buildSeedRegistry(definitions: SeedDefinition[], packageName: string = SEED_PACKAGE): string {\n  const collections: Record<string, Set<string>> = {}\n  const globals = new Set<string>()\n\n  for (const def of definitions) {\n    if (def.kind === 'global') globals.add(def.slug)\n    else if (def.kind === 'collection') {\n      collections[def.slug] ??= new Set()\n      const set = collections[def.slug]\n      for (const rec of def.build(tokens)) set?.add((rec as { _key: string })._key)\n    }\n  }\n\n  const lines = [`declare module '${packageName}' {`, '  interface SeedRegistry {', '    collections: {']\n  for (const slug of Object.keys(collections).sort()) lines.push(`      '${slug}': ${union([...(collections[slug] ?? [])].sort())}`)\n  lines.push('    }', `    globals: ${union([...globals].sort())}`, '  }', '}')\n  return lines.join('\\n')\n}\n"],"names":["file","ref","SEED_PACKAGE","tokens","union","values","length","map","v","join","buildSeedRegistry","definitions","packageName","collections","globals","Set","def","kind","add","slug","set","rec","build","_key","lines","Object","keys","sort","push"],"mappings":"AAAA,SAASA,IAAI,EAAEC,GAAG,QAAQ,YAAQ;AAGlC,mFAAmF,GACnF,OAAO,MAAMC,eAAe,0BAAyB;AAErD,MAAMC,SAAS;IAAEF;IAAKD;AAAK;AAC3B,MAAMI,QAAQ,CAACC,SAA8BA,OAAOC,MAAM,GAAGD,OAAOE,GAAG,CAAC,CAACC,IAAM,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAEC,IAAI,CAAC,SAAS;AAEvG;;;;;;;CAOC,GACD,OAAO,SAASC,kBAAkBC,WAA6B,EAAEC,cAAsBV,YAAY;IACjG,MAAMW,cAA2C,CAAC;IAClD,MAAMC,UAAU,IAAIC;IAEpB,KAAK,MAAMC,OAAOL,YAAa;QAC7B,IAAIK,IAAIC,IAAI,KAAK,UAAUH,QAAQI,GAAG,CAACF,IAAIG,IAAI;aAC1C,IAAIH,IAAIC,IAAI,KAAK,cAAc;YAClCJ,WAAW,CAACG,IAAIG,IAAI,CAAC,KAAK,IAAIJ;YAC9B,MAAMK,MAAMP,WAAW,CAACG,IAAIG,IAAI,CAAC;YACjC,KAAK,MAAME,OAAOL,IAAIM,KAAK,CAACnB,QAASiB,KAAKF,IAAI,AAACG,IAAyBE,IAAI;QAC9E;IACF;IAEA,MAAMC,QAAQ;QAAC,CAAC,gBAAgB,EAAEZ,YAAY,GAAG,CAAC;QAAE;QAA8B;KAAqB;IACvG,KAAK,MAAMO,QAAQM,OAAOC,IAAI,CAACb,aAAac,IAAI,GAAIH,MAAMI,IAAI,CAAC,CAAC,OAAO,EAAET,KAAK,GAAG,EAAEf,MAAM;WAAKS,WAAW,CAACM,KAAK,IAAI,EAAE;KAAE,CAACQ,IAAI,KAAK;IACjIH,MAAMI,IAAI,CAAC,SAAS,CAAC,aAAa,EAAExB,MAAM;WAAIU;KAAQ,CAACa,IAAI,KAAK,EAAE,OAAO;IACzE,OAAOH,MAAMf,IAAI,CAAC;AACpB"}