retold-remote 0.0.22 → 0.0.25

package/source/server/RetoldRemote-EbookService.js

@@ -1,12 +1,19 @@
 /**
- * Retold Remote -- Ebook Conversion Service
+ * Retold Remote -- Document Conversion Service
  *
- * Converts MOBI/AZW/KF8 ebooks to EPUB using Calibre's ebook-convert tool.
- * Conversions are cached so repeated requests are instant.
+ * Converts ebooks (MOBI/AZW/KF8) to EPUB and document formats
+ * (DOC/DOCX/RTF/ODT/WPD) to PDF for in-browser viewing.
+ *
+ * Uses:
+ *   - Calibre's ebook-convert for EPUB conversions
+ *   - LibreOffice headless for PDF conversions (preferred for layout docs)
+ *   - ebook-convert as fallback for PDF if LibreOffice unavailable
  *
  * API:
  *   convertToEpub(pAbsPath, pRelPath, fCallback)
  *     -> { Success, CacheKey, OutputFilename, SourcePath, FileSize }
+ *   convertToPdf(pAbsPath, pRelPath, fCallback)
+ *     -> { Success, CacheKey, OutputFilename, SourcePath, FileSize }
  *
  * @license MIT
  */
@@ -40,6 +47,26 @@ const _ConvertibleExtensions =
 	'cbr': true
 };
 
+// Extensions that should be converted to PDF for viewing
+// (layout-heavy documents that benefit from fixed-page rendering)
+const _PdfConvertibleExtensions =
+{
+	'doc': true,
+	'docx': true,
+	'rtf': true,
+	'odt': true,
+	'wpd': true,    // WordPerfect
+	'wps': true,    // Microsoft Works
+	'pages': true,  // Apple Pages (LibreOffice can sometimes handle)
+	'odp': true,    // OpenDocument Presentation
+	'ppt': true,    // PowerPoint
+	'pptx': true,   // PowerPoint (XML)
+	'ods': true,    // OpenDocument Spreadsheet
+	'xls': true,    // Excel
+	'xlsx': true,   // Excel (XML)
+	'csv': true     // CSV (renders as table in PDF)
+};
+
 class RetoldRemoteEbookService extends libFableServiceProviderBase
 {
 	constructor(pFable, pOptions, pServiceHash)
@@ -62,9 +89,23 @@ class RetoldRemoteEbookService extends libFableServiceProviderBase
 		// Ultravisor dispatcher — set via setDispatcher()
 		this._dispatcher = null;
 
+		// Orator-Conversion service reference — set via setConversionService()
+		this._conversionService = null;
+
 		this.fable.log.info('Ebook Service: using ParimeBinaryStorage (category: ebook-cache)');
 	}
 
+	/**
+	 * Set the orator-conversion service reference for document conversion.
+	 * Called from Server-Setup after the conversion service is instantiated.
+	 *
+	 * @param {object} pService - OratorFileTranslation instance
+	 */
+	setConversionService(pService)
+	{
+		this._conversionService = pService;
+	}
+
 	/**
 	 * Set the Ultravisor dispatcher for offloading heavy processing.
 	 *
@@ -86,6 +127,17 @@ class RetoldRemoteEbookService extends libFableServiceProviderBase
 		return !!_ConvertibleExtensions[pExtension];
 	}
 
+	/**
+	 * Check if a file extension can be converted to PDF for viewing.
+	 *
+	 * @param {string} pExtension - Lowercase file extension (no dot)
+	 * @returns {boolean}
+	 */
+	isPdfConvertible(pExtension)
+	{
+		return !!_PdfConvertibleExtensions[pExtension];
+	}
+
 	/**
 	 * Get the cache directory for a specific ebook file.
 	 * The key is based on the absolute path and modification time,
@@ -295,6 +347,145 @@ class RetoldRemoteEbookService extends libFableServiceProviderBase
 		}
 	}
 
+	/**
+	 * Convert a document to PDF via the orator-conversion doc-to-pdf converter.
+	 * Falls back to ebook-convert if the conversion service is not available.
+	 * Results are cached for fast repeated access.
+	 *
+	 * @param {string}   pAbsPath  - Absolute path to the source document
+	 * @param {string}   pRelPath  - Relative path (for the response)
+	 * @param {Function} fCallback - Callback(pError, pResult)
+	 */
+	convertToPdf(pAbsPath, pRelPath, fCallback)
+	{
+		let tmpSelf = this;
+
+		// Get file stats for cache key
+		let tmpStat;
+		try
+		{
+			tmpStat = libFs.statSync(pAbsPath);
+		}
+		catch (pError)
+		{
+			return fCallback(new Error('File not found.'));
+		}
+
+		let tmpCacheDir = this._getCacheDir(pAbsPath, tmpStat.mtimeMs);
+
+		// Check for cached manifest
+		let tmpManifestPath = libPath.join(tmpCacheDir, 'manifest-pdf.json');
+		if (libFs.existsSync(tmpManifestPath))
+		{
+			try
+			{
+				let tmpManifest = JSON.parse(libFs.readFileSync(tmpManifestPath, 'utf8'));
+				let tmpOutputPath = libPath.join(tmpCacheDir, tmpManifest.OutputFilename);
+				if (libFs.existsSync(tmpOutputPath))
+				{
+					this.fable.log.info(`PDF conversion cache hit for ${pRelPath}`);
+					return fCallback(null, tmpManifest);
+				}
+			}
+			catch (pError)
+			{
+				// Corrupted manifest, regenerate
+			}
+		}
+
+		// Ensure cache directory exists
+		if (!libFs.existsSync(tmpCacheDir))
+		{
+			libFs.mkdirSync(tmpCacheDir, { recursive: true });
+		}
+
+		let tmpOutputFilename = 'converted.pdf';
+		let tmpOutputPath = libPath.join(tmpCacheDir, tmpOutputFilename);
+		let tmpExt = libPath.extname(pAbsPath).replace(/^\./, '').toLowerCase();
+
+		this.fable.log.info(`Converting document to PDF: ${pRelPath}`);
+
+		// Try orator-conversion doc-to-pdf converter first
+		if (this._conversionService && this._conversionService.converters['doc-to-pdf'])
+		{
+			let tmpInputBuffer = libFs.readFileSync(pAbsPath);
+			let tmpMockRequest = { query: { ext: tmpExt }, params: {} };
+
+			this._conversionService.converters['doc-to-pdf'](tmpInputBuffer, tmpMockRequest,
+				(pConvertError, pPdfBuffer) =>
+				{
+					if (!pConvertError && pPdfBuffer && pPdfBuffer.length > 0)
+					{
+						libFs.writeFileSync(tmpOutputPath, pPdfBuffer);
+						return tmpSelf._finishPdfConversion(tmpOutputPath, tmpOutputFilename, tmpCacheDir, tmpManifestPath, pRelPath, 'orator-conversion', fCallback);
+					}
+
+					// Fall back to ebook-convert
+					tmpSelf.fable.log.info(`Orator-conversion failed, trying ebook-convert: ${pConvertError ? pConvertError.message : 'empty output'}`);
+					tmpSelf._convertToPdfLocal(pAbsPath, tmpOutputPath, tmpOutputFilename, tmpCacheDir, tmpManifestPath, pRelPath, fCallback);
+				});
+		}
+		else
+		{
+			// No orator-conversion doc-to-pdf — fall back to ebook-convert
+			this._convertToPdfLocal(pAbsPath, tmpOutputPath, tmpOutputFilename, tmpCacheDir, tmpManifestPath, pRelPath, fCallback);
+		}
+	}
+
+	/**
+	 * Convert to PDF locally using Calibre's ebook-convert.
+	 */
+	_convertToPdfLocal(pAbsPath, pOutputPath, pOutputFilename, pCacheDir, pManifestPath, pRelPath, fCallback)
+	{
+		try
+		{
+			let tmpCmd = `ebook-convert "${pAbsPath}" "${pOutputPath}"`;
+			libChildProcess.execSync(tmpCmd, { stdio: 'ignore', timeout: 120000 });
+
+			if (!libFs.existsSync(pOutputPath))
+			{
+				return fCallback(new Error('ebook-convert produced no output file.'));
+			}
+
+			return this._finishPdfConversion(pOutputPath, pOutputFilename, pCacheDir, pManifestPath, pRelPath, 'ebook-convert', fCallback);
+		}
+		catch (pError)
+		{
+			return fCallback(new Error('Document conversion failed: ' + pError.message));
+		}
+	}
+
+	/**
+	 * Finalize a PDF conversion: write manifest and return result.
+	 */
+	_finishPdfConversion(pOutputPath, pOutputFilename, pCacheDir, pManifestPath, pRelPath, pTool, fCallback)
+	{
+		let tmpOutputStat = libFs.statSync(pOutputPath);
+
+		let tmpResult =
+		{
+			Success: true,
+			SourcePath: pRelPath,
+			CacheKey: libPath.basename(pCacheDir),
+			OutputFilename: pOutputFilename,
+			FileSize: tmpOutputStat.size,
+			ConvertedAt: new Date().toISOString(),
+			ConvertedWith: pTool
+		};
+
+		try
+		{
+			libFs.writeFileSync(pManifestPath, JSON.stringify(tmpResult, null, '\t'));
+		}
+		catch (pWriteError)
+		{
+			this.fable.log.warn(`Could not write PDF manifest: ${pWriteError.message}`);
+		}
+
+		this.fable.log.info(`Converted to PDF: ${pRelPath} (${tmpOutputStat.size} bytes, via ${pTool})`);
+		return fCallback(null, tmpResult);
+	}
+
 	/**
 	 * Get the absolute path to a cached converted ebook file.
 	 *