@sanity/validation 3.14.3 → 6.12.0-next.112

package/lib/validateDocument-6pLTIHIn.d.ts

@@ -0,0 +1,277 @@
+import { CurrentUser, SanityDocument, Schema, SchemaType, ValidationContext as ValidationContext$1, ValidationMarker } from "@sanity/types";
+import { ConcurrencyLimiter } from "@sanity/util/concurrency-limiter";
+import { Observable } from "rxjs";
+import { TFunction } from "i18next";
+import { SanityClient } from "@sanity/client";
+interface LocaleSource {
+  currentLocale: {
+    id: string;
+  };
+  loadNamespaces(namespaces: string[]): Promise<void>;
+  t: TFunction;
+}
+declare module '@sanity/types' {
+  /**
+   * Extended validation context that includes internationalization
+   *
+   * Why is this not directly part of `@sanity/types`, you ask?
+   * Because `@sanity/types` shouldn't need to depend on the `i18next` package, which it needs
+   * for the `TFunction` type. The `ValidationContext` should never have been part of the types
+   * module in the first place, but is now unfortunately part of the public API and thus cannot
+   * be changed easily.
+   *
+   * This is a temporary solution until we can remove the `ValidationContext` from the types module,
+   * which is likely to happen at the next major version.
+   *
+   * @public
+   */
+  interface ValidationContext {
+    /**
+     * Internationalization utilities, for translation of validation messages
+     *
+     * See {@link LocaleSource} for details.
+     */
+    i18n: LocaleSource;
+  }
+}
+/** Machine-readable codes emitted by built-in document validation. @beta */
+declare const validationMarkerCodes: {
+  readonly arrayDuplicateItem: 'array.duplicate-item';
+  readonly arrayExactLength: 'array.exact-length';
+  readonly arrayMaximumLength: 'array.maximum-length';
+  readonly arrayMinimumLength: 'array.minimum-length';
+  readonly assetRequired: 'asset.required';
+  readonly custom: 'custom';
+  readonly dateInvalidFormat: 'date.invalid-format';
+  readonly dateMaximum: 'date.maximum';
+  readonly dateMinimum: 'date.minimum';
+  readonly documentUnknownType: 'document.unknown-type';
+  readonly mediaCustom: 'media.custom';
+  readonly mediaInvalidReference: 'media.invalid-reference';
+  readonly mediaNotFound: 'media.not-found';
+  readonly numberGreaterThan: 'number.greater-than';
+  readonly numberInteger: 'number.integer';
+  readonly numberLessThan: 'number.less-than';
+  readonly numberMaximum: 'number.maximum';
+  readonly numberMinimum: 'number.minimum';
+  readonly numberPrecision: 'number.precision';
+  readonly objectUnknownField: 'object.unknown-field';
+  readonly referenceInvalid: 'reference.invalid';
+  readonly referenceNotPublished: 'reference.not-published';
+  readonly ruleAllFailed: 'rule.all-failed';
+  readonly ruleEitherFailed: 'rule.either-failed';
+  readonly slugInvalidType: 'slug.invalid-type';
+  readonly slugMissingCurrent: 'slug.missing-current';
+  readonly slugNotUnique: 'slug.not-unique';
+  readonly stringEmail: 'string.email';
+  readonly stringExactLength: 'string.exact-length';
+  readonly stringLowercase: 'string.lowercase';
+  readonly stringMaximumLength: 'string.maximum-length';
+  readonly stringMinimumLength: 'string.minimum-length';
+  readonly stringRegexMatch: 'string.regex-match';
+  readonly stringRegexMismatch: 'string.regex-mismatch';
+  readonly stringUppercase: 'string.uppercase';
+  readonly stringUrlCredentialsNotAllowed: 'string.url.credentials-not-allowed';
+  readonly stringUrlInvalid: 'string.url.invalid';
+  readonly stringUrlNotAbsolute: 'string.url.not-absolute';
+  readonly stringUrlNotRelative: 'string.url.not-relative';
+  readonly stringUrlSchemeNotAllowed: 'string.url.scheme-not-allowed';
+  readonly validationException: 'validation.exception';
+  readonly validationFailed: 'validation.failed';
+  readonly valueNotAllowed: 'value.not-allowed';
+  readonly valueRequired: 'value.required';
+  readonly valueTypeMismatch: 'value.type-mismatch';
+};
+/** A code emitted by a built-in validator. @beta */
+type BuiltInValidationMarkerCode = (typeof validationMarkerCodes)[keyof typeof validationMarkerCodes];
+/**
+ * A built-in validation code or an application-defined custom code.
+ * Custom validators should namespace their codes, for example `custom.seo-title`.
+ * @beta
+ */
+type ValidationMarkerCode = BuiltInValidationMarkerCode | (string & {});
+/** A validation marker emitted by `validateDocument`, which always has a code. @beta */
+type DocumentValidationMarker = Omit<ValidationMarker, 'code'> & {
+  code: ValidationMarkerCode;
+};
+/**
+ * @internal
+ */
+declare function resolveTypeForArrayItem(item: unknown, candidates: SchemaType[]): SchemaType | undefined;
+/**
+ * @beta
+ */
+interface ValidateDocumentOptions {
+  /**
+   * The document to be validated
+   */
+  document: SanityDocument;
+  /** The compiled schema to validate against. */
+  schema: ValidationSchema;
+  /** A configured client used for reference checks and custom validators. */
+  client: ValidationClient;
+  /**
+   * Function used to check if referenced documents exists (and is published).
+   *
+   * If you're validating many documents in bulk, you may want to query for all
+   * document IDs first and provide your own implementation using those.
+   *
+   * If no function is provided a default one will be provided that will batch
+   * call the `doc` endpoint to check for document existence.
+   */
+  getDocumentExists?: (options: {
+    id: string;
+  }) => Promise<boolean>;
+  /**
+   * The maximum amount of custom validation functions to be running
+   * concurrently at once. This helps prevent custom validators from
+   * overwhelming backend services (e.g. called via fetch) used in async,
+   * user-defined validation functions. (i.e. `rule.custom(async() => {})`)
+   *
+   * Note that lowering this number may also help in cases where a custom
+   * validator could potentially exhaust the fetch concurrency. This is 5 by
+   * default.
+   */
+  maxCustomValidationConcurrency?: number;
+  /**
+   * The amount of allowed inflight fetch requests at once for this validation.
+   * You may need to up this value if you have complex custom validations that
+   * require many `client.fetch` requests at once. It's possible for a custom
+   * validator to stall if there are not enough concurrent fetch requests
+   * available to fulfill the custom validation. Must be a positive integer.
+   * This is 25 by default.
+   */
+  maxFetchConcurrency?: number;
+  /**
+   * The current user, when available. Used when resolving schema `hidden`
+   * conditionals so validation matches what the form shows. If omitted, hidden
+   * is resolved with no user (e.g. CLI or headless validation).
+   */
+  currentUser?: Omit<CurrentUser, 'role'> | null;
+}
+/** A compiled schema accepted across compatible `@sanity/types` versions. @beta */
+interface ValidationSchema {
+  get(name: string): unknown;
+}
+/**
+ * A configured Sanity client accepted across compatible client versions.
+ *
+ * This structural type describes the capabilities used internally by validation.
+ * The configured client is exposed to custom validators as a `SanityClient`, so it must be compatible with the full client API.
+ *
+ * @beta
+ */
+interface ValidationClient {
+  fetch: SanityClient['fetch'];
+  getDataUrl: SanityClient['getDataUrl'];
+  observable: Pick<SanityClient['observable'], 'fetch' | 'request'>;
+  withConfig(config: Parameters<SanityClient['withConfig']>[0]): ValidationClient;
+}
+/**
+ * The validation capabilities required from a resolved Studio source or workspace.
+ *
+ * @beta
+ */
+interface ValidationSource {
+  /** The compiled schema to validate against. */
+  schema: Schema;
+  /** Factory used to get the client passed to custom validators. */
+  getClient: (clientOptions: {
+    apiVersion: string;
+  }) => SanityClient;
+  /** Internationalization utilities used for validation messages. */
+  i18n: LocaleSource;
+}
+/**
+ * Options accepted by the compatibility overload for Studio workspace validation.
+ *
+ * @beta
+ */
+interface ValidateDocumentWorkspaceOptions extends Omit<ValidateDocumentOptions, 'client' | 'schema'> {
+  /** The resolved Studio workspace or source used for validation. */
+  workspace: ValidationSource;
+  /**
+   * Factory used to get the client passed to custom validators.
+   *
+   * @deprecated For internal use only
+   */
+  getClient?: ValidationSource['getClient'];
+  /** Validation environment exposed to custom validators. */
+  environment?: 'cli' | 'studio';
+}
+/**
+ * Validates a document against the schema in a resolved Studio workspace or source.
+ *
+ * @beta
+ * @deprecated Prefer {@link validateDocument} with `{document, schema, client}` for new code.
+ */
+declare function validateDocumentWithWorkspace({ document, workspace, getClient, getDocumentExists, environment, maxCustomValidationConcurrency, maxFetchConcurrency, currentUser }: ValidateDocumentWorkspaceOptions): Promise<DocumentValidationMarker[]>;
+/**
+ * Validates a document against the schema in a resolved Studio workspace or source.
+ *
+ * This compatibility overload preserves the existing `sanity` API. Prefer the
+ * `{document, schema, client}` overload for new code.
+ *
+ * @beta
+ */
+declare function validateDocument(options: ValidateDocumentWorkspaceOptions): Promise<DocumentValidationMarker[]>;
+/**
+ * Validates a document against a compiled schema. Returns validation markers
+ * without deciding whether the document may be edited or published.
+ *
+ * @beta
+ */
+declare function validateDocument(options: ValidateDocumentOptions): Promise<DocumentValidationMarker[]>;
+/** @internal */
+interface ValidateDocumentInternalOptions {
+  document: SanityDocument;
+  schema: Schema;
+  getClient: (clientOptions: {
+    apiVersion: string;
+  }) => SanityClient;
+  getDocumentExists?: (options: {
+    id: string;
+  }) => Promise<boolean>;
+  i18n?: LocaleSource;
+  environment: 'cli' | 'studio';
+  maxCustomValidationConcurrency?: number;
+  maxFetchConcurrency?: number;
+  currentUser?: Omit<CurrentUser, 'role'> | null;
+}
+/** @internal */
+declare function validateDocumentInternal({ document, schema, getClient, getDocumentExists, i18n, environment, maxCustomValidationConcurrency, maxFetchConcurrency, currentUser }: ValidateDocumentInternalOptions): Promise<DocumentValidationMarker[]>;
+/**
+ * @internal
+ */
+interface ValidateDocumentObservableOptions extends Pick<ValidationContext$1, 'getDocumentExists' | 'i18n'> {
+  getClient: (options: {
+    apiVersion: string;
+  }) => SanityClient;
+  document: SanityDocument;
+  schema: Schema;
+  environment: 'cli' | 'studio';
+  maxCustomValidationConcurrency?: number;
+  currentUser?: Omit<CurrentUser, 'role'> | null;
+}
+/**
+ * Validates a document against the given schema, returning an Observable
+ * @internal
+ */
+declare function validateDocumentObservable({ document, getClient, i18n, schema, getDocumentExists, environment, maxCustomValidationConcurrency, currentUser }: ValidateDocumentObservableOptions): Observable<DocumentValidationMarker[]>;
+/**
+ * this is used make optional properties required by replacing optionals with
+ * `T[P] | undefined`. this is used to prevent errors in `validateItem` where
+ * an option from a previous invocation would be incorrectly passed down.
+ *
+ * https://medium.com/terria/typescript-transforming-optional-properties-to-required-properties-that-may-be-undefined-7482cb4e1585
+ */
+type ExplicitUndefined<T> = { [P in keyof Required<T>]: Pick<T, P> extends Required<Pick<T, P>> ? T[P] : T[P] | undefined; };
+type ValidateItemOptions = {
+  value: unknown;
+  customValidationConcurrencyLimiter?: ConcurrencyLimiter;
+  hidden?: boolean;
+  currentUser?: Omit<CurrentUser, 'role'> | null;
+} & ExplicitUndefined<Omit<ValidationContext$1, 'hidden'>>;
+declare function validateItem(opts: ValidateItemOptions): Promise<ValidationMarker[]>;
+export { validationMarkerCodes as _, ValidationClient as a, resolveTypeForArrayItem as c, validateDocumentObservable as d, validateDocumentWithWorkspace as f, ValidationMarkerCode as g, DocumentValidationMarker as h, ValidateDocumentWorkspaceOptions as i, validateDocument as l, BuiltInValidationMarkerCode as m, ValidateDocumentObservableOptions as n, ValidationSchema as o, validateItem as p, ValidateDocumentOptions as r, ValidationSource as s, ValidateDocumentInternalOptions as t, validateDocumentInternal as u, ValidationContext$1 as v, LocaleSource as y };
+//# sourceMappingURL=validateDocument-6pLTIHIn.d.ts.map