@sinoia/hubdoc-tools 1.3.8 → 1.4.0

package/dist/services/hubdoc-client.js

@@ -0,0 +1,714 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HubDocClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const form_data_1 = __importDefault(require("form-data"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Complete HubDoc API Client with workspaces, folders, files, and pagination support
+ */
+class HubDocClient {
+    constructor(config) {
+        this.config = config;
+        const headers = {
+            'Accept': 'application/json'
+        };
+        // Set authentication headers based on auth type
+        if (config.authType === 'oauth2' && config.clientId && config.clientSecret) {
+            // OAuth2 Client Credentials
+            const credentials = Buffer.from(`${config.clientId}:${config.clientSecret}`).toString('base64');
+            headers['Authorization'] = `Basic ${credentials}`;
+        }
+        else if (config.token) {
+            // Bearer token
+            headers['Authorization'] = `Bearer ${config.token}`;
+        }
+        this.client = axios_1.default.create({
+            baseURL: config.apiUrl,
+            headers,
+            timeout: 60000
+        });
+        // Request interceptor for debugging
+        this.client.interceptors.request.use(request => {
+            console.log(chalk_1.default.gray(`🔗 ${request.method?.toUpperCase()} ${request.url}`));
+            return request;
+        });
+        // Response interceptor for error handling
+        this.client.interceptors.response.use(response => response, error => {
+            if (error.response) {
+                console.error(chalk_1.default.red(`❌ API Error ${error.response.status}: ${error.response.data?.message || error.message}`));
+            }
+            else {
+                console.error(chalk_1.default.red(`❌ Network Error: ${error.message}`));
+            }
+            return Promise.reject(error);
+        });
+    }
+    /**
+     * Test API connection and authentication
+     */
+    async testConnection() {
+        try {
+            const response = await this.client.get('/auth/me');
+            console.log(chalk_1.default.green(`✅ Connected as: ${response.data.email || response.data.username || 'User'}`));
+            return true;
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('❌ API connection failed:'), error.message);
+            return false;
+        }
+    }
+    /**
+     * Login and get JWT token
+     */
+    async login(email, password) {
+        try {
+            const response = await axios_1.default.post(`${this.config.apiUrl}/auth/login`, {
+                email,
+                password
+            });
+            const token = response.data.token || response.data.access_token;
+            if (!token) {
+                throw new Error('No token received from login response');
+            }
+            // Update client headers with new token
+            this.client.defaults.headers['Authorization'] = `Bearer ${token}`;
+            console.log(chalk_1.default.green('✅ Login successful'));
+            return token;
+        }
+        catch (error) {
+            throw new Error(`Login failed: ${error.response?.data?.message || error.message}`);
+        }
+    }
+    /**
+     * OAuth2 Client Credentials flow
+     */
+    async authenticateOAuth2() {
+        if (!this.config.clientId || !this.config.clientSecret) {
+            throw new Error('OAuth2 credentials not provided');
+        }
+        try {
+            const credentials = Buffer.from(`${this.config.clientId}:${this.config.clientSecret}`).toString('base64');
+            const response = await axios_1.default.post(`${this.config.apiUrl}/oauth/token`, {
+                grant_type: 'client_credentials'
+            }, {
+                headers: {
+                    'Authorization': `Basic ${credentials}`,
+                    'Content-Type': 'application/x-www-form-urlencoded'
+                }
+            });
+            const token = response.data.access_token;
+            if (!token) {
+                throw new Error('No access token received from OAuth2 response');
+            }
+            // Update client headers with new token
+            this.client.defaults.headers['Authorization'] = `Bearer ${token}`;
+            console.log(chalk_1.default.green('✅ OAuth2 authentication successful'));
+            return token;
+        }
+        catch (error) {
+            throw new Error(`OAuth2 authentication failed: ${error.response?.data?.error_description || error.response?.data?.message || error.message}`);
+        }
+    }
+    // ==================== WORKSPACES API ====================
+    /**
+     * Get all workspaces with pagination support
+     */
+    async getWorkspaces(params) {
+        try {
+            const queryParams = {};
+            if (params?.page)
+                queryParams.page = params.page;
+            if (params?.limit)
+                queryParams.limit = params.limit;
+            if (params?.sort)
+                queryParams.sort = params.sort;
+            if (params?.order)
+                queryParams.order = params.order;
+            if (params?.domain)
+                queryParams.domain = params.domain;
+            const response = await this.client.get('/workspaces', { params: queryParams });
+            return this.formatPaginatedResponse(response);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch workspaces: ${error.message}`);
+        }
+    }
+    /**
+     * Get all workspaces (paginated iterator)
+     */
+    async getAllWorkspaces(domain) {
+        const allWorkspaces = [];
+        let currentPage = 1;
+        let hasMore = true;
+        while (hasMore) {
+            const response = await this.getWorkspaces({
+                page: currentPage,
+                limit: 100,
+                domain
+            });
+            allWorkspaces.push(...response.data);
+            hasMore = response.pagination.has_next;
+            currentPage++;
+            console.log(chalk_1.default.gray(`📄 Loaded ${allWorkspaces.length} workspaces...`));
+        }
+        return allWorkspaces;
+    }
+    /**
+     * Create a new workspace
+     */
+    async createWorkspace(request) {
+        try {
+            const response = await this.client.post('/workspaces', request);
+            console.log(chalk_1.default.blue(`🏢 Created workspace: ${request.name}`));
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`Failed to create workspace "${request.name}": ${error.message}`);
+        }
+    }
+    /**
+     * Get workspace by ID
+     */
+    async getWorkspace(id) {
+        try {
+            const response = await this.client.get(`/workspaces/${id}`);
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch workspace ${id}: ${error.message}`);
+        }
+    }
+    /**
+     * Find workspace by name and optionally domain
+     */
+    async findWorkspace(name, domain) {
+        const workspaces = await this.getAllWorkspaces(domain);
+        return workspaces.find(w => w.name === name && (!domain || w.domain === domain)) || null;
+    }
+    /**
+     * Find or create workspace
+     */
+    async findOrCreateWorkspace(name, domain, permissions) {
+        let workspace = await this.findWorkspace(name, domain);
+        if (!workspace) {
+            const request = {
+                name,
+                description: `Auto-created workspace for: ${name}`,
+                domain
+            };
+            if (permissions) {
+                request.permissions = this.convertPermissions(permissions);
+            }
+            workspace = await this.createWorkspace(request);
+        }
+        return workspace;
+    }
+    // ==================== FOLDERS API ====================
+    /**
+     * Get folders with pagination support
+     */
+    async getFolders(params) {
+        try {
+            const queryParams = {};
+            if (params?.page)
+                queryParams.page = params.page;
+            if (params?.limit)
+                queryParams.limit = params.limit;
+            if (params?.sort)
+                queryParams.sort = params.sort;
+            if (params?.order)
+                queryParams.order = params.order;
+            if (params?.workspace_id)
+                queryParams.workspace_id = params.workspace_id;
+            if (params?.parent_id)
+                queryParams.parent_id = params.parent_id;
+            if (params?.domain)
+                queryParams.domain = params.domain;
+            const response = await this.client.get('/folders', { params: queryParams });
+            return this.formatPaginatedResponse(response);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch folders: ${error.message}`);
+        }
+    }
+    /**
+     * Get all folders (paginated iterator)
+     */
+    async getAllFolders(workspaceId, domain) {
+        const allFolders = [];
+        let currentPage = 1;
+        let hasMore = true;
+        while (hasMore) {
+            const response = await this.getFolders({
+                page: currentPage,
+                limit: 100,
+                workspace_id: workspaceId,
+                domain
+            });
+            allFolders.push(...response.data);
+            hasMore = response.pagination.has_next;
+            currentPage++;
+            console.log(chalk_1.default.gray(`📁 Loaded ${allFolders.length} folders...`));
+        }
+        return allFolders;
+    }
+    /**
+     * Create a new folder
+     */
+    async createFolder(request) {
+        try {
+            const response = await this.client.post('/folders', request);
+            console.log(chalk_1.default.blue(`📁 Created folder: ${request.name}`));
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`Failed to create folder "${request.name}": ${error.message}`);
+        }
+    }
+    /**
+     * Get folder by ID
+     */
+    async getFolder(id) {
+        try {
+            const response = await this.client.get(`/folders/${id}`);
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch folder ${id}: ${error.message}`);
+        }
+    }
+    /**
+     * Find or create folder hierarchy
+     */
+    async findOrCreateFolderPath(folderPath, workspaceId, domain, permissions) {
+        const pathParts = folderPath.split('/').filter(part => part.trim().length > 0);
+        let parentId;
+        let currentFolder;
+        for (const folderName of pathParts) {
+            const folders = await this.getAllFolders(workspaceId, domain);
+            // Find existing folder
+            currentFolder = folders.find(f => f.name === folderName &&
+                f.parent_id === parentId &&
+                (!workspaceId || f.workspace_id === workspaceId) &&
+                (!domain || f.domain === domain));
+            if (!currentFolder) {
+                // Create new folder
+                const request = {
+                    name: folderName,
+                    parent_id: parentId,
+                    workspace_id: workspaceId,
+                    domain
+                };
+                if (permissions) {
+                    request.permissions = this.convertPermissions(permissions);
+                }
+                currentFolder = await this.createFolder(request);
+            }
+            parentId = currentFolder.id;
+        }
+        if (!currentFolder) {
+            throw new Error(`Failed to create folder path: ${folderPath}`);
+        }
+        return currentFolder;
+    }
+    // ==================== FILES API ====================
+    /**
+     * Get files with pagination support
+     */
+    async getFiles(params) {
+        try {
+            const queryParams = {};
+            if (params?.page)
+                queryParams.page = params.page;
+            if (params?.limit)
+                queryParams.limit = params.limit;
+            if (params?.sort)
+                queryParams.sort = params.sort;
+            if (params?.order)
+                queryParams.order = params.order;
+            if (params?.folder_id)
+                queryParams.folder_id = params.folder_id;
+            if (params?.workspace_id)
+                queryParams.workspace_id = params.workspace_id;
+            if (params?.domain)
+                queryParams.domain = params.domain;
+            const response = await this.client.get('/files', { params: queryParams });
+            return this.formatPaginatedResponse(response);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch files: ${error.message}`);
+        }
+    }
+    /**
+     * Get all files (paginated iterator)
+     */
+    async getAllFiles(folderId, workspaceId, domain) {
+        const allFiles = [];
+        let currentPage = 1;
+        let hasMore = true;
+        while (hasMore) {
+            const response = await this.getFiles({
+                page: currentPage,
+                limit: 100,
+                folder_id: folderId,
+                workspace_id: workspaceId,
+                domain
+            });
+            allFiles.push(...response.data);
+            hasMore = response.pagination.has_next;
+            currentPage++;
+            console.log(chalk_1.default.gray(`📄 Loaded ${allFiles.length} files...`));
+        }
+        return allFiles;
+    }
+    /**
+     * Upload a file
+     */
+    async uploadFile(filePath, request) {
+        if (!await fs_extra_1.default.pathExists(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        const formData = new form_data_1.default();
+        const fileStream = fs_extra_1.default.createReadStream(filePath);
+        const fileName = path_1.default.basename(filePath);
+        const stats = await fs_extra_1.default.stat(filePath);
+        formData.append('file', fileStream, {
+            filename: fileName,
+            contentType: this.getMimeType(filePath)
+        });
+        // Add optional parameters
+        if (request.folder_id) {
+            formData.append('folder_id', request.folder_id);
+        }
+        if (request.workspace_id) {
+            formData.append('workspace_id', request.workspace_id);
+        }
+        if (request.domain) {
+            formData.append('domain', request.domain);
+        }
+        if (request.metadata) {
+            formData.append('metadata', JSON.stringify(request.metadata));
+        }
+        if (request.permissions) {
+            formData.append('permissions', JSON.stringify(request.permissions));
+        }
+        try {
+            const response = await this.client.post('/files', formData, {
+                headers: {
+                    ...formData.getHeaders(),
+                },
+                maxContentLength: Infinity,
+                maxBodyLength: Infinity
+            });
+            const file = response.data;
+            console.log(chalk_1.default.green(`✅ Uploaded: ${fileName} (${this.formatFileSize(stats.size)})`));
+            return file;
+        }
+        catch (error) {
+            throw new Error(`Failed to upload file "${fileName}": ${error.response?.data?.message || error.message}`);
+        }
+    }
+    /**
+     * Get file by ID
+     */
+    async getFile(id) {
+        try {
+            const response = await this.client.get(`/files/${id}`);
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch file ${id}: ${error.message}`);
+        }
+    }
+    /**
+     * Download a file
+     */
+    async downloadFile(id, targetPath) {
+        try {
+            // Create directory if it doesn't exist
+            await fs_extra_1.default.ensureDir(path_1.default.dirname(targetPath));
+            // Get download URL
+            const response = await this.client.get(`/files/${id}/download`, {
+                responseType: 'stream'
+            });
+            // Save to file
+            const writer = fs_extra_1.default.createWriteStream(targetPath);
+            response.data.pipe(writer);
+            return new Promise((resolve, reject) => {
+                writer.on('finish', resolve);
+                writer.on('error', reject);
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to download file ${id}: ${error.message}`);
+        }
+    }
+    // ==================== EXPORT METHODS ====================
+    /**
+     * Scan all accessible files and folders for export
+     */
+    async scanForExport(domain) {
+        console.log(chalk_1.default.blue('🔍 Scanning workspaces, folders, and files...'));
+        const exportItems = [];
+        // Get all workspaces
+        const workspaces = await this.getAllWorkspaces(domain);
+        console.log(chalk_1.default.gray(`Found ${workspaces.length} workspaces`));
+        for (const workspace of workspaces) {
+            // Add workspace to export items
+            exportItems.push({
+                id: workspace.id,
+                name: workspace.name,
+                type: 'workspace',
+                path: workspace.name,
+                metadata: workspace.metadata
+            });
+            // Get folders in workspace
+            const folders = await this.getAllFolders(workspace.id, domain);
+            console.log(chalk_1.default.gray(`Found ${folders.length} folders in workspace "${workspace.name}"`));
+            // Build folder hierarchy
+            const folderMap = new Map();
+            folders.forEach(folder => folderMap.set(folder.id, folder));
+            for (const folder of folders) {
+                const folderPath = this.buildFolderPath(folder, folderMap, workspace.name);
+                exportItems.push({
+                    id: folder.id,
+                    name: folder.name,
+                    type: 'folder',
+                    parent_id: folder.parent_id,
+                    workspace_id: folder.workspace_id,
+                    path: folderPath,
+                    metadata: folder.metadata
+                });
+                // Get files in folder
+                const files = await this.getAllFiles(folder.id, workspace.id, domain);
+                console.log(chalk_1.default.gray(`Found ${files.length} files in folder "${folder.name}"`));
+                for (const file of files) {
+                    exportItems.push({
+                        id: file.id,
+                        name: file.name,
+                        type: 'file',
+                        folder_id: file.folder_id,
+                        workspace_id: file.workspace_id,
+                        path: `${folderPath}/${file.name}`,
+                        size: file.size,
+                        metadata: file.metadata,
+                        download_url: `/files/${file.id}/download`
+                    });
+                }
+            }
+            // Get files directly in workspace (not in folders)
+            const directFiles = await this.getAllFiles(undefined, workspace.id, domain);
+            console.log(chalk_1.default.gray(`Found ${directFiles.length} files directly in workspace "${workspace.name}"`));
+            for (const file of directFiles) {
+                if (!file.folder_id) { // Only files not already in folders
+                    exportItems.push({
+                        id: file.id,
+                        name: file.name,
+                        type: 'file',
+                        workspace_id: file.workspace_id,
+                        path: `${workspace.name}/${file.name}`,
+                        size: file.size,
+                        metadata: file.metadata,
+                        download_url: `/files/${file.id}/download`
+                    });
+                }
+            }
+        }
+        // Get files not in any workspace (if any)
+        const orphanFiles = await this.getAllFiles(undefined, undefined, domain);
+        const workspaceFiles = exportItems.filter(item => item.type === 'file').map(item => item.id);
+        for (const file of orphanFiles) {
+            if (!workspaceFiles.includes(file.id)) {
+                exportItems.push({
+                    id: file.id,
+                    name: file.name,
+                    type: 'file',
+                    path: `Unorganized/${file.name}`,
+                    size: file.size,
+                    metadata: file.metadata,
+                    download_url: `/files/${file.id}/download`
+                });
+            }
+        }
+        console.log(chalk_1.default.green(`✅ Scan complete: ${exportItems.length} items found`));
+        return exportItems;
+    }
+    // ==================== IMPORT METHODS ====================
+    /**
+     * Import document using mapping
+     */
+    async importDocument(mapping) {
+        const result = {
+            success: false,
+            filePath: mapping.filePath
+        };
+        try {
+            let workspaceId;
+            let folderId;
+            // Handle workspace
+            if (mapping.workspace) {
+                const workspace = await this.findOrCreateWorkspace(mapping.workspace, mapping.domain, mapping.permissions);
+                workspaceId = workspace.id;
+            }
+            // Handle folder
+            if (mapping.targetFolder) {
+                const folder = await this.findOrCreateFolderPath(mapping.targetFolder, workspaceId, mapping.domain, mapping.permissions);
+                folderId = folder.id;
+            }
+            // Prepare upload request
+            const uploadRequest = {
+                folder_id: folderId,
+                workspace_id: workspaceId,
+                domain: mapping.domain,
+                metadata: mapping.metadata
+            };
+            if (mapping.permissions) {
+                uploadRequest.permissions = this.convertPermissions(mapping.permissions);
+            }
+            // Upload file
+            const file = await this.uploadFile(mapping.filePath, uploadRequest);
+            result.success = true;
+            result.document = file;
+            const targetLocation = [
+                mapping.workspace,
+                mapping.targetFolder,
+                path_1.default.basename(mapping.filePath)
+            ].filter(Boolean).join(' → ');
+            console.log(chalk_1.default.green(`✅ Imported: ${targetLocation}`));
+        }
+        catch (error) {
+            result.error = error.message;
+            console.error(chalk_1.default.red(`❌ Failed to import ${mapping.filePath}: ${error.message}`));
+        }
+        return result;
+    }
+    // ==================== SEARCH API ====================
+    /**
+     * Search across workspaces, folders, and files
+     */
+    async search(query, type, domain) {
+        try {
+            const params = { q: query };
+            if (type)
+                params.type = type;
+            if (domain)
+                params.domain = domain;
+            const response = await this.client.get('/search', { params });
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`Search failed: ${error.message}`);
+        }
+    }
+    // ==================== HELPER METHODS ====================
+    /**
+     * Format paginated response
+     */
+    formatPaginatedResponse(response) {
+        // Handle different pagination response formats
+        if (response.data.data && response.data.pagination) {
+            return response.data;
+        }
+        else if (Array.isArray(response.data)) {
+            // Fallback for non-paginated responses
+            return {
+                data: response.data,
+                pagination: {
+                    current_page: 1,
+                    total_pages: 1,
+                    total_items: response.data.length,
+                    items_per_page: response.data.length,
+                    has_next: false,
+                    has_prev: false
+                }
+            };
+        }
+        else {
+            throw new Error('Unexpected response format');
+        }
+    }
+    /**
+     * Build full folder path from hierarchy
+     */
+    buildFolderPath(folder, folderMap, workspaceName) {
+        const path = [];
+        let current = folder;
+        while (current) {
+            path.unshift(current.name);
+            current = current.parent_id ? folderMap.get(current.parent_id) : undefined;
+        }
+        return `${workspaceName}/${path.join('/')}`;
+    }
+    /**
+     * Convert DocumentMapping permissions to HubDoc API format
+     */
+    convertPermissions(permissions) {
+        if (!permissions)
+            return [];
+        const result = [];
+        if (permissions.read) {
+            result.push({
+                level: 'read',
+                users: permissions.read.users || [],
+                groups: permissions.read.groups || []
+            });
+        }
+        if (permissions.write) {
+            result.push({
+                level: 'write',
+                users: permissions.write.users || [],
+                groups: permissions.write.groups || []
+            });
+        }
+        return result;
+    }
+    /**
+     * Get MIME type from file extension
+     */
+    getMimeType(filePath) {
+        const ext = path_1.default.extname(filePath).toLowerCase();
+        const mimeTypes = {
+            '.pdf': 'application/pdf',
+            '.doc': 'application/msword',
+            '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            '.xls': 'application/vnd.ms-excel',
+            '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            '.ppt': 'application/vnd.ms-powerpoint',
+            '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+            '.txt': 'text/plain',
+            '.csv': 'text/csv',
+            '.json': 'application/json',
+            '.xml': 'application/xml',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.png': 'image/png',
+            '.gif': 'image/gif',
+            '.bmp': 'image/bmp',
+            '.tiff': 'image/tiff',
+            '.zip': 'application/zip',
+            '.rar': 'application/vnd.rar'
+        };
+        return mimeTypes[ext] || 'application/octet-stream';
+    }
+    /**
+     * Format file size for display
+     */
+    formatFileSize(bytes) {
+        const units = ['B', 'KB', 'MB', 'GB'];
+        let size = bytes;
+        let unitIndex = 0;
+        while (size >= 1024 && unitIndex < units.length - 1) {
+            size /= 1024;
+            unitIndex++;
+        }
+        return `${size.toFixed(1)} ${units[unitIndex]}`;
+    }
+}
+exports.HubDocClient = HubDocClient;
+//# sourceMappingURL=hubdoc-client.js.map