@easyling/sanity-connector 0.0.1

package/dist/services/documentCreationService.js

@@ -0,0 +1,938 @@
+export class DocumentCreationService {
+    constructor(client, defaultCreationMode) {
+        this.defaultCreationMode = 'draft';
+        this.client = client;
+        if (defaultCreationMode) {
+            this.defaultCreationMode = defaultCreationMode;
+        }
+    }
+    /**
+     * Set the default document creation mode
+     * @param mode - The creation mode to use by default ('draft' or 'published')
+     */
+    setDefaultCreationMode(mode) {
+        this.defaultCreationMode = mode;
+    }
+    /**
+     * Create a new Sanity document from translation response
+     * Requirements: 1.1, 1.2, 2.1, 3.2, 3.4
+     */
+    async createDocumentFromTranslation(originalDocument, translationResponse, options = {}) {
+        try {
+            // Enhanced input validation
+            const inputValidation = this.validateInputsForDocumentCreation(originalDocument, translationResponse, options);
+            if (!inputValidation.isValid) {
+                return {
+                    success: false,
+                    error: `Input validation failed: ${inputValidation.errors.join(', ')}`
+                };
+            }
+            // Get translated content (support both new array format and legacy formats)
+            const translatedContent = translationResponse.translatedDocuments?.[0] ||
+                translationResponse.translatedContent;
+            if (!translationResponse.success || !translatedContent) {
+                return {
+                    success: false,
+                    error: 'Translation response does not contain valid translated content'
+                };
+            }
+            // Validate translation response content
+            const responseValidation = this.validateTranslationResponseForCreation(translationResponse);
+            if (!responseValidation.isValid) {
+                return {
+                    success: false,
+                    error: `Translation response validation failed: ${responseValidation.errors.join(', ')}`
+                };
+            }
+            // Merge translated content back into original document structure
+            const newDocument = await this.mergeTranslatedContent(originalDocument, translatedContent, options);
+            // Validate the new document structure
+            const validationResult = this.validateDocumentStructure(newDocument);
+            if (!validationResult.isValid) {
+                return {
+                    success: false,
+                    error: `Document validation failed: ${validationResult.errors.join(', ')}`
+                };
+            }
+            // Additional business logic validation
+            const businessValidation = this.validateBusinessRules(newDocument, originalDocument);
+            if (!businessValidation.isValid) {
+                return {
+                    success: false,
+                    error: `Business rule validation failed: ${businessValidation.errors.join(', ')}`
+                };
+            }
+            // Determine effective creation mode (option override or default)
+            const effectiveCreationMode = options.creationMode || this.defaultCreationMode;
+            // Actually create the document in Sanity
+            try {
+                let createdDocument;
+                if (effectiveCreationMode === 'draft') {
+                    // Create as draft document by prefixing ID with 'drafts.'
+                    const draftId = newDocument._id.startsWith('drafts.')
+                        ? newDocument._id
+                        : `drafts.${newDocument._id}`;
+                    console.log('Creating draft document in Sanity:', draftId);
+                    createdDocument = await this.client.create({
+                        ...newDocument,
+                        _id: draftId
+                    });
+                    console.log('Draft document created successfully:', createdDocument._id);
+                }
+                else {
+                    // Create as published document (no prefix)
+                    // Strip 'drafts.' prefix if present to ensure it's a published document
+                    const publishedId = newDocument._id.startsWith('drafts.')
+                        ? newDocument._id.replace(/^drafts\./, '')
+                        : newDocument._id;
+                    console.log('Creating published document in Sanity:', publishedId);
+                    createdDocument = await this.client.create({
+                        ...newDocument,
+                        _id: publishedId
+                    });
+                    console.log('Published document created successfully:', createdDocument._id);
+                }
+                return {
+                    success: true,
+                    documentId: createdDocument._id,
+                    document: createdDocument
+                };
+            }
+            catch (sanityError) {
+                console.error('Failed to create document in Sanity:', sanityError);
+                return {
+                    success: false,
+                    error: `Failed to save document to Sanity: ${sanityError instanceof Error ? sanityError.message : 'Unknown Sanity error'}`
+                };
+            }
+        }
+        catch (error) {
+            // Enhanced error handling with more context
+            const errorMessage = this.formatErrorMessage(error, originalDocument._id);
+            return {
+                success: false,
+                error: errorMessage
+            };
+        }
+    }
+    /**
+     * Validate inputs for document creation
+     * Requirements: 4.3, 4.4
+     */
+    validateInputsForDocumentCreation(originalDocument, translationResponse, options) {
+        const errors = [];
+        // Validate original document
+        if (!originalDocument) {
+            errors.push('Original document is required');
+            return { isValid: false, errors };
+        }
+        if (!originalDocument._id) {
+            errors.push('Original document must have an _id');
+        }
+        if (!originalDocument._type) {
+            errors.push('Original document must have a _type');
+        }
+        // Validate translation response
+        if (!translationResponse) {
+            errors.push('Translation response is required');
+            return { isValid: false, errors };
+        }
+        // Validate options
+        if (options.targetLanguage && typeof options.targetLanguage !== 'string') {
+            errors.push('Target language must be a string');
+        }
+        if (options.sourceLanguage && typeof options.sourceLanguage !== 'string') {
+            errors.push('Source language must be a string');
+        }
+        if (options.createAsVariant !== undefined && typeof options.createAsVariant !== 'boolean') {
+            errors.push('createAsVariant must be a boolean');
+        }
+        if (options.parentDocumentId && typeof options.parentDocumentId !== 'string') {
+            errors.push('parentDocumentId must be a string');
+        }
+        return {
+            isValid: errors.length === 0,
+            errors
+        };
+    }
+    /**
+     * Validate business rules for document creation
+     * Requirements: 4.3, 4.4
+     */
+    validateBusinessRules(newDocument, originalDocument) {
+        const errors = [];
+        // Ensure new document has different ID from original
+        if (newDocument._id === originalDocument._id) {
+            errors.push('New document ID must be different from original document ID');
+        }
+        // Ensure new document has same type as original
+        if (newDocument._type !== originalDocument._type) {
+            errors.push(`New document type (${newDocument._type}) must match original document type (${originalDocument._type})`);
+        }
+        // Validate that essential content exists
+        const hasContent = this.documentHasContent(newDocument);
+        if (!hasContent) {
+            errors.push('New document must contain some translatable content');
+        }
+        // Validate slug uniqueness if present
+        if (newDocument.slug && originalDocument.slug) {
+            const newSlug = typeof newDocument.slug === 'object' ? newDocument.slug.current : newDocument.slug;
+            const originalSlug = typeof originalDocument.slug === 'object' ? originalDocument.slug.current : originalDocument.slug;
+            if (newSlug === originalSlug) {
+                errors.push('New document slug should be different from original to avoid conflicts');
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors
+        };
+    }
+    /**
+     * Check if document has meaningful content
+     */
+    documentHasContent(document) {
+        // Check for title
+        if (document.title && typeof document.title === 'string' && document.title.trim().length > 0) {
+            return true;
+        }
+        // Check for body content
+        const contentFields = ['body', 'content', 'text', 'description'];
+        for (const field of contentFields) {
+            if (document[field]) {
+                if (typeof document[field] === 'string' && document[field].trim().length > 0) {
+                    return true;
+                }
+                if (Array.isArray(document[field]) && document[field].length > 0) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Format error messages with additional context
+     * Requirements: 4.3, 4.4
+     */
+    formatErrorMessage(error, documentId) {
+        const baseMessage = error instanceof Error ? error.message : 'Unknown error occurred during document creation';
+        const contextInfo = documentId ? ` (Document ID: ${documentId})` : '';
+        // Add specific error handling for common issues
+        if (error instanceof Error) {
+            if (error.message.includes('validation')) {
+                return `Document validation error${contextInfo}: ${error.message}`;
+            }
+            if (error.message.includes('network') || error.message.includes('fetch')) {
+                return `Network error during document creation${contextInfo}: ${error.message}`;
+            }
+            if (error.message.includes('permission') || error.message.includes('unauthorized')) {
+                return `Permission error during document creation${contextInfo}: ${error.message}`;
+            }
+        }
+        return `Document creation error${contextInfo}: ${baseMessage}`;
+    }
+    /**
+     * Create multiple documents from bulk translation responses
+     * Requirements: 2.1, 3.2, 3.4
+     */
+    async createBulkDocumentsFromTranslations(originalDocuments, translationResponses, options = {}) {
+        const result = {
+            totalDocuments: originalDocuments.length,
+            successfulCreations: 0,
+            failedCreations: 0,
+            results: [],
+            errors: [],
+            rollbackInfo: {
+                canRollback: true,
+                createdDocumentIds: [],
+                rollbackInstructions: []
+            }
+        };
+        // Pre-validate all translation responses before creating any documents
+        const validationErrors = this.validateBulkTranslationResponses(originalDocuments, translationResponses);
+        if (validationErrors.length > 0) {
+            result.errors.push(...validationErrors);
+            result.failedCreations = originalDocuments.length;
+            result.rollbackInfo.canRollback = false;
+            result.rollbackInfo.rollbackInstructions.push('No documents were created due to validation failures');
+            // Add individual failure results
+            for (let i = 0; i < originalDocuments.length; i++) {
+                result.results.push({
+                    success: false,
+                    error: 'Bulk validation failed - no documents created'
+                });
+            }
+            return result;
+        }
+        // Track successful creations for potential rollback
+        const createdDocuments = [];
+        for (let i = 0; i < originalDocuments.length; i++) {
+            const originalDocument = originalDocuments[i];
+            const translationResponse = translationResponses[i];
+            if (!translationResponse) {
+                const error = `No translation response found for document ${originalDocument._id}`;
+                result.results.push({
+                    success: false,
+                    error
+                });
+                result.errors.push(error);
+                result.failedCreations++;
+                continue;
+            }
+            try {
+                // Additional validation before creation
+                const preCreationValidation = this.validateTranslationResponseForCreation(translationResponse);
+                if (!preCreationValidation.isValid) {
+                    const error = `Pre-creation validation failed for ${originalDocument._id}: ${preCreationValidation.errors.join(', ')}`;
+                    result.results.push({
+                        success: false,
+                        error
+                    });
+                    result.errors.push(error);
+                    result.failedCreations++;
+                    continue;
+                }
+                // Get all translated documents (support both new array format and legacy single document format)
+                const translatedDocuments = translationResponse.translatedDocuments ||
+                    (translationResponse.translatedContent ? [translationResponse.translatedContent] : []);
+                if (translatedDocuments.length === 0) {
+                    const error = `No translated documents found in response for ${originalDocument._id}`;
+                    result.results.push({
+                        success: false,
+                        error
+                    });
+                    result.errors.push(error);
+                    result.failedCreations++;
+                    continue;
+                }
+                // Create a document for each translated document in the response
+                for (let j = 0; j < translatedDocuments.length; j++) {
+                    const translatedContent = translatedDocuments[j];
+                    // Extract locale from the translated content
+                    const localeField = translatedContent.fields?.locale;
+                    const localeValue = localeField && typeof localeField === 'object' && 'value' in localeField
+                        ? localeField.value
+                        : localeField;
+                    const targetLocale = (localeValue ||
+                        translatedContent.locale ||
+                        options.targetLanguage ||
+                        'translated');
+                    console.log(`Creating document for ${originalDocument._id} with locale: ${targetLocale}`);
+                    // Create a single-document translation response for this document
+                    const singleDocumentResponse = {
+                        ...translationResponse,
+                        translatedDocuments: [translatedContent],
+                        translatedContent: translatedContent
+                    };
+                    const creationResult = await this.createDocumentFromTranslation(originalDocument, singleDocumentResponse, {
+                        ...options,
+                        targetLanguage: targetLocale
+                    });
+                    result.results.push(creationResult);
+                    if (creationResult.success && creationResult.documentId) {
+                        result.successfulCreations++;
+                        createdDocuments.push({
+                            documentId: creationResult.documentId,
+                            originalId: originalDocument._id
+                        });
+                        result.rollbackInfo.createdDocumentIds.push(creationResult.documentId);
+                    }
+                    else {
+                        result.failedCreations++;
+                        if (creationResult.error) {
+                            result.errors.push(creationResult.error);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+                result.results.push({
+                    success: false,
+                    error: errorMessage
+                });
+                result.errors.push(errorMessage);
+                result.failedCreations++;
+            }
+        }
+        // Generate rollback instructions
+        if (result.successfulCreations > 0) {
+            result.rollbackInfo.rollbackInstructions = [
+                `${result.successfulCreations} documents were successfully created.`,
+                'To rollback these changes, you would need to delete the following document IDs:',
+                ...result.rollbackInfo.createdDocumentIds.map(id => `- ${id}`),
+                'Note: This plugin does not automatically delete documents for safety reasons.',
+                'Manual deletion through Sanity Studio or API calls would be required.'
+            ];
+        }
+        else {
+            result.rollbackInfo.rollbackInstructions = ['No documents were created, no rollback needed.'];
+        }
+        return result;
+    }
+    /**
+     * Validate bulk translation responses before document creation
+     * Requirements: 4.3, 4.4
+     */
+    validateBulkTranslationResponses(originalDocuments, translationResponses) {
+        const errors = [];
+        // Check array lengths match
+        if (originalDocuments.length !== translationResponses.length) {
+            errors.push(`Mismatch between original documents (${originalDocuments.length}) and translation responses (${translationResponses.length})`);
+            return errors; // Critical error, return immediately
+        }
+        // Validate each pair
+        for (let i = 0; i < originalDocuments.length; i++) {
+            const originalDoc = originalDocuments[i];
+            const response = translationResponses[i];
+            if (!originalDoc) {
+                errors.push(`Original document at index ${i} is null or undefined`);
+                continue;
+            }
+            if (!originalDoc._id) {
+                errors.push(`Original document at index ${i} missing _id`);
+                continue;
+            }
+            if (!originalDoc._type) {
+                errors.push(`Original document at index ${i} missing _type`);
+                continue;
+            }
+            if (!response) {
+                errors.push(`Translation response at index ${i} is null or undefined`);
+                continue;
+            }
+            if (!response.success) {
+                // This is not necessarily an error for bulk validation, just skip this document
+                continue;
+            }
+            // Check for translated content (support both new array format and legacy formats)
+            const translatedDocuments = response.translatedDocuments ||
+                (response.translatedContent ? [response.translatedContent] : []);
+            if (translatedDocuments.length === 0) {
+                errors.push(`Translation response at index ${i} missing translatedDocuments/translatedContent despite success=true`);
+                continue;
+            }
+        }
+        return errors;
+    }
+    /**
+     * Validate translation response before document creation
+     * Requirements: 4.3, 4.4
+     */
+    validateTranslationResponseForCreation(response) {
+        const errors = [];
+        if (!response.success) {
+            errors.push('Translation response indicates failure');
+            return { isValid: false, errors };
+        }
+        // Get translated content (support both new array format and legacy formats)
+        const translatedDocuments = response.translatedDocuments ||
+            (response.translatedContent ? [response.translatedContent] : []);
+        if (translatedDocuments.length === 0) {
+            errors.push('Translation response missing translatedDocuments/translatedContent');
+            return { isValid: false, errors };
+        }
+        // Validate each translated document structure
+        for (let i = 0; i < translatedDocuments.length; i++) {
+            const content = translatedDocuments[i];
+            if (typeof content !== 'object' || content === null) {
+                errors.push(`Translated document at index ${i} must be an object`);
+                continue;
+            }
+            // Check for required fields
+            if (!content.body && !content.title && !content.fields) {
+                errors.push(`Translated document at index ${i} must contain at least one of: body, title, or fields`);
+            }
+            // Validate body content if present
+            if (content.body !== undefined) {
+                if (typeof content.body !== 'string') {
+                    errors.push(`Translated document at index ${i} body must be a string`);
+                }
+                else if (content.body.trim().length === 0) {
+                    errors.push(`Translated document at index ${i} body cannot be empty`);
+                }
+            }
+            // Validate title if present
+            if (content.title !== undefined) {
+                if (typeof content.title !== 'string') {
+                    errors.push(`Translated document at index ${i} title must be a string`);
+                }
+                else if (content.title.trim().length === 0) {
+                    errors.push(`Translated document at index ${i} title cannot be empty`);
+                }
+            }
+            // Validate slug if present
+            if (content.slug !== undefined) {
+                if (typeof content.slug !== 'string') {
+                    errors.push(`Translated document at index ${i} slug must be a string`);
+                }
+                else if (content.slug.trim().length === 0) {
+                    errors.push(`Translated document at index ${i} slug cannot be empty`);
+                }
+                else if (!/^[a-z0-9-_]+$/.test(content.slug)) {
+                    errors.push(`Translated document at index ${i} slug must contain only lowercase letters, numbers, hyphens, and underscores`);
+                }
+            }
+            // Validate fields if present
+            if (content.fields !== undefined) {
+                if (typeof content.fields !== 'object' || content.fields === null || Array.isArray(content.fields)) {
+                    errors.push(`Translated document at index ${i} fields must be an object`);
+                }
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors
+        };
+    }
+    /**
+     * Create rollback plan for failed bulk operations
+     * Requirements: 4.3, 4.4
+     */
+    createRollbackPlan(createdDocumentIds) {
+        if (createdDocumentIds.length === 0) {
+            return {
+                canRollback: true,
+                createdDocumentIds: [],
+                rollbackInstructions: ['No documents were created, no rollback needed.']
+            };
+        }
+        return {
+            canRollback: true,
+            createdDocumentIds: [...createdDocumentIds],
+            rollbackInstructions: [
+                `Rollback plan for ${createdDocumentIds.length} created documents:`,
+                '',
+                '1. Manual deletion required (for safety):',
+                ...createdDocumentIds.map(id => `   - Delete document: ${id}`),
+                '',
+                '2. Alternative: Use Sanity CLI or API:',
+                '   sanity documents delete <document-id>',
+                '',
+                '3. Or via Sanity Client API:',
+                '   client.delete(documentId)',
+                '',
+                'WARNING: This plugin does not provide automatic rollback to prevent',
+                'accidental data loss. Please review each document before deletion.'
+            ]
+        };
+    }
+    /**
+     * Merge translated content back into original document structure
+     * Requirements: 1.2, 3.2, 3.4
+     */
+    async mergeTranslatedContent(originalDocument, translatedContent, options) {
+        // Extract the target locale early for document ID generation
+        // Priority: options.targetLanguage > translatedContent.locale > fields.locale
+        let targetLang = options.targetLanguage;
+        if (!targetLang) {
+            if (translatedContent.locale) {
+                targetLang = translatedContent.locale;
+            }
+            else if (translatedContent.fields?.locale) {
+                const localeField = translatedContent.fields.locale;
+                if (localeField && typeof localeField === 'object' && 'value' in localeField) {
+                    targetLang = localeField.value;
+                }
+                else if (typeof localeField === 'string') {
+                    targetLang = localeField;
+                }
+            }
+        }
+        // Create a new document based on the original
+        const newDocument = {
+            ...originalDocument,
+            _id: this.generateNewDocumentId(originalDocument._id, targetLang),
+            // Remove system fields - they will be set by Sanity
+            _rev: undefined,
+            _createdAt: undefined,
+            _updatedAt: undefined,
+        };
+        // Update title if provided
+        if (translatedContent.title && translatedContent.title.trim()) {
+            newDocument.title = translatedContent.title;
+        }
+        // Update slug if provided - ensure it's in the correct format
+        if (translatedContent.slug && translatedContent.slug.trim()) {
+            // Check if original document has slug as an object with _type
+            if (typeof originalDocument.slug === 'object' && originalDocument.slug !== null && '_type' in originalDocument.slug) {
+                newDocument.slug = {
+                    _type: 'slug',
+                    current: translatedContent.slug
+                };
+            }
+            else {
+                // If original was a string or didn't exist, just use the string
+                newDocument.slug = translatedContent.slug;
+            }
+        }
+        // Convert HTML body back to portable text and merge
+        if (translatedContent.body && translatedContent.body.trim()) {
+            const portableTextContent = this.convertHtmlToPortableText(translatedContent.body);
+            // Find the main content field and update it
+            const contentFields = ['body', 'content', 'text', 'description'];
+            for (const field of contentFields) {
+                if (originalDocument[field]) {
+                    newDocument[field] = portableTextContent;
+                    break;
+                }
+            }
+            // If no content field found, add to body
+            if (!contentFields.some(field => originalDocument[field])) {
+                newDocument.body = portableTextContent;
+            }
+        }
+        // Merge other translated fields from the fields object
+        if (translatedContent.fields && typeof translatedContent.fields === 'object') {
+            for (const [fieldName, fieldValue] of Object.entries(translatedContent.fields)) {
+                // Skip title and slug as they're handled separately above
+                if (fieldName === 'title' || fieldName === 'slug' || fieldValue === undefined) {
+                    continue;
+                }
+                // Handle the field value based on the original document's structure
+                const processedValue = this.processTranslatedField(fieldName, fieldValue, originalDocument[fieldName]);
+                if (processedValue !== undefined) {
+                    newDocument[fieldName] = processedValue;
+                }
+            }
+        }
+        // Ensure locale field is set correctly with the target language
+        if (targetLang) {
+            // Check if original document has locale field with {dnt, value} structure
+            if (originalDocument.locale && typeof originalDocument.locale === 'object' && 'value' in originalDocument.locale) {
+                newDocument.locale = {
+                    ...originalDocument.locale,
+                    value: targetLang
+                };
+            }
+            else if (newDocument.locale && typeof newDocument.locale === 'object' && 'value' in newDocument.locale) {
+                // If locale field exists in newDocument but value is empty/wrong, fix it
+                newDocument.locale = {
+                    ...newDocument.locale,
+                    value: targetLang
+                };
+            }
+            else if (originalDocument.locale !== undefined) {
+                // If locale exists but is a plain string
+                newDocument.locale = targetLang;
+            }
+        }
+        // Clean up null fields that aren't defined in the original document's schema
+        // Remove fields that are explicitly null or undefined to avoid schema validation errors
+        const fieldsToClean = Object.keys(newDocument);
+        for (const field of fieldsToClean) {
+            if (newDocument[field] === null) {
+                delete newDocument[field];
+            }
+        }
+        // Add reference to parent document if creating as variant
+        if (options.createAsVariant && options.parentDocumentId) {
+            newDocument.parentDocument = {
+                _type: 'reference',
+                _ref: options.parentDocumentId
+            };
+        }
+        return newDocument;
+    }
+    /**
+     * Process a translated field value and convert it to the appropriate format
+     * based on the original document's structure
+     */
+    processTranslatedField(fieldName, translatedValue, originalValue) {
+        // If translatedValue is null or undefined, return it as-is
+        if (translatedValue === null || translatedValue === undefined) {
+            return translatedValue;
+        }
+        // Extract the actual value from TranslatableField objects
+        let actualValue = translatedValue;
+        let isDNT = false;
+        if (translatedValue && typeof translatedValue === 'object' && 'value' in translatedValue) {
+            // This is a TranslatableField object - extract the value
+            actualValue = translatedValue.value;
+            isDNT = translatedValue.dnt || false;
+        }
+        // If the field is marked as DNT, use the original value instead
+        if (isDNT && originalValue !== undefined) {
+            return originalValue;
+        }
+        // Check if the original value has a specific structure that we need to preserve
+        if (originalValue && typeof originalValue === 'object' && originalValue !== null) {
+            // Handle fields with {dnt, value} structure
+            if ('dnt' in originalValue && 'value' in originalValue) {
+                // IMPORTANT: Only use actualValue if it's not empty/null/undefined
+                // If actualValue is empty but translatedValue had a nested value, try to extract it
+                let finalValue = actualValue;
+                // Handle cases where translatedValue itself has a nested value structure
+                if (translatedValue && typeof translatedValue === 'object' && 'value' in translatedValue) {
+                    finalValue = translatedValue.value;
+                }
+                // If finalValue is still empty/null/undefined, don't replace the original
+                if (finalValue === null || finalValue === undefined || finalValue === '') {
+                    // Check if we should keep the original value
+                    if (originalValue.value !== null && originalValue.value !== undefined && originalValue.value !== '') {
+                        return originalValue;
+                    }
+                }
+                return {
+                    dnt: isDNT,
+                    value: finalValue
+                };
+            }
+            // Handle slug objects
+            if ('_type' in originalValue && originalValue._type === 'slug') {
+                return {
+                    _type: 'slug',
+                    current: typeof actualValue === 'string' ? actualValue : String(actualValue)
+                };
+            }
+            // Handle date/datetime objects
+            if ('_type' in originalValue && (originalValue._type === 'date' || originalValue._type === 'datetime')) {
+                return {
+                    _type: originalValue._type,
+                    value: actualValue
+                };
+            }
+            // Handle reference objects
+            if ('_type' in originalValue && originalValue._type === 'reference') {
+                return originalValue; // Keep references unchanged
+            }
+        }
+        // If the actual value is an HTML string, convert it to portable text
+        if (typeof actualValue === 'string' && this.isHtmlContent(actualValue)) {
+            return this.convertHtmlToPortableText(actualValue);
+        }
+        // Return the actual value as-is
+        return actualValue;
+    }
+    /**
+     * Convert HTML content back to Sanity portable text format
+     * Requirements: 3.2, 3.4
+     */
+    convertHtmlToPortableText(htmlContent) {
+        // This is a simplified HTML to portable text conversion
+        // In a real implementation, you might want to use a proper HTML parser
+        if (!htmlContent || !htmlContent.trim()) {
+            return [];
+        }
+        const blocks = [];
+        // Use a more precise regex to match complete HTML tags and their content
+        const htmlTagRegex = /<(h[1-6]|p|div|blockquote|li)([^>]*)>(.*?)<\/\1>/gi;
+        let match;
+        let lastIndex = 0;
+        while ((match = htmlTagRegex.exec(htmlContent)) !== null) {
+            const [fullMatch, tagName, attributes, content] = match;
+            // Skip if content is empty or just whitespace
+            if (!content.trim()) {
+                continue;
+            }
+            const block = {
+                _type: 'block',
+                _key: this.generateBlockKey(),
+                style: this.getBlockStyle(tagName.toLowerCase()),
+                children: this.parseInlineContent(content),
+                markDefs: []
+            };
+            // Handle list items
+            if (tagName.toLowerCase() === 'li') {
+                block.listItem = 'bullet'; // Default to bullet, could be enhanced
+            }
+            blocks.push(block);
+            lastIndex = match.index + fullMatch.length;
+        }
+        // Handle any remaining content that wasn't matched by tags
+        const remainingContent = htmlContent.substring(lastIndex).trim();
+        if (remainingContent) {
+            // Remove any remaining HTML tags and create a block
+            const cleanContent = remainingContent.replace(/<[^>]+>/g, '').trim();
+            if (cleanContent) {
+                blocks.push({
+                    _type: 'block',
+                    _key: this.generateBlockKey(),
+                    style: 'normal',
+                    children: this.parseInlineContent(cleanContent),
+                    markDefs: []
+                });
+            }
+        }
+        // If no blocks were created, create a default one with cleaned content
+        if (blocks.length === 0 && htmlContent.trim()) {
+            const cleanContent = htmlContent.replace(/<[^>]+>/g, '').trim();
+            if (cleanContent) {
+                blocks.push({
+                    _type: 'block',
+                    _key: this.generateBlockKey(),
+                    style: 'normal',
+                    children: this.parseInlineContent(cleanContent),
+                    markDefs: []
+                });
+            }
+        }
+        return blocks;
+    }
+    /**
+     * Parse inline content and handle formatting
+     */
+    parseInlineContent(content) {
+        const children = [];
+        // Remove HTML tags and extract text with basic formatting
+        const cleanContent = content
+            .replace(/<strong[^>]*>(.*?)<\/strong>/gi, '**$1**')
+            .replace(/<em[^>]*>(.*?)<\/em>/gi, '*$1*')
+            .replace(/<u[^>]*>(.*?)<\/u>/gi, '_$1_')
+            .replace(/<code[^>]*>(.*?)<\/code>/gi, '`$1`')
+            .replace(/<[^>]+>/g, '') // Remove remaining HTML tags
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&amp;/g, '&')
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'");
+        if (cleanContent.trim()) {
+            children.push({
+                _type: 'span',
+                _key: this.generateSpanKey(),
+                text: cleanContent,
+                marks: []
+            });
+        }
+        return children;
+    }
+    /**
+     * Get block style from HTML tag name
+     */
+    getBlockStyle(tagName) {
+        const styleMap = {
+            'h1': 'h1',
+            'h2': 'h2',
+            'h3': 'h3',
+            'h4': 'h4',
+            'h5': 'h5',
+            'h6': 'h6',
+            'blockquote': 'blockquote',
+            'p': 'normal',
+            'div': 'normal',
+            'li': 'normal'
+        };
+        return styleMap[tagName] || 'normal';
+    }
+    /**
+     * Check if content appears to be HTML
+     */
+    isHtmlContent(content) {
+        return /<[^>]+>/.test(content);
+    }
+    /**
+     * Generate a new document ID based on original ID and target language
+     */
+    generateNewDocumentId(originalId, targetLanguage) {
+        // Strip 'drafts.' prefix if present to generate clean base IDs
+        const cleanId = originalId.startsWith('drafts.')
+            ? originalId.replace(/^drafts\./, '')
+            : originalId;
+        const timestamp = Date.now();
+        const suffix = targetLanguage ? `-${targetLanguage}` : '-translated';
+        return `${cleanId}${suffix}-${timestamp}`;
+    }
+    /**
+     * Generate a unique key for portable text blocks
+     */
+    generateBlockKey() {
+        return Math.random().toString(36).substr(2, 9);
+    }
+    /**
+     * Generate a unique key for spans
+     */
+    generateSpanKey() {
+        return Math.random().toString(36).substr(2, 9);
+    }
+    /**
+     * Validate document structure before creation
+     * Requirements: 3.4
+     */
+    validateDocumentStructure(document) {
+        const errors = [];
+        // Check required fields
+        if (!document._id) {
+            errors.push('Document must have an _id');
+        }
+        if (!document._type) {
+            errors.push('Document must have a _type');
+        }
+        // Validate portable text fields
+        const portableTextFields = ['body', 'content', 'text', 'description'];
+        for (const field of portableTextFields) {
+            if (document[field] && Array.isArray(document[field])) {
+                const validationResult = this.validatePortableTextArray(document[field], field);
+                if (!validationResult.isValid) {
+                    errors.push(...validationResult.errors);
+                }
+            }
+        }
+        // Validate slug format
+        if (document.slug) {
+            if (typeof document.slug === 'object' && document.slug !== null && '_type' in document.slug) {
+                const slugObj = document.slug;
+                if (slugObj._type !== 'slug') {
+                    errors.push('Slug object must have _type of "slug"');
+                }
+                if (!slugObj.current) {
+                    errors.push('Slug object must have a current value');
+                }
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors
+        };
+    }
+    /**
+     * Validate portable text array structure
+     */
+    validatePortableTextArray(blocks, fieldName) {
+        const errors = [];
+        if (!Array.isArray(blocks)) {
+            errors.push(`${fieldName} must be an array`);
+            return { isValid: false, errors };
+        }
+        for (let i = 0; i < blocks.length; i++) {
+            const block = blocks[i];
+            if (!block || typeof block !== 'object') {
+                errors.push(`${fieldName}[${i}] must be an object`);
+                continue;
+            }
+            const blockObj = block;
+            if (!blockObj._type) {
+                errors.push(`${fieldName}[${i}] must have a _type`);
+            }
+            if (!blockObj._key) {
+                errors.push(`${fieldName}[${i}] must have a _key`);
+            }
+            if (blockObj._type === 'block') {
+                if (!Array.isArray(blockObj.children)) {
+                    errors.push(`${fieldName}[${i}] block must have children array`);
+                }
+                else {
+                    // Validate children
+                    const children = blockObj.children;
+                    for (let j = 0; j < children.length; j++) {
+                        const child = children[j];
+                        if (!child || typeof child !== 'object') {
+                            errors.push(`${fieldName}[${i}].children[${j}] must be an object`);
+                            continue;
+                        }
+                        const childObj = child;
+                        if (!childObj._type) {
+                            errors.push(`${fieldName}[${i}].children[${j}] must have a _type`);
+                        }
+                        if (!childObj._key) {
+                            errors.push(`${fieldName}[${i}].children[${j}] must have a _key`);
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors
+        };
+    }
+}
+//# sourceMappingURL=documentCreationService.js.map