@sanity/agent-mutations 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,452 @@
+import { InsertOperation, ManifestField, ManifestSchemaType, PatchOperations, ValidationContext, ValidationError, ValidationResult } from "@sanity/agent-schema";
+import { SanityClient, Transaction } from "@sanity/client";
+import { SanityDocumentLike } from "@sanity/types";
+/** Patch operations structure */
+interface PatchOperations$3 {
+  set?: Array<{
+    path: string;
+    value?: unknown;
+  }>;
+  unset?: string[];
+  append?: Array<{
+    path: string;
+    items: unknown[];
+  }>;
+  insertBefore?: InsertOperation[];
+  insertAfter?: InsertOperation[];
+}
+interface BuildTransactionOptions {
+  client: SanityClient;
+  documentId: string;
+  operations: PatchOperations$3;
+  setIfMissing: Record<string, unknown>;
+}
+/**
+ * Builds a Sanity transaction from patch operations and setIfMissing patches.
+ *
+ * The order of operations follows Sanity's recommended sequence:
+ * 1. setIfMissing - ensure parent paths exist
+ * 2. insertBefore/insertAfter - array shape changes (native insert semantics)
+ * 3. set - replace values at paths
+ * 4. unset - remove values at paths
+ * 5. append - insert items after the specified path (using insert: { after })
+ *
+ * This order ensures that:
+ * - Arrays exist before inserting into them
+ * - Insert operations don't conflict with set operations on the same array
+ *
+ * @param options - The transaction building options
+ * @returns A Sanity transaction ready to be committed
+ */
+declare function buildPatchTransaction(options: BuildTransactionOptions): Transaction;
+/**
+ * Check if an array field contains only primitive types
+ */
+declare function isPrimitiveArray(field: ManifestField | undefined): boolean;
+/**
+ * Check if a path contains numeric array index notation like [0], [1], etc.
+ */
+declare function hasNumericIndex(path: string): boolean;
+/**
+ * Parse a path with numeric index to extract components
+ * Finds the FIRST numeric index in the path, even if there's _key notation before it
+ * Example: "sections[0].bodyParagraphs[1]" → {basePath: "sections", index: 0, restPath: ".bodyParagraphs[1]"}
+ * Example: "sections[_key=="x"].bodyParagraphs[0]" → {basePath: "sections[_key=="x"].bodyParagraphs", index: 0, restPath: ""}
+ */
+declare function parseArrayIndex(path: string): {
+  basePath: string;
+  index: number;
+  restPath: string;
+} | null;
+/**
+ * Navigate to an array in the document using a dot-notation path
+ * Example: "sections.bodyParagraphs" in document {sections: {bodyParagraphs: [...]}}
+ */
+declare function getArrayAtPath(document: Record<string, unknown>, path: string): unknown[] | null;
+/**
+ * Get the _key value at a specific index in an object array
+ * Returns null if the item doesn't have a _key or index is out of bounds
+ */
+declare function getKeyAtIndex(array: unknown[], index: number): string | null;
+/** Insert operation structure for insertBefore/insertAfter */
+interface InsertOperation$1 {
+  arrayPath: string;
+  key: string;
+  items: unknown[];
+}
+/**
+ * Convert array index operations to proper format
+ * - Object arrays: [0] → [_key=="actualKey"]
+ * - Primitive arrays: All operations on same array are merged into single SET
+ */
+declare function convertArrayIndexOperations(operations: {
+  set?: Array<{
+    path: string;
+    value?: unknown;
+  }>;
+  unset?: string[];
+  append?: Array<{
+    path: string;
+    items: unknown[];
+  }>;
+  insertBefore?: InsertOperation$1[];
+  insertAfter?: InsertOperation$1[];
+}, typeSchema: ManifestSchemaType, allSchemas: ManifestSchemaType[], document: Record<string, unknown>): {
+  set?: Array<{
+    path: string;
+    value?: unknown;
+  }>;
+  unset?: string[];
+  append?: Array<{
+    path: string;
+    items: unknown[];
+  }>;
+  insertBefore?: InsertOperation$1[];
+  insertAfter?: InsertOperation$1[];
+};
+interface SkippedItem {
+  arrayPath: string;
+  index: number;
+  type: string | undefined;
+  reason: string;
+}
+interface FilterResult {
+  /** Whether any errors are structural (not per-item) — if true, caller should throw all errors */
+  hasStructuralErrors: boolean;
+  /** Items that were filtered out */
+  skippedItems: SkippedItem[];
+  /** Cleaned SET operations (invalid items removed from array values) */
+  set?: Array<{
+    path: string;
+    value?: unknown;
+  }>;
+  /** Cleaned APPEND operations */
+  append?: Array<{
+    path: string;
+    items: unknown[];
+  }>;
+  /** Cleaned INSERT operations */
+  insertBefore?: InsertOperation[];
+  insertAfter?: InsertOperation[];
+}
+/**
+ * Classify validation errors and filter invalid array items from operations.
+ *
+ * Errors with `itemIndex` and `arrayPath` are per-item — the invalid item can
+ * be removed and the rest of the array written successfully.
+ *
+ * Errors without these fields are structural — wrong path, not an array, etc.
+ * These cannot be fixed by filtering items.
+ */
+declare function filterInvalidArrayItems(ops: {
+  set?: Array<{
+    path: string;
+    value?: unknown;
+  }>;
+  append?: Array<{
+    path: string;
+    items: unknown[];
+  }>;
+  insertBefore?: InsertOperation[];
+  insertAfter?: InsertOperation[];
+}, errors: ValidationError[]): FilterResult;
+/**
+ * Format a partial write error message that tells the agent exactly
+ * what was written and what needs to be fixed via insertAfter.
+ */
+declare function formatPartialWriteError(skippedItems: SkippedItem[], totalItemsByPath: Map<string, number>): string;
+/**
+ * Generate a random 12-character key for Sanity array items
+ * Uses lowercase letters and numbers only
+ */
+declare function generateKey(): string;
+/**
+ * Recursively add missing _key fields to all objects in arrays
+ * This ensures Sanity array items have proper keys for tracking and updates
+ *
+ * @param value - The value to process (can be any type)
+ * @param options - Optional configuration
+ * @param options.ensureRootKey - If true, ensure the top-level object has a _key (for array item replacements)
+ * @returns The same value with _key fields added to array items where missing
+ */
+declare function addMissingKeys(value: unknown, options?: {
+  ensureRootKey?: boolean;
+}): unknown;
+/**
+ * Result of duplicate key regeneration
+ */
+interface RegenerateDuplicateKeysResult {
+  value: unknown;
+  keyMapping: Map<string, string>;
+  duplicatesFound: number;
+}
+/**
+ * Regenerate only duplicate _key fields in a document
+ * This preserves unique keys and only regenerates keys that appear more than once.
+ * The first occurrence of a duplicate key is kept, subsequent occurrences are regenerated.
+ *
+ * @param value - The value to process (can be any type)
+ * @returns Object containing the transformed value, key mapping, and count of duplicates found
+ */
+declare function regenerateDuplicateKeys(value: unknown): RegenerateDuplicateKeysResult;
+/**
+ * Key mapping utilities for mutation tools.
+ * Handles transformation of paths and keys after key regeneration.
+ */
+/**
+ * Normalize _key selector quote style from single quotes to double quotes.
+ * This ensures consistent path format across the codebase.
+ *
+ * @param path - The path to normalize
+ * @returns The path with single quotes converted to double quotes in _key selectors
+ *
+ * @example
+ * normalizeKeyQuotes("body[_key=='abc']") // "body[_key=\"abc\"]"
+ * normalizeKeyQuotes("body[_key==\"abc\"]") // "body[_key=\"abc\"]" (unchanged)
+ */
+declare function normalizeKeyQuotes(path: string): string;
+/**
+ * Transform a path string by replacing old key references with new ones based on the key mapping.
+ * This is used after key regeneration to ensure paths reference the correct regenerated keys.
+ *
+ * The function applies transformations iteratively until no more matches are found.
+ * This handles cases where multiple nested keys need to be replaced.
+ *
+ * The function tries multiple matching strategies per iteration:
+ * 1. Direct exact match of the full path
+ * 2. Longest prefix match - replaces the longest matching prefix with its mapped value
+ *
+ * @param path - The path string to transform (e.g., "content[_key=='oldKey'].image" or "content.0.image")
+ * @param keyMapping - Map of old paths to new paths from key regeneration
+ * @returns The transformed path with updated key references
+ *
+ * @example
+ * const keyMapping = new Map([
+ *   ["content.0", "content[_key=='abc123']"],
+ *   ["content[_key=='oldKey']", "content[_key=='abc123']"]
+ * ])
+ * transformPathWithKeyMapping("content.0.image", keyMapping)
+ * // Returns: "content[_key=='abc123'].image"
+ *
+ * transformPathWithKeyMapping("content[_key=='oldKey'].image", keyMapping)
+ * // Returns: "content[_key=='abc123'].image"
+ *
+ * // Multiple nested transformations:
+ * transformPathWithKeyMapping("content[_key=='old1'].media[_key=='old2'].asset", keyMapping)
+ * // Applies transformations iteratively until fully transformed
+ */
+declare function transformPathWithKeyMapping(path: string, keyMapping?: Map<string, string>): string;
+/**
+ * Map a single key through a key mapping.
+ * Used for transforming anchor keys in insertBefore/insertAfter operations.
+ *
+ * @param key - The key to map
+ * @param keyMapping - The key mapping (Record<string, string> or unknown)
+ * @returns The mapped key, or the original key if no mapping exists
+ */
+declare function mapKeyThroughKeyMapping(key: string, keyMapping: unknown): string;
+/** Patch operations structure (matches prepareOperations) */
+interface PatchOperations$2 {
+  set?: Array<{
+    path: string;
+    value?: unknown;
+  }>;
+  unset?: string[];
+  append?: Array<{
+    path: string;
+    items: unknown[];
+  }>;
+  insertBefore?: Array<{
+    arrayPath: string;
+    key: string;
+    items: unknown[];
+  }>;
+  insertAfter?: Array<{
+    arrayPath: string;
+    key: string;
+    items: unknown[];
+  }>;
+}
+interface NormalizeOptions {
+  typeSchema: ManifestSchemaType;
+  allSchemas: ManifestSchemaType[];
+}
+/**
+ * Normalize internationalized array items in patch operations to match the
+ * schema's expected format (v4 or v5).
+ *
+ * This runs as a step in the prepareOperations pipeline, after key normalization
+ * and before validation. It inspects each operation's target field: if the field
+ * is an internationalized array, it checks each item and converts between v4/v5
+ * format as needed.
+ */
+declare function normalizeInternationalizedArrays(operations: PatchOperations$2, options: NormalizeOptions): PatchOperations$2;
+/** Patch operations structure */
+interface PatchOperations$1 {
+  set?: Array<{
+    path: string;
+    value?: unknown;
+  }>;
+  unset?: string[];
+  append?: Array<{
+    path: string;
+    items: unknown[];
+  }>;
+  insertBefore?: InsertOperation[];
+  insertAfter?: InsertOperation[];
+  [key: string]: unknown;
+}
+/** Result of patch operations normalization */
+interface PatchNormalizationResult<T = PatchOperations$1> {
+  normalized: T;
+  validationErrors: ValidationError[];
+  /** setIfMissing patches for parent paths (ensures nested paths exist) */
+  setIfMissing: Record<string, unknown>;
+}
+interface NormalizePatchOptions {
+  /** Whether to add _strengthenOnPublish metadata for draft/version references. Defaults to true. */
+  applyStrengthenOnPublish?: boolean;
+  /** The existing document state, used to resolve append positions */
+  existingDocument?: Record<string, unknown>;
+}
+/**
+ * Normalizes reference objects in patch operations with unified logic.
+ *
+ * Handles the patch tool's operation format:
+ * - set: Array of {path, value} objects
+ * - unset: Array of path strings (no normalization needed)
+ * - append: Array of {path, items} objects
+ *
+ * Also resolves append paths to use the last item's _key for reliable ordering,
+ * and regenerates duplicate keys.
+ *
+ * @param client - Sanity client for document lookups
+ * @param operations - The patch operations object
+ * @param documentType - The document type name
+ * @param fullSchema - The full Sanity schema array
+ * @param targetDocumentId - The ID of the document being patched
+ * @param options - Optional configuration
+ * @returns Result object with normalized operations and validation errors
+ */
+declare function normalizePatchOperations<T extends PatchOperations$1>(client: SanityClient, operations: T, documentType: string, fullSchema: ManifestSchemaType[], targetDocumentId: string, options?: NormalizePatchOptions): Promise<PatchNormalizationResult<T>>;
+interface SchemaFieldDefinition {
+  type?: string;
+  name?: string;
+  of?: Array<{
+    type?: string;
+    name?: string;
+    to?: Array<{
+      type: string;
+    }>;
+    weak?: boolean;
+  }>;
+  to?: Array<{
+    type: string;
+  }>;
+  weak?: boolean;
+}
+/**
+ * Gets the reference field definition from schema, handling nested paths.
+ * Uses resolveFieldSchema which has special handling for portable text
+ * block.markDefs and other complex nested structures.
+ */
+declare function getReferenceFieldDefinition(fieldPath: string, typeSchema: ManifestSchemaType, fullSchema: ManifestSchemaType[]): SchemaFieldDefinition | null;
+/**
+ * Gets the schema definition for items in an array field
+ * Returns null for union arrays (arrays with multiple types) to signal
+ * that items need individual schema matching based on their _type
+ */
+declare function getArrayItemSchema(arrayFieldPath: string, typeSchema: ManifestSchemaType, fullSchema: ManifestSchemaType[]): SchemaFieldDefinition | null;
+/**
+ * Clear the document cache.
+ * Should be called at the start of each normalization operation.
+ */
+declare function clearDocumentCache(): void;
+/**
+ * Recursively traverses an object/array and normalizes all reference objects
+ */
+declare function traverseAndNormalize(client: SanityClient, value: unknown, currentPath: string, typeSchema: ManifestSchemaType | SchemaFieldDefinition, fullSchema: ManifestSchemaType[], targetDocumentId: string, validationErrors: ValidationError[], applyStrengthenOnPublish: boolean, parentObjectType?: string): Promise<unknown>;
+/**
+ * Normalizes all reference objects in a document with unified logic.
+ *
+ * Performs all reference normalization in a single pass:
+ * - Schema-based weak reference detection
+ * - Draft/versioned ID conversion to published IDs
+ * - Validation with batch error collection
+ * - Adding _weak: true and _strengthenOnPublish metadata
+ *
+ * @param client - Sanity client for document lookups
+ * @param document - The document object to normalize (must have _type and _id)
+ * @param fullSchema - The full Sanity schema array
+ * @returns Result object with normalized document and validation errors
+ *
+ * @example
+ * ```typescript
+ * const result = await normalizeDocumentReferences(
+ *   client,
+ *   document,
+ *   schema,
+ * )
+ *
+ * if (result.validationErrors.length > 0) {
+ *   // Handle validation errors
+ * }
+ *
+ * const normalizedDoc = result.normalized
+ * ```
+ */
+declare function normalizeDocumentReferences(client: SanityClient, document: SanityDocumentLike, schema: ManifestSchemaType[], applyStrengthenOnPublish?: boolean): Promise<{
+  normalized: SanityDocumentLike;
+  validationErrors: ValidationError[];
+}>;
+declare function acceptsFlatPortableText(fieldPath: string, typeSchema: ManifestSchemaType, allSchemas: ManifestSchemaType[]): boolean;
+/**
+ * Stricter check: the field's array accepts ONLY block items (no custom block
+ * types like tableBlock, codeBlock, image, etc.).
+ *
+ * This is the bar for *deterministic* markdown conversion. When an array mixes
+ * `block` with custom types, markdown's tables/code fences/etc. have no faithful
+ * mechanical mapping onto those custom types — so the deterministic converter
+ * would silently lose them (tables → bullet lists, fences → plain paragraphs).
+ * Such fields are routed to the generative path instead, where the worker has
+ * the schema and a raw-Portable-Text tool to build the custom blocks correctly.
+ */
+declare function acceptsOnlyFlatPortableText(fieldPath: string, typeSchema: ManifestSchemaType, allSchemas: ManifestSchemaType[]): boolean;
+/**
+ * Check whether a document type has any array field that accepts block items.
+ * Used to decide whether to include the markdown tool for a worker.
+ */
+declare function hasAnyFlatPortableTextField(typeSchema: ManifestSchemaType, allSchemas: ManifestSchemaType[]): boolean;
+/** Options for preparing operations */
+interface PrepareOperationsOptions {
+  /** Key mapping from duplicate key regeneration */
+  keyMapping?: Map<string, string>;
+  /** Schema for the document type */
+  typeSchema: ManifestSchemaType;
+  /** All schemas */
+  allSchemas: ManifestSchemaType[];
+  /** Current document state */
+  document: Record<string, unknown>;
+}
+/**
+ * Prepare patch operations for execution.
+ *
+ * This function:
+ * 1. Normalizes key quote style (single to double quotes)
+ * 2. Applies key mapping (if provided) to transform regenerated keys
+ * 3. Converts array indices to key selectors using document state
+ * 4. Converts append to set for arrays that don't exist on the document
+ * 5. Normalizes internationalized array items (v4 ↔ v5 format)
+ * 6. Adds missing _key fields to array items
+ *
+ * @param operations - Raw operations from tool params
+ * @param options - Preparation options including schema and document state
+ * @returns Prepared operations ready for validation and execution
+ */
+declare function prepareOperations(operations: PatchOperations, options: PrepareOperationsOptions): PatchOperations;
+/**
+ * Validate patch operations against the schema.
+ */
+declare function validatePatchOperations(operations: PatchOperations, documentType: string, schema: ManifestSchemaType[], context: ValidationContext): Promise<ValidationResult>;
+export { type SchemaFieldDefinition, acceptsFlatPortableText, acceptsOnlyFlatPortableText, addMissingKeys, buildPatchTransaction, clearDocumentCache, convertArrayIndexOperations, filterInvalidArrayItems, formatPartialWriteError, generateKey, getArrayAtPath, getArrayItemSchema, getKeyAtIndex, getReferenceFieldDefinition, hasAnyFlatPortableTextField, hasNumericIndex, isPrimitiveArray, mapKeyThroughKeyMapping, normalizeDocumentReferences, normalizeInternationalizedArrays, normalizeKeyQuotes, normalizePatchOperations, parseArrayIndex, prepareOperations, regenerateDuplicateKeys, transformPathWithKeyMapping, traverseAndNormalize, validatePatchOperations };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/buildPatchTransaction.ts","../src/convertArrayIndices.ts","../src/filterInvalidArrayItems.ts","../src/generateKey.ts","../src/keyMapping.ts","../src/normalizeInternationalizedArrays.ts","../src/normalizePatchOperations.ts","../src/normalizeReferences.ts","../src/portableTextCompat.ts","../src/prepareOperations.ts","../src/validatePatchOperations.ts"],"mappings":"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"}