@ditojs/admin 2.100.0 → 3.0.0

package/src/utils/schema/structure.js

@@ -0,0 +1,172 @@
+import { isObject, isString } from '@ditojs/utils'
+import { getTypeOptions, getSourceType } from './types.js'
+
+export function iterateSchemaComponents(schemas, callback) {
+  for (const schema of schemas) {
+    if (isSingleComponentView(schema)) {
+      const res = callback(schema.component, schema.name, 0)
+      if (res !== undefined) {
+        return res
+      }
+    } else if (isSchema(schema)) {
+      for (const [name, component] of Object.entries(schema.components || {})) {
+        const res = callback(component, name, 1)
+        if (res !== undefined) {
+          return res
+        }
+      }
+    }
+  }
+}
+
+export function iterateNestedSchemaComponents(schema, callback) {
+  return schema
+    ? iterateSchemaComponents([schema, ...getTabSchemas(schema)], callback)
+    : undefined
+}
+
+export function findNestedSchemaComponent(schema, callback) {
+  return (
+    iterateNestedSchemaComponents(
+      schema,
+      component => (callback(component) ? component : undefined)
+    ) ?? null
+  )
+}
+
+export function someNestedSchemaComponent(schema, callback) {
+  return (
+    iterateNestedSchemaComponents(
+      schema,
+      (component, name) => (callback(component, name) ? true : undefined)
+    ) ?? false
+  )
+}
+
+export function everyNestedSchemaComponent(schema, callback) {
+  return (
+    iterateNestedSchemaComponents(
+      schema,
+      component => (callback(component) ? undefined : false)
+    ) ?? true
+  )
+}
+
+export function hasNestedSchemaComponents(schema) {
+  return someNestedSchemaComponent(schema, () => true) ?? false
+}
+
+/**
+ * Returns whether `schema` has a component named `name` in its components or
+ * tabs, or in those of its unnested components, e.g. sections without
+ * `nested: true`, which share the data of `schema` without adding their own
+ * name to the data path.
+ */
+export function hasComponentNamed(schema, name) {
+  const found = iterateNestedSchemaComponents(
+    schema,
+    (component, componentName) => {
+      if (
+        isNested(component)
+          ? componentName === name
+          : hasComponentNamed(component, name)
+      ) {
+        return true
+      }
+    }
+  )
+  return !!found
+}
+
+export function isSchema(schema) {
+  return isObject(schema) && isString(schema.type)
+}
+
+export function isForm(schema) {
+  return isSchema(schema) && schema.type === 'form'
+}
+
+export function isView(schema) {
+  return isSchema(schema) && schema.type === 'view'
+}
+
+export function isTab(schema) {
+  return isSchema(schema) && schema.type === 'tab'
+}
+
+export function isPanel(schema) {
+  return isSchema(schema) && schema.type === 'panel'
+}
+
+// Returns whether `schema` is a panel that provides its own data through
+// `schema.data`, e.g. a filters panel, instead of sharing the data of its
+// schema, see `DitoPanel`.
+export function isPanelWithOwnData(schema) {
+  return isPanel(schema) && !!schema.data
+}
+
+export function isMenu(schema) {
+  return isSchema(schema) && schema.type === 'menu'
+}
+
+export function getSchemaIdentifier(schema) {
+  return JSON.stringify(schema)
+}
+
+export function isSingleComponentView(schema) {
+  return (
+    isView(schema) &&
+    isObject(schema.component)
+  )
+}
+
+export function isCompact(schema) {
+  return !!schema.compact
+}
+
+export function isInlined(schema) {
+  return !!(schema.inlined || schema.components)
+}
+
+export function isNested(schema) {
+  return !!(schema.nested || getTypeOptions(schema)?.defaultNested === true)
+}
+
+export function hasLabel(schema, generateLabels) {
+  const { label } = schema
+  return (
+    label !== false && (
+      !!label ||
+      generateLabels && getTypeOptions(schema)?.generateLabel
+    )
+  )
+}
+
+export function omitSpacing(schema) {
+  return !!getTypeOptions(schema)?.omitSpacing
+}
+
+export function getTabSchemas(schema) {
+  return schema?.tabs ? Object.values(schema.tabs) : []
+}
+
+export function getPanelSchemas(schema) {
+  return schema?.panels ? Object.values(schema.panels) : []
+}
+
+export function isObjectSource(schemaOrType) {
+  return getSourceType(schemaOrType) === 'object'
+}
+
+export function isListSource(schemaOrType) {
+  return getSourceType(schemaOrType) === 'list'
+}
+
+/**
+ * Returns whether `schema` is a source with its own resource, whose items are
+ * loaded, validated and submitted through their own forms, separately from
+ * the data that contains them.
+ */
+export function isSourceWithResource(schema) {
+  return !!getSourceType(schema) && !!schema.resource
+}

package/src/utils/schema/structure.test.js

@@ -0,0 +1,57 @@
+import { registerTypeComponent } from './types.js'
+import { hasComponentNamed } from './structure.js'
+
+// Register minimal type options, as the actual type components can't be
+// imported without a Vue SFC compiler:
+registerTypeComponent('text', { defaultNested: true })
+registerTypeComponent('section', { defaultNested: false })
+
+describe('hasComponentNamed()', () => {
+  const schema = {
+    type: 'form',
+    components: {
+      title: { type: 'text' },
+      unnested: {
+        type: 'section',
+        components: {
+          note: { type: 'text' },
+          inner: {
+            type: 'section',
+            components: { remark: { type: 'text' } }
+          }
+        }
+      },
+      nested: {
+        type: 'section',
+        nested: true,
+        components: { subtitle: { type: 'text' } }
+      }
+    },
+    tabs: {
+      tab: {
+        type: 'tab',
+        components: { edition: { type: 'text' } }
+      }
+    }
+  }
+
+  it('finds components and components in tabs', () => {
+    expect(hasComponentNamed(schema, 'title')).toBe(true)
+    expect(hasComponentNamed(schema, 'edition')).toBe(true)
+  })
+
+  it('finds components of unnested components', () => {
+    expect(hasComponentNamed(schema, 'note')).toBe(true)
+    expect(hasComponentNamed(schema, 'remark')).toBe(true)
+  })
+
+  it('finds nested components, but not their components', () => {
+    expect(hasComponentNamed(schema, 'nested')).toBe(true)
+    expect(hasComponentNamed(schema, 'subtitle')).toBe(false)
+  })
+
+  it('ignores the names of unnested components', () => {
+    expect(hasComponentNamed(schema, 'unnested')).toBe(false)
+    expect(hasComponentNamed(schema, 'unknown')).toBe(false)
+  })
+})

package/src/utils/schema/types.js

@@ -0,0 +1,34 @@
+import { isObject } from '@ditojs/utils'
+
+const typeComponents = {}
+
+const unknownTypeReported = {}
+
+export function registerTypeComponent(type, component) {
+  typeComponents[type] = component
+}
+
+export function getTypeComponent(type, allowNull = false) {
+  const component = typeComponents[type] || null
+  if (!component && !allowNull && !unknownTypeReported[type]) {
+    // Report each missing type only once, to avoid flooding the console:
+    unknownTypeReported[type] = true
+    throw new Error(`Unknown Dito.js component type: '${type}'`)
+  }
+  return component
+}
+
+function getType(schemaOrType) {
+  return isObject(schemaOrType) ? schemaOrType.type : schemaOrType
+}
+
+export function getTypeOptions(schemaOrType) {
+  return getTypeComponent(getType(schemaOrType), true) ?? null
+}
+
+export function getSourceType(schemaOrType) {
+  return (
+    getTypeOptions(schemaOrType)?.getSourceType?.(getType(schemaOrType)) ??
+    null
+  )
+}

package/src/utils/schema/validation.js

@@ -0,0 +1,142 @@
+import DitoContext from '../../DitoContext.js'
+import * as validators from '../../validators/index.js'
+import { isFunction, isRegExp, asArray, normalizeDataPath } from '@ditojs/utils'
+import { getTypeOptions } from './types.js'
+import { isSourceWithResource } from './structure.js'
+import {
+  getSchemaValue,
+  shouldRenderSchema,
+  processSchemaData
+} from './data.js'
+
+/**
+ * Returns the validations of a component schema, without requiring a
+ * component: the validations of the type's static `getTypeValidations()`
+ * option, `required`, and finally the `schema.rules` overrides, where
+ * `undefined` removes a validation. Schema values are evaluated with `context`.
+ */
+export function getValidations(schema, context) {
+  const validations = {
+    ...getTypeOptions(schema)?.getTypeValidations?.(schema, context)
+  }
+  if (getSchemaValue('required', { type: Boolean, schema, context })) {
+    validations.required = true
+  }
+  // Allow schema to override default rules and add any new ones:
+  for (const [name, setting] of Object.entries(schema.rules || {})) {
+    if (setting === undefined) {
+      delete validations[name]
+    } else {
+      validations[name] = setting
+    }
+  }
+  return validations
+}
+
+/**
+ * Returns the errors of validating `value` against `validations`, in the
+ * format of server errors, `[{ message }]`, with messages without the label
+ * prefix, or an empty array if the value is valid.
+ */
+export function getValueValidationErrors(value, validations) {
+  const errors = []
+  for (const [name, setting] of Object.entries(validations)) {
+    // eslint-disable-next-line import/namespace
+    const validator = validators[name]
+    if (
+      validator &&
+      // Only apply 'required' validator to empty values.
+      // Apply all other validators only to non-empty values.
+      (name === 'required' || value != null && value !== '')
+    ) {
+      const { validate, message } = validator
+      if (!validate(value, setting, validations)) {
+        errors.push({
+          message: isFunction(message)
+            ? message(value, setting, validations)
+            : message
+        })
+      }
+    }
+  }
+  return errors
+}
+
+/**
+ * Validates `data` along the components of `schema`, including tabs, panels
+ * and the nested forms of list and object items, skipping components whose
+ * `if` evaluates to `false` and sources with their own resource. Returns the
+ * errors in the format of server errors, `{ [dataPath]: [{ message }] }`, or
+ * `null` if the data is valid.
+ */
+export function getDataValidationErrors(schema, data, {
+  dataPath = '',
+  component = null,
+  rootData = data
+} = {}) {
+  let errors = null
+
+  const createContext = ({ schema, data, name, dataPath }) =>
+    new DitoContext(component, {
+      schema,
+      value: name != null ? data[name] : undefined,
+      name,
+      data,
+      dataPath,
+      rootData
+    })
+
+  const shouldProcess = entry => (
+    !isSourceWithResource(entry.schema) &&
+    shouldRenderSchema(entry.schema, createContext(entry))
+  )
+
+  const before = entry => {
+    const { schema, data, name, dataPath } = entry
+    const context = createContext(entry)
+    let value = data[name]
+    // Validate the value as displayed, like the components do, see
+    // `ValueMixin.value`:
+    const { format } = schema
+    if (isFunction(format)) {
+      value = format(context)
+    }
+    const validations = getValidations(schema, context)
+    const valueErrors = getValueValidationErrors(value, validations)
+    if (valueErrors.length > 0) {
+      errors ||= {}
+      errors[dataPath] = valueErrors
+    }
+  }
+
+  processSchemaData(schema, data, {
+    dataPath,
+    shouldProcess,
+    before,
+    options: { component, rootData }
+  })
+  return errors
+}
+
+/**
+ * Returns the entries of `errors` whose data paths match `match`, or `null` if
+ * none match. `match` can be a function receiving the data path, a regular
+ * expression, a data path, or an array of data paths.
+ */
+export function getMatchingValidationErrors(errors, match) {
+  let isMatchingDataPath
+  if (isFunction(match)) {
+    isMatchingDataPath = match
+  } else if (isRegExp(match)) {
+    isMatchingDataPath = dataPath => match.test(dataPath)
+  } else {
+    const dataPaths = asArray(match).map(normalizeDataPath)
+    isMatchingDataPath = dataPath => dataPaths.includes(dataPath)
+  }
+  const matchingEntries = Object.entries(errors || {}).filter(
+    ([dataPath]) => isMatchingDataPath(dataPath)
+  )
+  return matchingEntries.length > 0
+    ? Object.fromEntries(matchingEntries)
+    : null
+}