@easyling/sanity-connector 0.0.1 → 0.0.2-rc.1

package/dist/services/translationService.js

@@ -1,687 +0,0 @@
-import * as TranslationRequestProto from '@easyling/sanity/dist/generated/translation_request';
-import * as TranslationResponseProto from '@easyling/sanity/dist/generated/translation_response';
-export class TranslationService {
-    constructor(placeholderEndpoint = 'http://localhost:8275/translate', requestContentType = 'application/json', responseAcceptHeader = 'application/json') {
-        this.placeholderEndpoint = placeholderEndpoint;
-        this.requestContentType = requestContentType;
-        this.responseAcceptHeader = responseAcceptHeader;
-    }
-    /**
-     * Infer the Sanity field type from a value
-     *
-     * @param value - The field value to inspect
-     * @returns The inferred Sanity type string
-     */
-    inferSanityType(value) {
-        if (value === null || value === undefined) {
-            return 'undefined';
-        }
-        // Check for Sanity-specific object types
-        if (typeof value === 'object' && !Array.isArray(value)) {
-            const obj = value;
-            // Sanity objects have a _type field
-            if (obj._type) {
-                return obj._type;
-            }
-        }
-        // Check primitive types
-        if (typeof value === 'string') {
-            return 'string';
-        }
-        if (typeof value === 'number') {
-            return 'number';
-        }
-        if (typeof value === 'boolean') {
-            return 'boolean';
-        }
-        if (Array.isArray(value)) {
-            return 'array';
-        }
-        if (typeof value === 'object') {
-            return 'object';
-        }
-        return 'unknown';
-    }
-    /**
-     * Set authentication token and project ID
-     * Requirements: 4.1, 4.2, 4.3
-     *
-     * @param token - Access token for API authentication
-     * @param projectId - Project ID to include in requests
-     */
-    setAuthToken(token, projectId) {
-        this.accessToken = token;
-        this.projectId = projectId;
-    }
-    /**
-     * Clear authentication data
-     */
-    clearAuth() {
-        this.accessToken = undefined;
-        this.projectId = undefined;
-    }
-    /**
-     * Update configuration for content types and endpoint
-     * Allows partial updates - only provided parameters will be updated
-     * Requirements: 1.1, 2.3, 3.3
-     *
-     * @param endpoint - Optional translation API endpoint URL
-     * @param requestContentType - Optional request Content-Type header value
-     * @param responseAcceptHeader - Optional response Accept header value
-     */
-    setConfiguration(endpoint, requestContentType, responseAcceptHeader) {
-        if (endpoint !== undefined) {
-            this.placeholderEndpoint = endpoint;
-        }
-        if (requestContentType !== undefined) {
-            this.requestContentType = requestContentType;
-        }
-        if (responseAcceptHeader !== undefined) {
-            this.responseAcceptHeader = responseAcceptHeader;
-        }
-    }
-    /**
-     * Convert internal payload to Protocol Buffer binary format
-     * Requirements: Uses @easyling/sanity protobuf library
-     *
-     * @param payload - Internal translation request payload
-     * @returns Binary protobuf message
-     */
-    convertPayloadToProtobuf(payload) {
-        // Convert internal TranslatableField objects to protobuf format
-        // Type information should be set by this point (from contentExtractor)
-        const protoFields = {};
-        for (const [key, field] of Object.entries(payload.content.fields)) {
-            // Handle both TranslatableField objects and plain values (for backward compatibility)
-            if (field && typeof field === 'object' && 'value' in field) {
-                // Already a TranslatableField object - type should be set from contentExtractor
-                const typedField = field;
-                // Warn if type is missing - should be set by contentExtractor in normal flow
-                let fieldType = typedField.type;
-                if (!fieldType) {
-                    console.warn(`Field '${key}' missing type in protobuf conversion, inferring from value`);
-                    fieldType = this.inferSanityType(typedField.value);
-                }
-                protoFields[key] = {
-                    value: typeof typedField.value === 'string' ? typedField.value : JSON.stringify(typedField.value),
-                    dnt: typedField.dnt || false,
-                    type: fieldType
-                };
-            }
-            else {
-                // Plain value - may happen for direct API calls that bypass contentExtractor
-                console.warn(`Field '${key}' not in TranslatableField format, wrapping with inferred type`);
-                protoFields[key] = {
-                    value: typeof field === 'string' ? field : JSON.stringify(field),
-                    dnt: false,
-                    type: this.inferSanityType(field)
-                };
-            }
-        }
-        // Create protobuf message from our payload
-        const protoPayload = TranslationRequestProto.TranslationRequestPayload.create({
-            content: {
-                body: payload.content.body,
-                title: payload.content.title,
-                slug: payload.content.slug,
-                fields: protoFields
-            },
-            project: this.projectId || '', // Project code for identification
-            format: payload.format,
-            metadata: {
-                documentId: payload.metadata.documentId,
-                documentType: payload.metadata.documentType,
-                title: payload.metadata.title,
-                sourceLanguage: payload.metadata.sourceLanguage || '',
-                targetLanguage: payload.metadata.targetLanguage || '',
-                targetLocales: payload.metadata.targetLocales || []
-            }
-        });
-        // Encode protobuf message to binary format
-        return TranslationRequestProto.TranslationRequestPayload.encode(protoPayload).finish();
-    }
-    /**
-     * Convert protobuf payload to JSON for logging purposes only
-     *
-     * @param payload - Internal translation request payload
-     * @returns JSON representation for logging
-     */
-    convertPayloadToProtobufJSON(payload) {
-        // Convert internal TranslatableField objects to protobuf format
-        const protoFields = {};
-        for (const [key, field] of Object.entries(payload.content.fields)) {
-            if (field && typeof field === 'object' && 'value' in field) {
-                const typedField = field;
-                protoFields[key] = {
-                    value: typeof typedField.value === 'string' ? typedField.value : JSON.stringify(typedField.value),
-                    dnt: typedField.dnt || false,
-                    type: typedField.type || 'unknown'
-                };
-            }
-            else {
-                protoFields[key] = {
-                    value: typeof field === 'string' ? field : JSON.stringify(field),
-                    dnt: false,
-                    type: 'unknown'
-                };
-            }
-        }
-        const protoPayload = TranslationRequestProto.TranslationRequestPayload.create({
-            content: {
-                body: payload.content.body,
-                title: payload.content.title,
-                slug: payload.content.slug,
-                fields: protoFields
-            },
-            project: this.projectId || '',
-            format: payload.format,
-            metadata: {
-                documentId: payload.metadata.documentId,
-                documentType: payload.metadata.documentType,
-                title: payload.metadata.title,
-                sourceLanguage: payload.metadata.sourceLanguage || '',
-                targetLanguage: payload.metadata.targetLanguage || '',
-                targetLocales: payload.metadata.targetLocales || []
-            }
-        });
-        return TranslationRequestProto.TranslationRequestPayload.toJSON(protoPayload);
-    }
-    /**
-     * Normalize field values to ensure consistency
-     * Extracts values from TranslatableField objects and handles various formats
-     */
-    normalizeTranslatedFields(fields) {
-        const normalizedFields = {};
-        if (!fields || typeof fields !== 'object') {
-            return normalizedFields;
-        }
-        for (const [key, fieldValue] of Object.entries(fields)) {
-            // Handle both TranslatableField objects and plain values
-            if (fieldValue && typeof fieldValue === 'object' && 'value' in fieldValue) {
-                // It's already a TranslatableField object
-                normalizedFields[key] = {
-                    value: fieldValue.value,
-                    dnt: fieldValue.dnt || false,
-                    type: fieldValue.type || this.inferSanityType(fieldValue.value)
-                };
-            }
-            else {
-                // It's a plain value - wrap it in TranslatableField format
-                normalizedFields[key] = {
-                    value: fieldValue,
-                    dnt: false,
-                    type: this.inferSanityType(fieldValue)
-                };
-            }
-        }
-        return normalizedFields;
-    }
-    /**
-     * Convert binary protobuf response to internal format
-     * Requirements: Uses @easyling/sanity protobuf library
-     *
-     * @param binaryData - Binary protobuf response data
-     * @returns Internal translation response format
-     */
-    convertProtobufBinaryToResponse(binaryData) {
-        // Decode binary protobuf response
-        const protoResponse = TranslationResponseProto.TranslationResponse.decode(binaryData);
-        // Convert to internal format
-        const translatedDocuments = protoResponse.translatedDocuments.map(doc => {
-            // Convert protobuf TranslatableField back to internal format
-            const fields = {};
-            if (doc.fields && typeof doc.fields === 'object') {
-                for (const [key, protoField] of Object.entries(doc.fields)) {
-                    if (protoField && typeof protoField === 'object' && 'value' in protoField) {
-                        const fieldValue = protoField.value;
-                        const fieldType = protoField.type;
-                        try {
-                            // Try to parse as JSON if it's a stringified value
-                            const parsedValue = JSON.parse(fieldValue);
-                            fields[key] = {
-                                value: parsedValue,
-                                dnt: protoField.dnt || false,
-                                type: fieldType || this.inferSanityType(parsedValue)
-                            };
-                        }
-                        catch {
-                            // If parsing fails, use the string value as-is
-                            fields[key] = {
-                                value: fieldValue,
-                                dnt: protoField.dnt || false,
-                                type: fieldType || this.inferSanityType(fieldValue)
-                            };
-                        }
-                    }
-                }
-            }
-            return {
-                body: doc.body,
-                title: doc.title,
-                slug: doc.slug,
-                fields,
-                locale: doc.locale
-            };
-        });
-        return {
-            success: protoResponse.success,
-            translatedDocuments,
-            sourceLocale: protoResponse.sourceLocale,
-            error: protoResponse.error,
-            requestId: protoResponse.requestId
-        };
-    }
-    /**
-     * Convert protobuf JSON response back to internal format (for legacy support)
-     * Requirements: Uses @easyling/sanity protobuf library
-     *
-     * @param jsonData - JSON response data
-     * @returns Internal translation response format
-     */
-    convertProtobufJSONToResponse(jsonData) {
-        // Parse the JSON into a protobuf message
-        const protoResponse = TranslationResponseProto.TranslationResponse.fromJSON(jsonData);
-        // Convert to internal format
-        const translatedDocuments = protoResponse.translatedDocuments.map((doc, index) => {
-            // Get original document data from jsonData to handle mixed field formats
-            const originalDoc = jsonData.translatedDocuments?.[index];
-            // Convert protobuf TranslatableField back to internal format
-            const protoFields = {};
-            if (doc.fields && typeof doc.fields === 'object') {
-                for (const [key, protoField] of Object.entries(doc.fields)) {
-                    // Get the original value from jsonData to check if protobuf lost it
-                    const originalValue = originalDoc?.fields?.[key];
-                    // Handle protobuf field format
-                    if (protoField && typeof protoField === 'object' && 'value' in protoField) {
-                        const fieldValue = protoField.value;
-                        const fieldType = protoField.type;
-                        // Check if protobuf parsing lost the value (empty string when original had value)
-                        if ((fieldValue === '' || fieldValue === undefined) && originalValue !== undefined && originalValue !== '') {
-                            // Use original value instead
-                            protoFields[key] = originalValue;
-                        }
-                        else {
-                            try {
-                                // Try to parse as JSON if it's a stringified value
-                                const parsedValue = JSON.parse(fieldValue);
-                                protoFields[key] = {
-                                    value: parsedValue,
-                                    dnt: protoField.dnt || false,
-                                    type: fieldType || this.inferSanityType(parsedValue)
-                                };
-                            }
-                            catch {
-                                // If parsing fails, use the string value as-is
-                                protoFields[key] = {
-                                    value: fieldValue,
-                                    dnt: protoField.dnt || false,
-                                    type: fieldType || this.inferSanityType(fieldValue)
-                                };
-                            }
-                        }
-                    }
-                    else {
-                        // Plain value - but protobuf parsing might have lost it
-                        // Fall back to original JSON data if the value is empty/undefined
-                        if (originalValue !== undefined && (!protoField || protoField === '')) {
-                            protoFields[key] = originalValue;
-                        }
-                        else {
-                            protoFields[key] = protoField;
-                        }
-                    }
-                }
-            }
-            // Also check for fields in original data that might have been lost in protobuf conversion
-            if (originalDoc?.fields && typeof originalDoc.fields === 'object') {
-                for (const [key, originalValue] of Object.entries(originalDoc.fields)) {
-                    if (!(key in protoFields)) {
-                        protoFields[key] = originalValue;
-                    }
-                }
-            }
-            // Normalize the fields to ensure consistent format
-            const fields = this.normalizeTranslatedFields(protoFields);
-            return {
-                body: doc.body,
-                title: doc.title,
-                slug: doc.slug,
-                fields,
-                locale: doc.locale
-            };
-        });
-        return {
-            success: protoResponse.success,
-            translatedDocuments,
-            sourceLocale: protoResponse.sourceLocale,
-            error: protoResponse.error,
-            requestId: protoResponse.requestId
-        };
-    }
-    /**
-     * Prepare a translation request for a single document
-     * Requirements: 1.2, 1.3, 3.3, 2.5, 2.7
-     *
-     * @param content - Document content to translate
-     * @param documentType - Type of the document
-     * @param sourceLanguage - Source language code (optional)
-     * @param targetLanguage - Single target language code (optional, for backward compatibility)
-     * @param targetLocales - Array of target locale codes (optional, for multi-locale support)
-     */
-    prepareTranslationRequest(content, documentType = 'document', sourceLanguage, targetLanguage, targetLocales) {
-        if (!content || !content.documentId || !content.htmlContent) {
-            throw new Error('Invalid document content provided');
-        }
-        // Convert flat fields to TranslatableField objects and ensure type is ALWAYS set
-        const translatableFields = {};
-        if (content.fields) {
-            for (const [key, value] of Object.entries(content.fields)) {
-                // If the field is already in the new format, ensure type is set
-                if (value && typeof value === 'object' && 'value' in value) {
-                    const typedField = value;
-                    // Type should already be set from contentExtractor, but ensure it's never undefined
-                    if (!typedField.type) {
-                        console.warn(`Field '${key}' missing type, inferring from value`);
-                    }
-                    translatableFields[key] = {
-                        ...typedField,
-                        type: typedField.type || this.inferSanityType(typedField.value)
-                    };
-                }
-                else {
-                    // Convert flat field to TranslatableField object (should rarely happen)
-                    console.warn(`Field '${key}' not in TranslatableField format, converting`);
-                    translatableFields[key] = {
-                        value,
-                        dnt: false,
-                        type: this.inferSanityType(value)
-                    };
-                }
-            }
-        }
-        const payload = {
-            content: {
-                body: content.htmlContent,
-                title: content.title || `Document ${content.documentId}`,
-                slug: content.slug || '',
-                fields: translatableFields
-            },
-            format: 'html',
-            metadata: {
-                documentId: content.documentId,
-                documentType,
-                title: content.title || `Document ${content.documentId}`,
-                ...(sourceLanguage && { sourceLanguage }),
-                // Support both single targetLanguage (backward compatibility) and targetLocales array
-                ...(targetLanguage && { targetLanguage }),
-                ...(targetLocales && targetLocales.length > 0 && { targetLocales })
-            }
-        };
-        return {
-            documentId: content.documentId,
-            endpoint: this.placeholderEndpoint,
-            payload
-        };
-    }
-    /**
-     * Translate a single document
-     * Requirements: 1.2, 1.3, 3.3, 2.5, 2.7
-     *
-     * @param content - Document content to translate
-     * @param documentType - Type of the document
-     * @param sourceLanguage - Source language code (optional)
-     * @param targetLanguage - Single target language code (optional, for backward compatibility)
-     * @param targetLocales - Array of target locale codes (optional, for multi-locale support)
-     */
-    async translateDocument(content, documentType = 'document', sourceLanguage, targetLanguage, targetLocales) {
-        const request = this.prepareTranslationRequest(content, documentType, sourceLanguage, targetLanguage, targetLocales);
-        return this.sendTranslationRequest(request);
-    }
-    /**
-     * Send translation request to the configured endpoint
-     *
-     * Uses the @easyling/sanity Protocol Buffer library to format messages as JSON
-     * (not binary protobuf) for better compatibility with various backends.
-     * Handles the new array-based response format with backward compatibility.
-     * The service now expects translatedDocuments as an array, but will convert
-     * legacy formats (translatedContent or translations object) to the new format.
-     *
-     * Supports dual mode operation:
-     * - Authenticated mode: Uses Bearer token authentication when configured
-     * - Legacy mode: Works without authentication for backward compatibility
-     */
-    async sendTranslationRequest(request) {
-        try {
-            this.logTranslationRequest(request);
-            // Build headers with configured content types
-            // Requirements: 2.2, 2.3, 3.2, 3.3
-            const headers = {
-                'Content-Type': this.requestContentType,
-                'Accept': this.responseAcceptHeader
-            };
-            // Add Authorization header if access token is available
-            if (this.accessToken) {
-                headers['Authorization'] = `Bearer ${this.accessToken}`;
-            }
-            // Serialize payload based on configured content type
-            // Requirements: 2.2, 2.3
-            let body;
-            if (this.requestContentType === 'application/x-protobuf') {
-                // Use binary protobuf serialization
-                body = this.convertPayloadToProtobuf(request.payload);
-            }
-            else {
-                // Use JSON serialization (protobuf JSON format)
-                const protobufJSON = this.convertPayloadToProtobufJSON(request.payload);
-                body = JSON.stringify(protobufJSON);
-            }
-            const response = await fetch(request.endpoint, {
-                method: 'POST',
-                headers,
-                body: body // TypeScript fetch types are strict, but Uint8Array is valid
-            });
-            if (!response.ok) {
-                // Handle 401 Unauthorized
-                if (response.status === 401) {
-                    return {
-                        success: false,
-                        error: 'Authentication failed. Please check your access token in the Easyling Configuration.'
-                    };
-                }
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            // Parse response based on configured Accept header
-            // Requirements: 3.2, 3.3, 3.5
-            if (this.responseAcceptHeader === 'application/x-protobuf') {
-                // Parse binary protobuf response
-                const arrayBuffer = await response.arrayBuffer();
-                const binaryData = new Uint8Array(arrayBuffer);
-                return this.convertProtobufBinaryToResponse(binaryData);
-            }
-            // Parse JSON response
-            const data = await response.json();
-            // Try to parse as protobuf JSON format first
-            try {
-                // If the response has the expected protobuf structure, parse it
-                if (data.success !== undefined && (data.translatedDocuments || data.error)) {
-                    return this.convertProtobufJSONToResponse(data);
-                }
-            }
-            catch (protoError) {
-                console.warn('Failed to parse response as protobuf format, falling back to legacy handling:', protoError);
-            }
-            // New format: translatedDocuments array (without success field - for backward compatibility)
-            if (data.translatedDocuments && Array.isArray(data.translatedDocuments)) {
-                // Normalize fields in each translated document to ensure consistency
-                const normalizedDocuments = data.translatedDocuments.map((doc) => ({
-                    ...doc,
-                    fields: this.normalizeTranslatedFields(doc.fields || {})
-                }));
-                return {
-                    success: true,
-                    translatedDocuments: normalizedDocuments,
-                    sourceLocale: data.sourceLocale,
-                    requestId: data.requestId
-                };
-            }
-            // Backward compatibility: translations object (convert to array)
-            if (data.translations) {
-                const translatedDocuments = [];
-                for (const [locale, translation] of Object.entries(data.translations)) {
-                    if (translation && typeof translation === 'object' && 'content' in translation) {
-                        const content = translation.content;
-                        // Normalize fields to ensure consistency
-                        translatedDocuments.push({
-                            ...content,
-                            fields: this.normalizeTranslatedFields(content.fields || {}),
-                            locale
-                        });
-                    }
-                }
-                return {
-                    success: true,
-                    translatedDocuments,
-                    sourceLocale: data.sourceLocale,
-                    requestId: data.requestId,
-                    // Keep deprecated field for backward compatibility
-                    translations: data.translations
-                };
-            }
-            // Backward compatibility: single translatedContent object (convert to array)
-            if (data.translatedContent) {
-                const targetLocale = request.payload.metadata.targetLanguage ||
-                    request.payload.metadata.targetLocales?.[0];
-                // Normalize fields to ensure consistency
-                const normalizedContent = {
-                    ...data.translatedContent,
-                    fields: this.normalizeTranslatedFields(data.translatedContent.fields || {}),
-                    locale: targetLocale
-                };
-                return {
-                    success: true,
-                    translatedDocuments: [normalizedContent],
-                    sourceLocale: request.payload.metadata.sourceLanguage,
-                    requestId: data.requestId,
-                    // Keep deprecated field for backward compatibility
-                    translatedContent: data.translatedContent
-                };
-            }
-            // Fallback: treat data.content as translatedContent
-            if (data.content) {
-                const targetLocale = request.payload.metadata.targetLanguage ||
-                    request.payload.metadata.targetLocales?.[0];
-                // Normalize fields to ensure consistency
-                const normalizedContent = {
-                    ...data.content,
-                    fields: this.normalizeTranslatedFields(data.content.fields || {}),
-                    locale: targetLocale
-                };
-                return {
-                    success: true,
-                    translatedDocuments: [normalizedContent],
-                    sourceLocale: request.payload.metadata.sourceLanguage,
-                    requestId: data.requestId,
-                    // Keep deprecated field for backward compatibility
-                    translatedContent: data.content
-                };
-            }
-            throw new Error('Invalid response format: missing translatedDocuments, translations, or translatedContent');
-        }
-        catch (error) {
-            console.error(`Translation request failed for document ${request.documentId}:`, error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred'
-            };
-        }
-    }
-    /**
-     * Log translation request to console for verification
-     * Requirements: 1.3, 2.4
-     */
-    logTranslationRequest(request) {
-        console.log('Translation Request:', {
-            timestamp: new Date().toISOString(),
-            documentId: request.documentId,
-            endpoint: request.endpoint,
-            payload: request.payload
-        });
-    }
-    /**
-     * Process bulk translation for multiple documents
-     * Requirements: 2.1, 2.2, 2.3, 2.4, 2.5, 2.7
-     *
-     * @param contents - Array of document contents to translate
-     * @param documentType - Type of the documents
-     * @param sourceLanguage - Source language code (optional)
-     * @param targetLanguage - Single target language code (optional, for backward compatibility)
-     * @param targetLocales - Array of target locale codes (optional, for multi-locale support)
-     */
-    async processBulkTranslation(contents, documentType = 'document', sourceLanguage, targetLanguage, targetLocales) {
-        const summary = {
-            totalDocuments: contents.length,
-            processedDocuments: 0,
-            failedDocuments: 0,
-            requests: [],
-            responses: []
-        };
-        const localeCount = targetLocales?.length || 1;
-        console.log(`Starting bulk translation for ${contents.length} documents to ${localeCount} locale(s)`);
-        for (const content of contents) {
-            try {
-                // Prepare translation request for each document
-                const request = this.prepareTranslationRequest(content, documentType, sourceLanguage, targetLanguage, targetLocales);
-                // Send the translation request
-                const response = await this.sendTranslationRequest(request);
-                // Add to summary
-                summary.requests.push(request);
-                summary.responses.push(response);
-                if (response.success) {
-                    summary.processedDocuments++;
-                }
-                else {
-                    summary.failedDocuments++;
-                }
-            }
-            catch (error) {
-                console.error(`Failed to process document ${content.documentId}:`, error);
-                summary.failedDocuments++;
-                summary.responses.push({
-                    success: false,
-                    error: error instanceof Error ? error.message : 'Unknown error occurred'
-                });
-            }
-        }
-        // Log bulk operation summary
-        this.logBulkTranslationSummary(summary);
-        return summary;
-    }
-    /**
-     * Log bulk translation summary
-     * Requirements: 2.5
-     */
-    logBulkTranslationSummary(summary) {
-        console.log('Bulk Translation Summary:', {
-            timestamp: new Date().toISOString(),
-            totalDocuments: summary.totalDocuments,
-            processedDocuments: summary.processedDocuments,
-            failedDocuments: summary.failedDocuments,
-            successRate: summary.totalDocuments > 0
-                ? ((summary.processedDocuments / summary.totalDocuments) * 100).toFixed(2) + '%'
-                : '0%'
-        });
-    }
-    /**
-     * Update the placeholder endpoint
-     */
-    setEndpoint(endpoint) {
-        this.placeholderEndpoint = endpoint;
-    }
-    /**
-     * Get the current endpoint
-     */
-    getEndpoint() {
-        return this.placeholderEndpoint;
-    }
-}
-//# sourceMappingURL=translationService.js.map