@teleporthq/teleport-uidl-validator 0.18.0

package/src/parser/index.ts

@@ -0,0 +1,227 @@
+import { UIDLUtils } from '@teleporthq/teleport-shared'
+
+import {
+  UIDLDynamicReference,
+  ComponentUIDL,
+  ProjectUIDL,
+  UIDLNode,
+  UIDLConditionalNode,
+  UIDLRepeatNode,
+  UIDLSlotNode,
+  UIDLElementNode,
+  UIDLStaticValue,
+  UIDLStyleSetConditions,
+  UIDLDesignTokens,
+  ParserError,
+} from '@teleporthq/teleport-types'
+
+interface ParseComponentJSONParams {
+  noClone?: boolean
+}
+
+export const parseComponentJSON = (
+  input: Record<string, unknown>,
+  params: ParseComponentJSONParams = {}
+): ComponentUIDL => {
+  const safeInput = params.noClone ? input : UIDLUtils.cloneObject(input)
+
+  if (input?.styleSetDefinitions) {
+    const { styleSetDefinitions } = safeInput
+
+    Object.values(styleSetDefinitions).forEach((styleRef) => {
+      const { conditions = [] } = styleRef
+      styleRef.content = UIDLUtils.transformStylesAssignmentsToJson(styleRef.content)
+      if (conditions.length > 0) {
+        conditions.forEach((style: UIDLStyleSetConditions) => {
+          style.content = UIDLUtils.transformStylesAssignmentsToJson(style.content) as Record<
+            string,
+            UIDLStaticValue
+          >
+        })
+      }
+    })
+  }
+
+  const node = safeInput.node as Record<string, unknown>
+  const result: ComponentUIDL = {
+    ...(safeInput as unknown as ComponentUIDL),
+  }
+
+  // other parsers for other sections of the component here
+  result.node = parseComponentNode(node) as UIDLElementNode
+
+  return result
+}
+
+interface ParseProjectJSONParams {
+  noClone?: boolean
+}
+
+export const parseProjectJSON = (
+  input: Record<string, unknown>,
+  params: ParseProjectJSONParams = {}
+): ProjectUIDL => {
+  const safeInput = params.noClone ? input : UIDLUtils.cloneObject(input)
+  const root = safeInput.root as Record<string, unknown>
+  const result = {
+    ...(safeInput as unknown as ProjectUIDL),
+  }
+  result.root = parseComponentJSON(root, { noClone: true })
+
+  if (result.root?.designLanguage) {
+    const { tokens = {} } = result.root.designLanguage
+
+    result.root.designLanguage.tokens = Object.keys(tokens).reduce(
+      (acc: UIDLDesignTokens, tokenId: string) => {
+        const token = tokens[tokenId]
+        if (typeof token === 'string' || typeof token === 'number') {
+          acc[tokenId] = {
+            type: 'static',
+            content: token,
+          }
+        } else {
+          acc[tokenId] = token
+        }
+        return acc
+      },
+      {}
+    )
+  }
+
+  if (result.components) {
+    result.components = Object.keys(result.components).reduce(
+      (parsedComponnets: Record<string, ComponentUIDL>, key) => {
+        parsedComponnets[key] = parseComponentJSON(
+          result.components[key] as unknown as Record<string, unknown>
+        )
+        return parsedComponnets
+      },
+      {}
+    )
+  }
+
+  return result
+}
+
+const parseComponentNode = (node: Record<string, unknown>): UIDLNode => {
+  switch ((node as unknown as UIDLNode).type) {
+    case 'element':
+      const elementContent = node.content as Record<string, unknown>
+
+      if (elementContent?.referencedStyles) {
+        Object.values(elementContent.referencedStyles).forEach((styleRef) => {
+          const { content } = styleRef
+
+          switch (content.mapType) {
+            case 'inlined': {
+              content.styles = UIDLUtils.transformStylesAssignmentsToJson(
+                content.styles as Record<string, string>
+              )
+              break
+            }
+
+            case 'project-referenced':
+              break
+
+            case 'component-referenced': {
+              if (['string', 'number'].includes(typeof styleRef.content.content)) {
+                styleRef.content.content = {
+                  type: 'static',
+                  content: styleRef.content.content,
+                }
+              }
+              break
+            }
+
+            default: {
+              throw new ParserError(
+                `Un-expected mapType passed in referencedStyles - ${content.mapType}`
+              )
+            }
+          }
+        })
+      }
+
+      if (elementContent.style) {
+        elementContent.style = UIDLUtils.transformStylesAssignmentsToJson(
+          elementContent.style as Record<string, unknown>
+        )
+      }
+
+      if (elementContent.attrs) {
+        elementContent.attrs = UIDLUtils.transformAttributesAssignmentsToJson(
+          elementContent.attrs as Record<string, unknown>
+        )
+      }
+
+      // @ts-ignore
+      if (elementContent.abilities?.link) {
+        // @ts-ignore
+        const { content, type } = elementContent.abilities?.link
+        if (type === 'url' && typeof content.url === 'string') {
+          content.url = UIDLUtils.transformStringAssignmentToJson(content.url)
+        }
+      }
+
+      if (Array.isArray(elementContent.children)) {
+        elementContent.children = elementContent.children.map((child) => {
+          if (typeof child === 'string') {
+            return UIDLUtils.transformStringAssignmentToJson(child)
+          } else {
+            return parseComponentNode(child)
+          }
+        }, [])
+      }
+
+      return node as unknown as UIDLNode
+
+    case 'conditional':
+      const conditionalNode = node as unknown as UIDLConditionalNode
+      const { reference } = conditionalNode.content
+
+      conditionalNode.content.node = parseComponentNode(
+        conditionalNode.content.node as unknown as Record<string, unknown>
+      )
+
+      if (typeof reference === 'string') {
+        conditionalNode.content.reference = UIDLUtils.transformStringAssignmentToJson(
+          reference
+        ) as UIDLDynamicReference
+      }
+
+      return conditionalNode
+
+    case 'repeat':
+      const repeatNode = node as unknown as UIDLRepeatNode
+      const { dataSource } = repeatNode.content
+
+      repeatNode.content.node = parseComponentNode(
+        repeatNode.content.node as unknown as Record<string, unknown>
+      ) as UIDLElementNode
+
+      if (typeof dataSource === 'string') {
+        repeatNode.content.dataSource = UIDLUtils.transformStringAssignmentToJson(dataSource)
+      }
+
+      return repeatNode
+
+    case 'slot':
+      const slotNode = node as unknown as UIDLSlotNode
+
+      if (slotNode.content.fallback) {
+        slotNode.content.fallback = parseComponentNode(
+          slotNode.content.fallback as unknown as Record<string, unknown>
+        ) as UIDLElementNode | UIDLStaticValue | UIDLDynamicReference
+      }
+
+      return slotNode
+
+    case 'dynamic':
+    case 'static':
+    case 'raw':
+      return node as unknown as UIDLNode
+
+    default:
+      throw new ParserError(`parseComponentNode attempted to parsed invalid node type ${node.type}`)
+  }
+}

package/src/validator/index.ts

@@ -0,0 +1,105 @@
+import {
+  ProjectUIDL,
+  ComponentUIDL,
+  ProjectValidationError,
+  ComponentValidationError,
+  VComponentUIDL,
+  VProjectUIDL,
+} from '@teleporthq/teleport-types'
+import { componentUIDLDecoder, rootComponentUIDLDecoder, projectUIDLDecoder } from '../decoders'
+import * as utils from './utils'
+
+interface ValidationResult {
+  valid: boolean
+  errorMsg: string
+  componentUIDL?: VComponentUIDL
+  projectUIDL?: VProjectUIDL
+}
+
+export default class Validator {
+  public validateComponentSchema(input: Record<string, unknown>): ValidationResult {
+    try {
+      const cleanedUIDL = utils.validateNulls(input)
+      const uidl = componentUIDLDecoder.runWithException(cleanedUIDL)
+
+      return { valid: true, errorMsg: '', componentUIDL: uidl }
+    } catch (e) {
+      const errorMsg = utils.formatErrors([{ kind: e.kind, message: e.message, at: e.at }])
+      throw new ComponentValidationError(`Component - ${input?.name} \n
+      ${errorMsg}`)
+    }
+  }
+
+  public validateRootComponentSchema(input: Record<string, unknown>): ValidationResult {
+    try {
+      const cleanedUIDL = utils.validateNulls(input)
+      const uidl = rootComponentUIDLDecoder.runWithException(cleanedUIDL)
+
+      return { valid: true, errorMsg: '', componentUIDL: uidl }
+    } catch (e) {
+      const errorMsg = utils.formatErrors([{ kind: e.kind, message: e.message, at: e.at }])
+      throw new ComponentValidationError(`Component - ${input?.name}\n
+      ${errorMsg}`)
+    }
+  }
+
+  public validateProjectSchema(input: Record<string, unknown>): ValidationResult {
+    try {
+      const cleanedUIDL = utils.validateNulls(input)
+      const uidl = projectUIDLDecoder.runWithException(cleanedUIDL)
+
+      return { valid: true, errorMsg: '', projectUIDL: uidl }
+    } catch (e) {
+      const errorMsg = utils.formatErrors([{ kind: e.kind, message: e.message, at: e.at }])
+      throw new ProjectValidationError(`${input.name}\n
+      ${errorMsg}`)
+    }
+  }
+
+  public validateComponentContent(input: ComponentUIDL): ValidationResult {
+    const errorsInDefinitions = utils.checkDynamicDefinitions(
+      input as unknown as Record<string, unknown>
+    )
+    const errorsWithLocalVariables = utils.checkForLocalVariables(input)
+
+    utils.checkForDuplicateDefinitions(input)
+    const errors = [...errorsInDefinitions, ...errorsWithLocalVariables]
+
+    if (errors.length > 0) {
+      throw new ComponentValidationError(
+        `UIDL Component Content Validation Error. Please check the following: \n${errors}`
+      )
+    }
+
+    return { valid: true, errorMsg: '' }
+  }
+
+  public validateProjectContent(input: ProjectUIDL): ValidationResult {
+    const errorsOnRouteNode = utils.checkRouteDefinition(input) || []
+    let allErrors = errorsOnRouteNode
+
+    if (errorsOnRouteNode.length === 0) {
+      const errorsInStyleSet = utils.checkProjectStyleSet(input)
+      const errorsInRootComponent = utils.checkRootComponent(input)
+
+      const errorsWithComponentNaming = utils.checkComponentNaming(input)
+      const errorsWtihComponentExistence = utils.checkComponentExistenceAndReferences(input)
+
+      allErrors = [
+        ...errorsOnRouteNode,
+        ...errorsWtihComponentExistence,
+        ...errorsWithComponentNaming,
+        ...errorsInRootComponent,
+        ...errorsInStyleSet,
+      ]
+    }
+
+    if (allErrors.length > 0) {
+      throw new ProjectValidationError(
+        `UIDL Project Content Validation Error. Please check the following: ${allErrors}`
+      )
+    }
+
+    return { valid: true, errorMsg: '' }
+  }
+}