@pro-laico/create-atomic-payload 0.1.4

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

@@ -0,0 +1,24 @@
+'use server'
+import 'server-only' //DO NOT REMOVE
+import { GCFunction } from '@/ts/types'
+import { getPayload, Where } from 'payload'
+import configPromise from '@payload-config'
+import cacheLogger from '@/utilities/log/cache'
+
+/** Gets all pages set in the pages collection and returns them as an array of strings. */
+export const getCachedPages: GCFunction<'pages'> = async (tag, draft) => {
+  const payload = await getPayload({ config: configPromise })
+  const where: Where = { href: { exists: true } }
+  if (!draft) Object.assign(where, { live: { equals: true } })
+  const result = await payload.find({
+    collection: 'pages',
+    draft,
+    where,
+    limit: 0,
+    overrideAccess: draft,
+    select: { href: true },
+  })
+  const returns = result.docs?.map(({ href }) => href).filter((href) => href != null) || []
+  cacheLogger({ tag, draft })
+  return returns
+}

package/template/src/utilities/get/cache/getShortcutSet.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 shortcut set. */
+export const getCachedShortcutSet: GCFunction<'shortcutSet'> = async (tag, draft) => {
+  const payload = await getPayload({ config: configPromise })
+  const shortcutSet = await payload
+    .find({ draft, collection: 'shortcutSet', pagination: false, limit: 1, where: { active: { equals: true } } })
+    .then((result) => result.docs[0] || null)
+
+  cacheLogger({ tag, draft })
+  return shortcutSet
+}

package/template/src/utilities/get/cache/getSiteCSS.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 site css stored in payload, under the global 'draftStorage' or 'publishedStorage'.
+export const getCachedSiteCSS: GCFunction<'site-css'> = async (tag, draft) => {
+  const payload = await getPayload({ config: configPromise })
+  const results = await payload
+    .findGlobal({ draft, slug: `${draft ? 'draft' : 'published'}Storage`, select: { layoutCSS: true } })
+    .then((res) => res.layoutCSS)
+
+  cacheLogger({ tag, draft })
+  return results || ''
+}

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

@@ -0,0 +1,14 @@
+'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'
+
+/** Gets all site metadata from the siteMetaData global.*/
+export const getCachedSiteMetadata: GCFunction<'site-metadata'> = async (tag, draft) => {
+  const payload = await getPayload({ config: configPromise })
+  const results = await payload.findGlobal({ slug: 'siteMetaData', draft })
+  cacheLogger({ tag, draft })
+  return results
+}

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

@@ -0,0 +1,50 @@
+'use server'
+import 'server-only' //DO NOT REMOVE
+import { GCFunction } from '@/ts/types'
+import { getPayload, Where } from 'payload'
+import configPromise from '@payload-config'
+import cacheLogger from '@/utilities/log/cache'
+import { getServerSideURL } from '@/utilities/get/getURL'
+
+/** Gets the pages stored in payload and formats them into a sitemap array. */
+export const getCachedSitemap: GCFunction<'sitemap'> = async (tag, draft) => {
+  const payload = await getPayload({ config: configPromise })
+  const where: Where = { href: { exists: true } }
+  if (!draft) Object.assign(where, { live: { equals: true }, 'meta.noIndex': { equals: false } })
+  const results = await payload.find({
+    collection: 'pages',
+    draft,
+    where,
+    depth: 0,
+    limit: 0,
+    overrideAccess: draft,
+    select: { href: true, updatedAt: true, meta: { priority: true, noIndex: true, changeFrequency: true } },
+  })
+
+  const pages = results.docs || []
+  const pagesWithout404 = pages.filter(({ href }) => href !== '/404') // Exclude 404 page
+  const dateFallback = new Date().toISOString()
+
+  const sitemap = pagesWithout404
+    ? pagesWithout404.map((page) => {
+        const { href, updatedAt, meta } = page
+        if (href === '/') {
+          return {
+            priority: 1,
+            url: `${getServerSideURL()}`,
+            lastModified: updatedAt || dateFallback,
+            changeFrequency: meta?.changeFrequency || 'monthly',
+          }
+        }
+        return {
+          priority: meta?.priority || 0.5,
+          url: `${getServerSideURL()}${href}`,
+          lastModified: updatedAt || dateFallback,
+          changeFrequency: meta?.changeFrequency || 'monthly',
+        }
+      })
+    : []
+
+  cacheLogger({ tag, draft })
+  return sitemap
+}

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

@@ -0,0 +1,14 @@
+'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 tracking settings from payload about posthog, vercel and google tag manager. */
+export const getCachedTracking: GCFunction<'tracking'> = async (tag, draft) => {
+  const payload = await getPayload({ config: configPromise })
+  const results = await payload.findGlobal({ slug: 'tracking', draft })
+  cacheLogger({ tag, draft })
+  return results
+}

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

@@ -0,0 +1,129 @@
+'use server'
+import 'server-only' //DO NOT REMOVE
+import { mt } from '@/utilities/mergeTags'
+import { unstable_cache } from 'next/cache'
+import { GCArgs, GCReturns, GCFunction, Last } from '@/ts/types'
+
+//Getter Imports
+import { getCachedPages } from './getPages'
+import { getCachedImage } from './getImage'
+import { getCachedFooter } from './getFooter'
+import { getCachedHeader } from './getHeader'
+import { getCachedSiteCSS } from './getSiteCSS'
+import { getCachedSitemap } from './getSitemap'
+import { getCachedPageByHref } from './getPage'
+import { getCachedTracking } from './getTracking'
+import { getCachedDesignSet } from './getDesignSet'
+import { getCachedShortcutSet } from './getShortcutSet'
+import { getCachedSiteMetadata } from './getSiteMetadata'
+import { getCachedAtomicClasses } from './getAtomicClasses'
+import { getCachedAtomicActions } from './getAtomicActions'
+import { getCachedFormSubmissions } from './getFormSubmissions'
+import { getCachedIconByName, getCachedIconSet, getCachedIconOptions } from './getIcon'
+import { getCachedAllForms, getCachedAtomicForms, getCachedBackendForms } from './getForms'
+
+const getRegistry = {
+  pages: getCachedPages,
+  image: getCachedImage,
+  header: getCachedHeader,
+  footer: getCachedFooter,
+  page: getCachedPageByHref,
+  icon: getCachedIconByName,
+  sitemap: getCachedSitemap,
+  iconSet: getCachedIconSet,
+  tracking: getCachedTracking,
+  'site-css': getCachedSiteCSS,
+  designSet: getCachedDesignSet,
+  'all-forms': getCachedAllForms,
+  shortcutSet: getCachedShortcutSet,
+  'atomic-forms': getCachedAtomicForms,
+  'icon-options': getCachedIconOptions,
+  'site-metadata': getCachedSiteMetadata,
+  'backend-forms': getCachedBackendForms,
+  'atomic-classes': getCachedAtomicClasses,
+  'atomic-actions': getCachedAtomicActions,
+  'form-submissions': getCachedFormSubmissions,
+}
+
+async function getCached(...args: GCArgs<'icon'>): GCReturns<'icon'>
+async function getCached(...args: GCArgs<'page'>): GCReturns<'page'>
+async function getCached(...args: GCArgs<'image'>): GCReturns<'image'>
+async function getCached(...args: GCArgs<'pages'>): GCReturns<'pages'>
+async function getCached(...args: GCArgs<'header'>): GCReturns<'header'>
+async function getCached(...args: GCArgs<'footer'>): GCReturns<'footer'>
+async function getCached(...args: GCArgs<'sitemap'>): GCReturns<'sitemap'>
+async function getCached(...args: GCArgs<'iconSet'>): GCReturns<'iconSet'>
+async function getCached(...args: GCArgs<'site-css'>): GCReturns<'site-css'>
+async function getCached(...args: GCArgs<'tracking'>): GCReturns<'tracking'>
+async function getCached(...args: GCArgs<'all-forms'>): GCReturns<'all-forms'>
+async function getCached(...args: GCArgs<'designSet'>): GCReturns<'designSet'>
+async function getCached(...args: GCArgs<'shortcutSet'>): GCReturns<'shortcutSet'>
+async function getCached(...args: GCArgs<'atomic-forms'>): GCReturns<'atomic-forms'>
+async function getCached(...args: GCArgs<'icon-options'>): GCReturns<'icon-options'>
+async function getCached(...args: GCArgs<'backend-forms'>): GCReturns<'backend-forms'>
+async function getCached(...args: GCArgs<'site-metadata'>): GCReturns<'site-metadata'>
+async function getCached(...args: GCArgs<'atomic-classes'>): GCReturns<'atomic-classes'>
+async function getCached(...args: GCArgs<'atomic-actions'>): GCReturns<'atomic-actions'>
+async function getCached(...args: GCArgs<'form-submissions'>): GCReturns<'form-submissions'>
+async function getCached(...args: GCArgs<'all'>): GCReturns<'all'> {
+  const [tag, a, b] = args
+  let tid = ''
+  let draft = false
+
+  if (typeof a === 'string') tid = a
+  if (typeof a === 'boolean') draft = a
+  if (typeof b === 'boolean') draft = b
+
+  const draftTag: 'draft' | undefined = draft ? 'draft' : undefined
+
+  // Key parts are used to create the cache key that identifies this specific cache.
+  // e.g: ['pages', '/example', 'draft']
+  const keyParts: string[] = [tag] /* 'page' */
+  if (tid) keyParts.push(tid) /* '/example' */
+  if (draft) keyParts.push('draft') /* 'draft' */
+
+  // When any tag inside dependencyTags is revalidated, this cache will be busted.
+  // e.g: ['pages', 'draft', '/example', 'pages:draft']
+  const dependencyTags: string[] = [tag]
+  if (tid) dependencyTags.push(tid) /* '/example' */
+  if (draft) dependencyTags.push(mt([tag, draftTag])) /* 'page:draft' */
+  dependencyTags.push(draft ? 'draft' : 'published') /* Enables revalidation of all draft or published documents respectively */
+  if (tid) dependencyTags.push(mt([tag, tid, draftTag])) /* 'page:/example:draft' */
+
+  const getter = getRegistry[tag] as GCFunction<typeof tag>
+
+  // Additional dependency tags
+  switch (tag) {
+    case 'icon': {
+      const iconSet = args[args.length - 1] as Last<typeof args>
+      dependencyTags.push(mt(['iconSet', draftTag]))
+      //If you update the icon doc, this ensures the icon is updated.
+      const iconItem = iconSet.iconsArray?.find((item) => item.name === tid)
+      if (iconItem && iconItem.icon) dependencyTags.push(mt(['icon', iconItem.icon]))
+      break
+    }
+    case 'icon-options': {
+      dependencyTags.push(mt(['iconSet', draftTag]))
+      break
+    }
+    case 'form-submissions': {
+      dependencyTags.push(mt(['backend-forms']))
+      break
+    }
+    case 'atomic-actions': {
+      dependencyTags.push(mt(['settings', draftTag]))
+      break
+    }
+    case 'all-forms': {
+      dependencyTags.push(mt(['backend-forms']))
+      dependencyTags.push(mt(['atomic-forms', draftTag]))
+      break
+    }
+    default:
+      break
+  }
+
+  return unstable_cache(async () => getter(...args), keyParts, { tags: dependencyTags })()
+}
+
+export default getCached

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

@@ -0,0 +1,5 @@
+import 'server-only' //DO NOT REMOVE
+import getCached from '.'
+import { cache } from 'react'
+
+export default cache(getCached)

package/template/src/utilities/get/getImageURL.ts

@@ -0,0 +1,20 @@
+import { getClientSideURL } from '@/utilities/get/getURL'
+
+/**
+ * Processes image resource URL to ensure proper formatting
+ * @param url The original URL from the resource
+ * @param cacheTag Optional cache tag to append to the URL
+ * @returns Properly formatted URL with cache tag if provided
+ */
+export const getImageUrl = (url: string | null | undefined, cacheTag?: string | null): string => {
+  if (!url) return ''
+
+  if (cacheTag && cacheTag !== '') cacheTag = encodeURIComponent(cacheTag)
+
+  // Check if URL already has http/https protocol
+  if (url.startsWith('http://') || url.startsWith('https://')) return cacheTag ? `${url}?${cacheTag}` : url
+
+  // Otherwise prepend client-side URL
+  const baseUrl = getClientSideURL()
+  return cacheTag ? `${baseUrl}${url}?${cacheTag}` : `${baseUrl}${url}`
+}

package/template/src/utilities/get/getMeUser.ts

@@ -0,0 +1,22 @@
+import { cookies } from 'next/headers'
+import type { User } from '@/ts/types'
+import { redirect } from 'next/navigation'
+import { getClientSideURL } from './getURL'
+
+type MeUserArgs = { nullUserRedirect?: string; validUserRedirect?: string }
+
+export const getMeUser = async (args?: MeUserArgs): Promise<{ token: string; user: User }> => {
+  const { nullUserRedirect, validUserRedirect } = args || {}
+  const cookieStore = await cookies()
+  const token = cookieStore.get('payload-token')?.value
+
+  const meUserReq = await fetch(`${getClientSideURL()}/api/users/me`, { headers: { Authorization: `JWT ${token}` } })
+
+  const { user }: { user: User } = await meUserReq.json()
+
+  if (validUserRedirect && meUserReq.ok && user) redirect(validUserRedirect)
+  if (nullUserRedirect && (!meUserReq.ok || !user)) redirect(nullUserRedirect)
+
+  // Token will exist here because if it doesn't the user will be redirected
+  return { token: token!, user }
+}

package/template/src/utilities/get/getURL.ts

@@ -0,0 +1,20 @@
+export const getServerSideURL = () => {
+  const url = process.env.NEXT_PUBLIC_SERVER_URL
+
+  if (!url && process.env.VERCEL_PROJECT_PRODUCTION_URL) return `https://${process.env.VERCEL_PROJECT_PRODUCTION_URL}`
+
+  return url || 'http://localhost:3000'
+}
+
+export const getClientSideURL = () => {
+  if (!!(typeof window !== 'undefined' && window.document && window.document.createElement)) {
+    const protocol = window.location.protocol
+    const domain = window.location.hostname
+    const port = window.location.port
+    return `${protocol}//${domain}${port ? `:${port}` : ''}`
+  }
+
+  if (process.env.VERCEL_PROJECT_PRODUCTION_URL) return `https://${process.env.VERCEL_PROJECT_PRODUCTION_URL}`
+
+  return process.env.NEXT_PUBLIC_SERVER_URL || ''
+}

package/template/src/utilities/log/cache.ts

@@ -0,0 +1,8 @@
+import 'server-only'
+import { AllTags } from '@/ts/types'
+import { mt } from '@/utilities/mergeTags'
+
+export default function cacheLogger({ tag, tid, draft }: { tag: AllTags; tid?: string; draft?: boolean }) {
+  const fullTag: string = mt([tag, tid, draft ? 'draft' : undefined])
+  if (process?.env?.LOGS === 'true') console.log('\x1b[32m%s\x1b[0m', `[GET] - ${fullTag}`)
+}

package/template/src/utilities/log/manual.ts

@@ -0,0 +1,11 @@
+export default function manualLogger(message: string) {
+  let color
+  if (message.includes('[INFO]')) color = '\x1b[38;5;117m%s\x1b[0m'
+  if (message.includes('[Warning]')) color = '\x1b[38;5;208m%s\x1b[0m'
+  if (message.includes('[Error]')) color = '\x1b[38;5;196m%s\x1b[0m'
+  if (message.includes('[Preview]')) color = '\x1b[38;5;226m%s\x1b[0m'
+  if (message.includes('[STORE]')) color = '\x1b[38;5;117m%s\x1b[0m'
+  if (message.includes('[UPDATE]')) color = '\x1b[38;5;117m%s\x1b[0m'
+  if (message.includes('[GENERATE]')) color = '\x1b[38;5;117m%s\x1b[0m'
+  if (process?.env?.LOGS === 'true') console.log(color, message)
+}

package/template/src/utilities/log/revalidation.ts

@@ -0,0 +1,6 @@
+import 'server-only'
+import { RevalidationLoggerType } from '@/ts/types'
+
+export default function revalidationLogger(tags: RevalidationLoggerType) {
+  if (process?.env?.LOGS === 'true') console.log('\x1b[38;5;226m%s\x1b[0m', `[Revalidate] - Tags | ${tags.join(' | ')}`)
+}

package/template/src/utilities/mergeTags.ts

@@ -0,0 +1,7 @@
+/** Merge Tags */
+export function mt(stringArray: (string | undefined)[]): string {
+  let returnString = ''
+  if (stringArray.length === 0) return returnString
+  else returnString = stringArray.filter((part) => part).join(':')
+  return returnString
+}

package/template/src/utilities/propertyApplicatorUtility.ts

@@ -0,0 +1,20 @@
+import type { PosthogProperty } from '@/ts/types'
+
+/**
+ * Generates data attributes as props for server components
+ * @param attributes Array of attribute objects containing property and value
+ * @returns An object with data attributes as props
+ */
+export default function postHogPropertyApplicator(attributes: (string | PosthogProperty)[] | null | undefined): Record<string, string> | undefined {
+  if (!Array.isArray(attributes) || attributes.length === 0) return
+  if (!attributes.every((attr) => typeof attr === 'object' && attr !== null && 'propertyObfuscated' in attr && 'valueObfuscated' in attr)) return
+
+  return (attributes as PosthogProperty[]).reduce(
+    (acc, attr) => {
+      const { propertyObfuscated, valueObfuscated } = attr
+      acc[`data-ph-capture-attribute-${propertyObfuscated}`] = String(valueObfuscated)
+      return acc
+    },
+    {} as Record<string, string>,
+  )
+}

package/template/src/utilities/revalidateTag.ts

@@ -0,0 +1,55 @@
+'use server'
+import 'server-only'
+import { mt } from './mergeTags'
+import { revalidateTag as rt } from 'next/cache'
+import revalidationLogger from '@/utilities/log/revalidation'
+import { AllTags, PromiseTagGroup, RArgs, RReturns } from '@/ts/types'
+
+/** Used by the admin ui site triggers component to revalidate all draft or published pages */
+async function revalidateTag<T extends PromiseTagGroup>(...args: RArgs<T>): RReturns<T>
+async function revalidateTag<T extends Exclude<AllTags, PromiseTagGroup>>(...args: RArgs<T>): RReturns<T>
+async function revalidateTag(...args: RArgs<'all'>): RReturns<'all'> {
+  const [tag, a, b] = args
+  let tid = ''
+  let draft = false
+
+  if (typeof a === 'string') tid = a
+  if (typeof a === 'boolean') draft = a
+  if (typeof b === 'boolean') draft = b
+
+  const tags: string[] = []
+  let t: string = tag
+
+  if (tid) t = mt([tag, tid])
+
+  // Secondary revalidations and special handlings for specific tags.
+  switch (tag) {
+    case 'pages':
+      revalidateTag('sitemap', draft)
+      break
+    case 'designSet':
+    case 'shortcutSet':
+    case 'atomic-classes':
+      revalidateTag('site-css', draft)
+      break
+    case 'draft':
+    case 'published':
+      rt(t,'max')
+      revalidationLogger([t])
+      return { success: true, message: `Revalidated ${tag}`, timestamp: new Date().toISOString() }
+    default:
+      break
+  }
+
+  if (draft) {
+    rt(mt([t, 'draft']),'max')
+    tags.push(mt([t, 'draft']))
+  } else {
+    rt(t,'max')
+    tags.push(t)
+  }
+
+  revalidationLogger(tags)
+}
+
+export { revalidateTag }

package/template/src/utilities/runAPF.ts

@@ -0,0 +1,10 @@
+import { RunAPFProps } from '@/ts/types/apf'
+
+/**
+ * Checks if a document has been marked as changed in the context.
+ * If the documents data includes 'active' it will only return true if active = true.
+ */
+export const runAPF = ({ context, id, apf, data }: RunAPFProps): boolean => {
+  if (data instanceof Object && 'active' in data && data.active) return Boolean(context[`${id}-${apf}`])
+  else return Boolean(context[`${id}-${apf}`])
+}

package/template/src/utilities/sanitizeData.ts

@@ -0,0 +1,24 @@
+import traverse from 'traverse'
+
+/** Recursively removes undefined, null, empty arrays, and empty objects without mutating the original data. */
+function sanitizeData<T>(incomingData: T): T {
+  const data = traverse(incomingData).clone()
+  traverse(data).forEach(function () {
+    this.before(function (node) {
+      if (this.key === 'richText') this.update(node, true) // Do Not Sanitize Children Of Rich Text
+    })
+    this.after(function (node) {
+      if (
+        node === undefined ||
+        node === null ||
+        (Array.isArray(node) && node.length === 0) ||
+        (typeof node === 'object' && !Array.isArray(node) && Object.keys(node).length === 0)
+      ) {
+        this.remove()
+      }
+    })
+  })
+  return data
+}
+
+export default sanitizeData

package/template/src/utilities/seedNestedRelationship.ts

@@ -0,0 +1,5 @@
+import type { Page } from '@/ts/types'
+
+export function toPageRelationship({ title, slug, href, id }: Page) {
+  return { title, slug, href, id }
+}

package/template/tailwind.config.js

@@ -0,0 +1,9 @@
+/** @type {import('tailwindcss').Config} */
+
+//This is purely to allow you to have tailwind intellisense when writing actual tailwind classes.
+//It has 0 effect on the actual css. Which is handled by unocss.
+
+module.exports = {
+  content: ['./src/**/*.{js,ts,jsx,tsx,mdx}', './src/**/*.{html,vue,svelte,astro}'],
+  corePlugins: { preflight: false },
+}

package/template/tsconfig.json

@@ -0,0 +1,49 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "target": "ES2022",
+    "baseUrl": ".",
+    "lib": [
+      "DOM",
+      "DOM.Iterable",
+      "ES2022"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ],
+      "react": [
+        "./node_modules/@types/react"
+      ],
+      "@payload-config": [
+        "./src/payload.config.ts"
+      ]
+    }
+  },
+  "include": [
+    "**/*.ts",
+    "**/*.tsx",
+    "next-env.d.ts",
+    "tailwind.config.js",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}