@rglabs/butterfly 2.0.1

package/dist/utils/resourceHandlers.js

@@ -0,0 +1,684 @@
+import { restoreFieldsFromFiles, restoreAiTaskFromFiles, restoreTableRecordFromFiles } from './files.js';
+import { smartReadBfyContent } from './bfySplitter.js';
+import { promises as fs } from 'fs';
+import { basename, dirname, join } from 'path';
+import { parse as yamlParse } from 'yaml';
+export async function updateRecord(api, tableName, data) {
+    const formData = new URLSearchParams();
+    formData.append('id', data.id.toString());
+    Object.entries(data).forEach(([key, value]) => {
+        if (key !== 'id' && value !== null && value !== undefined) {
+            formData.append(key, typeof value === 'object' ? JSON.stringify(value) : String(value));
+        }
+    });
+    const response = await api.httpClient.post(`/admin/ajax/cms_object/operation?do=${tableName}__edit`, formData, {
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+    });
+    if (response.data?.success) {
+        return { success: true, message: `Updated ${tableName} (ID: ${data.id})`, resourceId: data.id };
+    }
+    else {
+        const errorMsg = response.data?.error || response.data?.message || 'Unknown error';
+        return { success: false, message: `Failed to update ${tableName}: ${errorMsg}` };
+    }
+}
+export async function updateRecordField(api, tableName, id, fieldName, fieldValue) {
+    const formData = new URLSearchParams();
+    formData.append('id', id.toString());
+    formData.append(fieldName, fieldValue);
+    const response = await api.httpClient.post(`/admin/ajax/cms_object/operation?do=${tableName}__edit`, formData, {
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+    });
+    if (response.data?.success) {
+        return { success: true, message: `Updated ${tableName}.${fieldName} (ID: ${id})`, resourceId: id };
+    }
+    else {
+        const errorMsg = response.data?.error || response.data?.message || 'Unknown error';
+        return { success: false, message: `Failed to update ${tableName}.${fieldName}: ${errorMsg}` };
+    }
+}
+export async function updateRecordFields(api, tableName, id, fields) {
+    const formData = new URLSearchParams();
+    formData.append('id', id.toString());
+    Object.entries(fields).forEach(([key, value]) => {
+        if (value !== undefined) {
+            formData.append(key, value);
+        }
+    });
+    const response = await api.httpClient.post(`/admin/ajax/cms_object/operation?do=${tableName}__edit`, formData, {
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+    });
+    if (response.data?.success) {
+        return { success: true, message: `Updated ${tableName} (ID: ${id})`, resourceId: id };
+    }
+    else {
+        const errorMsg = response.data?.error || response.data?.message || 'Unknown error';
+        return { success: false, message: `Failed to update ${tableName}: ${errorMsg}` };
+    }
+}
+export async function handleWorkflowJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    return updateRecord(api, 'bfy_workflows', data);
+}
+export async function handleWorkflowVersionJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    return updateRecord(api, 'bfy_workflow_versions', data);
+}
+export async function handleWorkflowNodeJson(api, filePath) {
+    const nodeData = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    const fileDir = dirname(filePath);
+    let codeContent = null;
+    try {
+        codeContent = await smartReadBfyContent(join(fileDir, 'code.bfy'));
+    }
+    catch { }
+    let paramsData = null;
+    try {
+        paramsData = yamlParse(await fs.readFile(join(fileDir, 'params.yaml'), 'utf-8')) || {};
+    }
+    catch { }
+    const formData = new URLSearchParams();
+    formData.append('id', nodeData.id.toString());
+    Object.entries(nodeData).forEach(([key, value]) => {
+        if (key !== 'id' && value !== null && value !== undefined) {
+            formData.append(key, String(value));
+        }
+    });
+    if (paramsData !== null) {
+        if (codeContent !== null)
+            paramsData.code = codeContent;
+        formData.append('params', JSON.stringify(paramsData));
+    }
+    else if (codeContent !== null) {
+        formData.append('code', codeContent);
+    }
+    const response = await api.httpClient.post('/admin/ajax/cms_object/operation?do=bfy_workflow_nodes__edit', formData, {
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+    });
+    if (response.data?.success) {
+        return { success: true, message: `Updated workflow node (ID: ${nodeData.id})`, resourceId: nodeData.id };
+    }
+    else {
+        const errorMsg = response.data?.error || response.data?.message || 'Unknown error';
+        return { success: false, message: `Failed to update workflow node: ${errorMsg}` };
+    }
+}
+export async function handleWorkflowNodeCode(api, filePath) {
+    const nodeData = JSON.parse(await fs.readFile(join(dirname(filePath), 'node.json'), 'utf-8'));
+    const codeContent = await smartReadBfyContent(filePath);
+    const paramsYamlPath = join(dirname(filePath), 'params.yaml');
+    let hasParamsFile = false;
+    try {
+        await fs.access(paramsYamlPath);
+        hasParamsFile = true;
+    }
+    catch { }
+    const formData = new URLSearchParams();
+    formData.append('id', nodeData.id.toString());
+    if (hasParamsFile) {
+        const paramsData = yamlParse(await fs.readFile(paramsYamlPath, 'utf-8')) || {};
+        paramsData.code = codeContent;
+        formData.append('params', JSON.stringify(paramsData));
+    }
+    else {
+        formData.append('code', codeContent);
+    }
+    const response = await api.httpClient.post('/admin/ajax/cms_object/operation?do=bfy_workflow_nodes__edit', formData, {
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+    });
+    if (response.data?.success) {
+        return { success: true, message: `Updated workflow node code (ID: ${nodeData.id})`, resourceId: nodeData.id };
+    }
+    else {
+        const errorMsg = response.data?.error || response.data?.message || 'Unknown error';
+        return { success: false, message: `Failed to update workflow node code: ${errorMsg}` };
+    }
+}
+export async function handleWorkflowNodeParams(api, filePath) {
+    const nodeData = JSON.parse(await fs.readFile(join(dirname(filePath), 'node.json'), 'utf-8'));
+    const paramsData = yamlParse(await fs.readFile(filePath, 'utf-8')) || {};
+    try {
+        paramsData.code = await smartReadBfyContent(join(dirname(filePath), 'code.bfy'));
+    }
+    catch { }
+    const formData = new URLSearchParams();
+    formData.append('id', nodeData.id.toString());
+    formData.append('params', JSON.stringify(paramsData));
+    const response = await api.httpClient.post('/admin/ajax/cms_object/operation?do=bfy_workflow_nodes__edit', formData, {
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+    });
+    if (response.data?.success) {
+        return { success: true, message: `Updated workflow node params (ID: ${nodeData.id})`, resourceId: nodeData.id };
+    }
+    else {
+        const errorMsg = response.data?.error || response.data?.message || 'Unknown error';
+        return { success: false, message: `Failed to update workflow node params: ${errorMsg}` };
+    }
+}
+export async function handleWorkflowConnections(api, filePath) {
+    try {
+        const fileConnections = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+        if (!Array.isArray(fileConnections)) {
+            return { success: false, message: 'connections.json must contain an array of connections' };
+        }
+        const pathParts = filePath.split('/');
+        const versionDir = pathParts[pathParts.length - 2];
+        if (!versionDir || !versionDir.startsWith('v')) {
+            return { success: false, message: 'Could not determine workflow version from path' };
+        }
+        const versionJsonPath = join(dirname(filePath), 'version.json');
+        let versionData;
+        try {
+            versionData = JSON.parse(await fs.readFile(versionJsonPath, 'utf-8'));
+        }
+        catch {
+            return { success: false, message: 'version.json not found in same directory as connections.json' };
+        }
+        const workflowVersionId = versionData.id;
+        if (!workflowVersionId) {
+            return { success: false, message: 'workflow_version_id not found in version.json' };
+        }
+        const dbConnections = await api.fetchTable('bfy_workflow_connections', 'workflow_version_id', workflowVersionId.toString());
+        for (const fileConn of fileConnections) {
+            if (fileConn.id) {
+                const matchingDbConn = dbConnections.find(db => db.id === fileConn.id);
+                if (matchingDbConn && matchingDbConn.workflow_version_id !== workflowVersionId) {
+                    return {
+                        success: false,
+                        message: `Connection ID ${fileConn.id} belongs to a different workflow version (${matchingDbConn.workflow_version_id}). Cannot proceed - file may be from wrong workflow.`
+                    };
+                }
+            }
+        }
+        const workflowNodes = await api.fetchTable('bfy_workflow_nodes', 'workflow_version_id', workflowVersionId.toString());
+        const validNodeIds = new Set(workflowNodes.map((n) => n.id));
+        for (const fileConn of fileConnections) {
+            if (fileConn.source_node_id && !validNodeIds.has(fileConn.source_node_id)) {
+                return {
+                    success: false,
+                    message: `Invalid source_node_id ${fileConn.source_node_id} in connections.json - node does not exist in this workflow version`
+                };
+            }
+            if (fileConn.target_node_id && !validNodeIds.has(fileConn.target_node_id)) {
+                return {
+                    success: false,
+                    message: `Invalid target_node_id ${fileConn.target_node_id} in connections.json - node does not exist in this workflow version`
+                };
+            }
+        }
+        const dbConnectionMap = new Map();
+        dbConnections.forEach(conn => dbConnectionMap.set(conn.id, conn));
+        const fileConnectionMap = new Map();
+        fileConnections.forEach(conn => {
+            if (conn.id) {
+                fileConnectionMap.set(conn.id, conn);
+            }
+        });
+        const connectionsToDelete = Array.from(dbConnectionMap.keys()).filter(dbId => !fileConnectionMap.has(dbId));
+        if (dbConnections.length > 2 && connectionsToDelete.length > dbConnections.length * 0.5) {
+            return {
+                success: false,
+                message: `Safety check failed: ${connectionsToDelete.length} of ${dbConnections.length} connections would be deleted (>${(connectionsToDelete.length / dbConnections.length * 100).toFixed(0)}%). This may indicate an incomplete connections.json file. If this is intentional, manually delete connections first, then upload the file.`
+            };
+        }
+        const operations = {
+            created: 0,
+            updated: 0,
+            deleted: 0,
+            skipped: 0,
+            errors: []
+        };
+        for (const dbId of connectionsToDelete) {
+            try {
+                const result = await api.deleteWorkflowConnection(dbId);
+                if (result?.success) {
+                    operations.deleted++;
+                }
+                else {
+                    operations.errors.push(`Failed to delete connection ${dbId}: ${result?.error || 'Unknown error'}`);
+                }
+            }
+            catch (error) {
+                operations.errors.push(`Error deleting connection ${dbId}: ${error.message}`);
+            }
+        }
+        for (const fileConn of fileConnections) {
+            if (!fileConn.id) {
+                try {
+                    const createData = {
+                        workflow_version_id: workflowVersionId,
+                        source_node_id: fileConn.source_node_id,
+                        target_node_id: fileConn.target_node_id,
+                        source_output_key: fileConn.source_output_key || '',
+                        target_input_key: fileConn.target_input_key || '',
+                        connection_type: fileConn.connection_type || 'default'
+                    };
+                    const result = await api.createWorkflowConnection(createData);
+                    if (result?.success) {
+                        operations.created++;
+                        fileConn.id = result.id;
+                    }
+                    else {
+                        operations.errors.push(`Failed to create connection: ${result?.error || 'Unknown error'}`);
+                    }
+                }
+                catch (error) {
+                    operations.errors.push(`Error creating connection: ${error.message}`);
+                }
+            }
+            else {
+                const dbConn = dbConnectionMap.get(fileConn.id);
+                if (!dbConn) {
+                    operations.errors.push(`Connection ID ${fileConn.id} not found in database - may have been deleted externally`);
+                    continue;
+                }
+                if (dbConn.workflow_version_id !== workflowVersionId) {
+                    operations.errors.push(`Connection ID ${fileConn.id} belongs to different workflow version ${dbConn.workflow_version_id}`);
+                    continue;
+                }
+                const hasChanged = fileConn.source_node_id !== dbConn.source_node_id ||
+                    fileConn.target_node_id !== dbConn.target_node_id ||
+                    (fileConn.source_output_key || '') !== (dbConn.source_output_key || '') ||
+                    (fileConn.target_input_key || '') !== (dbConn.target_input_key || '') ||
+                    (fileConn.connection_type || 'default') !== (dbConn.connection_type || 'default');
+                if (hasChanged) {
+                    try {
+                        const updateData = {
+                            source_node_id: fileConn.source_node_id,
+                            target_node_id: fileConn.target_node_id,
+                            source_output_key: fileConn.source_output_key || '',
+                            target_input_key: fileConn.target_input_key || '',
+                            connection_type: fileConn.connection_type || 'default'
+                        };
+                        const result = await api.updateWorkflowConnection(fileConn.id, updateData);
+                        if (result?.success) {
+                            operations.updated++;
+                        }
+                        else {
+                            operations.errors.push(`Failed to update connection ${fileConn.id}: ${result?.error || 'Unknown error'}`);
+                        }
+                    }
+                    catch (error) {
+                        operations.errors.push(`Error updating connection ${fileConn.id}: ${error.message}`);
+                    }
+                }
+                else {
+                    operations.skipped++;
+                }
+            }
+        }
+        if (operations.created > 0 && operations.errors.length === 0) {
+            try {
+                const backupPath = filePath + '.backup';
+                await fs.copyFile(filePath, backupPath);
+                await fs.writeFile(filePath, JSON.stringify(fileConnections, null, 2), 'utf-8');
+                await fs.unlink(backupPath);
+            }
+            catch (error) {
+                operations.errors.push(`Failed to update connections.json with new IDs: ${error.message}`);
+            }
+        }
+        const messageParts = [];
+        if (operations.created > 0)
+            messageParts.push(`${operations.created} created`);
+        if (operations.updated > 0)
+            messageParts.push(`${operations.updated} updated`);
+        if (operations.deleted > 0)
+            messageParts.push(`${operations.deleted} deleted`);
+        if (operations.skipped > 0)
+            messageParts.push(`${operations.skipped} unchanged`);
+        const message = messageParts.length > 0
+            ? `Synced workflow connections (${messageParts.join(', ')})`
+            : 'No connection changes detected';
+        if (operations.errors.length > 0) {
+            const hasSuccesses = operations.created > 0 || operations.updated > 0 || operations.deleted > 0;
+            return {
+                success: !hasSuccesses,
+                message: `${message} - Errors encountered: ${operations.errors.join('; ')}`
+            };
+        }
+        return { success: true, message };
+    }
+    catch (error) {
+        return { success: false, message: `Failed to sync connections: ${error.message}` };
+    }
+}
+export async function handleWebserviceJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    const restoredData = await restoreTableRecordFromFiles(dirname(filePath), 'webservices', data);
+    return updateRecord(api, 'webservices', restoredData);
+}
+export async function handleWebservicePageCode(api, filePath) {
+    const webserviceData = JSON.parse(await fs.readFile(join(dirname(filePath), 'webservice.json'), 'utf-8'));
+    const pageCode = await smartReadBfyContent(filePath);
+    return updateRecordField(api, 'webservices', webserviceData.id, 'page_code', pageCode);
+}
+export async function handlePdfTemplateJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    const restoredData = await restoreTableRecordFromFiles(dirname(filePath), 'pdf_templates', data);
+    return updateRecord(api, 'pdf_templates', restoredData);
+}
+export async function handlePdfTemplateTwig(api, filePath) {
+    const templateData = JSON.parse(await fs.readFile(join(dirname(filePath), 'pdf_template.json'), 'utf-8'));
+    const restoredData = await restoreTableRecordFromFiles(dirname(filePath), 'pdf_templates', templateData);
+    return updateRecordField(api, 'pdf_templates', restoredData.id, 'template', restoredData.template || '');
+}
+export async function handleCronjobJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    const restoredData = await restoreTableRecordFromFiles(dirname(filePath), 'bfy_cronjobs', data);
+    return updateRecord(api, 'bfy_cronjobs', restoredData);
+}
+export async function handleCronjobCode(api, filePath) {
+    const cronjobData = JSON.parse(await fs.readFile(join(dirname(filePath), 'cronjob.json'), 'utf-8'));
+    const restoredData = await restoreTableRecordFromFiles(dirname(filePath), 'bfy_cronjobs', cronjobData);
+    return updateRecordField(api, 'bfy_cronjobs', restoredData.id, 'code', restoredData.code || '');
+}
+export async function handleEmailTemplateJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    const restoredData = await restoreTableRecordFromFiles(dirname(filePath), 'cms_email_templates', data);
+    return updateRecord(api, 'cms_email_templates', restoredData);
+}
+export async function handleEmailTemplateBfy(api, filePath) {
+    const templateData = JSON.parse(await fs.readFile(join(dirname(filePath), 'template.json'), 'utf-8'));
+    const restoredData = await restoreTableRecordFromFiles(dirname(filePath), 'cms_email_templates', templateData);
+    return updateRecordFields(api, 'cms_email_templates', restoredData.id, {
+        subject: restoredData.subject,
+        content: restoredData.content
+    });
+}
+export async function handleEmailLayoutJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    const restoredData = await restoreTableRecordFromFiles(dirname(filePath), 'cms_email_layouts', data);
+    return updateRecord(api, 'cms_email_layouts', restoredData);
+}
+export async function handleEmailLayoutBfy(api, filePath) {
+    const layoutData = JSON.parse(await fs.readFile(join(dirname(filePath), 'layout.json'), 'utf-8'));
+    const restoredData = await restoreTableRecordFromFiles(dirname(filePath), 'cms_email_layouts', layoutData);
+    return updateRecordFields(api, 'cms_email_layouts', restoredData.id, {
+        layout_html: restoredData.layout_html,
+        layout_text: restoredData.layout_text
+    });
+}
+export async function handleObjectJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    return updateRecord(api, 'objects', data);
+}
+export async function handleObjectSpecJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    const restoredData = await restoreFieldsFromFiles(dirname(filePath), data);
+    return updateRecord(api, 'object_specs', restoredData);
+}
+export async function handleObjectListingQuery(api, filePath) {
+    const objectData = JSON.parse(await fs.readFile(join(dirname(filePath), 'object.json'), 'utf-8'));
+    const listingQueryContent = await smartReadBfyContent(filePath);
+    return updateRecordField(api, 'objects', objectData.id, 'listing_query', listingQueryContent);
+}
+export async function handleObjectSpecCodeFile(api, filePath) {
+    const fileName = basename(filePath);
+    const specDir = dirname(filePath);
+    const specData = JSON.parse(await fs.readFile(join(specDir, 'spec.json'), 'utf-8'));
+    let columnName;
+    let content;
+    if (fileName === 'code.bfy') {
+        columnName = 'val_1';
+        content = await smartReadBfyContent(filePath);
+    }
+    else if (fileName === 'template_code.bfy') {
+        columnName = 'val_1';
+        content = await smartReadBfyContent(filePath);
+    }
+    else if (fileName === 'processing_code.bfy') {
+        columnName = 'val_2';
+        content = await smartReadBfyContent(filePath);
+    }
+    else if (fileName === 'filter_code.bfy') {
+        columnName = 'val_3';
+        content = await smartReadBfyContent(filePath);
+    }
+    else if (fileName === 'configuration.yaml') {
+        columnName = 'val_1';
+        content = await fs.readFile(filePath, 'utf-8');
+    }
+    else if (fileName === 'code.js') {
+        columnName = 'js_code';
+        content = await fs.readFile(filePath, 'utf-8');
+    }
+    else if (fileName === 'style.css') {
+        columnName = 'css_code';
+        content = await fs.readFile(filePath, 'utf-8');
+    }
+    else {
+        return { success: false, message: `Unsupported code file: ${fileName}` };
+    }
+    return updateRecordField(api, 'object_specs', specData.id, columnName, content);
+}
+export async function handlePageJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    const restoredData = await restoreTableRecordFromFiles(dirname(filePath), 'pages', data);
+    return updateRecord(api, 'pages', restoredData);
+}
+export async function handleStateMachineJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    return updateRecord(api, 'bfy_state_machines', data);
+}
+export async function handleStateMachineStateJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    return updateRecord(api, 'bfy_state_machine_states', data);
+}
+export async function handleStateMachineRoleJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    const restoredData = await restoreTableRecordFromFiles(dirname(filePath), 'bfy_state_machine_roles', data);
+    return updateRecord(api, 'bfy_state_machine_roles', restoredData);
+}
+export async function handleStateMachineRoleCode(api, filePath) {
+    const roleData = JSON.parse(await fs.readFile(join(dirname(filePath), 'role.json'), 'utf-8'));
+    const restoredData = await restoreTableRecordFromFiles(dirname(filePath), 'bfy_state_machine_roles', roleData);
+    return updateRecordField(api, 'bfy_state_machine_roles', restoredData.id, 'validation_code', restoredData.validation_code || '');
+}
+export async function handleStateMachineTransitionJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    const restoredData = await restoreTableRecordFromFiles(dirname(filePath), 'bfy_state_machine_transitions', data);
+    return updateRecord(api, 'bfy_state_machine_transitions', restoredData);
+}
+export async function handleStateMachineTransitionCode(api, filePath, fieldName) {
+    const transitionData = JSON.parse(await fs.readFile(join(dirname(filePath), 'transition.json'), 'utf-8'));
+    const restoredData = await restoreTableRecordFromFiles(dirname(filePath), 'bfy_state_machine_transitions', transitionData);
+    return updateRecordField(api, 'bfy_state_machine_transitions', restoredData.id, fieldName, restoredData[fieldName] || '');
+}
+export async function handleStateMachineActionJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    const restoredData = await restoreTableRecordFromFiles(dirname(filePath), 'bfy_sm_actions', data);
+    return updateRecord(api, 'bfy_sm_actions', restoredData);
+}
+export async function handleStateMachineActionCode(api, filePath) {
+    const actionData = JSON.parse(await fs.readFile(join(dirname(filePath), 'action.json'), 'utf-8'));
+    const restoredData = await restoreTableRecordFromFiles(dirname(filePath), 'bfy_sm_actions', actionData);
+    return updateRecordField(api, 'bfy_sm_actions', restoredData.id, 'code', restoredData.code || '');
+}
+export async function handleTransitionActionJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    return updateRecord(api, 'bfy_sm_transition_actions', data);
+}
+export async function handleStateMachineSpecJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    const restoredData = await restoreFieldsFromFiles(dirname(filePath), data);
+    let tableName = '';
+    if (filePath.includes('/transitions/')) {
+        tableName = 'bfy_state_machine_transition_specs';
+    }
+    else if (filePath.includes('/actions/')) {
+        tableName = 'bfy_sm_action_specs';
+    }
+    else {
+        return { success: false, message: 'Unknown spec type' };
+    }
+    return updateRecord(api, tableName, restoredData);
+}
+export async function handleAiTaskJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    const restoredData = await restoreAiTaskFromFiles(dirname(filePath), data);
+    const formData = new URLSearchParams();
+    formData.append('id', restoredData.id.toString());
+    Object.entries(restoredData).forEach(([key, value]) => {
+        if (key !== 'id' && value !== null && value !== undefined) {
+            formData.append(key, typeof value === 'string' ? value : JSON.stringify(value));
+        }
+    });
+    const response = await api.httpClient.post('/admin/ajax/cms_object/operation?do=bfy_ai_tasks__edit', formData, {
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+    });
+    if (response.data?.success) {
+        return { success: true, message: `Updated AI task (ID: ${restoredData.id})`, resourceId: restoredData.id };
+    }
+    else {
+        const errorMsg = response.data?.error || response.data?.message || 'Unknown error';
+        return { success: false, message: `Failed to update AI task: ${errorMsg}` };
+    }
+}
+export async function handleAiTaskCodeFile(api, filePath, fieldName) {
+    const taskData = JSON.parse(await fs.readFile(join(dirname(filePath), 'task.json'), 'utf-8'));
+    let fieldValue;
+    if (basename(filePath).endsWith('.json')) {
+        const content = await fs.readFile(filePath, 'utf-8');
+        fieldValue = JSON.stringify(JSON.parse(content));
+    }
+    else if (basename(filePath).endsWith('.bfy')) {
+        fieldValue = await smartReadBfyContent(filePath);
+    }
+    else {
+        fieldValue = await fs.readFile(filePath, 'utf-8');
+    }
+    return updateRecordField(api, 'bfy_ai_tasks', taskData.id, fieldName, fieldValue);
+}
+export async function handleReportJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    const restoredData = await restoreFieldsFromFiles(dirname(filePath), data);
+    const response = await api.updateReport(restoredData.id, restoredData);
+    if (response?.success) {
+        return { success: true, message: `Updated report (ID: ${restoredData.id})`, resourceId: restoredData.id };
+    }
+    else {
+        const errorMsg = response?.error || response?.message || 'Unknown error';
+        return { success: false, message: `Failed to update report: ${errorMsg}` };
+    }
+}
+export async function handleReportSpecJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    const restoredData = await restoreFieldsFromFiles(dirname(filePath), data);
+    const response = await api.updateReportSpec(restoredData.id, restoredData);
+    if (response?.success) {
+        return { success: true, message: `Updated report spec (ID: ${restoredData.id})`, resourceId: restoredData.id };
+    }
+    else {
+        const errorMsg = response?.error || response?.message || 'Unknown error';
+        return { success: false, message: `Failed to update report spec: ${errorMsg}` };
+    }
+}
+export async function handleReportSpecCode(api, filePath) {
+    const specData = JSON.parse(await fs.readFile(join(dirname(filePath), 'spec.json'), 'utf-8'));
+    const codeContent = await fs.readFile(filePath, 'utf-8');
+    const response = await api.updateReportSpec(specData.id, { js_code: codeContent });
+    if (response?.success) {
+        return { success: true, message: `Updated report spec js_code (ID: ${specData.id})`, resourceId: specData.id };
+    }
+    else {
+        const errorMsg = response?.error || response?.message || 'Unknown error';
+        return { success: false, message: `Failed to update report spec js_code: ${errorMsg}` };
+    }
+}
+export async function handleReportQueryJson(api, filePath) {
+    const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+    const restoredData = await restoreFieldsFromFiles(dirname(filePath), data);
+    const response = await api.updateReportQuery(restoredData.id, restoredData);
+    if (response?.success) {
+        return { success: true, message: `Updated report query (ID: ${restoredData.id})`, resourceId: restoredData.id };
+    }
+    else {
+        const errorMsg = response?.error || response?.message || 'Unknown error';
+        return { success: false, message: `Failed to update report query: ${errorMsg}` };
+    }
+}
+export async function handleReportQueryCode(api, filePath, field) {
+    const queryData = JSON.parse(await fs.readFile(join(dirname(filePath), 'query.json'), 'utf-8'));
+    const codeContent = filePath.endsWith('.bfy') ? await smartReadBfyContent(filePath) : await fs.readFile(filePath, 'utf-8');
+    if (process.env.BUTTERFLY_DEBUG === 'true') {
+        console.log(`[DEBUG] handleReportQueryCode: Updating query ID ${queryData.id}, field: ${field}, content length: ${codeContent.length}`);
+    }
+    const response = await api.updateReportQuery(queryData.id, { [field]: codeContent });
+    if (process.env.BUTTERFLY_DEBUG === 'true') {
+        console.log('[DEBUG] handleReportQueryCode response:', JSON.stringify(response, null, 2));
+    }
+    if (response?.success) {
+        return { success: true, message: `Updated report query ${field} (ID: ${queryData.id})`, resourceId: queryData.id };
+    }
+    else {
+        const errorMsg = response?.error || response?.message || 'Unknown error';
+        return { success: false, message: `Failed to update report query ${field}: ${errorMsg}` };
+    }
+}
+export async function handleReportMainQuery(api, filePath) {
+    const reportData = JSON.parse(await fs.readFile(join(dirname(filePath), 'report.json'), 'utf-8'));
+    const queryContent = await smartReadBfyContent(filePath);
+    const response = await api.updateReport(reportData.id, { query: queryContent });
+    if (response?.success) {
+        return { success: true, message: `Updated report main query (ID: ${reportData.id})`, resourceId: reportData.id };
+    }
+    else {
+        const errorMsg = response?.error || response?.message || 'Unknown error';
+        return { success: false, message: `Failed to update report main query: ${errorMsg}` };
+    }
+}
+export async function handleTranslationYaml(api, filePath) {
+    const isoCode = basename(filePath).replace(/\.(yaml|yml)$/, '');
+    const content = await fs.readFile(filePath, 'utf-8');
+    const translations = yamlParse(content);
+    if (!translations || typeof translations !== 'object') {
+        return { success: false, message: `Invalid YAML content in ${filePath}` };
+    }
+    const languages = await api.fetchTable('bfy_languages', 'iso_code', isoCode);
+    if (!languages || languages.length === 0) {
+        return { success: false, message: `Language not found for ISO code: ${isoCode}` };
+    }
+    const language = languages[0];
+    const sourceTexts = await api.fetchTable('bfy_translation_texts');
+    const sourceTextMap = new Map();
+    sourceTexts.forEach((t) => sourceTextMap.set(t.source, t.id));
+    const translationEntries = [];
+    let newSourceTexts = 0;
+    for (const [source, translated] of Object.entries(translations)) {
+        let textId = sourceTextMap.get(source);
+        if (textId === undefined) {
+            const result = await api.performOperation('bfy_translation_texts', 'add', { source });
+            if (result.success && result.id) {
+                textId = result.id;
+                sourceTextMap.set(source, textId);
+                newSourceTexts++;
+            }
+            else {
+                continue;
+            }
+        }
+        translationEntries.push({ textId, text: translated || '' });
+    }
+    const formData = new URLSearchParams();
+    formData.append('id', language.id.toString());
+    formData.append('name', language.name);
+    formData.append('iso_code', language.iso_code);
+    formData.append('translations', '1');
+    for (const entry of translationEntries) {
+        formData.append(`translation[${entry.textId}]`, entry.text);
+    }
+    const response = await api.httpClient.post('/admin/ajax/cms_object/operation?do=bfy_languages__edit', formData, { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } });
+    if (response.data?.success) {
+        const count = translationEntries.length;
+        const message = newSourceTexts > 0
+            ? `Updated ${count} translations for ${language.name} (${isoCode}), created ${newSourceTexts} new source texts`
+            : `Updated ${count} translations for ${language.name} (${isoCode})`;
+        return { success: true, message, resourceId: language.id };
+    }
+    else {
+        const errorMsg = response.data?.error || response.data?.message || 'Unknown error';
+        return { success: false, message: `Failed to update translations for ${isoCode}: ${errorMsg}` };
+    }
+}
+//# sourceMappingURL=resourceHandlers.js.map