@sinoia/hubdoc-tools 1.4.0 → 1.5.1

package/dist/services/hubdoc-client.js

@@ -1,714 +0,0 @@
-"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