@sinoia/hubdoc-tools 1.3.6 → 1.3.7

package/plugins/nuxeo/index.ts

@@ -1,512 +0,0 @@
-import axios, { AxiosInstance } from 'axios';
-import fs from 'fs-extra';
-import path from 'path';
-import {
-  DocumentSourcePlugin,
-  DocumentSource,
-  PluginConfig,
-  ScanResult,
-  PluginImportOptions,
-  PluginExportOptions,
-  ImportResult,
-  ExportResult
-} from '../../src/types/plugins';
-
-interface NuxeoConfig extends PluginConfig {
-  baseUrl: string;
-  username: string;
-  password: string;
-  repository?: string; // Default repository name, usually 'default'
-  rootPath?: string; // Starting path, defaults to '/default-domain/workspaces'
-  limit?: number;
-}
-
-interface NuxeoDocument {
-  uid: string;
-  name: string;
-  title: string;
-  type: string;
-  path: string;
-  state: string;
-  isFolder: boolean;
-  lastModified: string;
-  created: string;
-  properties: {
-    'dc:title': string;
-    'dc:description'?: string;
-    'dc:creator': string;
-    'dc:lastContributor': string;
-    'dc:created': string;
-    'dc:modified': string;
-    'file:content'?: {
-      name: string;
-      'mime-type': string;
-      length: number;
-      digest?: string;
-    };
-    [key: string]: any;
-  };
-  facets?: string[];
-  changeToken?: string;
-}
-
-export default class NuxeoPlugin implements DocumentSourcePlugin {
-  readonly name = 'nuxeo';
-  readonly version = '1.0.0';
-  readonly description = 'Nuxeo ECM document source';
-  readonly supportedOperations = ['import', 'export', 'both'] as const;
-
-  private config?: NuxeoConfig;
-  private apiClient?: AxiosInstance;
-
-  async testConnection(config: PluginConfig): Promise<boolean> {
-    try {
-      const client = this.createApiClient(config as NuxeoConfig);
-      const response = await client.get('/user/Administrator');
-      return response.status === 200;
-    } catch (error: any) {
-      console.error(`Nuxeo connection test failed: ${error.message}`);
-      return false;
-    }
-  }
-
-  async scan(config: PluginConfig, options?: PluginImportOptions): Promise<ScanResult> {
-    this.config = config as NuxeoConfig;
-    this.apiClient = this.createApiClient(this.config);
-
-    const sources: DocumentSource[] = [];
-    const errors: string[] = [];
-    let totalSize = 0;
-
-    try {
-      const limit = (this.config as any).limit || (options as any)?.limit;
-      console.log(`🔍 Scanning Nuxeo repository${limit ? ` (limit: ${limit})` : ''}...`);
-
-      const rootPath = this.config.rootPath || '/default-domain/workspaces';
-      const documents = await this.scanPath(rootPath);
-
-      let processedCount = 0;
-      for (const doc of documents) {
-        if (!doc.isFolder && doc.properties['file:content']) {
-          const fileContent = doc.properties['file:content'];
-          
-          const source: DocumentSource = {
-            id: doc.uid,
-            name: fileContent.name || doc.name,
-            path: this.getDocumentPath(doc),
-            size: fileContent.length || 0,
-            mimeType: fileContent['mime-type'] || 'application/octet-stream',
-            lastModified: new Date(doc.properties['dc:modified']),
-            metadata: {
-              nuxeoUid: doc.uid,
-              nuxeoPath: doc.path,
-              docType: doc.type,
-              title: doc.properties['dc:title'],
-              description: doc.properties['dc:description'],
-              creator: doc.properties['dc:creator'],
-              lastContributor: doc.properties['dc:lastContributor'],
-              createdAt: doc.properties['dc:created'],
-              state: doc.state,
-              facets: doc.facets,
-              changeToken: doc.changeToken,
-              digest: fileContent.digest
-            }
-          };
-
-          // Apply filters
-          if (this.shouldIncludeSource(source, options)) {
-            sources.push(source);
-            totalSize += source.size;
-            processedCount++;
-
-            // Check limit
-            if (limit && processedCount >= limit) {
-              console.log(`📏 Reached limit of ${limit} files`);
-              break;
-            }
-          }
-        }
-      }
-
-      return {
-        sources,
-        totalCount: sources.length,
-        totalSize,
-        errors
-      };
-    } catch (error: any) {
-      return {
-        sources: [],
-        totalCount: 0,
-        totalSize: 0,
-        errors: [`Nuxeo scan failed: ${error.message}`]
-      };
-    }
-  }
-
-  private async scanPath(docPath: string): Promise<NuxeoDocument[]> {
-    if (!this.apiClient) throw new Error('API client not initialized');
-
-    const allDocuments: NuxeoDocument[] = [];
-    let currentPageIndex = 0;
-    const pageSize = 100;
-
-    try {
-      while (true) {
-        // Use NXQL query to get all documents under the specified path
-        const query = `SELECT * FROM Document WHERE ecm:path STARTSWITH '${docPath}' AND ecm:isVersion = 0 AND ecm:isTrashed = 0`;
-        
-        const response = await this.apiClient.get('/search/lang/NXQL/execute', {
-          params: {
-            query: query,
-            currentPageIndex: currentPageIndex,
-            pageSize: pageSize,
-            sortBy: 'dc:title',
-            sortOrder: 'ASC'
-          }
-        });
-
-        const documents: NuxeoDocument[] = response.data.entries || [];
-        
-        if (documents.length === 0) {
-          break;
-        }
-
-        // Process both files and folders
-        for (const doc of documents) {
-          allDocuments.push(doc);
-          
-          // If it's a folder and has children, we could recursively scan
-          // but the STARTSWITH query should already include all descendants
-        }
-
-        // Check if there are more pages
-        if (documents.length < pageSize) {
-          break;
-        }
-        currentPageIndex++;
-      }
-
-      return allDocuments;
-    } catch (error: any) {
-      if (error.response?.status === 404) {
-        console.warn(`Warning: Path not found: ${docPath}`);
-        return [];
-      }
-      throw error;
-    }
-  }
-
-  async import(
-    config: PluginConfig,
-    sources: DocumentSource[],
-    targetDir: string,
-    options?: PluginImportOptions
-  ): Promise<ImportResult[]> {
-    this.config = config as NuxeoConfig;
-    this.apiClient = this.createApiClient(this.config);
-
-    const results: ImportResult[] = [];
-    const batchSize = options?.batchSize || 5;
-
-    // Process in batches to respect API limits
-    for (let i = 0; i < sources.length; i += batchSize) {
-      const batch = sources.slice(i, i + batchSize);
-      
-      for (const source of batch) {
-        const result = await this.importSingle(source, targetDir);
-        results.push(result);
-        
-        // Small delay to respect rate limits
-        await this.sleep(200);
-      }
-    }
-
-    return results;
-  }
-
-  private async importSingle(source: DocumentSource, targetDir: string): Promise<ImportResult> {
-    try {
-      if (!this.apiClient) throw new Error('API client not initialized');
-
-      const targetPath = path.join(targetDir, source.path);
-      const targetDirectory = path.dirname(targetPath);
-      
-      await fs.ensureDir(targetDirectory);
-
-      // Download file content from Nuxeo using the blob download endpoint
-      const response = await this.apiClient.get(`/id/${source.id}/@blob/file:content`, {
-        responseType: 'stream'
-      });
-      
-      const writer = fs.createWriteStream(targetPath);
-      response.data.pipe(writer);
-
-      return new Promise((resolve) => {
-        writer.on('finish', () => {
-          resolve({
-            success: true,
-            source,
-            localPath: targetPath,
-            bytesTransferred: source.size
-          });
-        });
-
-        writer.on('error', (error) => {
-          resolve({
-            success: false,
-            source,
-            error: error.message
-          });
-        });
-      });
-    } catch (error: any) {
-      return {
-        success: false,
-        source,
-        error: error.message
-      };
-    }
-  }
-
-  async export?(
-    config: PluginConfig,
-    localSources: DocumentSource[],
-    options?: PluginExportOptions
-  ): Promise<ExportResult[]> {
-    this.config = config as NuxeoConfig;
-    this.apiClient = this.createApiClient(this.config);
-
-    const results: ExportResult[] = [];
-    const rootPath = this.config.rootPath || '/default-domain/workspaces';
-
-    for (const source of localSources) {
-      try {
-        // Determine target path in Nuxeo
-        let targetPath = rootPath;
-        
-        if (options?.preserveStructure && source.path.includes('/')) {
-          const folderPath = path.dirname(source.path);
-          const targetFolderId = await this.createFolderStructure(folderPath, rootPath);
-          targetPath = targetFolderId;
-        }
-
-        // Read local file
-        const fileContent = await fs.readFile(source.id);
-        // Normalize filename to NFC to handle accented characters consistently across platforms
-        const fileName = (options?.preserveStructure ? path.basename(source.path) : source.name).normalize('NFC');
-
-        // Create document in Nuxeo using multipart form data
-        const FormData = require('form-data');
-        const form = new FormData();
-        
-        // Document metadata
-        const docData = {
-          'entity-type': 'document',
-          type: 'File',
-          name: fileName,
-          properties: {
-            'dc:title': fileName,
-            'dc:description': `Uploaded via hubdoc-tools`
-          }
-        };
-
-        form.append('entity-type', 'document');
-        form.append('type', 'File');
-        form.append('name', fileName);
-        form.append('properties', JSON.stringify({
-          'dc:title': fileName,
-          'dc:description': 'Uploaded via hubdoc-tools'
-        }));
-        
-        // Attach file
-        form.append('file', fileContent, {
-          filename: fileName,
-          contentType: source.mimeType || 'application/octet-stream'
-        });
-
-        const uploadResponse = await this.apiClient!.post(`/path${targetPath}`, form, {
-          headers: {
-            ...form.getHeaders()
-          }
-        });
-
-        const resultTargetPath = options?.preserveStructure ? source.path : source.name;
-
-        results.push({
-          success: true,
-          targetPath: resultTargetPath,
-          source,
-          bytesTransferred: source.size
-        });
-      } catch (error: any) {
-        results.push({
-          success: false,
-          targetPath: options?.targetPath || '',
-          source,
-          error: error.message
-        });
-      }
-    }
-
-    return results;
-  }
-
-  private async createFolderStructure(folderPath: string, parentPath: string): Promise<string> {
-    if (!this.apiClient) throw new Error('API client not initialized');
-
-    const parts = folderPath.split('/').filter(part => part.length > 0);
-    let currentPath = parentPath;
-
-    for (const folderName of parts) {
-      const expectedPath = `${currentPath}/${folderName}`;
-      
-      try {
-        // Check if folder already exists
-        const response = await this.apiClient.get(`/path${expectedPath}`);
-        
-        if (response.data && response.data.type === 'Folder') {
-          currentPath = expectedPath;
-          continue;
-        }
-      } catch (error: any) {
-        // Folder doesn't exist, create it
-        if (error.response?.status === 404) {
-          try {
-            const createResponse = await this.apiClient.post(`/path${currentPath}`, {
-              'entity-type': 'document',
-              type: 'Folder',
-              name: folderName,
-              properties: {
-                'dc:title': folderName
-              }
-            }, {
-              headers: {
-                'Content-Type': 'application/json'
-              }
-            });
-            
-            currentPath = expectedPath;
-          } catch (createError: any) {
-            throw new Error(`Failed to create folder ${folderName}: ${createError.message}`);
-          }
-        } else {
-          throw error;
-        }
-      }
-    }
-
-    return currentPath;
-  }
-
-  getConfigSchema(): Record<string, any> {
-    return {
-      type: 'object',
-      properties: {
-        baseUrl: {
-          type: 'string',
-          description: 'Nuxeo base URL (e.g., http://localhost:8080/nuxeo)',
-          required: true
-        },
-        username: {
-          type: 'string',
-          description: 'Nuxeo username',
-          required: true
-        },
-        password: {
-          type: 'string',
-          description: 'Nuxeo password',
-          required: true
-        },
-        repository: {
-          type: 'string',
-          description: 'Nuxeo repository name (default: default)',
-          default: 'default'
-        },
-        rootPath: {
-          type: 'string',
-          description: 'Starting path in Nuxeo (default: /default-domain/workspaces)',
-          default: '/default-domain/workspaces'
-        },
-        limit: {
-          type: 'number',
-          description: 'Maximum number of documents to scan (useful for testing)',
-          required: false
-        }
-      },
-      required: ['baseUrl', 'username', 'password']
-    };
-  }
-
-  async initialize(config: PluginConfig): Promise<void> {
-    this.config = config as NuxeoConfig;
-    
-    if (!this.config.baseUrl || !this.config.username || !this.config.password) {
-      throw new Error('Nuxeo base URL, username, and password are required');
-    }
-
-    this.apiClient = this.createApiClient(this.config);
-  }
-
-  async destroy(): Promise<void> {
-    this.config = undefined;
-    this.apiClient = undefined;
-  }
-
-  private createApiClient(config: NuxeoConfig): AxiosInstance {
-    const repository = config.repository || 'default';
-    const baseURL = `${config.baseUrl.replace(/\/$/, '')}/api/v1/repo/${repository}`;
-    
-    return axios.create({
-      baseURL,
-      auth: {
-        username: config.username,
-        password: config.password
-      },
-      headers: {
-        'Content-Type': 'application/json',
-        'Accept': 'application/json'
-      },
-      timeout: 30000
-    });
-  }
-
-  private getDocumentPath(doc: NuxeoDocument): string {
-    // Remove the repository-specific prefix from the path
-    let cleanPath = doc.path.replace(/^\/default-domain\/workspaces\//, '');
-    
-    // If the document has a file content, use the file name
-    if (doc.properties['file:content']?.name) {
-      const pathParts = cleanPath.split('/');
-      pathParts[pathParts.length - 1] = doc.properties['file:content'].name;
-      cleanPath = pathParts.join('/');
-    }
-    
-    return cleanPath || doc.name;
-  }
-
-  private shouldIncludeSource(source: DocumentSource, options?: PluginImportOptions): boolean {
-    // Apply size filter
-    if (options?.filters?.maxSize && source.size > options.filters.maxSize) {
-      return false;
-    }
-
-    // Apply date range filter
-    if (options?.filters?.dateRange) {
-      const { from, to } = options.filters.dateRange;
-      if (from && source.lastModified < from) return false;
-      if (to && source.lastModified > to) return false;
-    }
-
-    // Apply MIME type filter
-    if (options?.filters?.mimeTypes && !options.filters.mimeTypes.includes(source.mimeType)) {
-      return false;
-    }
-
-    return true;
-  }
-
-  private sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-}

package/plugins/nuxeo/plugin.json

@@ -1,12 +0,0 @@
-{
-  "name": "nuxeo",
-  "version": "1.0.0",
-  "description": "Nuxeo document source plugin",
-  "author": "HubDoc Tools",
-  "main": "index.ts",
-  "hubdocToolVersion": "^1.0.0",
-  "dependencies": {
-    "axios": "^1.5.0",
-    "fs-extra": "^11.1.0"
-  }
-}