@justanarthur/payload-www 0.1.1

package/dist/data-collections.js

@@ -0,0 +1,625 @@
+
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/core/access/index.ts
+var anyone = () => true;
+var authenticated = ({ req: { user } }) => Boolean(user);
+var authenticatedOrPublished = ({ req: { user } }) => {
+  if (user)
+    return true;
+  return { _status: { equals: "published" } };
+};
+
+// src/render/_locale.ts
+function prefixFor(locale, defaultLocale, mode) {
+  if (mode === "never")
+    return "";
+  if (mode === "as-needed" && locale === defaultLocale)
+    return "";
+  return `/${locale}`;
+}
+function resolveLocale(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const r = req;
+  if (typeof r.locale === "string" && r.locale.length > 0)
+    return r.locale;
+  const fallback = r.payload?.config?.localization?.defaultLocale;
+  if (typeof fallback === "string" && fallback.length > 0)
+    return fallback;
+  return "";
+}
+function allLocales(req) {
+  if (!req || typeof req !== "object")
+    return [];
+  const r = req;
+  const list = r.payload?.config?.localization?.locales;
+  if (!Array.isArray(list) || list.length === 0)
+    return [];
+  const out = [];
+  for (const entry of list) {
+    if (typeof entry === "string" && entry.length > 0) {
+      out.push(entry);
+    } else if (entry && typeof entry === "object" && "code" in entry) {
+      const code = entry.code;
+      if (typeof code === "string" && code.length > 0)
+        out.push(code);
+    }
+  }
+  return out;
+}
+
+// src/render/hooks/_shared.ts
+var cachePromise = null;
+function nextCacheImport() {
+  return cachePromise ??= import("next/cache");
+}
+function shouldSkipRevalidate(context) {
+  return Boolean(context?.disableRevalidate);
+}
+async function safeRevalidatePath(payload, path) {
+  try {
+    const { revalidatePath } = await nextCacheImport();
+    revalidatePath(path);
+  } catch (error) {
+    payload.logger.error(`revalidatePath("${path}") failed: ${String(error)}`);
+  }
+}
+async function safeRevalidateTag(payload, tag, profile = "max") {
+  try {
+    const { revalidateTag } = await nextCacheImport();
+    revalidateTag(tag, profile);
+  } catch (error) {
+    payload.logger.error(`revalidateTag("${tag}") failed: ${String(error)}`);
+  }
+}
+
+// src/render/hooks/revalidateCollection.ts
+function createRevalidateCollectionHook(options) {
+  const {
+    collectionSlug,
+    urlPathPrefix = "",
+    sitemapTag,
+    localePrefix: modeOption,
+    defaultLocale: defaultLocaleOption,
+    pathMode = "url"
+  } = options;
+  const resolvedSitemapTag = sitemapTag === false ? false : sitemapTag ?? `${collectionSlug}-sitemap`;
+  const resolveDefaults = (req) => {
+    const mode = modeOption ?? "always";
+    const defaultLocale = defaultLocaleOption ?? req?.payload?.config?.localization?.defaultLocale ?? "";
+    return { mode, defaultLocale };
+  };
+  const localesToFanOut = (req) => {
+    const all = allLocales(req);
+    if (all.length > 0)
+      return all;
+    const single = resolveLocale(req);
+    return single ? [single] : [];
+  };
+  const collectionPath = (slug, locale, mode, defaultLocale) => {
+    const prefix = prefixFor(locale, defaultLocale, mode);
+    if (!slug)
+      return `${prefix}${urlPathPrefix}` || "/";
+    return `${prefix}${urlPathPrefix}/${slug}`;
+  };
+  const fanOutPaths = async (payload, req, slug, label) => {
+    const { mode, defaultLocale } = resolveDefaults(req);
+    const locales = localesToFanOut(req);
+    for (const locale of locales) {
+      const path = collectionPath(slug, locale, mode, defaultLocale);
+      payload.logger.info?.(`${label} ${path}`);
+      await safeRevalidatePath(payload, path);
+    }
+  };
+  const fireCollectionTags = async (payload, docId, req) => {
+    if (typeof docId === "string" || typeof docId === "number") {
+      await safeRevalidateTag(payload, `collection_${collectionSlug}_${docId}`);
+    }
+    if (resolvedSitemapTag !== false) {
+      await safeRevalidateTag(payload, resolvedSitemapTag);
+    }
+  };
+  const afterChange = async ({ doc, previousDoc, req }) => {
+    if (shouldSkipRevalidate(req.context))
+      return doc;
+    const { payload } = req;
+    const typed = doc;
+    const prev = previousDoc;
+    const isPublished = typed._status === "published";
+    const wasPublished = prev?._status === "published";
+    const prevSlugIsString = typeof prev?.slug === "string";
+    const slugChanged = prevSlugIsString && prev?.slug !== typed.slug;
+    if (isPublished) {
+      if (pathMode !== "tag-only") {
+        await fanOutPaths(payload, req, typed.slug, `Revalidating ${collectionSlug} at path:`);
+      }
+      await fireCollectionTags(payload, typed.id, req);
+    }
+    if (wasPublished && (!isPublished || slugChanged)) {
+      if (pathMode !== "tag-only") {
+        await fanOutPaths(payload, req, prev?.slug, `Revalidating old ${collectionSlug} at path:`);
+      }
+      await fireCollectionTags(payload, typed.id, req);
+    }
+    return doc;
+  };
+  const afterDelete = async ({ doc, req }) => {
+    if (shouldSkipRevalidate(req.context))
+      return doc ?? null;
+    const { payload } = req;
+    const typed = doc;
+    if (pathMode !== "tag-only") {
+      await fanOutPaths(payload, req, typed?.slug, `Revalidating deleted ${collectionSlug} at path:`);
+    }
+    await fireCollectionTags(payload, typed?.id, req);
+    return doc ?? null;
+  };
+  return { afterChange, afterDelete };
+}
+var createRevalidatePageHooks = (opts = {}) => createRevalidateCollectionHook({
+  collectionSlug: "pages",
+  urlPathPrefix: "",
+  ...opts
+});
+
+// src/config/constants.ts
+var PAGES_RENDER_PATH = "@justanarthur/payload-www/render-pages#PagesPage";
+var POSTS_RENDER_PATH = "@justanarthur/payload-www/render-pages#PostsPage";
+var HEADER_RENDER_PATH = "@justanarthur/payload-www/render-pages#HeaderPage";
+var FOOTER_RENDER_PATH = "@justanarthur/payload-www/render-pages#FooterPage";
+var LIVE_PREVIEW_LISTENER_PATH = "@justanarthur/payload-www/render-components#LivePreviewListener";
+var PAGES_SLUG = "pages";
+var POSTS_SLUG = "posts";
+var STATIC_PAGES_SLUG = "staticPages";
+
+// src/data/collections/Pages/index.ts
+var HOME_PAGE_SLUG = "";
+var PAGES_SLUG2 = PAGES_SLUG;
+var createPagesCollection = (blocks, options = {}) => {
+  const {
+    renderPath = PAGES_RENDER_PATH,
+    slug: collectionSlug = PAGES_SLUG2,
+    localePrefix,
+    defaultLocale
+  } = options;
+  const slugField = {
+    name: "slug",
+    type: "text",
+    required: true,
+    unique: true,
+    index: true,
+    admin: { position: "sidebar" },
+    validate: (value) => {
+      if (typeof value !== "string")
+        return "Slug must be a string";
+      if (value !== "" && !/^[a-z0-9-]+$/.test(value)) {
+        return "Slug must be lowercase, with hyphens (no spaces or special characters)";
+      }
+      return true;
+    }
+  };
+  const baseFields = [
+    {
+      name: "title",
+      type: "text",
+      required: true,
+      localized: true
+    },
+    {
+      type: "tabs",
+      tabs: [
+        {
+          fields: [
+            {
+              name: "blocks",
+              type: "blocks",
+              blocks,
+              required: true,
+              admin: { initCollapsed: true }
+            }
+          ],
+          label: "Content"
+        }
+      ]
+    },
+    {
+      name: "publishedAt",
+      type: "date",
+      admin: { position: "sidebar" }
+    },
+    slugField
+  ];
+  const { afterChange: revalidateAfterChange, afterDelete: revalidateAfterDelete } = createRevalidateCollectionHook({
+    collectionSlug,
+    urlPathPrefix: "",
+    localePrefix,
+    defaultLocale
+  });
+  return {
+    slug: collectionSlug,
+    custom: { path: renderPath },
+    access: {
+      create: authenticated,
+      delete: authenticated,
+      read: authenticatedOrPublished,
+      update: authenticated
+    },
+    fields: baseFields,
+    hooks: {
+      afterChange: [revalidateAfterChange],
+      afterDelete: [revalidateAfterDelete]
+    },
+    versions: { drafts: { autosave: { interval: 1000 } } }
+  };
+};
+
+// src/data/collections/Posts/index.ts
+var POSTS_SLUG2 = "posts";
+var createPostsCollection = (options = {}) => {
+  const {
+    renderPath = POSTS_RENDER_PATH,
+    slug: collectionSlug = POSTS_SLUG2,
+    localePrefix,
+    defaultLocale
+  } = options;
+  const slugField = {
+    name: "slug",
+    type: "text",
+    required: true,
+    unique: true,
+    index: true,
+    admin: { position: "sidebar" }
+  };
+  const baseFields = [
+    {
+      name: "title",
+      type: "text",
+      required: true,
+      localized: true
+    },
+    {
+      name: "excerpt",
+      type: "text",
+      required: false,
+      localized: true
+    },
+    {
+      name: "content",
+      type: "richText",
+      required: false,
+      localized: true
+    },
+    {
+      name: "publishedAt",
+      type: "date",
+      admin: { position: "sidebar" }
+    },
+    slugField
+  ];
+  const { afterChange, afterDelete } = createRevalidateCollectionHook({
+    collectionSlug,
+    urlPathPrefix: "/posts",
+    localePrefix,
+    defaultLocale
+  });
+  return {
+    slug: collectionSlug,
+    custom: { path: renderPath },
+    access: {
+      create: authenticated,
+      delete: authenticated,
+      read: authenticatedOrPublished,
+      update: authenticated
+    },
+    fields: baseFields,
+    hooks: {
+      afterChange: [afterChange],
+      afterDelete: [afterDelete]
+    },
+    versions: { drafts: { autosave: { interval: 1000 } } }
+  };
+};
+
+// src/data/collections/StaticPages/index.ts
+var createStaticPagesCollection = (blocks) => {
+  const { afterChange, afterDelete } = createRevalidateCollectionHook({
+    collectionSlug: STATIC_PAGES_SLUG,
+    pathMode: "tag-only",
+    sitemapTag: "static-pages"
+  });
+  return {
+    slug: STATIC_PAGES_SLUG,
+    dbName: "sp",
+    admin: { group: "System", useAsTitle: "title" },
+    access: {
+      create: authenticated,
+      delete: authenticated,
+      read: authenticatedOrPublished,
+      update: authenticated
+    },
+    fields: [
+      {
+        name: "kind",
+        type: "select",
+        required: true,
+        unique: true,
+        index: true,
+        options: [
+          { label: "Not found (404)", value: "not-found" },
+          { label: "Server error (500)", value: "server-error" },
+          { label: "Search empty", value: "search-empty" },
+          { label: "Offline", value: "offline" }
+        ],
+        admin: {
+          position: "sidebar",
+          description: "Which system page this row powers. One row per kind."
+        }
+      },
+      {
+        name: "title",
+        type: "text",
+        required: true,
+        localized: true,
+        admin: { description: "Admin-only label. Not rendered." }
+      },
+      {
+        type: "tabs",
+        tabs: [
+          {
+            fields: [
+              {
+                name: "blocks",
+                type: "blocks",
+                localized: true,
+                blocks,
+                admin: { initCollapsed: true },
+                dbName: "b"
+              }
+            ],
+            label: "Content"
+          }
+        ]
+      },
+      {
+        name: "publishedAt",
+        type: "date",
+        admin: { position: "sidebar" }
+      }
+    ],
+    hooks: {
+      afterChange: [afterChange],
+      afterDelete: [afterDelete]
+    },
+    versions: { drafts: { autosave: { interval: 1000 } } }
+  };
+};
+
+// src/core/fields/link.ts
+var appearanceOptions = {
+  default: { label: "Default", value: "default" },
+  outline: { label: "Outline", value: "outline" }
+};
+var link = (options = {}) => {
+  const {
+    appearances,
+    disableLabel = false,
+    relationTo = [PAGES_SLUG],
+    localized = false,
+    overrides = {}
+  } = options;
+  const result = {
+    name: "link",
+    type: "group",
+    admin: { hideGutter: true },
+    fields: [
+      {
+        type: "row",
+        fields: [
+          {
+            name: "type",
+            type: "radio",
+            admin: { layout: "horizontal", width: "50%" },
+            defaultValue: "reference",
+            options: [
+              { label: "Internal link", value: "reference" },
+              { label: "Custom URL", value: "custom" }
+            ]
+          },
+          {
+            name: "newTab",
+            type: "checkbox",
+            admin: { style: { alignSelf: "flex-end" }, width: "50%" },
+            label: "Open in new tab"
+          }
+        ]
+      }
+    ]
+  };
+  const linkTypes = [
+    {
+      name: "reference",
+      type: "relationship",
+      admin: { condition: (_, siblingData) => siblingData?.type === "reference" },
+      label: "Document to link to",
+      relationTo,
+      required: true,
+      localized
+    },
+    {
+      name: "url",
+      type: "text",
+      admin: { condition: (_, siblingData) => siblingData?.type === "custom" },
+      label: "Custom URL",
+      required: true,
+      localized
+    }
+  ];
+  if (!disableLabel) {
+    result.fields.push({
+      type: "row",
+      fields: [
+        ...linkTypes,
+        {
+          name: "label",
+          type: "text",
+          admin: { width: "50%" },
+          label: "Label",
+          required: true,
+          localized
+        }
+      ]
+    });
+  } else {
+    result.fields = [...result.fields, ...linkTypes];
+  }
+  if (appearances !== false) {
+    const opts = appearances ? appearances.map((a) => appearanceOptions[a]) : [appearanceOptions.default, appearanceOptions.outline];
+    result.fields.push({
+      name: "appearance",
+      type: "select",
+      admin: { description: "Choose how the link should be rendered." },
+      defaultValue: "default",
+      options: opts
+    });
+  }
+  return { ...result, ...overrides };
+};
+
+// src/render/hooks/revalidateGlobal.ts
+function createRevalidateGlobalHook(slug) {
+  return async ({ doc, req: { payload, context, locale } }) => {
+    if (shouldSkipRevalidate(context))
+      return doc;
+    const tags = [`global_${slug}`, `global_${slug}_${locale}`];
+    payload.logger.info?.(`Revalidating global: ${tags.join(", ")}`);
+    for (const tag of tags) {
+      await safeRevalidateTag(payload, tag);
+    }
+    return doc;
+  };
+}
+
+// src/data/collections/globals/Header/config.ts
+var createHeaderGlobal = (options = {}) => {
+  const { renderPath = HEADER_RENDER_PATH, linkRelationTo = [PAGES_SLUG] } = options;
+  const navColumnBlock = {
+    slug: "navColumn",
+    fields: [
+      { name: "title", type: "text", required: true, localized: true },
+      { name: "links", type: "array", fields: [link({ appearances: false, localized: true, relationTo: linkRelationTo })] }
+    ]
+  };
+  const navItemBlock = {
+    slug: "navItem",
+    fields: [link({ appearances: false, localized: true, relationTo: linkRelationTo })]
+  };
+  return {
+    slug: "header",
+    custom: { path: renderPath },
+    access: { read: () => true },
+    fields: [
+      {
+        name: "nav",
+        type: "blocks",
+        required: true,
+        blocks: [navColumnBlock, navItemBlock]
+      }
+    ],
+    hooks: {
+      afterChange: [createRevalidateGlobalHook("header")]
+    }
+  };
+};
+
+// src/data/collections/globals/Footer/config.ts
+var createFooterGlobal = (options = {}) => {
+  const { renderPath = FOOTER_RENDER_PATH, linkRelationTo = [PAGES_SLUG] } = options;
+  const navColumnBlock = {
+    slug: "navColumn",
+    fields: [
+      { name: "title", type: "text", required: true, localized: true },
+      { name: "links", type: "array", fields: [link({ appearances: false, localized: true, relationTo: linkRelationTo })] }
+    ]
+  };
+  const navItemBlock = {
+    slug: "navItem",
+    fields: [link({ appearances: false, localized: true, relationTo: linkRelationTo })]
+  };
+  return {
+    slug: "footer",
+    custom: { path: renderPath },
+    access: { read: () => true },
+    fields: [
+      {
+        name: "nav",
+        type: "blocks",
+        required: true,
+        blocks: [navColumnBlock, navItemBlock]
+      }
+    ],
+    hooks: {
+      afterChange: [createRevalidateGlobalHook("footer")]
+    }
+  };
+};
+
+// src/data/collections/previewPath.ts
+var collectionPrefixMap = {
+  posts: "/posts",
+  pages: ""
+};
+function generatePreviewPath({
+  collection,
+  slug
+}) {
+  if (slug === undefined || slug === null)
+    return null;
+  const encodedSlug = encodeURIComponent(slug);
+  const params = new URLSearchParams({
+    path: `${collectionPrefixMap[collection] ?? ""}/${encodedSlug}`,
+    previewSecret: process.env.PREVIEW_SECRET || ""
+  });
+  return `/next/preview?${params.toString()}`;
+}
+
+// src/exports/data-collections.ts
+var data_collections_default = {
+  createPagesCollection,
+  createPostsCollection,
+  createStaticPagesCollection,
+  createHeaderGlobal,
+  createFooterGlobal,
+  generatePreviewPath,
+  HOME_PAGE_SLUG,
+  PAGES_SLUG: PAGES_SLUG2,
+  POSTS_SLUG: POSTS_SLUG2,
+  STATIC_PAGES_SLUG
+};
+export {
+  generatePreviewPath,
+  data_collections_default as default,
+  createStaticPagesCollection,
+  createPostsCollection,
+  createPagesCollection,
+  createHeaderGlobal,
+  createFooterGlobal,
+  STATIC_PAGES_SLUG,
+  POSTS_SLUG2 as POSTS_SLUG,
+  PAGES_SLUG2 as PAGES_SLUG,
+  HOME_PAGE_SLUG
+};

package/dist/data-seed.d.ts

@@ -0,0 +1,76 @@
+import { Payload } from "payload";
+type SeedPageInput = {
+	slug: string;
+	title: Record<string, string>;
+	meta?: Record<string, {
+		title?: string;
+		description?: string;
+	}>;
+	blocks?: Array<Record<string, unknown>>;
+	status?: "draft" | "published";
+	publishedAt?: string;
+};
+type SeedPostInput = {
+	slug: string;
+	title: Record<string, string>;
+	excerpt?: Record<string, string>;
+	content?: Record<string, unknown>;
+	status?: "draft" | "published";
+	publishedAt?: string;
+};
+type SeedUserInput = {
+	email: string;
+	password?: string;
+	name?: string;
+};
+type SeedCategoryInput = {
+	title: string;
+	slug?: string;
+};
+type CreateBaseSeedOptions = {
+	defaultLocale?: string;
+	locales?: string[];
+	users?: SeedUserInput[];
+	categories?: SeedCategoryInput[];
+	pages?: SeedPageInput[];
+	posts?: SeedPostInput[];
+	dryRun?: boolean;
+};
+type CreateBaseSeedResult = {
+	users: Array<{
+		id: string | number;
+		email: string;
+	}>;
+	categories: Array<{
+		id: string | number;
+		title: string;
+		slug: string;
+	}>;
+	pages: Array<{
+		id: string | number;
+		slug: string;
+		locale: string;
+	}>;
+	posts: Array<{
+		id: string | number;
+		slug: string;
+		locale: string;
+	}>;
+};
+/**
+* Idempotent seeder for the lib's collections. Re-running on the
+* same database is a no-op for users (matched by email) and
+* categories (matched by title); pages and posts are matched by
+* slug and re-created if missing.
+*
+* Pages and posts are created once per slug — localized values are
+* stored in a single doc per slug. Tests assert the alternate
+* resolution by querying `locale: 'all'`.
+*
+* Throws on:
+*   - any block slug in a Page's `layout` that doesn't exist on the
+*     Pages collection's `blocks` field
+*   - a block without a `blockType`
+*/
+declare function createBaseSeed(payload: Payload, options?: CreateBaseSeedOptions): Promise<CreateBaseSeedResult>;
+export { createBaseSeed as default, createBaseSeed, SeedUserInput, SeedPostInput, SeedPageInput, SeedCategoryInput, CreateBaseSeedResult, CreateBaseSeedOptions };