@thorprovider/storefront 0.3.1 → 0.4.0-mvp.2

package/skills/sf-view-gen/scripts/schema-validate.mjs

@@ -0,0 +1,132 @@
+// Minimal, dependency-free validator for the JSON Schema subset used by the
+// published storefront schemas. It supports exactly the keywords those schemas
+// use (type, required, properties, items, additionalProperties, minLength,
+// enum) so a document is validated against the same artifact the package
+// publishes, with no duplicated hand-rolled shape contract.
+
+// Validation keywords this validator understands. Annotation-only keywords are
+// allowed through without affecting the result. Any other keyword is reported
+// as unsupported so a future schema cannot silently be treated as valid.
+const VALIDATION_KEYWORDS = new Set([
+  'type',
+  'enum',
+  'minLength',
+  'required',
+  'properties',
+  'additionalProperties',
+  'items',
+])
+// `default` is an annotation: it documents a field's default value but does not
+// affect validation. Feature config contracts use it so `normalizeConfig` can
+// apply declared defaults without a second source of truth.
+const ANNOTATION_KEYWORDS = new Set(['$schema', '$id', 'title', 'description', 'default'])
+const SUPPORTED_KEYWORDS = new Set([...VALIDATION_KEYWORDS, ...ANNOTATION_KEYWORDS])
+
+function typeOf(value) {
+  if (Array.isArray(value)) return 'array'
+  if (value === null) return 'null'
+  return typeof value
+}
+
+function isObject(value) {
+  return typeOf(value) === 'object'
+}
+
+// Own-property lookup: inherited keys (`constructor`, `__proto__`, `toString`)
+// must never be mistaken for declared schema properties or present data, or an
+// `additionalProperties` constraint could be bypassed.
+function hasOwn(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key)
+}
+
+// Walk the schema itself (independent of any value) so an unsupported keyword
+// anywhere in the tree fails clearly instead of being ignored.
+function collectUnsupportedKeywords(schema, path, errors) {
+  if (!isObject(schema)) return
+  for (const keyword of Object.keys(schema)) {
+    if (!SUPPORTED_KEYWORDS.has(keyword)) {
+      errors.push(`${path || 'manifest'} uses an unsupported schema keyword "${keyword}".`)
+    }
+  }
+  const properties = isObject(schema.properties) ? schema.properties : {}
+  for (const key of Object.keys(properties)) {
+    collectUnsupportedKeywords(properties[key], `${path || 'manifest'}.${key}`, errors)
+  }
+  if (isObject(schema.items)) {
+    collectUnsupportedKeywords(schema.items, `${path || 'manifest'}[]`, errors)
+  }
+  if (isObject(schema.additionalProperties)) {
+    collectUnsupportedKeywords(schema.additionalProperties, `${path || 'manifest'}.*`, errors)
+  }
+}
+
+export function validateSchemaSupported(schema) {
+  const errors = []
+  collectUnsupportedKeywords(schema, '', errors)
+  return errors
+}
+
+/**
+ * Validate `value` against `schema`, returning a list of human-readable errors.
+ * Each error is prefixed with the dotted path of the offending field (the root
+ * uses `manifest`), so callers can name the bad input precisely.
+ */
+export function validateAgainstSchema(value, schema, path = '') {
+  const errors = []
+  const label = path || 'manifest'
+
+  if (!isObject(schema)) {
+    errors.push(`${label} uses an invalid schema (expected an object).`)
+    return errors
+  }
+
+  // The schema tree is checked once, at the root, so unsupported keywords fail
+  // closed regardless of which fields the value happens to contain.
+  if (!path) errors.push(...validateSchemaSupported(schema))
+
+  if (schema.type) {
+    const types = Array.isArray(schema.type) ? schema.type : [schema.type]
+    if (!types.includes(typeOf(value))) {
+      errors.push(`${label} must be of type ${types.join(' | ')}.`)
+      return errors
+    }
+  }
+
+  if (Array.isArray(schema.enum) && !schema.enum.includes(value)) {
+    errors.push(`${label} must be one of: ${schema.enum.join(', ')}.`)
+  }
+
+  if (
+    typeof value === 'string' &&
+    typeof schema.minLength === 'number' &&
+    value.length < schema.minLength
+  ) {
+    errors.push(`${label} must be at least ${schema.minLength} character(s).`)
+  }
+
+  if (isObject(value)) {
+    for (const key of schema.required ?? []) {
+      if (!hasOwn(value, key)) errors.push(`${label} is missing required property "${key}".`)
+    }
+    const properties = isObject(schema.properties) ? schema.properties : {}
+    const additional = schema.additionalProperties
+    for (const key of Object.keys(value)) {
+      const childPath = path ? `${path}.${key}` : key
+      if (hasOwn(properties, key)) {
+        errors.push(...validateAgainstSchema(value[key], properties[key], childPath))
+      } else if (isObject(additional)) {
+        errors.push(...validateAgainstSchema(value[key], additional, childPath))
+      } else if (additional === false) {
+        errors.push(`${label} has unknown property "${key}".`)
+      }
+    }
+  }
+
+  if (Array.isArray(value) && isObject(schema.items)) {
+    value.forEach((item, index) => {
+      errors.push(...validateAgainstSchema(item, schema.items, `${path}[${index}]`))
+    })
+  }
+
+  return errors
+}