@vue-skuilder/db 0.1.6 → 0.1.8-0

package/src/util/packer/CouchDBToStaticPacker.ts

@@ -14,6 +14,7 @@ import {
   StaticCourseManifest,
   AttachmentData,
 } from './types';
+import { FileSystemAdapter } from '../migrator/FileSystemAdapter';
 
 export class CouchDBToStaticPacker {
   private config: PackerConfig;
@@ -86,6 +87,94 @@ export class CouchDBToStaticPacker {
     };
   }
 
+  /**
+   * Pack a CouchDB course database and write the static files to disk
+   */
+  async packCourseToFiles(
+    sourceDB: PouchDB.Database, 
+    courseId: string, 
+    outputDir: string, 
+    fsAdapter: FileSystemAdapter
+  ): Promise<{ 
+    manifest: StaticCourseManifest; 
+    filesWritten: number; 
+    attachmentsFound: number; 
+  }> {
+    logger.info(`Packing course ${courseId} to files in ${outputDir}`);
+    
+    // First, pack the course data
+    const packedData = await this.packCourse(sourceDB, courseId);
+    
+    // Write the files using the FileSystemAdapter
+    const filesWritten = await this.writePackedDataToFiles(packedData, outputDir, fsAdapter);
+    
+    return {
+      manifest: packedData.manifest,
+      filesWritten,
+      attachmentsFound: packedData.attachments ? packedData.attachments.size : 0,
+    };
+  }
+
+  /**
+   * Write packed course data to files using FileSystemAdapter
+   */
+  private async writePackedDataToFiles(
+    packedData: PackedCourseData,
+    outputDir: string,
+    fsAdapter: FileSystemAdapter
+  ): Promise<number> {
+    let totalFiles = 0;
+    
+    // Ensure output directory exists
+    await fsAdapter.ensureDir(outputDir);
+    
+    // Write manifest
+    const manifestPath = fsAdapter.joinPath(outputDir, 'manifest.json');
+    await fsAdapter.writeJson(manifestPath, packedData.manifest, { spaces: 2 });
+    totalFiles++;
+    logger.info(`Wrote manifest: ${manifestPath}`);
+    
+    // Create subdirectories
+    const chunksDir = fsAdapter.joinPath(outputDir, 'chunks');
+    const indicesDir = fsAdapter.joinPath(outputDir, 'indices');
+    await fsAdapter.ensureDir(chunksDir);
+    await fsAdapter.ensureDir(indicesDir);
+    
+    // Write chunks
+    for (const [chunkId, chunkData] of packedData.chunks) {
+      const chunkPath = fsAdapter.joinPath(chunksDir, `${chunkId}.json`);
+      await fsAdapter.writeJson(chunkPath, chunkData);
+      totalFiles++;
+    }
+    logger.info(`Wrote ${packedData.chunks.size} chunk files`);
+    
+    // Write indices
+    for (const [indexName, indexData] of packedData.indices) {
+      const indexPath = fsAdapter.joinPath(indicesDir, `${indexName}.json`);
+      await fsAdapter.writeJson(indexPath, indexData, { spaces: 2 });
+      totalFiles++;
+    }
+    logger.info(`Wrote ${packedData.indices.size} index files`);
+    
+    // Write attachments
+    if (packedData.attachments && packedData.attachments.size > 0) {
+      for (const [attachmentPath, attachmentData] of packedData.attachments) {
+        const fullAttachmentPath = fsAdapter.joinPath(outputDir, attachmentPath);
+        
+        // Ensure attachment directory exists
+        const attachmentDir = fsAdapter.dirname(fullAttachmentPath);
+        await fsAdapter.ensureDir(attachmentDir);
+        
+        // Write binary file
+        await fsAdapter.writeFile(fullAttachmentPath, attachmentData.buffer);
+        totalFiles++;
+      }
+      logger.info(`Wrote ${packedData.attachments.size} attachment files`);
+    }
+    
+    return totalFiles;
+  }
+
   private async extractCourseConfig(db: PouchDB.Database): Promise<CourseConfig> {
     try {
       return await db.get<CourseConfig>('CourseConfig');
@@ -322,11 +411,12 @@ export class CouchDBToStaticPacker {
 
     try {
       const designDocId = designDoc._id; // e.g., "_design/elo"
-      const viewPath = `${designDocId}/${viewName}`;
+      const designDocName = designDocId.replace('_design/', ''); // Extract just "elo"
+      const viewPath = `${designDocName}/${viewName}`;
       
       logger.info(`Querying CouchDB view: ${viewPath}`);
       
-      // Query the view directly from CouchDB
+      // Query the view directly from CouchDB using PouchDB format: "designDocName/viewName"
       const viewResults = await this.sourceDB.query(viewPath, {
         include_docs: false,
       });

package/src/util/tuiLogger.ts

@@ -0,0 +1,139 @@
+// TUI-aware logging utility that redirects logs to file in Node.js
+import * as fs from 'fs';
+import * as path from 'path';
+import { getAppDataDirectory } from './dataDirectory';
+
+let logFile: string | null = null;
+let isNodeEnvironment = false;
+
+/**
+ * Initialize TUI logging - redirect console logs to file in Node.js
+ */
+export function initializeTuiLogging(): void {
+  // Detect Node.js environment
+  isNodeEnvironment = typeof window === 'undefined' && typeof process !== 'undefined';
+  
+  if (!isNodeEnvironment) {
+    return; // Browser environment - keep normal console logging
+  }
+
+  try {
+    // Set up log file path
+    logFile = path.join(getAppDataDirectory(), 'lastrun.log');
+    
+    // Clear previous log file
+    if (fs.existsSync(logFile)) {
+      fs.unlinkSync(logFile);
+    }
+    
+    // Create initial log entry
+    const startTime = new Date().toISOString();
+    fs.writeFileSync(logFile, `=== TUI Session Started: ${startTime} ===\n`);
+    
+    // Redirect console methods to file
+    const originalConsole = {
+      // eslint-disable-next-line no-console
+      log: console.log,
+      // eslint-disable-next-line no-console
+      error: console.error,
+      // eslint-disable-next-line no-console
+      warn: console.warn,
+      // eslint-disable-next-line no-console
+      info: console.info
+    };
+    
+    const writeToLog = (level: string, args: any[]) => {
+      const timestamp = new Date().toISOString();
+      const message = args.map(arg => 
+        typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)
+      ).join(' ');
+      
+      const logEntry = `[${timestamp}] ${level}: ${message}\n`;
+      
+      try {
+        fs.appendFileSync(logFile!, logEntry);
+      } catch (err) {
+        // Fallback to original console if file write fails
+        originalConsole.error('Failed to write to log file:', err);
+        originalConsole[level.toLowerCase() as keyof typeof originalConsole](...args);
+      }
+    };
+    
+    // Override console methods
+    // eslint-disable-next-line no-console
+    console.log = (...args) => writeToLog('INFO', args);
+    // eslint-disable-next-line no-console
+    console.info = (...args) => writeToLog('INFO', args);
+    // eslint-disable-next-line no-console
+    console.warn = (...args) => writeToLog('WARN', args);
+    // eslint-disable-next-line no-console
+    console.error = (...args) => writeToLog('ERROR', args);
+    
+    // Store original methods for potential restoration
+    (console as any)._originalMethods = originalConsole;
+    
+    // eslint-disable-next-line no-console
+    console.log('TUI logging initialized - logs redirected to', logFile);
+    
+  } catch (err) {
+    // eslint-disable-next-line no-console
+    console.error('Failed to initialize TUI logging:', err);
+  }
+}
+
+/**
+ * Get the current log file path (for debugging)
+ */
+export function getLogFilePath(): string | null {
+  return logFile;
+}
+
+/**
+ * Show user-facing message (always visible in TUI)
+ */
+export function showUserMessage(message: string): void {
+  if (isNodeEnvironment) {
+    // In Node.js, write directly to stdout to bypass log redirection
+    process.stdout.write(message + '\n');
+  } else {
+    // In browser, use normal console
+    // eslint-disable-next-line no-console
+    console.log(message);
+  }
+}
+
+/**
+ * Show user-facing error (always visible in TUI)
+ */
+export function showUserError(message: string): void {
+  if (isNodeEnvironment) {
+    // In Node.js, write directly to stderr to bypass log redirection
+    process.stderr.write('Error: ' + message + '\n');
+  } else {
+    // In browser, use normal console
+    // eslint-disable-next-line no-console
+    console.error(message);
+  }
+}
+
+/**
+ * Logger object with standard log levels
+ */
+export const logger = {
+  debug: (message: string, ...args: any[]) => {
+    // eslint-disable-next-line no-console
+    console.log(`[DEBUG] ${message}`, ...args);
+  },
+  info: (message: string, ...args: any[]) => {
+    // eslint-disable-next-line no-console
+    console.info(`[INFO] ${message}`, ...args);
+  },
+  warn: (message: string, ...args: any[]) => {
+    // eslint-disable-next-line no-console
+    console.warn(`[WARN] ${message}`, ...args);
+  },
+  error: (message: string, ...args: any[]) => {
+    // eslint-disable-next-line no-console
+    console.error(`[ERROR] ${message}`, ...args);
+  },
+};