@pro-laico/create-atomic-payload 0.1.4

package/template/src/ui/rowLabels/simpleText.tsx

@@ -0,0 +1,41 @@
+'use client'
+import { SimpleTextChild } from '@/ts/types'
+import { Pill, RowLabel, useRowLabel, SectionTitle } from '@payloadcms/ui'
+
+const TRUNCATE_LENGTH = 50
+const TRUNCATE_SUFFIX = '...'
+
+export const SimpleTextRowLabel = () => {
+  const { data, path, rowNumber } = useRowLabel<SimpleTextChild>()
+  const { text } = data
+
+  let elaborationPill: string | null = null
+  if (text) elaborationPill = text.length > TRUNCATE_LENGTH ? `"${text.slice(0, TRUNCATE_LENGTH)}${TRUNCATE_SUFFIX}"` : `"${text}"`
+
+  const formattedRowNumber = String(rowNumber ?? 0).padStart(2, '0')
+
+  return (
+    <RowLabel
+      path={path}
+      rowNumber={rowNumber}
+      label={
+        <>
+          <span>{formattedRowNumber}</span>
+          <Pill pillStyle="white" size="small">
+            Simple Text
+          </Pill>
+          {elaborationPill && (
+            <Pill pillStyle="white" size="small">
+              {elaborationPill}
+            </Pill>
+          )}
+          <SectionTitle path={`${path}.blockName`} readOnly={false} />
+        </>
+      }
+    />
+  )
+}
+
+SimpleTextRowLabel.displayName = 'SimpleTextRowLabel'
+
+export default SimpleTextRowLabel

package/template/src/utilities/deepMerge.ts

@@ -0,0 +1,30 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+
+/**
+ * Simple object check.
+ * @param item
+ * @returns {boolean}
+ */
+export function isObject(item: unknown): item is object {
+  return typeof item === 'object' && !Array.isArray(item)
+}
+
+/**
+ * Deep merge two objects.
+ * @param target
+ * @param ...sources
+ */
+export default function deepMerge<T, R>(target: T, source: R): T {
+  const output = { ...target }
+  if (isObject(target) && isObject(source)) {
+    Object.keys(source).forEach((key) => {
+      if (isObject(source[key])) {
+        if (!(key in target)) Object.assign(output, { [key]: source[key] })
+        else output[key] = deepMerge(target[key], source[key])
+      } else Object.assign(output, { [key]: source[key] })
+    })
+  }
+
+  return output
+}

package/template/src/utilities/extractSVG.ts

@@ -0,0 +1,9 @@
+export const extractSvgContent = (svgString: string): string => svgString.match(/<svg[^>]*>([\s\S]*)<\/svg>/i)?.[1] || svgString
+
+export const extractSvgProps = (svgString: string): Record<string, string> => {
+  const match = svgString.match(/<svg([^>]*)>/i)
+  if (!match) return {}
+  const props: Record<string, string> = {}
+  for (const [, key, value] of match[1].matchAll(/(\w+)="([^"]*)"/g)) props[key] = value
+  return props
+}

package/template/src/utilities/format/toKebabCase.ts

@@ -0,0 +1,79 @@
+/**
+ * Configuration options for toKebabCase function.
+ *
+ * @options addQuotes, unicodeNormalization, camelCaseHandling, lowercase, dashCollapse, dashTrim
+ */
+export interface NameKebabOptions {
+  /**
+   * Add ' to beginning and end.
+   *
+   * @Default false
+   */
+  addQuotes?: boolean
+  /**
+   * Disable unicode normalization and diacritic removal
+   *
+   * @Default false
+   */
+  unicodeNormalization?: boolean
+  /**
+   * Disable camelCase/PascalCase boundary detection
+   *
+   * @Default false
+   */
+  camelCaseHandling?: boolean
+  /**
+   * Disable conversion to lowercase
+   *
+   * @Default false
+   */
+  lowercase?: boolean
+  /**
+   * Disable collapsing multiple dashes into single dash
+   *
+   * @Default false
+   */
+  dashCollapse?: boolean
+  /**
+   * Disable trimming dashes from start and end
+   *
+   * @Default false
+   */
+  dashTrim?: boolean
+}
+
+/**
+ * Converts a string to kebab-case format by normalizing unicode characters, handling camelCase/PascalCase boundaries, and replacing non-alphanumeric characters with dashes.
+ * Returns an empty string for null/undefined input or when the result would be empty.
+ */
+export function toKebabCase(input?: string | null, options: NameKebabOptions = {}): string {
+  if (!input) return ''
+  let s = input
+
+  // 1. Unicode normalize and strip diacritics: "Crème" -> "Creme"
+  if (options?.unicodeNormalization) s = s.normalize('NFKD').replace(/[\u0300-\u036f]/g, '')
+
+  // 2. Handle camelCase / PascalCase / acronym boundaries:
+  if (options?.camelCaseHandling) {
+    s = s
+      .replace(/([a-z0-9])([A-Z])/g, '$1-$2') // fooBar -> foo-Bar
+      .replace(/([A-Z]+)([A-Z][a-z0-9]+)/g, '$1-$2') // JSONData -> JSON-Data
+  }
+
+  // 3. Replace any run of non-alphanumeric characters with a dash
+  s = s.replace(/[^A-Za-z0-9]+/g, '-')
+
+  // 4. Lowercase
+  if (options?.lowercase) s = s.toLowerCase()
+
+  // 5. Collapse multiple dashes and trim edges
+  if (options?.dashCollapse) s = s.replace(/-+/g, '-')
+
+  // 6. Trim dashes from start and end
+  if (options?.dashTrim) s = s.replace(/^-|-$/g, '')
+
+  // 7. Add quotes if requested
+  if (options?.addQuotes) s = `'${s}'`
+
+  return s
+}

package/template/src/utilities/format/toTitleCase.ts

@@ -0,0 +1,47 @@
+/**
+ * Converts various text formats to Title Case by normalizing unicode characters,
+ * handling different case boundaries, and properly capitalizing words.
+ * Returns an empty string for null/undefined input or when the result would be empty.
+ */
+export function toTitleCase(input?: string | null): string {
+  if (!input) return ''
+
+  // 1. Unicode normalize and strip diacritics: "Crème" -> "Creme"
+  let s = input.normalize('NFKD').replace(/[\u0300-\u036f]/g, '')
+
+  // 2. Handle different case boundaries and separators:
+  s = s
+    // Handle camelCase / PascalCase boundaries
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2') // fooBar -> foo Bar
+    .replace(/([A-Z]+)([A-Z][a-z0-9]+)/g, '$1 $2') // JSONData -> JSON Data
+
+    // Handle kebab-case and snake_case
+    .replace(/[-_]+/g, ' ') // Replace dashes and underscores with spaces
+
+    // Handle other separators (dots, colons, etc.)
+    .replace(/[.\s]+/g, ' ') // Replace dots and multiple spaces with single space
+
+  // 3. Split into words and capitalize each word
+  const words = s.split(/\s+/).filter((word) => word.length > 0)
+
+  if (words.length === 0) return ''
+
+  // 4. Capitalize each word properly
+  const titleCaseWords = words.map((word) => {
+    // Handle acronyms (all caps words)
+    if (/^[A-Z]+$/.test(word)) {
+      return word // Keep acronyms as-is
+    }
+
+    // Handle mixed case words (like "iPhone", "McDonald")
+    if (/^[A-Z][a-z]+$/.test(word)) {
+      return word // Already properly capitalized
+    }
+
+    // Handle words that start with lowercase
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+  })
+
+  // 5. Join words with spaces and trim
+  return titleCaseWords.join(' ').trim()
+}

package/template/src/utilities/formatDurationWithTokens.ts

@@ -0,0 +1,56 @@
+import dayjs from 'dayjs'
+import duration from 'dayjs/plugin/duration'
+
+dayjs.extend(duration)
+
+export function formatDurationString(ms: number, template: string): string {
+  const dur = dayjs.duration(ms)
+
+  const tokens: Record<string, () => string> = {
+    '{d}': () => {
+      const d = dur.days()
+      return d > 0 ? `${d} day${d !== 1 ? 's' : ''}` : '0 days'
+    },
+    '{dh}': () => {
+      const d = dur.days()
+      const h = dur.hours()
+      const parts = []
+      if (d > 0) parts.push(`${d} day${d !== 1 ? 's' : ''}`)
+      if (h > 0) parts.push(`${h} hour${h !== 1 ? 's' : ''}`)
+      return parts.join(' and ') || '0 hours'
+    },
+    '{h}': () => {
+      const h = dur.asHours()
+      const whole = Math.floor(h)
+      return `${whole} hour${whole !== 1 ? 's' : ''}`
+    },
+    '{hm}': () => {
+      const h = dur.hours()
+      const m = dur.minutes()
+      const parts = []
+      if (h > 0) parts.push(`${h} hour${h !== 1 ? 's' : ''}`)
+      if (m > 0) parts.push(`${m} minute${m !== 1 ? 's' : ''}`)
+      return parts.join(' and ') || '0 minutes'
+    },
+    '{m}': () => {
+      const m = Math.floor(dur.asMinutes())
+      return `${m} minute${m !== 1 ? 's' : ''}`
+    },
+    '{ms}': () => {
+      const m = dur.minutes()
+      const s = dur.seconds()
+      const parts = []
+      if (m > 0) parts.push(`${m} minute${m !== 1 ? 's' : ''}`)
+      if (s > 0) parts.push(`${s} second${s !== 1 ? 's' : ''}`)
+      return parts.join(' and ') || '0 seconds'
+    },
+    '{s}': () => {
+      const s = Math.floor(dur.asSeconds())
+      return `${s} second${s !== 1 ? 's' : ''}`
+    },
+  }
+
+  return template.replace(/\{[a-z]+\}/g, (match) => {
+    return tokens[match]?.() ?? match
+  })
+}

package/template/src/utilities/generateMetaData.ts

@@ -0,0 +1,45 @@
+import { Metadata } from 'next'
+import { PageReturn, SiteMetaDatum, Image } from '@/ts/types'
+
+type GenerateMetaDataArgs = { page?: PageReturn; siteMetadata?: SiteMetaDatum }
+type GenerateMetaData = (args: GenerateMetaDataArgs) => Metadata
+
+const processImageUrl = (image: Image | string | null | undefined): string | undefined => {
+  if (!image || typeof image === 'string') return
+  const url = image.sizes?.og?.url || image.url
+  return url || undefined
+}
+
+/** Gets the page metadata for a given page and site metadata. Returns a finished Metadata object.*/
+export const GenerateMetaData: GenerateMetaData = ({ page, siteMetadata }) => {
+  const { siteName, fallbackOGImage, fallbackLightFavicon, fallbackDarkFavicon, fallbackSiteDescription } = siteMetadata || {}
+  const { title, description, image, lightFavicon, darkFavicon, noIndex } = page?.meta || {}
+
+  const imageUrl = processImageUrl(image)
+  const darkFaviconUrl = processImageUrl(darkFavicon)
+  const lightFaviconUrl = processImageUrl(lightFavicon)
+  const fallbackOGImageUrl = processImageUrl(fallbackOGImage)
+  const fallbackDarkFaviconUrl = processImageUrl(fallbackDarkFavicon)
+  const fallbackLightFaviconUrl = processImageUrl(fallbackLightFavicon)
+
+  const metadata: Metadata = {
+    title: title || siteName || 'Atomic Payload',
+    robots: page ? (noIndex ? 'noindex' : 'index, follow') : 'noindex',
+    description: description || fallbackSiteDescription || '',
+    openGraph: {
+      siteName: siteName || 'Atomic Payload',
+      images: imageUrl || fallbackOGImageUrl || undefined,
+      description: description || fallbackSiteDescription || '',
+    },
+  }
+
+  const icons: Metadata['icons'] = []
+
+  if (lightFaviconUrl) icons.push({ url: lightFaviconUrl })
+  if (darkFaviconUrl) icons.push({ url: darkFaviconUrl, media: '(prefers-color-scheme: dark)' })
+  if (fallbackLightFaviconUrl && !lightFaviconUrl) icons.push({ url: fallbackLightFaviconUrl })
+  if (fallbackDarkFaviconUrl && !darkFaviconUrl) icons.push({ url: fallbackDarkFaviconUrl, media: '(prefers-color-scheme: dark)' })
+
+  const result = { ...metadata, icons }
+  return result
+}

package/template/src/utilities/generatePreviewPath.ts

@@ -0,0 +1,43 @@
+import { PayloadRequest } from 'payload'
+import { getClientSideURL } from './get/getURL'
+
+type Props = {
+  data: Partial<any>
+  req: PayloadRequest
+}
+
+export const generateLivePreviewPath = async ({ data, req: { payload } }: Props): Promise<string> => {
+  try {
+    let slug = typeof data?.title === 'string' ? data.title : 'testing'
+    let path = '/testing'
+    // Because href is updated by the field, we need to use breadcrumbs to get the latest href.
+    const href = data?.breadcrumbs && data?.breadcrumbs?.length > 0 ? data?.breadcrumbs[data?.breadcrumbs?.length - 1]?.url : undefined
+
+    //Handle For Collections With Test Path
+    if (typeof data?.testPath === 'string') {
+      try {
+        const page = await payload.findByID({ collection: 'pages', id: data?.testPath, select: { href: true } })
+        if (page?.href) path = page.href
+        //eslint-disable-next-line @typescript-eslint/no-unused-vars
+      } catch (error) {
+        payload.logger.info('No Page Found. Loading /testing instead.')
+      }
+    }
+
+    //Handle For Collections With Href
+    if (typeof href === 'string') {
+      path = href
+      if (typeof data?.slug === 'string') slug = data.slug || 'home'
+    }
+
+    const encodedParams = new URLSearchParams({ slug, path, collection: 'pages', previewSecret: process.env.PREVIEW_SECRET || '' })
+
+    const url = `/next/preview?${encodedParams.toString()}`
+
+    return getClientSideURL() + url
+    //eslint-disable-next-line @typescript-eslint/no-unused-vars
+  } catch (error) {
+    payload.logger.error('Error generating live preview path')
+    return '/testing'
+  }
+}

package/template/src/utilities/get/cache/getAtomicActions.ts

@@ -0,0 +1,48 @@
+'use server'
+import 'server-only' //DO NOT REMOVE
+import configPromise from '@payload-config'
+import { getPayload, Where } from 'payload'
+import cacheLogger from '@/utilities/log/cache'
+import { AtomicStoreInitialState, GCFunction } from '@/ts/types'
+
+/** Gets all atomic actions stored in the pages collection. */
+export const getCachedAtomicActions: GCFunction<'atomic-actions'> = async (tag, draft) => {
+  const payload = await getPayload({ config: configPromise })
+  const where: Where = { storedAtomicActions: { exists: true } }
+  if (!draft) Object.assign(where, { live: { equals: true } })
+  const draftPublished = draft ? 'draft' : 'published'
+
+  const settings = await payload.findGlobal({ slug: 'settings' })
+  const version = settings?.[draftPublished]?.storeVersion || 0
+
+  /*   const actions = await payload
+    .find({
+      draft,
+      where,
+      limit: 0,
+      depth: 1,
+      pagination: false,
+      collection: 'pages',
+      select: { storedAtomicActions: true },
+    })
+    .then((res) => {
+      const allActions: StoredAtomicActions = {}
+
+      res.docs
+        ?.map(({ storedAtomicActions }) => storedAtomicActions)
+        .filter((action): action is StoredAtomicActions => Boolean(action && Object.keys(action).length > 0))
+        .forEach((actions) => {
+          Object.assign(allActions, actions)
+        })
+
+      return allActions
+    }) */
+
+  const result: AtomicStoreInitialState = {
+    version,
+    //storedAtomicActions: actions,
+  }
+
+  cacheLogger({ tag, draft })
+  return result
+}

package/template/src/utilities/get/cache/getAtomicClasses.ts

@@ -0,0 +1,20 @@
+'use server'
+import 'server-only'
+import { GCFunction } from '@/ts/types'
+import configPromise from '@payload-config'
+import { getPayload, Where } from 'payload'
+import cacheLogger from '@/utilities/log/cache'
+
+export const getCachedAtomicClasses: GCFunction<'atomic-classes'> = async (tag, draft) => {
+  const payload = await getPayload({ config: configPromise })
+
+  const and: Where[] = [{ or: [{ storedAtomicClasses: { exists: true } }, { href: { equals: '/' } }] }]
+  if (!draft) and.push({ live: { equals: true } })
+  const where: Where = { and }
+
+  const res = await payload.find({ collection: 'pages', draft, where, limit: 0, pagination: false, depth: 0, select: { storedAtomicClasses: true } })
+  const result = res.docs.flatMap((doc) => doc.storedAtomicClasses ?? [])
+
+  cacheLogger({ tag, draft })
+  return result
+}

package/template/src/utilities/get/cache/getDesignSet.ts

@@ -0,0 +1,15 @@
+'use server'
+import 'server-only' //DO NOT REMOVE
+import { getPayload } from 'payload'
+import { GCFunction } from '@/ts/types'
+import configPromise from '@payload-config'
+import cacheLogger from '@/utilities/log/cache'
+
+/** Gets the active design set. */
+export const getCachedDesignSet: GCFunction<'designSet'> = async (tag, draft) => {
+  const payload = await getPayload({ config: configPromise })
+  const result = await payload.find({ collection: tag, draft, where: { active: { equals: true } }, limit: 1 }).then((res) => res.docs[0] || null)
+
+  cacheLogger({ tag, draft })
+  return result
+}

package/template/src/utilities/get/cache/getFooter.ts

@@ -0,0 +1,17 @@
+'use server'
+import 'server-only' //DO NOT REMOVE
+import { getPayload } from 'payload'
+import { GCFunction } from '@/ts/types'
+import configPromise from '@payload-config'
+import cacheLogger from '@/utilities/log/cache'
+
+/** Gets the active footer. */
+export const getCachedFooter: GCFunction<'footer'> = async (tag, draft) => {
+  const payload = await getPayload({ config: configPromise })
+  const results = await payload
+    .find({ draft, collection: tag, limit: 1, pagination: false, where: { active: { equals: true } } })
+    .then((res) => res.docs[0])
+
+  cacheLogger({ tag, draft })
+  return results
+}

package/template/src/utilities/get/cache/getFormSubmissions.ts

@@ -0,0 +1,17 @@
+'use server'
+import 'server-only' //DO NOT REMOVE
+import { getPayload } from 'payload'
+import { GCFunction } from '@/ts/types'
+import configPromise from '@payload-config'
+import cacheLogger from '@/utilities/log/cache'
+
+/** Returns the form submissions. Tag: form-submissions */
+export const getCachedFormSubmissions: GCFunction<'form-submissions'> = async (tag, tid) => {
+  const payload = await getPayload({ config: configPromise })
+  const results = await payload
+    .find({ collection: 'form-submissions', limit: 0, depth: 0, pagination: false, where: { 'form.title': { equals: tid } } })
+    .then((res) => res.docs.map((doc) => doc))
+
+  cacheLogger({ tag })
+  return results
+}

package/template/src/utilities/get/cache/getForms.ts

@@ -0,0 +1,43 @@
+'use server'
+import 'server-only' //DO NOT REMOVE
+import configPromise from '@payload-config'
+import { getPayload, Where } from 'payload'
+import cacheLogger from '@/utilities/log/cache'
+import { Form, GCFunction, StoredAtomicForm } from '@/ts/types'
+
+/** Gets all backend forms stored in the forms collection. */
+export const getCachedBackendForms: GCFunction<'backend-forms'> = async (tag) => {
+  const payload = await getPayload({ config: configPromise })
+  const results = await payload.find({ draft: false, collection: 'forms', limit: 1000, pagination: false }).then((res) => res.docs.map((doc) => doc))
+  cacheLogger({ tag })
+  return results
+}
+
+/** Gets all atomic forms stored in the pages collection. */
+export const getCachedAtomicForms: GCFunction<'atomic-forms'> = async (tag, draft) => {
+  const payload = await getPayload({ config: configPromise })
+  const where: Where = { storedAtomicForms: { exists: true } }
+  if (!draft) Object.assign(where, { live: { equals: true } })
+  const results = await payload.find({ draft, collection: 'pages', limit: 1000, where, select: { storedAtomicForms: true } }).then((res) =>
+    res.docs
+      .map((doc) => doc.storedAtomicForms)
+      .filter(Boolean)
+      .flat()
+      .filter((form): form is StoredAtomicForm => form !== undefined),
+  )
+
+  cacheLogger({ tag, draft })
+  return results
+}
+
+/** Used in Atomic Blocks Dynamic Form Submission Only */
+export const getCachedAllForms: GCFunction<'all-forms'> = async (tag, draft, atomicForms, backendForms) => {
+  // Add id from forms to atomicForms by matching backendForm
+  const mergedAtomicForms = atomicForms.map((atomicForm: StoredAtomicForm) => {
+    const matchingForm = backendForms.find((form: Form) => form.title === atomicForm.backendForm)
+    return { ...atomicForm, backendFormID: matchingForm ? matchingForm.id : '' }
+  })
+
+  cacheLogger({ tag, draft })
+  return mergedAtomicForms
+}

package/template/src/utilities/get/cache/getHeader.ts

@@ -0,0 +1,17 @@
+'use server'
+import 'server-only' //DO NOT REMOVE
+import { getPayload } from 'payload'
+import { GCFunction } from '@/ts/types'
+import configPromise from '@payload-config'
+import cacheLogger from '@/utilities/log/cache'
+
+/** Gets the active header. */
+export const getCachedHeader: GCFunction<'header'> = async (tag, draft) => {
+  const payload = await getPayload({ config: configPromise })
+  const results = await payload
+    .find({ collection: tag, draft, limit: 1, pagination: false, where: { active: { equals: true } } })
+    .then((res) => res.docs[0])
+
+  cacheLogger({ tag, draft })
+  return results
+}

package/template/src/utilities/get/cache/getIcon.ts

@@ -0,0 +1,51 @@
+'use server'
+import 'server-only' //DO NOT REMOVE
+import { getPayload } from 'payload'
+import configPromise from '@payload-config'
+import type { GCFunction } from '@/ts/types'
+import cacheLogger from '@/utilities/log/cache'
+import { toTitleCase } from '@/utilities/format/toTitleCase'
+
+/** Type guard to check if icon is a string (when depth: 0, icon is always a string ID). */
+const isIconString = (item: {
+  name: string
+  icon?: (string | null) | { id: string } | null
+  id?: string | null
+}): item is { name: string; icon: string; id?: string | null } => {
+  return typeof item.icon === 'string' && item.icon.length > 0
+}
+
+/** Gets the active icon sets icons array. Specifically only the name and icon reference id of each icon. */
+export const getCachedIconSet: GCFunction<'iconSet'> = async (tag, draft) => {
+  const payload = await getPayload({ config: configPromise })
+  const results = await payload
+    .find({ collection: 'iconSet', depth: 0, limit: 1, draft, pagination: false, select: { iconsArray: true }, where: { active: { equals: true } } })
+    .then((res) => res.docs[0] || null)
+
+  /* Returns something like this: [
+    { name: 'day', icon: '691253680387340779b42915' },
+    { name: 'night', icon: '6912536c0387340779b4291f' }
+  ] */
+  const filteredResults = results?.iconsArray?.filter(isIconString).map(({ id, ...item }) => ({ name: item.name, icon: item.icon })) || []
+  cacheLogger({ tag, draft })
+  return { iconsArray: filteredResults }
+}
+
+/** Gets the SVG string that matches the passed in icon name, from the active icon set collection. */
+export const getCachedIconByName: GCFunction<'icon'> = async (tag, tid, draft, iconSet) => {
+  if (!iconSet?.iconsArray) return
+  const iconItem = iconSet.iconsArray.find((item) => item.name === tid)
+  if (!iconItem?.icon || typeof iconItem.icon !== 'string') return
+  const payload = await getPayload({ config: configPromise })
+  const icon = await payload
+    .find({ collection: 'icon', limit: 1, draft, where: { id: { equals: iconItem.icon } } })
+    .then((res) => res.docs[0] || null)
+  cacheLogger({ tag, tid, draft })
+  return icon?.svgString || undefined
+}
+
+/** Formats the icon set into a list of options for the icon select field. */
+export const getCachedIconOptions: GCFunction<'icon-options'> = async (tag, draft, iconSet) => {
+  cacheLogger({ tag, draft })
+  return iconSet?.iconsArray?.map((icon) => ({ value: icon.name, label: toTitleCase(icon.name) })) || []
+}

package/template/src/utilities/get/cache/getImage.ts

@@ -0,0 +1,20 @@
+'use server'
+import 'server-only' //DO NOT REMOVE
+import { getPayload } from 'payload'
+import { GCFunction } from '@/ts/types'
+import configPromise from '@payload-config'
+import cacheLogger from '@/utilities/log/cache'
+
+export const getCachedImage: GCFunction<'image'> = async (tag, tid, version) => {
+  if (!tid) return ''
+
+  const payload = await getPayload({ config: configPromise })
+  const image = await payload.findByID({ collection: 'images', id: tid })
+  if (!image) return
+
+  const url = version ? image.sizes?.[version]?.url || image.url : image.url
+  if (!url) return
+
+  cacheLogger({ tag, tid })
+  return url
+}

package/template/src/utilities/get/cache/getPage.ts

@@ -0,0 +1,35 @@
+'use server'
+import 'server-only' //DO NOT REMOVE
+import { GCFunction } from '@/ts/types'
+import configPromise from '@payload-config'
+import { getPayload, Where } from 'payload'
+import cacheLogger from '@/utilities/log/cache'
+import manualLogger from '@/utilities/log/manual'
+import sanitizeData from '@/utilities/sanitizeData'
+
+/** Gets a page by its href. */
+export const getCachedPageByHref: GCFunction<'page'> = async (tag, tid, draft, pages) => {
+  if (!pages.includes(tid)) {
+    manualLogger(`[Warning] - Page not found - ${tid}`)
+    return
+  }
+  const payload = await getPayload({ config: configPromise })
+  const where: Where = { href: { equals: tid } }
+  if (!draft) Object.assign(where, { live: { equals: true } })
+  const results = await payload
+    .find({
+      collection: 'pages',
+      draft,
+      where,
+      limit: 1,
+      depth: 1000,
+      pagination: false,
+      overrideAccess: draft,
+      select: { meta: true, children: true, mainClassName: true },
+    })
+    .then((res) => res.docs?.[0] || null)
+    .then((res) => sanitizeData(res))
+
+  cacheLogger({ tag, tid, draft })
+  return results
+}