@sanity/validation 3.14.3 → 6.12.0-next.32

package/lib/validateDocument-C6wlQ7gA.d.ts

@@ -0,0 +1,151 @@
+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;
+  }
+}
+/**
+ * @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: Schema;
+  /** A configured client used for reference checks and custom validators. */
+  client: SanityClient;
+  /**
+   * 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;
+}
+/**
+ * Validates a document against a compiled schema. Returns validation markers
+ * without deciding whether the document may be edited or published.
+ *
+ * @beta
+ */
+declare function validateDocument({ client, document, schema, ...options }: ValidateDocumentOptions): Promise<ValidationMarker[]>;
+/** @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<ValidationMarker[]>;
+/**
+ * @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<ValidationMarker[]>;
+/**
+ * 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 { validateDocument as a, validateItem as c, resolveTypeForArrayItem as i, ValidationContext$1 as l, ValidateDocumentObservableOptions as n, validateDocumentInternal as o, ValidateDocumentOptions as r, validateDocumentObservable as s, ValidateDocumentInternalOptions as t, LocaleSource as u };
+//# sourceMappingURL=validateDocument-C6wlQ7gA.d.ts.map