@sinoia/hubdoc-tools 1.3.2 → 1.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinoia/hubdoc-tools",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "Professional command-line tool for HubDoc document management and bulk import/export",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,6 +9,7 @@
   },
   "files": [
     "dist",
+    "plugins",
     "README.md",
     "LICENSE"
   ],

package/plugins/alfresco/index.ts

@@ -0,0 +1,518 @@
+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 AlfrescoConfig extends PluginConfig {
+  baseUrl: string;
+  username: string;
+  password: string;
+  siteId?: string;
+  folderId?: string; // Starting folder ID, defaults to root
+  includeFolders?: boolean;
+  limit?: number;
+}
+
+interface AlfrescoNode {
+  id: string;
+  name: string;
+  nodeType: string;
+  isFolder: boolean;
+  isFile: boolean;
+  createdAt: string;
+  modifiedAt: string;
+  createdByUser: {
+    id: string;
+    displayName: string;
+  };
+  modifiedByUser: {
+    id: string;
+    displayName: string;
+  };
+  content?: {
+    mimeType: string;
+    sizeInBytes: number;
+  };
+  properties?: Record<string, any>;
+  path?: {
+    name: string;
+    isComplete: boolean;
+    elements: Array<{
+      id: string;
+      name: string;
+    }>;
+  };
+}
+
+export default class AlfrescoPlugin implements DocumentSourcePlugin {
+  readonly name = 'alfresco';
+  readonly version = '1.0.0';
+  readonly description = 'Alfresco ECM document source';
+  readonly supportedOperations = ['import', 'export', 'both'] as const;
+
+  private config?: AlfrescoConfig;
+  private apiClient?: AxiosInstance;
+  private readonly apiVersion = 'alfresco/versions/1';
+
+  async testConnection(config: PluginConfig): Promise<boolean> {
+    try {
+      const client = this.createApiClient(config as AlfrescoConfig);
+      const response = await client.get('/people/-me-');
+      return response.status === 200;
+    } catch (error: any) {
+      console.error(`Alfresco connection test failed: ${error.message}`);
+      return false;
+    }
+  }
+
+  async scan(config: PluginConfig, options?: PluginImportOptions): Promise<ScanResult> {
+    this.config = config as AlfrescoConfig;
+    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 Alfresco repository${limit ? ` (limit: ${limit})` : ''}...`);
+
+      // Determine starting node ID
+      let startingNodeId = this.config.folderId || '-root-';
+      
+      // If siteId is provided, get the document library
+      if (this.config.siteId) {
+        startingNodeId = await this.getSiteDocumentLibraryId(this.config.siteId);
+      }
+
+      const nodes = await this.scanNode(startingNodeId);
+
+      let processedCount = 0;
+      for (const node of nodes) {
+        if (node.isFile && node.content) {
+          const source: DocumentSource = {
+            id: node.id,
+            name: node.name,
+            path: this.getNodePath(node),
+            size: node.content.sizeInBytes,
+            mimeType: node.content.mimeType,
+            lastModified: new Date(node.modifiedAt),
+            metadata: {
+              alfrescoId: node.id,
+              nodeType: node.nodeType,
+              createdAt: node.createdAt,
+              createdBy: node.createdByUser.displayName,
+              modifiedBy: node.modifiedByUser.displayName,
+              properties: node.properties
+            }
+          };
+
+          // 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: [`Alfresco scan failed: ${error.message}`]
+      };
+    }
+  }
+
+  private async scanNode(nodeId: string, parentPath: string = ''): Promise<AlfrescoNode[]> {
+    if (!this.apiClient) throw new Error('API client not initialized');
+
+    const allNodes: AlfrescoNode[] = [];
+    let skipCount = 0;
+    const maxItems = 100;
+
+    try {
+      while (true) {
+        const response = await this.apiClient.get(`/nodes/${nodeId}/children`, {
+          params: {
+            skipCount,
+            maxItems,
+            include: 'properties,path',
+            fields: 'id,name,nodeType,isFolder,isFile,createdAt,modifiedAt,createdByUser,modifiedByUser,content,properties,path'
+          }
+        });
+
+        const nodes: AlfrescoNode[] = response.data.list.entries.map((entry: any) => {
+          const node = entry.entry;
+          // Add full path information
+          (node as any).fullPath = parentPath ? `${parentPath}/${node.name}` : node.name;
+          return node;
+        });
+
+        // Process files immediately
+        const files = nodes.filter(node => node.isFile);
+        allNodes.push(...files);
+
+        // Recursively process folders if includeFolders is enabled or not specified
+        if (this.config?.includeFolders !== false) {
+          const folders = nodes.filter(node => node.isFolder);
+          for (const folder of folders) {
+            const folderPath = parentPath ? `${parentPath}/${folder.name}` : folder.name;
+            const subNodes = await this.scanNode(folder.id, folderPath);
+            allNodes.push(...subNodes);
+          }
+        }
+
+        // Check if there are more items
+        if (nodes.length < maxItems) {
+          break;
+        }
+        skipCount += maxItems;
+      }
+
+      return allNodes;
+    } catch (error: any) {
+      if (error.response?.status === 404) {
+        console.warn(`Warning: Node not found: ${nodeId}`);
+        return [];
+      }
+      throw error;
+    }
+  }
+
+  async import(
+    config: PluginConfig,
+    sources: DocumentSource[],
+    targetDir: string,
+    options?: PluginImportOptions
+  ): Promise<ImportResult[]> {
+    this.config = config as AlfrescoConfig;
+    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 Alfresco
+      const response = await this.apiClient.get(`/nodes/${source.id}/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 AlfrescoConfig;
+    this.apiClient = this.createApiClient(this.config);
+
+    const results: ExportResult[] = [];
+    
+    // Determine target folder ID
+    let targetFolderId = this.config.folderId || '-root-';
+    if (this.config.siteId) {
+      targetFolderId = await this.getSiteDocumentLibraryId(this.config.siteId);
+    }
+
+    for (const source of localSources) {
+      try {
+        // Determine target folder for this document
+        let actualTargetFolderId = targetFolderId;
+        
+        if (options?.preserveStructure && source.path.includes('/')) {
+          const folderPath = path.dirname(source.path);
+          actualTargetFolderId = await this.createFolderStructure(folderPath, 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');
+
+        // Upload file to Alfresco
+        const FormData = require('form-data');
+        const form = new FormData();
+        
+        form.append('filedata', fileContent, fileName);
+        form.append('name', fileName);
+        form.append('nodeType', 'cm:content');
+
+        const response = await this.apiClient!.post(`/nodes/${actualTargetFolderId}/children`, form, {
+          headers: {
+            ...form.getHeaders()
+          }
+        });
+
+        const targetPath = options?.preserveStructure ? source.path : source.name;
+
+        results.push({
+          success: true,
+          targetPath,
+          source,
+          bytesTransferred: source.size
+        });
+      } catch (error: any) {
+        results.push({
+          success: false,
+          targetPath: options?.targetPath || '',
+          source,
+          error: error.message
+        });
+      }
+    }
+
+    return results;
+  }
+
+  private async getSiteDocumentLibraryId(siteId: string): Promise<string> {
+    if (!this.apiClient) throw new Error('API client not initialized');
+
+    try {
+      const response = await this.apiClient.get(`/sites/${siteId}/containers`);
+      const containers = response.data.list.entries;
+      
+      const documentLibrary = containers.find((container: any) => 
+        container.entry.folderId === 'documentLibrary'
+      );
+
+      if (!documentLibrary) {
+        throw new Error(`Document library not found for site: ${siteId}`);
+      }
+
+      return documentLibrary.entry.id;
+    } catch (error: any) {
+      throw new Error(`Failed to get document library for site ${siteId}: ${error.message}`);
+    }
+  }
+
+  private async createFolderStructure(folderPath: string, parentId: string): Promise<string> {
+    if (!this.apiClient) throw new Error('API client not initialized');
+
+    const parts = folderPath.split('/').filter(part => part.length > 0);
+    let currentParentId = parentId;
+
+    for (const folderName of parts) {
+      // Check if folder already exists
+      try {
+        const response = await this.apiClient.get(`/nodes/${currentParentId}/children`, {
+          params: {
+            where: `(name='${folderName}' AND nodeType='cm:folder')`,
+            maxItems: 1
+          }
+        });
+
+        const existingFolder = response.data.list.entries[0];
+        
+        if (existingFolder) {
+          currentParentId = existingFolder.entry.id;
+        } else {
+          // Create new folder
+          const createResponse = await this.apiClient.post(`/nodes/${currentParentId}/children`, {
+            name: folderName,
+            nodeType: 'cm:folder'
+          });
+          currentParentId = createResponse.data.entry.id;
+        }
+      } catch (error: any) {
+        throw new Error(`Failed to create folder structure: ${error.message}`);
+      }
+    }
+
+    return currentParentId;
+  }
+
+  getConfigSchema(): Record<string, any> {
+    return {
+      type: 'object',
+      properties: {
+        baseUrl: {
+          type: 'string',
+          description: 'Alfresco base URL (e.g., http://localhost:8080/alfresco)',
+          required: true
+        },
+        username: {
+          type: 'string',
+          description: 'Alfresco username',
+          required: true
+        },
+        password: {
+          type: 'string',
+          description: 'Alfresco password',
+          required: true
+        },
+        siteId: {
+          type: 'string',
+          description: 'Alfresco site ID to scan (optional, uses repository root if not specified)',
+          required: false
+        },
+        folderId: {
+          type: 'string',
+          description: 'Starting folder ID (optional, uses site document library or root)',
+          required: false
+        },
+        includeFolders: {
+          type: 'boolean',
+          description: 'Include subfolders in scan (default: true)',
+          default: true
+        },
+        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 AlfrescoConfig;
+    
+    if (!this.config.baseUrl || !this.config.username || !this.config.password) {
+      throw new Error('Alfresco 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: AlfrescoConfig): AxiosInstance {
+    const baseURL = `${config.baseUrl.replace(/\/$/, '')}/api/-default-/public/${this.apiVersion}`;
+    
+    return axios.create({
+      baseURL,
+      auth: {
+        username: config.username,
+        password: config.password
+      },
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      timeout: 30000
+    });
+  }
+
+  private getNodePath(node: AlfrescoNode): string {
+    // Use the full path if available from scanning
+    if ((node as any).fullPath) {
+      return (node as any).fullPath;
+    }
+
+    // Construct path from path collection
+    if (node.path && node.path.isComplete) {
+      const pathParts = node.path.elements
+        .filter(element => element.name !== 'Company Home') // Skip root element
+        .map(element => element.name);
+      pathParts.push(node.name);
+      return pathParts.join('/');
+    }
+
+    return node.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/alfresco/plugin.json

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