@pro-laico/create-atomic-payload 0.1.4

package/template/src/blocks/submitForm/form/rateLimiting/simpleSlidingWindow/serverFunction.ts

@@ -0,0 +1,46 @@
+'use server'
+import { FormFunction } from '@/ts/types'
+import { FrlSimpleSlidingWindow as FrlSimpleSlidingWindowType } from '@/ts/types'
+
+const lastCleanup: Record<string, number> = {}
+const memoryStore: Record<string, Record<string, number[]>> = {}
+
+export const FrlSimpleSlidingWindow: FormFunction<{ block: FrlSimpleSlidingWindowType }> = async (args) => {
+  const { context, response, block } = args
+  const { backendFormID, ip } = context
+  const { rateLimit, rateLimitPeriod, validationMessage } = block
+
+  // Ensure store for this formID exists. (The store unifies all front end forms rate limiting to the backend form.)
+  if (!memoryStore[backendFormID]) memoryStore[backendFormID] = {}
+  if (!lastCleanup[backendFormID]) lastCleanup[backendFormID] = 0
+
+  const now = Date.now()
+  const windowStart = now - rateLimitPeriod * 60000
+
+  const timestamps = memoryStore[backendFormID][ip] || []
+  const recentRequests = timestamps.filter((ts) => ts > windowStart)
+
+  // Add the current request to the store.
+  memoryStore[backendFormID][ip] = [...recentRequests, now]
+
+  // Only run cleanup for this formID if rateLimitPeriod has passed since last cleanup
+  if (now - lastCleanup[backendFormID] > rateLimitPeriod * 60000) {
+    Object.keys(memoryStore[backendFormID]).forEach((ipKey) => {
+      const filtered = memoryStore[backendFormID][ipKey].filter((ts) => ts > windowStart)
+      if (filtered.length === 0) delete memoryStore[backendFormID][ipKey]
+      else memoryStore[backendFormID][ipKey] = filtered
+    })
+    lastCleanup[backendFormID] = now
+  }
+
+  if (recentRequests.length >= rateLimit) {
+    const earliest = Math.min(...recentRequests)
+    const durationMs = earliest + rateLimitPeriod * 60000 - now
+    response.success = false
+    context.waitFor = durationMs
+    response.fm = validationMessage
+    return args
+  }
+
+  return args
+}

package/template/src/blocks/submitForm/form/sanitation/blocks.ts

@@ -0,0 +1,6 @@
+import { FsCombineTwoFields } from './combineTwoFields/block'
+
+export { FsCombineTwoFields }
+const fsBlocks = [FsCombineTwoFields]
+
+export default fsBlocks

package/template/src/blocks/submitForm/form/sanitation/combineTwoFields/block.ts

@@ -0,0 +1,19 @@
+import type { Block } from 'payload'
+import { APField } from '@/fields/apf'
+
+const d = {
+  addBetween: 'Adds a string between the two fields. Defaults to a space.',
+}
+
+export const FsCombineTwoFields: Block = {
+  slug: 'FsCombineTwoFields',
+  interfaceName: 'FsCombineTwoFields',
+  admin: { disableBlockName: true },
+  labels: { singular: 'Combine Two Fields', plural: 'Combine Two Fields' },
+  fields: [
+    APField({ type: 'text', apf: ['form'], name: 'firstFieldName', required: true }),
+    APField({ type: 'text', apf: ['form'], name: 'addBetween', admin: { description: d.addBetween } }),
+    APField({ type: 'text', apf: ['form'], name: 'secondFieldName', required: true }),
+    APField({ type: 'text', apf: ['form'], name: 'outputFieldName', required: true }),
+  ],
+}

package/template/src/blocks/submitForm/form/sanitation/combineTwoFields/serverFunction.ts

@@ -0,0 +1,22 @@
+'use server'
+import { FormFunction } from '@/ts/types'
+import { FsCombineTwoFields as FsCombineTwoFieldsType } from '@/ts/types'
+
+export const FsCombineTwoFields: FormFunction<{ block: FsCombineTwoFieldsType }> = async (args) => {
+  const { formData, block } = args
+  const { firstFieldName, secondFieldName, outputFieldName } = block
+
+  if (!formData.get(firstFieldName) || !formData.get(secondFieldName)) {
+    args.response.success = false
+    args.response.fm = `Combine Two Fields Block Needs: ${firstFieldName} and ${secondFieldName}`
+    return args
+  }
+
+  const firstFieldValue = formData.get(firstFieldName)
+  const addBetween = block.addBetween || ' '
+  const secondFieldValue = formData.get(secondFieldName)
+
+  formData.set(outputFieldName, `${firstFieldValue}${addBetween}${secondFieldValue}`)
+
+  return args
+}

package/template/src/blocks/submitForm/form/sanitation/functions.ts

@@ -0,0 +1 @@
+export * from './combineTwoFields/serverFunction'

package/template/src/blocks/submitForm/form/validation/blocks.ts

@@ -0,0 +1,6 @@
+import { FvIsUnique } from './isUnique/block'
+
+export { FvIsUnique }
+const fvBlocks = [FvIsUnique]
+
+export default fvBlocks

package/template/src/blocks/submitForm/form/validation/functions.ts

@@ -0,0 +1 @@
+export * from './isUnique/serverFunction'

package/template/src/blocks/submitForm/form/validation/isUnique/block.ts

@@ -0,0 +1,19 @@
+import type { Block } from 'payload'
+import { APField } from '@/fields/apf'
+import { ValidationMessageField } from '@/fields/validationMessage'
+
+const d = {
+  limit: 'The number of times the field can be used. It defaults to 1.',
+}
+
+export const FvIsUnique: Block = {
+  slug: 'FvIsUnique',
+  interfaceName: 'FvIsUnique',
+  admin: { disableBlockName: true },
+  labels: { singular: 'Is Unique', plural: 'Is Unique' },
+  fields: [
+    APField({ type: 'text', apf: ['form'], name: 'fieldName', required: true }),
+    APField({ type: 'number', apf: ['form'], name: 'limit', required: true, admin: { description: d.limit } }),
+    ValidationMessageField,
+  ],
+}

package/template/src/blocks/submitForm/form/validation/isUnique/serverFunction.ts

@@ -0,0 +1,40 @@
+'use server'
+import getCached from '@/utilities/get/cache/react'
+import { FvIsUnique as FvIsUniqueType } from '@/ts/types'
+import { FilterSubmissionsByFieldAndValue, FormFunction } from '@/ts/types'
+
+/** Filters form submissions based on field and value inputs. */
+const filterSubmissionsByFieldAndValue: FilterSubmissionsByFieldAndValue = ({ submissions, fieldName, fieldValue }) => {
+  return submissions.filter((submission) => {
+    if (!submission.submissionData || !Array.isArray(submission.submissionData)) return false
+    return submission.submissionData.some((data) => data.field === fieldName && data.value === String(fieldValue))
+  })
+}
+
+export const FvIsUnique: FormFunction<{ block: FvIsUniqueType }> = async (args) => {
+  const { formData, storedForm, response, block } = args
+  const { fieldName, validationMessage } = block
+
+  if (!formData.get(fieldName)) {
+    response.success = false
+    response.fm = `This form is missing a field named: ${fieldName}`
+    return args
+  }
+
+  const cachedSubmissions = await getCached('form-submissions', storedForm.backendForm)
+  const submissions = filterSubmissionsByFieldAndValue({ submissions: cachedSubmissions, fieldName, fieldValue: formData.get(fieldName) })
+
+  if (submissions.length > 0) {
+    if (!formData.get(fieldName)) {
+      response.success = false
+      response.fm = `Field '${fieldName}' not found in form data.`
+      return args
+    }
+
+    response.success = false
+    response.fm = validationMessage
+    return args
+  }
+
+  return args
+}

package/template/src/blocks/submitForm/form/zap.ts

@@ -0,0 +1,8 @@
+import { z } from '@/ts/zap'
+import sanitationBlocks from './sanitation/blocks'
+import validationBlocks from './validation/blocks'
+import rateLimitBlocks from './rateLimiting/blocks'
+
+export const FormRateLimitBlockType = z.ap.add(z.enum(rateLimitBlocks.map((block) => block.slug)), { id: 'FormRateLimitBlockType' })
+export const FormSanitationBlockType = z.ap.add(z.enum(sanitationBlocks.map((block) => block.slug)), { id: 'FormSanitationBlockType' })
+export const FormValidationBlockType = z.ap.add(z.enum(validationBlocks.map((block) => block.slug)), { id: 'FormValidationBlockType' })

package/template/src/blocks/submitForm/formProcessor.ts

@@ -0,0 +1,222 @@
+'use server'
+//Function Imports
+import { FvIsUnique } from '@/blocks/submitForm/form/validation/functions'
+import { IsTrimText } from '@/blocks/submitForm/input/sanitation/functions'
+import { FsCombineTwoFields } from '@/blocks/submitForm/form/sanitation/functions'
+import { FrlSimpleSlidingWindow } from '@/blocks/submitForm/form/rateLimiting/functions'
+import { IvContains, IvDoesNotContain } from '@/blocks/submitForm/input/validation/functions'
+
+//Other Imports
+import { CookiePreferences } from '@/ts/types/actions'
+import {
+  AFPBase,
+  RunBlocksMethod,
+  FormFunction,
+  ProcessMethod,
+  FormFunctionsMap,
+  PreProcessMethod,
+  PostProcessMethod,
+  MessageProcessorMethod,
+} from '@/ts/types/forms'
+import type {
+  FormRateLimitBlocks,
+  FormSanitationBlocks,
+  FormValidationBlocks,
+  InputSanitationBlocks,
+  InputValidationBlocks,
+  StoredAtomicFormInput,
+} from '@/ts/types'
+import { formatDurationString } from '@/utilities/formatDurationWithTokens'
+
+const formFunctions: FormFunctionsMap = {
+  FrlSimpleSlidingWindow,
+  FsCombineTwoFields,
+  FvIsUnique,
+  IsTrimText,
+  IvContains,
+  IvDoesNotContain,
+}
+
+class SubmitFormProcessor {
+  //Context
+  private success: boolean = true
+  private args: AFPBase | undefined
+  private CCPreferences: CookiePreferences | undefined
+
+  //Form Level Values
+  private formRateLimitBlocks: FormRateLimitBlocks | undefined
+  private formSanitationBlocks: FormSanitationBlocks | undefined
+  private formValidationBlocks: FormValidationBlocks | undefined
+  private formInputBlocks: StoredAtomicFormInput[] | undefined
+
+  //Input Level Values
+  private inputSanitationBlocks: InputSanitationBlocks | undefined
+  private inputValidationBlocks: InputValidationBlocks | undefined
+
+  private reset(target: 'context' | 'form' | 'input' | 'all') {
+    if (target === 'context') {
+      this.args = undefined
+      this.success = true
+      this.CCPreferences = undefined
+    }
+    if (target === 'form') {
+      this.formRateLimitBlocks = undefined
+      this.formSanitationBlocks = undefined
+      this.formValidationBlocks = undefined
+      this.formInputBlocks = undefined
+    }
+    if (target === 'input') {
+      this.inputSanitationBlocks = undefined
+      this.inputValidationBlocks = undefined
+    }
+    if (target === 'all') {
+      this.reset('context')
+      this.reset('form')
+      this.reset('input')
+    }
+  }
+
+  private preProcess: PreProcessMethod = (args) => {
+    const { submissionData, headers, storedForm } = args
+    const { formData, clientData, submissionID } = submissionData
+    this.formInputBlocks = storedForm.inputs
+    this.CCPreferences = clientData.preferences
+    this.formSanitationBlocks = storedForm.sanitation
+    this.formValidationBlocks = storedForm.validation
+    this.formRateLimitBlocks = storedForm.rateLimiting
+    this.args = {
+      formData,
+      storedForm,
+      response: { success: true, submissionID, formData: new FormData(), fm: '', im: {} },
+      context: {
+        headers,
+        clientData,
+        backendFormID: storedForm.id,
+        referer: headers.get('referer') || 'unknown',
+        ip: headers.get('x-forwarded-for') || headers.get('x-real-ip') || headers.get('cf-connecting-ip') || 'unknown',
+      },
+    }
+  }
+
+  process: ProcessMethod = async (args) => {
+    this.preProcess(args)
+
+    //DO NOT CHANGE ORDER.
+    await this.formRateLimitProcessor(true)
+    await this.inputProcessor()
+    await this.formSanitationProcessor()
+    await this.formValidationProcessor()
+    await this.formRateLimitProcessor(false)
+
+    return this.postProcess()
+  }
+
+  private async formRateLimitProcessor(start: boolean) {
+    if (!this.formRateLimitBlocks || !this.success) return
+    const rateLimitArray = this.formRateLimitBlocks.filter((rateLimit) => rateLimit.atStart === start)
+    for (const block of rateLimitArray) if (this.success) await this.runBlocks({ block, type: block.blockType })
+  }
+
+  private async formSanitationProcessor() {
+    if (!this.formSanitationBlocks || !this.success) return
+    for (const block of this.formSanitationBlocks) if (this.success) await this.runBlocks({ block, type: block.blockType })
+  }
+
+  private async formValidationProcessor() {
+    if (!this.formValidationBlocks || !this.success) return
+    for (const block of this.formValidationBlocks) if (this.success) await this.runBlocks({ block, type: block.blockType })
+  }
+
+  private async inputProcessor() {
+    if (!this.formInputBlocks || !this.success) return
+    for (const input of this.formInputBlocks) {
+      if ((!input.sanitationBlocks && !input.validationBlocks) || !input.inputName) continue
+      this.inputSanitationBlocks = input.sanitationBlocks
+      this.inputValidationBlocks = input.validationBlocks
+      await this.inputSanitationProcessor(input.inputName)
+      await this.inputValidationProcessor(input.inputName)
+      this.reset('input')
+    }
+  }
+
+  private async inputSanitationProcessor(inputName: string) {
+    if (!this.inputSanitationBlocks) return
+    for (const block of this.inputSanitationBlocks) await this.runBlocks({ block: { ...block, inputName }, type: block.blockType, persevere: true })
+  }
+
+  private async inputValidationProcessor(inputName: string) {
+    if (!this.inputValidationBlocks) return
+    for (const block of this.inputValidationBlocks) await this.runBlocks({ block: { ...block, inputName }, type: block.blockType, persevere: true })
+  }
+
+  private runBlocks: RunBlocksMethod = async ({ type, block, persevere }) => {
+    if (!this.args) throw new Error('Args is not defined in form processor.')
+    if (!this.args.response.success) if (!persevere) return
+    const augmentedArgs: Parameters<FormFunction>[0] = { ...this.args, block }
+
+    const fn = formFunctions[type]
+    if (!fn) throw new Error(`Unknown Server Function: ${type} in form processor runBlocksFunction`)
+
+    //TODO: Fix typing
+    this.args = await fn(augmentedArgs as any)
+    if (!this.args.response.success) this.success = false
+  }
+
+  private postProcess: PostProcessMethod = () => {
+    if (!this.args?.formData) throw new Error('Form data is not defined in form processor postProcess')
+    if (!this.CCPreferences) throw new Error('CCPreferences is not defined in form processor postProcess')
+    const { response, storedForm, context, formData } = this.args
+    const { clientData, referer, headers, ip, waitFor } = context
+    const submitToPayload = Array.from(this.args.formData.entries())
+      //Only accepts string values currently
+      .filter((entry): entry is [string, string] => typeof entry[1] === 'string')
+      .map(([key, value]) => ({ field: key, value }))
+
+    //Handle Data Collection
+    if (this.CCPreferences.userData) {
+      submitToPayload.push({ field: 'ip', value: ip })
+      submitToPayload.push({ field: 'timezone', value: clientData.timezone })
+      submitToPayload.push({ field: 'userAgent', value: headers.get('user-agent') || 'unknown' })
+    }
+    if (this.CCPreferences.analytics) {
+      submitToPayload.push({ field: 'referer', value: referer })
+      submitToPayload.push({ field: 'screenWidth', value: clientData.screenWidth })
+      submitToPayload.push({ field: 'screenHeight', value: clientData.screenHeight })
+    }
+
+    // Process Form & Input Messages
+    let fm
+    if (response.fm) fm = response.fm
+    else if (this.success) fm = storedForm.sm || 'Form submitted successfully!'
+    else fm = storedForm.em || 'Failed to submit form.'
+    fm = this.messageProcessor({ vm: fm, formData, waitFor })
+    if (Object.keys(response.im).length > 0) {
+      for (const [key, vm] of Object.entries(response.im)) response.im[key] = this.messageProcessor({ vm, formData, waitFor })
+    }
+
+    //Submit Form Processor Response
+    const fps = { response: { ...response, fm }, submitToPayload }
+    this.reset('all')
+    return fps
+  }
+
+  private messageProcessor: MessageProcessorMethod = ({ vm, formData, waitFor }) => {
+    if (vm?.includes('{{') && vm?.includes('}}')) {
+      if (waitFor) vm = formatDurationString(waitFor, vm)
+      vm = vm.replace(/\{\{([^}]+)\}\}/g, (match: string, fieldKey: string) => {
+        // Check if the field exists in formData
+        if (formData.get(fieldKey) !== undefined) return String(formData.get(fieldKey))
+        // If field doesn't exist, return the original placeholder
+        return match
+      })
+    }
+
+    return vm
+  }
+}
+
+const submitFormProcessor = new SubmitFormProcessor()
+
+export async function getSubmitFormProcessor() {
+  return submitFormProcessor
+}

package/template/src/blocks/submitForm/input/sanitation/blocks.ts

@@ -0,0 +1,5 @@
+import { IsTrimText } from './trimText/block'
+export * from './trimText/block'
+
+const isBlocks = [IsTrimText]
+export default isBlocks

package/template/src/blocks/submitForm/input/sanitation/functions.ts

@@ -0,0 +1 @@
+export * from './trimText/serverFunction'

package/template/src/blocks/submitForm/input/sanitation/trimText/block.ts

@@ -0,0 +1,24 @@
+import type { Block } from 'payload'
+import { APField } from '@/fields/apf'
+
+const d = {
+  trimCharacters: 'The characters to trim. Comma seperated list. Defaults to just removing spaces.',
+}
+
+const options = [
+  { label: 'Beginning', value: 'beginning' },
+  { label: 'End', value: 'end' },
+  { label: 'Both', value: 'both' },
+]
+
+export const IsTrimText: Block = {
+  slug: 'IsTrimText',
+  interfaceName: 'IsTrimText',
+  admin: { disableBlockName: true },
+  labels: { singular: 'Trim Text', plural: 'Trim Text' },
+  custom: { usedOn: ['text', 'textarea', 'email'] },
+  fields: [
+    APField({ type: 'select', apf: ['form'], required: true, name: 'trimType', defaultValue: 'both', options }),
+    APField({ type: 'text', apf: ['form'], required: true, name: 'trimCharacters', admin: { description: d.trimCharacters } }),
+  ],
+}

package/template/src/blocks/submitForm/input/sanitation/trimText/serverFunction.ts

@@ -0,0 +1,63 @@
+'use server'
+import { FormFunction } from '@/ts/types'
+import { IsTrimText as IsTrimTextType } from '@/ts/types'
+
+export const IsTrimText: FormFunction<{ block: IsTrimTextType & { inputName: string } }> = async (args) => {
+  const { formData, response, block } = args
+  const { trimCharacters, trimType, inputName } = block
+
+  //Get the input value
+  const inputValue = formData.get(inputName)
+  if (typeof inputValue !== 'string') {
+    response.success = false
+    response.fm = `Input Value is not a string: ${inputName}`
+    return args
+  }
+
+  //Get the characters we can trim
+  const trimCharactersArray = trimCharacters
+    ?.split(',')
+    .map((char: string) => char.trim())
+    .filter((char: string) => char.length > 0)
+  if (!trimCharactersArray) {
+    response.success = false
+    response.fm = `Trim Characters is required: ${inputName}`
+    return args
+  }
+
+  //Trim the input value based on the trim type
+  switch (trimType) {
+    case 'beginning':
+      for (const char of trimCharactersArray) {
+        if (char.length === 0) continue
+        const escapedChar = escapeRegex(char)
+        formData.set(inputName, inputValue.replace(new RegExp(`^${escapedChar}+`, 'g'), ''))
+      }
+      break
+    case 'end':
+      for (const char of trimCharactersArray) {
+        if (char.length === 0) continue
+        const escapedChar = escapeRegex(char)
+        formData.set(inputName, inputValue.replace(new RegExp(`${escapedChar}+$`, 'g'), ''))
+      }
+      break
+    case 'both':
+      for (const char of trimCharactersArray) {
+        if (char.length === 0) continue
+        const escapedChar = escapeRegex(char)
+        const regexPattern = `^${escapedChar}+|${escapedChar}+$`
+        formData.set(inputName, inputValue.replace(new RegExp(regexPattern, 'g'), ''))
+      }
+      break
+    default:
+      // If no valid trim type, return original value
+      break
+  }
+
+  return args
+}
+
+// Helper function to escape regex special characters (for the trim characters)
+const escapeRegex = (str: string) => {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}

package/template/src/blocks/submitForm/input/useOn.ts

@@ -0,0 +1,8 @@
+import sanitationBlocks from './sanitation/blocks'
+import validationBlocks from './validation/blocks'
+
+/**
+ * Pre-computed mapping of block slugs to their usedOn field types.
+ * This is calculated once at module load time to avoid runtime recalculation.
+ */
+export const useOn = [...sanitationBlocks, ...validationBlocks].map((block) => ({ block: block.slug, usedOn: block.custom?.usedOn }))

package/template/src/blocks/submitForm/input/validation/blocks.ts

@@ -0,0 +1,6 @@
+import { IvContains } from './contains/block'
+import { IvDoesNotContain } from './doesNotContain/block'
+export { IvContains, IvDoesNotContain }
+
+const ivBlocks = [IvContains, IvDoesNotContain]
+export default ivBlocks

package/template/src/blocks/submitForm/input/validation/contains/block.ts

@@ -0,0 +1,12 @@
+import type { Block } from 'payload'
+import { APField } from '@/fields/apf'
+import { ValidationMessageField } from '@/fields/validationMessage'
+
+export const IvContains: Block = {
+  slug: 'IvContains',
+  interfaceName: 'IvContains',
+  admin: { disableBlockName: true },
+  labels: { singular: 'Contains Value', plural: 'Contains Value' },
+  custom: { usedOn: ['text', 'textarea', 'email'] },
+  fields: [APField({ type: 'text', apf: ['form'], name: 'containsValue', required: true }), ValidationMessageField],
+}

package/template/src/blocks/submitForm/input/validation/contains/serverFunction.ts

@@ -0,0 +1,23 @@
+'use server'
+import { FormFunction } from '@/ts/types'
+import { IvContains as IvContainsType } from '@/ts/types'
+
+export const IvContains: FormFunction<{ block: IvContainsType & { inputName: string } }> = async (args) => {
+  const { formData, response, block } = args
+  const { containsValue, validationMessage, inputName } = block
+
+  const inputValue = formData.get(inputName)
+  if (typeof inputValue !== 'string') {
+    response.success = false
+    response.fm = `Input Value is not a string: ${inputName}`
+    return args
+  }
+
+  if (!inputValue.includes(containsValue)) {
+    response.success = false
+    response.im[inputName] = validationMessage
+    return args
+  }
+
+  return args
+}

package/template/src/blocks/submitForm/input/validation/doesNotContain/block.ts

@@ -0,0 +1,12 @@
+import type { Block } from 'payload'
+import { APField } from '@/fields/apf'
+import { ValidationMessageField } from '@/fields/validationMessage'
+
+export const IvDoesNotContain: Block = {
+  slug: 'IvDoesNotContain',
+  interfaceName: 'IvDoesNotContain',
+  admin: { disableBlockName: true },
+  labels: { singular: 'Does Not Contain', plural: 'Does Not Contain' },
+  custom: { usedOn: ['text', 'textarea', 'email'] },
+  fields: [APField({ type: 'text', apf: ['form'], name: 'doesNotContainValue' }), ValidationMessageField],
+}

package/template/src/blocks/submitForm/input/validation/doesNotContain/serverFunction.ts

@@ -0,0 +1,23 @@
+'use server'
+import { FormFunction } from '@/ts/types'
+import { IvDoesNotContain as IvDoesNotContainType } from '@/ts/types'
+
+export const IvDoesNotContain: FormFunction<{ block: IvDoesNotContainType & { inputName: string } }> = async (args) => {
+  const { formData, response, block } = args
+  const { doesNotContainValue, validationMessage, inputName } = block
+
+  const inputValue = formData.get(inputName)
+  if (typeof inputValue !== 'string') {
+    response.success = false
+    response.fm = `Input Value is not a string: ${inputName}`
+    return args
+  }
+
+  if (doesNotContainValue && inputValue.includes(doesNotContainValue)) {
+    response.success = false
+    response.im[inputName] = validationMessage
+    return args
+  }
+
+  return args
+}

package/template/src/blocks/submitForm/input/validation/functions.ts

@@ -0,0 +1,2 @@
+export * from './contains/serverFunction'
+export * from './doesNotContain/serverFunction'

package/template/src/blocks/submitForm/input/zap.ts

@@ -0,0 +1,6 @@
+import { z } from '@/ts/zap'
+import sanitationBlocks from './sanitation/blocks'
+import validationBlocks from './validation/blocks'
+
+export const InputSanitationBlockType = z.ap.add(z.enum(sanitationBlocks.map((block) => block.slug)), { id: 'InputSanitationBlockType' })
+export const InputValidationBlockType = z.ap.add(z.enum(validationBlocks.map((block) => block.slug)), { id: 'InputValidationBlockType' })

package/template/src/blocks/submitForm/serverFunction.ts

@@ -0,0 +1,42 @@
+'use server'
+import getCached from '@/utilities/get/cache/react'
+import { SubmitFormFunction } from '@/ts/types'
+import { getSubmitFormProcessor } from './formProcessor'
+import { getServerSideURL } from '@/utilities/get/getURL'
+import { draftMode, headers as nextHeaders } from 'next/headers'
+
+const formProcessor = await getSubmitFormProcessor()
+
+export const submitForm: SubmitFormFunction = async (submissionData) => {
+  const headers = await nextHeaders()
+  const { isEnabled: draft } = await draftMode()
+  const { blockID, submissionID, formData } = submissionData
+
+  try {
+    // Get the stored form
+    const backendForms = await getCached('backend-forms')
+    if (!backendForms) return { success: false, formData, submissionID, fm: 'No backend forms found.', im: {} }
+    const atomicForms = await getCached('atomic-forms', draft)
+    if (!atomicForms) return { success: false, formData, submissionID, fm: 'No stored atomic forms found.', im: {} }
+    const allForms = await getCached('all-forms', draft, atomicForms, backendForms)
+    if (!allForms) return { success: false, formData, submissionID, fm: 'No all forms found.', im: {} }
+    const storedForm = allForms.find((form) => form.id === blockID)
+    if (!storedForm || !storedForm.id) return { success: false, formData, submissionID, fm: 'No backend form found for this atomic form.', im: {} }
+
+    const { response, submitToPayload } = await formProcessor.process({ submissionData, headers, storedForm })
+
+    if (response.success) {
+      const req = await fetch(`${getServerSideURL()}/api/form-submissions`, {
+        body: JSON.stringify({ form: storedForm.backendFormID, submissionData: submitToPayload }),
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+      })
+      if (!req.ok) return { success: false, formData, submissionID, fm: 'Failed to store form submission.', im: {} }
+    }
+
+    return response
+  } catch (err: unknown) {
+    console.error(err)
+    return { success: false, formData, submissionID, fm: 'Unknown Error. Please try again later.', im: {} }
+  }
+}