@rglabs/butterfly 1.0.0

package/dist/utils/files.js

@@ -0,0 +1,732 @@
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { stringify as yamlStringify } from 'yaml';
+const TABLE_CONFIGS = {
+    pages: {
+        folderNameField: 'link',
+        codeFields: [
+            { field: 'page_code', filename: 'page_code', extension: 'bfy' }
+        ],
+        hasSpecs: false
+    },
+    bfy_ai_tasks: {
+        folderNameField: 'system_name',
+        codeFields: [
+            { field: 'prompt', filename: 'prompt', extension: 'bfy' },
+            { field: 'output_format', filename: 'output_format', extension: 'json' },
+            { field: 'system_message', filename: 'system_message', extension: 'bfy' },
+            { field: 'action_code', filename: 'action_code', extension: 'bfy' },
+            { field: 'action_preview_code', filename: 'action_preview_code', extension: 'bfy' },
+            { field: 'initial_code', filename: 'initial_code', extension: 'bfy' }
+        ],
+        hasSpecs: false
+    },
+    objects: {
+        folderNameField: 'table_name',
+        codeFields: [
+            { field: 'listing_query', filename: 'listing_query', extension: 'bfy' }
+        ],
+        hasSpecs: true,
+        specsTable: 'object_specs',
+        specsForeignKey: 'object_id'
+    },
+    bfy_state_machines: {
+        folderNameField: 'name',
+        hasSpecs: false
+    },
+    bfy_state_machine_states: {
+        folderNameField: 'system_name',
+        hasSpecs: false
+    },
+    bfy_state_machine_roles: {
+        folderNameField: 'name',
+        codeFields: [
+            { field: 'validation_code', filename: 'validation_code', extension: 'bfy' }
+        ],
+        hasSpecs: false
+    },
+    bfy_state_machine_transitions: {
+        folderNameField: 'transition_system_name',
+        codeFields: [
+            { field: 'action_code', filename: 'action_code', extension: 'bfy' },
+            { field: 'validation_code', filename: 'validation_code', extension: 'bfy' }
+        ],
+        hasSpecs: true,
+        specsTable: 'bfy_state_machine_transition_specs',
+        specsForeignKey: 'bfy_state_machine_transition_id'
+    },
+    bfy_sm_actions: {
+        folderNameField: 'name',
+        codeFields: [
+            { field: 'code', filename: 'code', extension: 'bfy' }
+        ],
+        hasSpecs: true,
+        specsTable: 'bfy_sm_action_specs',
+        specsForeignKey: 'bfy_sm_action_id'
+    },
+    bfy_cronjobs: {
+        folderNameField: 'name',
+        codeFields: [
+            { field: 'code', filename: 'code', extension: 'bfy' }
+        ],
+        hasSpecs: false
+    },
+    cms_email_templates: {
+        folderNameField: 'system_name',
+        codeFields: [
+            { field: 'subject', filename: 'subject', extension: 'bfy' },
+            { field: 'content', filename: 'content', extension: 'bfy' }
+        ],
+        hasSpecs: false
+    },
+    pdf_templates: {
+        folderNameField: 'system_name',
+        codeFields: [
+            { field: 'template', filename: 'template', extension: 'bfy' }
+        ],
+        hasSpecs: false
+    },
+    cms_email_layouts: {
+        folderNameField: 'name',
+        codeFields: [
+            { field: 'layout_html', filename: 'layout_html', extension: 'bfy' },
+            { field: 'layout_text', filename: 'layout_text', extension: 'bfy' }
+        ],
+        hasSpecs: false
+    },
+    bfy_workflows: {
+        folderNameField: 'name',
+        hasSpecs: false
+    },
+    bfy_workflow_versions: {
+        folderNameField: 'version_number',
+        hasSpecs: false
+    },
+    bfy_workflow_nodes: {
+        folderNameField: 'name',
+        codeFields: [
+            { field: 'code', filename: 'code', extension: 'bfy' }
+        ],
+        hasSpecs: false
+    }
+};
+export async function cleanupDirectory(dirPath) {
+    try {
+        await fs.rm(dirPath, { recursive: true, force: true });
+    }
+    catch (error) {
+    }
+}
+export async function saveResource(outputPath, resourceType, resourceName, data) {
+    const dir = join(outputPath, resourceType);
+    await fs.mkdir(dir, { recursive: true });
+    const filePath = join(dir, `${resourceName}.json`);
+    await fs.writeFile(filePath, JSON.stringify(data, null, 2));
+}
+function getAiTaskFieldMappings() {
+    return [
+        { field: 'prompt', filename: 'prompt', extension: 'bfy' },
+        { field: 'output_format', filename: 'output_format', extension: 'json' },
+        { field: 'system_message', filename: 'system_message', extension: 'bfy' },
+        { field: 'action_code', filename: 'action_code', extension: 'bfy' },
+        { field: 'action_preview_code', filename: 'action_preview_code', extension: 'bfy' },
+        { field: 'initial_code', filename: 'initial_code', extension: 'bfy' }
+    ];
+}
+export async function saveAiTask(outputPath, aiTask) {
+    const folderName = aiTask.system_name || aiTask.name || aiTask.id || `ai-task-${aiTask.id}`;
+    const taskDir = join(outputPath, 'bfy_ai_tasks', folderName);
+    await fs.mkdir(taskDir, { recursive: true });
+    const mappings = getAiTaskFieldMappings();
+    const strippedTask = { ...aiTask };
+    for (const mapping of mappings) {
+        const content = aiTask[mapping.field];
+        if (content) {
+            const filePath = join(taskDir, `${mapping.filename}.${mapping.extension}`);
+            await fs.writeFile(filePath, typeof content === 'string' ? content : JSON.stringify(content, null, 2));
+            delete strippedTask[mapping.field];
+        }
+    }
+    const taskFile = join(taskDir, 'task.json');
+    await fs.writeFile(taskFile, JSON.stringify(strippedTask, null, 2));
+}
+export async function restoreTableRecordFromFiles(recordDir, tableName, recordData) {
+    const restored = { ...recordData };
+    const config = TABLE_CONFIGS[tableName] || {};
+    try {
+        if (config.codeFields) {
+            for (const codeField of config.codeFields) {
+                const codePath = join(recordDir, `${codeField.filename}.${codeField.extension}`);
+                try {
+                    const content = await fs.readFile(codePath, 'utf-8');
+                    restored[codeField.field] = content;
+                }
+                catch {
+                }
+            }
+        }
+    }
+    catch (err) {
+        return recordData;
+    }
+    return restored;
+}
+export async function restorePageFromFiles(pageDir, pageData) {
+    return restoreTableRecordFromFiles(pageDir, 'pages', pageData);
+}
+export async function restoreAiTaskFromFiles(taskDir, taskData) {
+    const restored = { ...taskData };
+    const mappings = getAiTaskFieldMappings();
+    try {
+        for (const mapping of mappings) {
+            const filePath = join(taskDir, `${mapping.filename}.${mapping.extension}`);
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                if (mapping.extension === 'json') {
+                    restored[mapping.field] = JSON.parse(content);
+                }
+                else {
+                    restored[mapping.field] = content;
+                }
+            }
+            catch {
+            }
+        }
+    }
+    catch (err) {
+        return taskData;
+    }
+    return restored;
+}
+function getFieldMapping(spec) {
+    const mappings = [];
+    const type = spec.type;
+    if (spec.listing_query) {
+        mappings.push({ filename: 'listing_query', extension: 'bfy' });
+    }
+    if (spec.js_code) {
+        mappings.push({ filename: 'code', extension: 'js' });
+    }
+    if (spec.css_code) {
+        mappings.push({ filename: 'style', extension: 'css' });
+    }
+    switch (type) {
+        case 'calculated':
+            if (spec.val_1)
+                mappings.push({ filename: 'code', extension: 'bfy' });
+            break;
+        case 'custom':
+            if (spec.val_1)
+                mappings.push({ filename: 'template_code', extension: 'bfy' });
+            if (spec.val_2)
+                mappings.push({ filename: 'processing_code', extension: 'bfy' });
+            break;
+        case 'filter':
+            if (spec.val_3)
+                mappings.push({ filename: 'filter_code', extension: 'bfy' });
+            break;
+        case 'nested':
+        case 'nested_single':
+            if (spec.val_1)
+                mappings.push({ filename: 'configuration', extension: 'yaml' });
+            break;
+    }
+    return mappings;
+}
+function stripExportedFields(data, mappings) {
+    const stripped = { ...data };
+    for (const mapping of mappings) {
+        const filename = mapping.filename;
+        switch (filename) {
+            case 'listing_query':
+                delete stripped.listing_query;
+                break;
+            case 'code':
+                if (mapping.extension === 'js') {
+                    delete stripped.js_code;
+                }
+                else if (mapping.extension === 'bfy') {
+                    delete stripped.val_1;
+                }
+                break;
+            case 'style':
+                delete stripped.css_code;
+                break;
+            case 'configuration':
+                delete stripped.val_1;
+                break;
+            case 'template_code':
+                delete stripped.val_1;
+                break;
+            case 'processing_code':
+                delete stripped.val_2;
+                break;
+            case 'filter_code':
+                delete stripped.val_3;
+                break;
+        }
+    }
+    return stripped;
+}
+export async function restoreFieldsFromFiles(baseDir, data) {
+    const restored = { ...data };
+    try {
+        const listingQueryPath = join(baseDir, 'listing_query.bfy');
+        try {
+            const content = await fs.readFile(listingQueryPath, 'utf-8');
+            restored.listing_query = content;
+        }
+        catch {
+        }
+        if (data.type) {
+            const mappings = getFieldMapping(data);
+            for (const mapping of mappings) {
+                const filePath = join(baseDir, `${mapping.filename}.${mapping.extension}`);
+                try {
+                    const content = await fs.readFile(filePath, 'utf-8');
+                    switch (mapping.filename) {
+                        case 'listing_query':
+                            restored.listing_query = content;
+                            break;
+                        case 'code':
+                            if (mapping.extension === 'js') {
+                                restored.js_code = content;
+                            }
+                            else if (mapping.extension === 'bfy') {
+                                restored.val_1 = content;
+                            }
+                            break;
+                        case 'style':
+                            restored.css_code = content;
+                            break;
+                        case 'configuration':
+                            restored.val_1 = content;
+                            break;
+                        case 'template_code':
+                            restored.val_1 = content;
+                            break;
+                        case 'processing_code':
+                            restored.val_2 = content;
+                            break;
+                        case 'filter_code':
+                            restored.val_3 = content;
+                            break;
+                    }
+                }
+                catch {
+                }
+            }
+        }
+        if (!data.type && data.alias !== undefined) {
+            const mainQueryPath = join(baseDir, 'main_query.bfy');
+            try {
+                const content = await fs.readFile(mainQueryPath, 'utf-8');
+                restored.query = content;
+            }
+            catch {
+            }
+        }
+        if (data.name !== undefined && data.system_name !== undefined) {
+            const queryCodePath = join(baseDir, 'query_code.bfy');
+            try {
+                const content = await fs.readFile(queryCodePath, 'utf-8');
+                restored.query = content;
+            }
+            catch {
+            }
+            const scriptPath = join(baseDir, 'script.js');
+            try {
+                const content = await fs.readFile(scriptPath, 'utf-8');
+                restored.js_code = content;
+            }
+            catch {
+            }
+        }
+        if (data.field_name !== undefined) {
+            const codePath = join(baseDir, 'code.js');
+            try {
+                const content = await fs.readFile(codePath, 'utf-8');
+                restored.js_code = content;
+            }
+            catch {
+            }
+        }
+    }
+    catch (err) {
+        return data;
+    }
+    return restored;
+}
+async function exportSpecFiles(specDir, spec) {
+    const mappings = getFieldMapping(spec);
+    for (const mapping of mappings) {
+        let content = '';
+        const filename = mapping.filename;
+        switch (filename) {
+            case 'listing_query':
+                content = spec.listing_query || '';
+                break;
+            case 'code':
+                content = spec.js_code || spec.val_1 || '';
+                break;
+            case 'style':
+                content = spec.css_code || '';
+                break;
+            case 'configuration':
+                content = spec.val_1 || '';
+                break;
+            case 'template_code':
+                content = spec.val_1 || '';
+                break;
+            case 'processing_code':
+                content = spec.val_2 || '';
+                break;
+            case 'filter_code':
+                content = spec.val_3 || '';
+                break;
+        }
+        if (content) {
+            const filePath = join(specDir, `${filename}.${mapping.extension}`);
+            await fs.writeFile(filePath, content);
+        }
+    }
+}
+export async function saveObjectWithSpecs(outputPath, tableName, objectData, specs) {
+    const subfolder = objectData.is_cms_object === 1 ? 'butterfly' : objectData.database_alias || 'app';
+    const tableDir = join(outputPath, 'objects', subfolder, tableName);
+    await fs.mkdir(tableDir, { recursive: true });
+    const strippedObjectData = { ...objectData };
+    if (objectData.listing_query) {
+        delete strippedObjectData.listing_query;
+    }
+    const objectFile = join(tableDir, 'object.json');
+    await fs.writeFile(objectFile, JSON.stringify(strippedObjectData, null, 2));
+    if (objectData.listing_query) {
+        const listingQueryFile = join(tableDir, 'listing_query.bfy');
+        await fs.writeFile(listingQueryFile, objectData.listing_query);
+    }
+    if (specs && specs.length > 0) {
+        for (const spec of specs) {
+            const specDir = join(tableDir, spec.column_name);
+            await fs.mkdir(specDir, { recursive: true });
+            const mappings = getFieldMapping(spec);
+            const strippedSpec = stripExportedFields(spec, mappings);
+            const specFile = join(specDir, 'spec.json');
+            await fs.writeFile(specFile, JSON.stringify(strippedSpec, null, 2));
+            await exportSpecFiles(specDir, spec);
+        }
+    }
+}
+export async function saveTableRecord(outputPath, tableName, recordData, specs) {
+    const config = TABLE_CONFIGS[tableName] || {};
+    const tableDir = join(outputPath, tableName);
+    await fs.mkdir(tableDir, { recursive: true });
+    let folderName;
+    if (config.folderNameField && recordData[config.folderNameField]) {
+        folderName = String(recordData[config.folderNameField]).replace(/[^a-zA-Z0-9-_]/g, '_');
+    }
+    else {
+        folderName = recordData.name || recordData.id || `${tableName}-${recordData.id}`;
+    }
+    const recordDir = join(tableDir, folderName);
+    await fs.mkdir(recordDir, { recursive: true });
+    const strippedData = { ...recordData };
+    if (config.codeFields) {
+        for (const codeField of config.codeFields) {
+            if (recordData[codeField.field]) {
+                const codeFile = join(recordDir, `${codeField.filename}.${codeField.extension}`);
+                await fs.writeFile(codeFile, recordData[codeField.field]);
+                delete strippedData[codeField.field];
+            }
+        }
+    }
+    let jsonFileName;
+    if (tableName === 'bfy_state_machine_states') {
+        jsonFileName = 'state.json';
+    }
+    else if (tableName === 'bfy_state_machine_roles') {
+        jsonFileName = 'role.json';
+    }
+    else if (tableName === 'bfy_state_machine_transitions') {
+        jsonFileName = 'transition.json';
+    }
+    else if (tableName === 'bfy_sm_actions') {
+        jsonFileName = 'action.json';
+    }
+    else if (tableName === 'bfy_ai_tasks') {
+        jsonFileName = 'task.json';
+    }
+    else if (tableName === 'bfy_cronjobs') {
+        jsonFileName = 'cronjob.json';
+    }
+    else if (tableName === 'cms_email_templates') {
+        jsonFileName = 'template.json';
+    }
+    else if (tableName === 'cms_email_layouts') {
+        jsonFileName = 'layout.json';
+    }
+    else if (tableName === 'pages') {
+        jsonFileName = 'page.json';
+    }
+    else if (tableName === 'bfy_ai_tasks') {
+        jsonFileName = 'task.json';
+    }
+    else {
+        jsonFileName = `${tableName.slice(0, -1)}.json`;
+    }
+    const recordFile = join(recordDir, jsonFileName);
+    await fs.writeFile(recordFile, JSON.stringify(strippedData, null, 2));
+    if (config.hasSpecs && specs && specs.length > 0) {
+        for (const spec of specs) {
+            const specDir = join(recordDir, spec.column_name);
+            await fs.mkdir(specDir, { recursive: true });
+            await exportSpecFiles(specDir, spec);
+            const mappings = getFieldMapping(spec);
+            const strippedSpec = stripExportedFields(spec, mappings);
+            const specFile = join(specDir, 'spec.json');
+            await fs.writeFile(specFile, JSON.stringify(strippedSpec, null, 2));
+        }
+    }
+}
+export async function savePageData(outputPath, pageData) {
+    await saveTableRecord(outputPath, 'pages', pageData);
+}
+export async function saveReportData(outputPath, reportData, specs, queries, categories) {
+    const reportDir = join(outputPath, 'reports', reportData.alias || `report_${reportData.id}`);
+    await fs.mkdir(reportDir, { recursive: true });
+    const strippedReportData = { ...reportData };
+    if (reportData.query) {
+        delete strippedReportData.query;
+    }
+    const reportFile = join(reportDir, 'report.json');
+    await fs.writeFile(reportFile, JSON.stringify(strippedReportData, null, 2));
+    if (reportData.query) {
+        const mainQueryFile = join(reportDir, 'main_query.bfy');
+        await fs.writeFile(mainQueryFile, reportData.query);
+    }
+    if (queries && queries.length > 0) {
+        const queriesDir = join(reportDir, 'queries');
+        await fs.mkdir(queriesDir, { recursive: true });
+        for (const query of queries) {
+            const strippedQuery = { ...query };
+            if (query.query) {
+                delete strippedQuery.query;
+            }
+            if (query.js_code) {
+                delete strippedQuery.js_code;
+            }
+            const queryName = query.name || `${query.system_name}`;
+            const queryDir = join(queriesDir, queryName);
+            await fs.mkdir(queryDir, { recursive: true });
+            const queryFile = join(queryDir, 'query.json');
+            await fs.writeFile(queryFile, JSON.stringify(strippedQuery, null, 2));
+            if (query.query) {
+                const queryCodeFile = join(queryDir, 'query_code.bfy');
+                await fs.writeFile(queryCodeFile, query.query);
+            }
+            if (query.js_code) {
+                const scriptFile = join(queryDir, 'script.js');
+                await fs.writeFile(scriptFile, query.js_code);
+            }
+        }
+    }
+    if (specs && specs.length > 0) {
+        const specsDir = join(reportDir, 'specs');
+        await fs.mkdir(specsDir, { recursive: true });
+        for (const spec of specs) {
+            const strippedSpec = { ...spec };
+            if (spec.js_code) {
+                delete strippedSpec.js_code;
+            }
+            const fieldName = spec.field_name || `field_${spec.id}`;
+            const specDir = join(specsDir, fieldName);
+            await fs.mkdir(specDir, { recursive: true });
+            const specFile = join(specDir, 'spec.json');
+            await fs.writeFile(specFile, JSON.stringify(strippedSpec, null, 2));
+            if (spec.js_code) {
+                const jsFile = join(specDir, 'code.js');
+                await fs.writeFile(jsFile, spec.js_code);
+            }
+        }
+    }
+    if (categories && categories.length > 0) {
+        const categoriesFile = join(outputPath, 'reports', 'categories.json');
+        await fs.writeFile(categoriesFile, JSON.stringify(categories, null, 2));
+    }
+}
+export async function saveStateMachineData(outputPath, stateMachine, states, roles, transitions, transitionSpecs, actions, actionSpecs, transitionActions) {
+    const config = TABLE_CONFIGS.bfy_state_machines;
+    const folderName = stateMachine[config.folderNameField] || `state_machine_${stateMachine.id}`;
+    const stateMachineDir = join(outputPath, 'bfy_state_machines', folderName);
+    await fs.mkdir(stateMachineDir, { recursive: true });
+    await fs.writeFile(join(stateMachineDir, 'state_machine.json'), JSON.stringify(stateMachine, null, 2));
+    if (states && states.length > 0) {
+        const statesDir = join(stateMachineDir, 'states');
+        for (const state of states) {
+            const config = TABLE_CONFIGS.bfy_state_machine_states;
+            const folderName = state[config.folderNameField] || `state_${state.id}`;
+            const stateDir = join(statesDir, folderName);
+            await fs.mkdir(stateDir, { recursive: true });
+            await fs.writeFile(join(stateDir, 'state.json'), JSON.stringify(state, null, 2));
+        }
+    }
+    if (roles && roles.length > 0) {
+        const rolesDir = join(stateMachineDir, 'roles');
+        for (const role of roles) {
+            const config = TABLE_CONFIGS.bfy_state_machine_roles;
+            const folderName = role[config.folderNameField] || `role_${role.id}`;
+            const roleDir = join(rolesDir, folderName);
+            await fs.mkdir(roleDir, { recursive: true });
+            const strippedRole = { ...role };
+            if (role.validation_code) {
+                delete strippedRole.validation_code;
+            }
+            await fs.writeFile(join(roleDir, 'role.json'), JSON.stringify(strippedRole, null, 2));
+            if (role.validation_code) {
+                await fs.writeFile(join(roleDir, 'validation_code.bfy'), role.validation_code);
+            }
+        }
+    }
+    if (transitions && transitions.length > 0) {
+        const transitionsDir = join(stateMachineDir, 'transitions');
+        for (const transition of transitions) {
+            const config = TABLE_CONFIGS.bfy_state_machine_transitions;
+            const folderName = transition[config.folderNameField] || `transition_${transition.id}`;
+            const transitionDir = join(transitionsDir, folderName);
+            await fs.mkdir(transitionDir, { recursive: true });
+            const strippedTransition = { ...transition };
+            if (transition.action_code) {
+                delete strippedTransition.action_code;
+            }
+            if (transition.validation_code) {
+                delete strippedTransition.validation_code;
+            }
+            await fs.writeFile(join(transitionDir, 'transition.json'), JSON.stringify(strippedTransition, null, 2));
+            if (transition.action_code) {
+                await fs.writeFile(join(transitionDir, 'action_code.bfy'), transition.action_code);
+            }
+            if (transition.validation_code) {
+                await fs.writeFile(join(transitionDir, 'validation_code.bfy'), transition.validation_code);
+            }
+            const relatedSpecs = transitionSpecs.filter(spec => spec.bfy_state_machine_transition_id === transition.id);
+            if (relatedSpecs.length > 0) {
+                const specsDir = join(transitionDir, 'specs');
+                await fs.mkdir(specsDir, { recursive: true });
+                for (const spec of relatedSpecs) {
+                    const specName = spec.name || `spec_${spec.id}`;
+                    const specDir = join(specsDir, specName);
+                    await fs.mkdir(specDir, { recursive: true });
+                    const mappings = getFieldMapping(spec);
+                    const strippedSpec = stripExportedFields(spec, mappings);
+                    await fs.writeFile(join(specDir, 'spec.json'), JSON.stringify(strippedSpec, null, 2));
+                    await exportSpecFiles(specDir, spec);
+                }
+            }
+        }
+    }
+    if (actions && actions.length > 0) {
+        const actionsDir = join(stateMachineDir, 'actions');
+        for (const action of actions) {
+            const config = TABLE_CONFIGS.bfy_sm_actions;
+            const folderName = action[config.folderNameField] || `action_${action.id}`;
+            const actionDir = join(actionsDir, folderName);
+            await fs.mkdir(actionDir, { recursive: true });
+            const strippedAction = { ...action };
+            if (action.code) {
+                delete strippedAction.code;
+            }
+            await fs.writeFile(join(actionDir, 'action.json'), JSON.stringify(strippedAction, null, 2));
+            if (action.code) {
+                await fs.writeFile(join(actionDir, 'code.bfy'), action.code);
+            }
+            const relatedSpecs = actionSpecs.filter(spec => spec.bfy_sm_action_id === action.id);
+            if (relatedSpecs.length > 0) {
+                const specsDir = join(actionDir, 'specs');
+                await fs.mkdir(specsDir, { recursive: true });
+                for (const spec of relatedSpecs) {
+                    const specName = spec.name || `spec_${spec.id}`;
+                    const specDir = join(specsDir, specName);
+                    await fs.mkdir(specDir, { recursive: true });
+                    const mappings = getFieldMapping(spec);
+                    const strippedSpec = stripExportedFields(spec, mappings);
+                    await fs.writeFile(join(specDir, 'spec.json'), JSON.stringify(strippedSpec, null, 2));
+                    await exportSpecFiles(specDir, spec);
+                }
+            }
+        }
+    }
+    if (transitionActions && transitionActions.length > 0) {
+        const transitionActionsDir = join(stateMachineDir, 'transition_actions');
+        await fs.mkdir(transitionActionsDir, { recursive: true });
+        for (const mapping of transitionActions) {
+            const fileName = `${mapping.bfy_state_machine_transition_id}_${mapping.bfy_sm_action_id}.json`;
+            await fs.writeFile(join(transitionActionsDir, fileName), JSON.stringify(mapping, null, 2));
+        }
+    }
+}
+export async function saveWorkflowData(outputPath, workflow, versions, nodes, connections) {
+    const config = TABLE_CONFIGS.bfy_workflows;
+    const folderName = workflow[config.folderNameField] || `workflow_${workflow.id}`;
+    const workflowDir = join(outputPath, 'bfy_workflows', folderName);
+    await fs.mkdir(workflowDir, { recursive: true });
+    await fs.writeFile(join(workflowDir, 'workflow.json'), JSON.stringify(workflow, null, 2));
+    if (versions && versions.length > 0) {
+        for (const version of versions) {
+            const versionFolderName = `v${version.version_number}`;
+            const versionDir = join(workflowDir, versionFolderName);
+            await fs.mkdir(versionDir, { recursive: true });
+            await fs.writeFile(join(versionDir, 'version.json'), JSON.stringify(version, null, 2));
+            const versionNodes = nodes.filter(n => n.bfy_workflow_version_id === version.id);
+            if (versionNodes.length > 0) {
+                const nodesDir = join(versionDir, 'nodes');
+                await fs.mkdir(nodesDir, { recursive: true });
+                for (const node of versionNodes) {
+                    const nodeTitle = node.title || node.name || 'node';
+                    const nodeFolderName = `${String(nodeTitle).replace(/[^a-zA-Z0-9-_]/g, '_')}_${node.id}`;
+                    const nodeDir = join(nodesDir, nodeFolderName);
+                    await fs.mkdir(nodeDir, { recursive: true });
+                    const strippedNode = { ...node };
+                    if (node.code) {
+                        delete strippedNode.code;
+                    }
+                    if (node.params) {
+                        delete strippedNode.params;
+                    }
+                    await fs.writeFile(join(nodeDir, 'node.json'), JSON.stringify(strippedNode, null, 2));
+                    if (node.code) {
+                        await fs.writeFile(join(nodeDir, 'code.bfy'), node.code);
+                    }
+                    if (node.params) {
+                        let paramsData = node.params;
+                        if (typeof paramsData === 'string') {
+                            try {
+                                paramsData = JSON.parse(paramsData);
+                            }
+                            catch {
+                            }
+                        }
+                        if (paramsData && typeof paramsData === 'object' && !Array.isArray(paramsData)) {
+                            if (paramsData.code) {
+                                if (!node.code) {
+                                    await fs.writeFile(join(nodeDir, 'code.bfy'), paramsData.code);
+                                }
+                                const { code: _code, ...paramsWithoutCode } = paramsData;
+                                paramsData = paramsWithoutCode;
+                            }
+                        }
+                        if (paramsData && typeof paramsData === 'object' && Object.keys(paramsData).length > 0) {
+                            const yamlContent = yamlStringify(paramsData);
+                            await fs.writeFile(join(nodeDir, 'params.yaml'), yamlContent);
+                        }
+                    }
+                }
+            }
+            const versionNodeIds = versionNodes.map(n => n.id);
+            const versionConnections = connections.filter(c => versionNodeIds.includes(c.source_node_id) || versionNodeIds.includes(c.target_node_id));
+            if (versionConnections.length > 0) {
+                await fs.writeFile(join(versionDir, 'connections.json'), JSON.stringify(versionConnections, null, 2));
+            }
+        }
+    }
+}
+//# sourceMappingURL=files.js.map