@joeygrable94/utm-src-pub-validators 0.0.3

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@joeygrable94/utm-src-pub-validators",
+  "description": "Schema Validator for UTM.Src.Pub types",
+  "version": "0.0.3",
+  "author": "Joey Grable <joey@getcommunity.com> (https://joeygrable.com)",
+  "contributors": [],
+  "main": "src/index.ts",
+  "files": [
+    "src"
+  ],
+  "peerDependencies": {
+    "valibot": "^1.1.0"
+  },
+  "keywords": [],
+  "license": "ISC",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": "joeygrable94/utm-src-pub-validators.git",
+  "type": "module",
+  "scripts": {
+    "publish-manual": "npm publish"
+  }
+}

package/src/constants-limits.ts

@@ -0,0 +1,50 @@
+// Generics
+export const LIMIT_MIN_LABEL = 1
+export const LIMIT_MAX_LABEL = 255
+export const LIMIT_MIN_VALUE = 1
+export const LIMIT_MAX_VALUE = 255
+export const LIMIT_MAX_DESCRIPTION = 1024
+// Users
+export const LIMIT_MIN_USERNAME = 3
+export const LIMIT_MAX_USERNAME = 255
+export const LIMIT_MIN_EMAIL = 5
+export const LIMIT_MAX_EMAIL = 255
+export const LIMIT_MIN_PASSWORD = 8
+export const LIMIT_MAX_PASSWORD = 255
+export const LIMIT_MAX_PROVIDER = 255
+// Strapi
+export const LIMIT_MIN_NAME = 2
+export const LIMIT_MAX_NAME = 255
+export const LIMIT_MIN_PRODUCT_ID = 2
+export const LIMIT_MAX_PRODUCT_ID = 64
+export const LIMIT_MIN_PRICE_ID = 2
+export const LIMIT_MAX_PRICE_ID = 64
+export const LIMIT_MIN_UNIT_AMOUNT = 0
+export const LIMIT_MIN_UNIT_TERM_IN_MONTHS = 1
+export const LIMIT_MAX_UNIT_TERM_IN_MONTHS = 12
+// URLs
+export const LIMIT_MIN_DESTINATION = 10
+export const LIMIT_MAX_DESTINATION = 2048
+export const LIMIT_MIN_DOMAIN = 10
+export const LIMIT_MAX_DOMAIN = 253
+export const LIMIT_MIN_PATH = 1
+export const LIMIT_MAX_PATH = 2038
+export const LIMIT_MIN_QUERY = 1
+export const LIMIT_MAX_QUERY = 2038
+export const LIMIT_MIN_FRAGMENT = 1
+export const LIMIT_MAX_FRAGMENT = 2038
+// UTM Parameters
+export const LIMIT_MIN_UTM_SOURCE = 1
+export const LIMIT_MAX_UTM_SOURCE = 2026
+export const LIMIT_MIN_UTM_MEDIUM = 1
+export const LIMIT_MAX_UTM_MEDIUM = 2026
+export const LIMIT_MIN_UTM_CAMPAIGN = 1
+export const LIMIT_MAX_UTM_CAMPAIGN = 2024
+export const LIMIT_MIN_UTM_CREATIVE_FORMAT = 1
+export const LIMIT_MAX_UTM_CREATIVE_FORMAT = 2017
+export const LIMIT_MIN_UTM_CONTENT = 1
+export const LIMIT_MAX_UTM_CONTENT = 2025
+export const LIMIT_MIN_UTM_TERM = 1
+export const LIMIT_MAX_UTM_TERM = 2028
+export const LIMIT_MIN_UTM_ID = 1
+export const LIMIT_MAX_UTM_ID = 2030

package/src/constants-regex.ts

@@ -0,0 +1,8 @@
+// Generics
+export const REGEX_VALUE = /^[a-zA-Z0-9._-]+$/
+export const ERROR_MESSAGE_REGEX_VALUE = `can only contain letters, numbers, and the special characters: - _ .`
+
+export const REGEX_DOMAIN =
+  /^(?=.{1,253}$)(?!\-)((xn--)?[a-zA-Z0-9]{1,59}(-[a-zA-Z0-9]{1,62})?\.)+([a-zA-Z]{2,63}|xn--[a-zA-Z0-9]{2,59})$/
+
+export const ERROR_MESSAGE_REGEX_DOMAIN = 'please provide a valid domain name'

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from './constants-limits'
+export * from './constants-regex'
+export * from './utilities'
+export * from './validators-generics'
+export * from './validators-groups'
+export * from './validators-stripe'
+export * from './validators-urls'
+export * from './validators-users'
+export * from './validators-utm-params'

package/src/utilities.ts

@@ -0,0 +1,64 @@
+import * as v from 'valibot'
+
+function omitUndefined<T extends Record<string, any>>(obj: T): Partial<T> {
+  const result: Partial<T> = {}
+  for (const key in obj) {
+    if (obj[key] !== undefined) {
+      result[key] = obj[key]
+    }
+  }
+  return result
+}
+
+type ValidateAndCleanSuccess<T> = {
+  data: Partial<T>
+  error: null
+  errors: null
+}
+
+type ValidateAndCleanFailure<T> = {
+  data: null
+  error: string
+  errors: Record<string, string>
+}
+
+type ValidateAndCleanResult<T> = ValidateAndCleanSuccess<T> | ValidateAndCleanFailure<T>
+
+export function validateAndClean<T>(
+  schema: v.BaseSchema<T, Partial<T>, v.BaseIssue<T>>,
+  input: unknown
+): ValidateAndCleanResult<T> {
+  try {
+    const parsed = v.parse(schema, input)
+    const cleaned = omitUndefined(parsed)
+    return { data: cleaned, error: null, errors: null }
+  } catch (err: unknown) {
+    if (err instanceof v.ValiError) {
+      const errors: Record<string, string> = {}
+      for (const issue of err.issues) {
+        const field = issue.path?.[0]?.key || 'unknown'
+        errors[field] = issue.message
+      }
+      return { data: null, error: null, errors }
+    }
+    let errorMessage = 'Unknown error'
+    if (err instanceof Error) {
+      errorMessage = err.message
+    } else {
+      errorMessage = String(err)
+    }
+    return { data: null, error: errorMessage, errors: null }
+  }
+}
+
+export function isValidationSuccess<T>(
+  result: ValidateAndCleanResult<T>
+): result is ValidateAndCleanSuccess<T> {
+  return result.error === null && result.errors === null
+}
+
+export function isValidationFailure<T>(
+  result: ValidateAndCleanResult<T>
+): result is ValidateAndCleanFailure<T> {
+  return result.error !== null || result.errors !== null
+}

package/src/validators-generics.ts

@@ -0,0 +1,90 @@
+import * as v from 'valibot'
+import {
+  LIMIT_MAX_LABEL,
+  LIMIT_MIN_LABEL,
+  LIMIT_MAX_VALUE,
+  LIMIT_MIN_VALUE,
+  LIMIT_MAX_DESCRIPTION,
+  LIMIT_MIN_NAME,
+  LIMIT_MAX_NAME
+} from './constants-limits'
+import { ERROR_MESSAGE_REGEX_VALUE, REGEX_VALUE } from './constants-regex'
+
+// reference id for relationships
+export const IsValidReferenceId = v.object({
+  id: v.number('please provide a valid id number')
+})
+
+// cost
+export const IsValidCost = v.pipe(
+  v.number('please enter a cost value'),
+  v.minValue(0),
+  v.maxValue(
+    1000000,
+    'your campaign cost exceeds our $1 million dollar limit, please contact us for enterprise solutions'
+  )
+)
+export const IsValidOrUndefinedCost = v.undefinedable(IsValidCost)
+
+// label
+export const IsValidLabel = v.pipe(
+  v.string('please provide a label'),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_LABEL,
+    `the label is too short, it must be at least ${LIMIT_MIN_LABEL} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_LABEL,
+    `the label is too long, it must be ${LIMIT_MAX_LABEL} characters or less`
+  )
+)
+export const IsValidOrUndefinedLabel = v.undefinedable(IsValidLabel)
+
+// value
+export const IsValidValue = v.pipe(
+  v.string('please provide a value'),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_VALUE,
+    `the value is too short, it must be at least ${LIMIT_MIN_VALUE} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_VALUE,
+    `the value is too long, it must be ${LIMIT_MAX_VALUE} characters or less`
+  ),
+  v.regex(REGEX_VALUE, `the value ${ERROR_MESSAGE_REGEX_VALUE}`)
+)
+export const IsValidOrUndefinedValue = v.undefinedable(IsValidValue)
+
+// description (optional)
+export const IsValidDescription = v.nullable(
+  v.pipe(
+    v.string('the description must be a string'),
+    v.trim(),
+    v.maxLength(
+      LIMIT_MAX_DESCRIPTION,
+      `the description is too long, it must be ${LIMIT_MAX_DESCRIPTION} characters or less`
+    )
+  )
+)
+export const IsValidOrUndefinedDescription = v.optional(IsValidDescription)
+
+// is_active
+export const IsValidIsActive = v.boolean('isActive must be a boolean')
+export const IsValidOrUndefinedIsActive = v.undefinedable(IsValidIsActive)
+
+// name
+export const IsValidName = v.pipe(
+  v.string('please provide a name'),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_NAME,
+    `the name is too short, it must be at least ${LIMIT_MIN_NAME} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_NAME,
+    `the name is too long, it must be ${LIMIT_MAX_NAME} characters or less`
+  )
+)
+export const IsValidOrUndefinedName = v.undefinedable(IsValidName)

package/src/validators-groups.ts

@@ -0,0 +1,15 @@
+import * as v from 'valibot'
+
+export const IsValidApplyValueTo = v.picklist([
+  'source',
+  'medium',
+  'campaign',
+  'content',
+  'creative',
+  'term',
+  'id'
+])
+export const IsValidOrUndefinedApplyValueTo = v.nullable(IsValidApplyValueTo)
+
+export const IsValidApplyValueAs = v.picklist(['prefix', 'suffix'])
+export const IsValidOrUndefinedApplyValueAs = v.nullable(IsValidApplyValueAs)

package/src/validators-stripe.ts

@@ -0,0 +1,65 @@
+import * as v from 'valibot'
+import {
+  LIMIT_MIN_PRICE_ID,
+  LIMIT_MAX_PRICE_ID,
+  LIMIT_MIN_UNIT_AMOUNT,
+  LIMIT_MIN_UNIT_TERM_IN_MONTHS,
+  LIMIT_MAX_UNIT_TERM_IN_MONTHS,
+  LIMIT_MIN_PRODUCT_ID,
+  LIMIT_MAX_PRODUCT_ID
+} from './constants-limits'
+
+// product_id
+export const IsValidProductId = v.pipe(
+  v.string('please provide a product_id'),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_PRODUCT_ID,
+    `the product_id is too short, it must be at least ${LIMIT_MIN_PRODUCT_ID} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_PRODUCT_ID,
+    `the product_id is too long, it must be ${LIMIT_MAX_PRODUCT_ID} characters or less`
+  )
+)
+export const IsValidOrUndefinedProductId = v.undefinedable(IsValidProductId)
+
+// price_id
+export const IsValidPriceId = v.pipe(
+  v.string('please provide a price_id'),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_PRICE_ID,
+    `the price_id is too short, it must be at least ${LIMIT_MIN_PRICE_ID} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_PRICE_ID,
+    `the price_id is too long, it must be ${LIMIT_MAX_PRICE_ID} characters or less`
+  )
+)
+export const IsValidOrUndefinedPriceId = v.undefinedable(IsValidPriceId)
+
+// unit_amount
+export const IsValidUnitAmount = v.pipe(
+  v.number('please provide a unit_amount'),
+  v.minValue(
+    LIMIT_MIN_UNIT_AMOUNT,
+    `the unit_amount must be a decimal greater than or equal to ${LIMIT_MIN_UNIT_AMOUNT}`
+  )
+)
+export const IsValidOrUndefinedUnitAmount = v.undefinedable(IsValidUnitAmount)
+
+export const IsValidUnitTermInMonths = v.pipe(
+  v.number('please provide a unit_term_in_months'),
+  v.minValue(
+    LIMIT_MIN_UNIT_TERM_IN_MONTHS,
+    `the unit_term_in_months must be an integer greater than or equal to ${LIMIT_MIN_UNIT_TERM_IN_MONTHS}`
+  ),
+  v.maxValue(
+    LIMIT_MAX_UNIT_TERM_IN_MONTHS,
+    `the unit_term_in_months must be an integer less than or equal to ${LIMIT_MAX_UNIT_TERM_IN_MONTHS}`
+  )
+)
+export const IsValidOrUndefinedUnitTermInMonths = v.undefinedable(
+  IsValidUnitTermInMonths
+)

package/src/validators-urls.ts

@@ -0,0 +1,98 @@
+import * as v from 'valibot'
+import {
+  LIMIT_MAX_DESTINATION,
+  LIMIT_MAX_DOMAIN,
+  LIMIT_MAX_FRAGMENT,
+  LIMIT_MAX_PATH,
+  LIMIT_MAX_QUERY,
+  LIMIT_MIN_DESTINATION,
+  LIMIT_MIN_DOMAIN,
+  LIMIT_MIN_FRAGMENT,
+  LIMIT_MIN_PATH,
+  LIMIT_MIN_QUERY
+} from './constants-limits'
+import { ERROR_MESSAGE_REGEX_DOMAIN, REGEX_DOMAIN } from './constants-regex'
+
+// destination
+export const IsValidUrlDestination = v.pipe(
+  v.string('please provide a url destination'),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_DESTINATION,
+    `the url destination is too short, it must be at least ${LIMIT_MIN_DESTINATION} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_DESTINATION,
+    `the url destination is too long, it must be ${LIMIT_MAX_DESTINATION} characters or less`
+  ),
+  v.url('please provide a valid url')
+)
+export const IsValidOrUndefinedUrlDestination = v.nullable(IsValidUrlDestination)
+
+// protocol
+export const IsValidUrlProtocol = v.picklist(
+  ['http', 'https'],
+  'please provide a valid url protocol'
+)
+export const IsValidOrUndefinedUrlProtocol = v.nullable(IsValidUrlProtocol)
+
+// domain
+export const IsValidUrlDomain = v.pipe(
+  v.string('please provide a domain'),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_DOMAIN,
+    `the domain is too short, it must be at least ${LIMIT_MIN_DOMAIN} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_DOMAIN,
+    `the domain is too long, it must be ${LIMIT_MAX_DOMAIN} characters or less`
+  ),
+  v.regex(REGEX_DOMAIN, ERROR_MESSAGE_REGEX_DOMAIN)
+)
+export const IsValidOrUndefinedUrlDomain = v.nullable(IsValidUrlDomain)
+
+// path
+export const IsValidUrlPath = v.pipe(
+  v.string('please provide a url path'),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_PATH,
+    `the url path is too short, it must be at least ${LIMIT_MIN_PATH} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_PATH,
+    `the url path is too long, it must be ${LIMIT_MAX_PATH} characters or less`
+  )
+)
+export const IsValidOrUndefinedUrlPath = v.nullable(IsValidUrlPath)
+
+// query
+export const IsValidUrlQuery = v.pipe(
+  v.string('please provide a url query'),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_QUERY,
+    `the url query is too short, it must be at least ${LIMIT_MIN_QUERY} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_QUERY,
+    `the url query is too long, it must be ${LIMIT_MAX_QUERY} characters or less`
+  )
+)
+export const IsValidOrUndefinedUrlQuery = v.nullable(IsValidUrlQuery)
+
+// fragment
+export const IsValidUrlFragment = v.pipe(
+  v.string('please provide a url hash/fragment'),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_FRAGMENT,
+    `the url hash/fragment is too short, it must be at least ${LIMIT_MIN_FRAGMENT} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_FRAGMENT,
+    `the url hash/fragment is too long, it must be ${LIMIT_MAX_FRAGMENT} characters or less`
+  )
+)
+export const IsValidOrUndefinedUrlFragment = v.nullable(IsValidUrlFragment)

package/src/validators-users.ts

@@ -0,0 +1,71 @@
+import * as v from 'valibot'
+import {
+  LIMIT_MAX_EMAIL,
+  LIMIT_MAX_PASSWORD,
+  LIMIT_MAX_PROVIDER,
+  LIMIT_MAX_USERNAME,
+  LIMIT_MIN_EMAIL,
+  LIMIT_MIN_PASSWORD,
+  LIMIT_MIN_USERNAME
+} from './constants-limits'
+import { ERROR_MESSAGE_REGEX_VALUE, REGEX_VALUE } from './constants-regex'
+
+export const IsValidUsername = v.pipe(
+  v.string('please provide a username'),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_USERNAME,
+    `your username is too short, it must be at least ${LIMIT_MIN_USERNAME} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_USERNAME,
+    `your username is too long, it must be ${LIMIT_MAX_USERNAME} characters or less`
+  ),
+  v.regex(REGEX_VALUE, `your username ${ERROR_MESSAGE_REGEX_VALUE}`)
+)
+export const IsValidOrUndefinedUsername = v.undefinedable(IsValidUsername)
+
+export const IsValidEmail = v.pipe(
+  v.string('please provide an email'),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_EMAIL,
+    `your email is too short, it must be at least ${LIMIT_MIN_EMAIL} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_EMAIL,
+    `your email is too long, it must be ${LIMIT_MAX_EMAIL} characters or less`
+  ),
+  v.email('please provide a valid email address')
+)
+export const IsValidOrUndefinedEmail = v.undefinedable(IsValidEmail)
+
+export const IsValidPassword = v.pipe(
+  v.string('a password is required'),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_PASSWORD,
+    `your password is too short, it must be at least ${LIMIT_MIN_PASSWORD} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_PASSWORD,
+    `your password is too long, it must be ${LIMIT_MAX_PASSWORD} characters or less`
+  )
+)
+export const IsValidOrUndefinedPassword = v.undefinedable(IsValidPassword)
+
+export const IsValidProvider = v.pipe(
+  v.string('please enter a provider'),
+  v.trim(),
+  v.maxLength(
+    LIMIT_MAX_PROVIDER,
+    `the provider string is too long, it must be ${LIMIT_MAX_PROVIDER} characters or less`
+  )
+)
+export const IsValidOrUndefinedProvider = v.undefinedable(IsValidProvider)
+
+export const IsValidConfirmed = v.boolean()
+export const IsValidOrUndefinedConfirmed = v.undefinedable(IsValidConfirmed)
+
+export const IsValidBlocked = v.boolean()
+export const IsValidOrUndefinedBlocked = v.undefinedable(IsValidBlocked)

package/src/validators-utm-params.ts

@@ -0,0 +1,132 @@
+import * as v from 'valibot'
+import {
+  LIMIT_MAX_UTM_CAMPAIGN,
+  LIMIT_MAX_UTM_CREATIVE_FORMAT,
+  LIMIT_MAX_UTM_MEDIUM,
+  LIMIT_MAX_UTM_SOURCE,
+  LIMIT_MIN_UTM_CAMPAIGN,
+  LIMIT_MIN_UTM_CREATIVE_FORMAT,
+  LIMIT_MIN_UTM_MEDIUM,
+  LIMIT_MIN_UTM_SOURCE,
+  LIMIT_MIN_UTM_CONTENT,
+  LIMIT_MAX_UTM_CONTENT,
+  LIMIT_MIN_UTM_TERM,
+  LIMIT_MAX_UTM_TERM,
+  LIMIT_MIN_UTM_ID,
+  LIMIT_MAX_UTM_ID
+} from './constants-limits'
+import { ERROR_MESSAGE_REGEX_VALUE, REGEX_VALUE } from './constants-regex'
+
+// utm_source
+export const IsValidUrlUtmSource = v.pipe(
+  v.string(),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_UTM_SOURCE,
+    `the utm_source is too short, it must be at least ${LIMIT_MIN_UTM_SOURCE} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_UTM_SOURCE,
+    `the utm_source is too long, it must be ${LIMIT_MAX_UTM_SOURCE} characters or less`
+  ),
+  v.regex(REGEX_VALUE, `utm_source ${ERROR_MESSAGE_REGEX_VALUE}`)
+)
+export const IsValidOrUndefinedUrlUtmSource = v.nullable(IsValidUrlUtmSource)
+
+// utm_medium
+export const IsValidUrlUtmMedium = v.pipe(
+  v.string(),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_UTM_MEDIUM,
+    `the utm_medium is too short, it must be at least ${LIMIT_MIN_UTM_MEDIUM} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_UTM_MEDIUM,
+    `the utm_medium is too long, it must be ${LIMIT_MAX_UTM_MEDIUM} characters or less`
+  ),
+  v.regex(REGEX_VALUE, `utm_medium ${ERROR_MESSAGE_REGEX_VALUE}`)
+)
+export const IsValidOrUndefinedUrlUtmMedium = v.nullable(IsValidUrlUtmMedium)
+
+// utm_campaign
+export const IsValidUrlUtmCampaign = v.pipe(
+  v.string(),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_UTM_CAMPAIGN,
+    `the utm_campaign is too short, it must be at least ${LIMIT_MIN_UTM_CAMPAIGN} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_UTM_CAMPAIGN,
+    `the utm_campaign is too long, it must be ${LIMIT_MAX_UTM_CAMPAIGN} characters or less`
+  ),
+  v.regex(REGEX_VALUE, `utm_campaign ${ERROR_MESSAGE_REGEX_VALUE}`)
+)
+export const IsValidOrUndefinedUrlUtmCampaign = v.nullable(IsValidUrlUtmCampaign)
+
+// utm_creative_format
+export const IsValidUrlUtmCreativeFormat = v.pipe(
+  v.string(),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_UTM_CREATIVE_FORMAT,
+    `the utm_creative_format is too short, it must be at least ${LIMIT_MIN_UTM_CREATIVE_FORMAT} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_UTM_CREATIVE_FORMAT,
+    `the utm_creative_format is too long, it must be ${LIMIT_MAX_UTM_CREATIVE_FORMAT} characters or less`
+  ),
+  v.regex(REGEX_VALUE, `utm_creative_format ${ERROR_MESSAGE_REGEX_VALUE}`)
+)
+export const IsValidOrUndefinedUrlUtmCreativeFormat = v.nullable(
+  IsValidUrlUtmCreativeFormat
+)
+
+// utm_content
+export const IsValidUrlUtmContent = v.pipe(
+  v.string(),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_UTM_CONTENT,
+    `the utm_content is too short, it must be at least ${LIMIT_MIN_UTM_CONTENT} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_UTM_CONTENT,
+    `the utm_content is too long, it must be ${LIMIT_MAX_UTM_CONTENT} characters or less`
+  ),
+  v.regex(REGEX_VALUE, `utm_content ${ERROR_MESSAGE_REGEX_VALUE}`)
+)
+export const IsValidOrUndefinedUrlUtmContent = v.nullable(IsValidUrlUtmContent)
+
+// utm_term
+export const IsValidUrlUtmTerm = v.pipe(
+  v.string(),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_UTM_TERM,
+    `the utm_term is too short, it must be at least ${LIMIT_MIN_UTM_TERM} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_UTM_TERM,
+    `the utm_term is too long, it must be ${LIMIT_MAX_UTM_TERM} characters or less`
+  ),
+  v.regex(REGEX_VALUE, `utm_term ${ERROR_MESSAGE_REGEX_VALUE}`)
+)
+export const IsValidOrUndefinedUrlUtmTerm = v.nullable(IsValidUrlUtmTerm)
+
+// utm_id
+export const IsValidUrlUtmId = v.pipe(
+  v.string(),
+  v.trim(),
+  v.minLength(
+    LIMIT_MIN_UTM_ID,
+    `the utm_id is too short, it must be at least ${LIMIT_MIN_UTM_ID} characters`
+  ),
+  v.maxLength(
+    LIMIT_MAX_UTM_ID,
+    `the utm_id is too long, it must be ${LIMIT_MAX_UTM_ID} characters or less`
+  ),
+  v.regex(REGEX_VALUE, `utm_id ${ERROR_MESSAGE_REGEX_VALUE}`)
+)
+export const IsValidOrUndefinedUrlUtmId = v.nullable(IsValidUrlUtmId)