@sanity/validation 3.14.4 → 6.12.0-next.112

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2016 - 2023 Sanity.io
+Copyright (c) 2016 - 2026 Sanity.io
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -0,0 +1,52 @@
+# @sanity/validation
+
+Validates complete Sanity documents against a compiled Sanity schema.
+
+```ts
+import {validateDocument, validationMarkerCodes} from '@sanity/validation'
+
+const markers = await validateDocument({document, schema, client})
+
+for (const marker of markers) {
+  if (marker.code === validationMarkerCodes.stringMinimumLength) {
+    const {actualLength, minimumLength} = marker.details || {}
+    if (typeof actualLength === 'number' && typeof minimumLength === 'number') {
+      console.log(`Expected at least ${minimumLength} characters, got ${actualLength}`)
+    }
+  }
+}
+
+const summary = markers
+  .map((marker) => {
+    const path = marker.path
+      .map((segment) => (typeof segment === 'object' ? segment._key : segment))
+      .join('.')
+
+    return `[${marker.level}] ${path || '<document>'}: ${marker.message} (${marker.code})`
+  })
+  .join('\n')
+```
+
+Every returned marker includes a stable machine-readable `code` alongside its localized `message`,
+`level`, and `path`. Built-in failures may also include structured `details`. Custom validators can
+return their own `code` and `details`; custom codes should be namespaced, for example
+`custom.seo-title`.
+
+The package does not apply mutations or decide whether a document may be edited or published.
+
+## Migrating from `sanity`
+
+Add `@sanity/validation` as a direct dependency. The workspace-based API is available as a
+compatibility overload, so call sites that only import `validateDocument` can migrate by changing
+the import:
+
+```ts
+import {validateDocument} from '@sanity/validation'
+
+const markers = await validateDocument({document, workspace})
+```
+
+Call sites that also import `ValidateDocumentOptions` from `sanity` should use
+`ValidateDocumentWorkspaceOptions` for the workspace-shaped options.
+
+Prefer the `{document, schema, client}` API for new code.

package/lib/_internal.d.ts

@@ -0,0 +1,96 @@
+import { c as resolveTypeForArrayItem, d as validateDocumentObservable, g as ValidationMarkerCode, n as ValidateDocumentObservableOptions, p as validateItem, t as ValidateDocumentInternalOptions, u as validateDocumentInternal, v as ValidationContext, y as LocaleSource } from "./validateDocument-6pLTIHIn.js";
+import { Path, Rule as Rule$1, RuleClass, Schema, SchemaType, SchemaValidationValue, ValidationContext as ValidationContext$1, ValidationError, ValidationMarker } from "@sanity/types";
+declare function getFallbackLocaleSource(): LocaleSource;
+declare const validationLocaleStrings: {
+  readonly 'array.exact-length': 'Must have exactly {{wantedLength}} items';
+  readonly 'array.exact-length_blocks': 'Must have exactly {{wantedLength}} blocks';
+  readonly 'array.item-duplicate': "Can't be a duplicate";
+  readonly 'array.maximum-length': 'Must have at most {{maxLength}} items';
+  readonly 'array.maximum-length_blocks': 'Must have at most {{maxLength}} blocks';
+  readonly 'array.minimum-length': 'Must have at least {{minLength}} items';
+  readonly 'array.minimum-length_blocks': 'Must have at least {{minLength}} blocks';
+  readonly 'date.invalid-format': 'Must be a valid ISO-8601 formatted date string';
+  readonly 'date.maximum': 'Must be at or before {{maxDate}}';
+  readonly 'date.minimum': 'Must be at or after {{minDate}}';
+  readonly 'generic.incorrect-type': 'Expected type "{{expectedType}}", got "{{actualType}}"';
+  readonly 'generic.not-allowed': 'Value did not match any allowed values';
+  readonly 'generic.not-allowed_hint': 'Value "{{hint}}" did not match any allowed values';
+  readonly 'generic.required': 'Required';
+  readonly 'number.greater-than': 'Must be greater than {{threshold}}';
+  readonly 'number.less-than': 'Must be less than {{threshold}}';
+  readonly 'number.maximum': 'Must be lower than or equal to {{maxNumber}}';
+  readonly 'number.maximum-precision': 'Max precision is {{limit}}';
+  readonly 'number.minimum': 'Must be greater than or equal to {{minNumber}}';
+  readonly 'number.non-integer': 'Must be an integer';
+  readonly 'object.asset-required': 'Asset is required';
+  readonly 'object.asset-required_file': 'File is required';
+  readonly 'object.asset-required_image': 'Image is required';
+  readonly 'object.media-not-found': 'The asset could not be found in the Media Library';
+  readonly 'object.not-media-library-asset': 'Must be a reference to a Media Library asset';
+  readonly 'object.not-reference': 'Must be a reference to a document';
+  readonly 'object.reference-not-published': 'Referenced document must be published';
+  readonly 'slug.missing-current': 'Slug must have a value';
+  readonly 'slug.not-object': 'Slug must be an object';
+  readonly 'slug.not-unique': 'Slug is already in use';
+  readonly 'string.email': 'Must be a valid email address';
+  readonly 'string.exact-length': 'Must be exactly {{wantedLength}} characters long';
+  readonly 'string.lowercase': 'Must be all lowercase characters';
+  readonly 'string.maximum-length': 'Must be at most {{maxLength}} characters long';
+  readonly 'string.minimum-length': 'Must be at least {{minLength}} characters long';
+  readonly 'string.regex-does-not-match': 'Does not match "{{name}}"-pattern';
+  readonly 'string.regex-match': 'Should not match "{{name}}"-pattern';
+  readonly 'string.uppercase': 'Must be all uppercase characters';
+  readonly 'string.url.disallowed-scheme': 'Does not match allowed protocols/schemes';
+  readonly 'string.url.includes-credentials': 'Username/password not allowed';
+  readonly 'string.url.invalid': 'Not a valid URL';
+  readonly 'string.url.not-absolute': 'Relative URLs are not allowed';
+  readonly 'string.url.not-relative': 'Only relative URLs are allowed';
+};
+declare function inferFromSchema(schema: Schema): Schema;
+declare function inferFromSchemaType(typeDef: SchemaType, _schema: Schema, _visited?: Set<SchemaType>): SchemaType;
+declare function inferFromSchemaType(typeDef: SchemaType): SchemaType;
+/**
+ * Checks if a validation function uses the context parameter.
+ *
+ * Functions with 2+ parameters like `(rule, context) => ...` need runtime context
+ * (e.g., `context.hidden`, `context.document`) and cannot be pre-evaluated at schema compile time.
+ *
+ * Functions with 1 parameter like `(rule) => rule.required()` don't need context
+ * and can be normalized immediately for better performance.
+ *
+ * @internal
+ */
+declare function hasValidationContext(validation: SchemaValidationValue | undefined): boolean;
+/**
+ * Concrete Rule implementation with validation logic.
+ * This extends the base Rule class from `@sanity/schema` and adds the validate method.
+ *
+ * Note: `RuleClass` and `Rule` are split to fit the current `@sanity/types`
+ * setup. Classes are a bit weird in the `@sanity/types` package because classes
+ * create an actual javascript class while simultaneously creating a type
+ * definition.
+ *
+ * This implicitly creates two types:
+ * 1. the instance type — `Rule` and
+ * 2. the static/class type - `RuleClass`
+ *
+ * The `RuleClass` type contains the static methods and the `Rule` instance
+ * contains the instance methods.
+ *
+ * This package exports the RuleClass as a value without implicitly exporting
+ * an instance definition. This should help reminder downstream users to import
+ * from the `@sanity/types` package.
+ *
+ * @internal
+ */
+declare const Rule: RuleClass;
+declare function convertToValidationMarker(validatorResult: true | true[] | string | string[] | ValidationError | ValidationError[], level: 'error' | 'warning' | 'info' | undefined, context: ValidationContext, fallback?: {
+  code: ValidationMarkerCode;
+  details?: Record<string, unknown>;
+}): ValidationMarker[];
+declare function getTypeChain(type: SchemaType | undefined, visited?: Set<SchemaType>): SchemaType[];
+declare function normalizeValidationRules(typeDef: SchemaType | undefined, context?: ValidationContext$1): Rule$1[];
+declare function pathToString(path?: Path | undefined): string;
+declare function typeString(obj: unknown): string;
+export { type LocaleSource, Rule, type ValidateDocumentInternalOptions, type ValidateDocumentObservableOptions, type ValidationContext, convertToValidationMarker, getFallbackLocaleSource, getTypeChain, hasValidationContext, inferFromSchema, inferFromSchemaType, normalizeValidationRules, pathToString, resolveTypeForArrayItem, typeString, validateDocumentInternal, validateDocumentObservable, validateItem, validationLocaleStrings };
+//# sourceMappingURL=_internal.d.ts.map

package/lib/_internal.js

@@ -0,0 +1,39 @@
+import { c as normalizeValidationRules, d as convertToValidationMarker, f as pathToString, i as validateDocumentObservable, l as Rule, m as validationLocaleStrings, o as validateItem, p as getFallbackLocaleSource, r as validateDocumentInternal, s as getTypeChain, t as resolveTypeForArrayItem, u as typeString } from "./validateDocument-Cq33kUmN.js";
+function inferFromSchemaType(typeDef) {
+	return traverse(typeDef, /* @__PURE__ */ new Set()), typeDef;
+}
+function traverse(typeDef, visited) {
+	if (!visited.has(typeDef)) {
+		if (visited.add(typeDef), hasValidationContext(typeDef.validation) || (typeDef.validation = normalizeValidationRules(typeDef)), "fields" in typeDef) for (let field of typeDef.fields) traverse(field.type, visited);
+		if ("of" in typeDef) for (let candidate of typeDef.of) traverse(candidate, visited);
+		if (typeDef.annotations) for (let annotation of typeDef.annotations) traverse(annotation, visited);
+	}
+}
+/**
+* Checks if a validation function uses the context parameter.
+*
+* Functions with 2+ parameters like `(rule, context) => ...` need runtime context
+* (e.g., `context.hidden`, `context.document`) and cannot be pre-evaluated at schema compile time.
+*
+* Functions with 1 parameter like `(rule) => rule.required()` don't need context
+* and can be normalized immediately for better performance.
+*
+* @internal
+*/
+function hasValidationContext(validation) {
+	if (!validation) return !1;
+	if (Array.isArray(validation)) return validation.some(hasValidationContext);
+	if (typeof validation != "function") return !1;
+	if (validation.length >= 2) return !0;
+	let signature = Function.prototype.toString.call(validation);
+	return /\(\s*\w+\s*,\s*\.\.\./.test(signature);
+}
+function inferFromSchema(schema) {
+	return schema.getLocalTypeNames().forEach((typeName) => {
+		let schemaType = schema.get(typeName);
+		schemaType && inferFromSchemaType(schemaType);
+	}), schema;
+}
+export { Rule, convertToValidationMarker, getFallbackLocaleSource, getTypeChain, hasValidationContext, inferFromSchema, inferFromSchemaType, normalizeValidationRules, pathToString, resolveTypeForArrayItem, typeString, validateDocumentInternal, validateDocumentObservable, validateItem, validationLocaleStrings };
+
+//# sourceMappingURL=_internal.js.map

package/lib/_internal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_internal.js","names":[],"sources":["../src/inferFromSchemaType.ts","../src/inferFromSchema.ts"],"sourcesContent":["import {type Schema, type SchemaType, type SchemaValidationValue} from '@sanity/types'\n\nimport {normalizeValidationRules} from './util/normalizeValidationRules'\n\n// NOTE: this overload is for TS API compatibility with a previous implementation\nexport function inferFromSchemaType(\n  typeDef: SchemaType,\n  // these are intentionally unused\n  _schema: Schema,\n  _visited?: Set<SchemaType>,\n): SchemaType\n// note: this seemingly redundant overload is required\nexport function inferFromSchemaType(typeDef: SchemaType): SchemaType\nexport function inferFromSchemaType(typeDef: SchemaType): SchemaType {\n  traverse(typeDef, new Set())\n  return typeDef\n}\n\nfunction traverse(typeDef: SchemaType, visited: Set<SchemaType>) {\n  if (visited.has(typeDef)) {\n    return\n  }\n\n  visited.add(typeDef)\n\n  const usesValidationContext = hasValidationContext(typeDef.validation)\n\n  // Only normalize validation at schema-compile time when it doesn't rely on runtime context.\n  // Context-aware validation functions must be evaluated during validation, where context exists.\n  if (!usesValidationContext) {\n    typeDef.validation = normalizeValidationRules(typeDef)\n  }\n\n  if ('fields' in typeDef) {\n    for (const field of typeDef.fields) {\n      traverse(field.type, visited)\n    }\n  }\n\n  if ('of' in typeDef) {\n    for (const candidate of typeDef.of) {\n      traverse(candidate, visited)\n    }\n  }\n\n  // @ts-expect-error TODO (eventually): `annotations` does not exist on the SchemaType yet\n  if (typeDef.annotations) {\n    // @ts-expect-error TODO (eventually): `annotations` does not exist on the SchemaType yet\n    for (const annotation of typeDef.annotations) {\n      traverse(annotation, visited)\n    }\n  }\n}\n\n/**\n * Checks if a validation function uses the context parameter.\n *\n * Functions with 2+ parameters like `(rule, context) => ...` need runtime context\n * (e.g., `context.hidden`, `context.document`) and cannot be pre-evaluated at schema compile time.\n *\n * Functions with 1 parameter like `(rule) => rule.required()` don't need context\n * and can be normalized immediately for better performance.\n *\n * @internal\n */\nexport function hasValidationContext(validation: SchemaValidationValue | undefined): boolean {\n  if (!validation) return false\n  if (Array.isArray(validation)) {\n    return validation.some(hasValidationContext)\n  }\n  if (typeof validation !== 'function') return false\n\n  // Check declared parameter count first (most common case)\n  if (validation.length >= 2) return true\n\n  // Function.length doesn't count rest parameters, so check the signature for patterns like\n  // `(rule, ...args)` which would have length === 1 but still expects context\n  const signature = Function.prototype.toString.call(validation)\n  return /\\(\\s*\\w+\\s*,\\s*\\.\\.\\./.test(signature)\n}\n","import {type Schema} from '@sanity/types'\n\nimport {inferFromSchemaType} from './inferFromSchemaType'\n\n// Note: Mutates schema. Refactor when @sanity/schema supports middlewares\nexport function inferFromSchema(schema: Schema): Schema {\n  const typeNames = schema.getLocalTypeNames()\n\n  typeNames.forEach((typeName) => {\n    const schemaType = schema.get(typeName)\n\n    if (schemaType) {\n      inferFromSchemaType(schemaType)\n    }\n  })\n\n  return schema\n}\n"],"mappings":";AAaA,SAAgB,oBAAoB,SAAiC;CAEnE,OADA,SAAS,yBAAS,IAAI,IAAI,CAAC,GACpB;AACT;AAEA,SAAS,SAAS,SAAqB,SAA0B;CAC3D,aAAQ,IAAI,OAAO,GAcvB;MAVA,QAAQ,IAAI,OAAO,GAEW,qBAAqB,QAAQ,UAIlC,MACvB,QAAQ,aAAa,yBAAyB,OAAO,IAGnD,YAAY,SACd,KAAK,IAAM,SAAS,QAAQ,QAC1B,SAAS,MAAM,MAAM,OAAO;EAIhC,IAAI,QAAQ,SACV,KAAK,IAAM,aAAa,QAAQ,IAC9B,SAAS,WAAW,OAAO;EAK/B,IAAI,QAAQ,aAEV,KAAK,IAAM,cAAc,QAAQ,aAC/B,SAAS,YAAY,OAAO;CAdA;AAiBlC;;;;;;;;;;;;AAaA,SAAgB,qBAAqB,YAAwD;CAC3F,IAAI,CAAC,YAAY,OAAO;CACxB,IAAI,MAAM,QAAQ,UAAU,GAC1B,OAAO,WAAW,KAAK,oBAAoB;CAE7C,IAAI,OAAO,cAAe,YAAY,OAAO;CAG7C,IAAI,WAAW,UAAU,GAAG,OAAO;CAInC,IAAM,YAAY,SAAS,UAAU,SAAS,KAAK,UAAU;CAC7D,OAAO,wBAAwB,KAAK,SAAS;AAC/C;AC1EA,SAAgB,gBAAgB,QAAwB;CAWtD,OARA,OAFyB,kBAEjB,CAAC,CAAC,SAAS,aAAa;EAC9B,IAAM,aAAa,OAAO,IAAI,QAAQ;EAEtC,AAAI,cACF,oBAAoB,UAAU;CAElC,CAAC,GAEM;AACT"}

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+import { _ as validationMarkerCodes, a as ValidationClient, f as validateDocumentWithWorkspace, g as ValidationMarkerCode, h as DocumentValidationMarker, i as ValidateDocumentWorkspaceOptions, l as validateDocument, m as BuiltInValidationMarkerCode, o as ValidationSchema, r as ValidateDocumentOptions, s as ValidationSource } from "./validateDocument-6pLTIHIn.js";
+export { type BuiltInValidationMarkerCode, type DocumentValidationMarker, type ValidateDocumentOptions, type ValidateDocumentWorkspaceOptions, type ValidationClient, type ValidationMarkerCode, type ValidationSchema, type ValidationSource, validateDocument, validateDocumentWithWorkspace, validationMarkerCodes };