@rglabs/butterfly 2.0.1

package/dist/utils/resourceMapping.d.ts

@@ -0,0 +1,32 @@
+export interface ResourceConfig {
+    downloadType: string;
+    displayName: string;
+    isCore: true;
+}
+export interface SubEntityConfig {
+    parentTable: string;
+    foreignKey: string;
+    displayName: string;
+    isCore: false;
+}
+export type TableConfig = ResourceConfig | SubEntityConfig;
+export declare const CORE_TABLES: Record<string, ResourceConfig>;
+export declare const SUB_ENTITY_TABLES: Record<string, SubEntityConfig>;
+export declare const TABLE_CONFIG: Record<string, TableConfig>;
+export declare function isCoreTable(tableName: string): boolean;
+export declare function isSubEntity(tableName: string): boolean;
+export declare function getTableConfig(tableName: string): TableConfig | undefined;
+export declare function getRootParentInfo(tableName: string): {
+    rootTable: string;
+    downloadType: string;
+    foreignKeyChain: Array<{
+        table: string;
+        foreignKey: string;
+    }>;
+} | null;
+export declare function getParentTable(tableName: string): string | null;
+export declare function getForeignKey(tableName: string): string | null;
+export declare function shouldAutoDownload(tableName: string): boolean;
+export declare function getCoreTableNames(): string[];
+export declare function getSubEntityTableNames(): string[];
+//# sourceMappingURL=resourceMapping.d.ts.map

package/dist/utils/resourceMapping.js

@@ -0,0 +1,210 @@
+export const CORE_TABLES = {
+    'objects': {
+        downloadType: 'objects',
+        displayName: 'Objects',
+        isCore: true,
+    },
+    'cms_reports': {
+        downloadType: 'reports',
+        displayName: 'Reports',
+        isCore: true,
+    },
+    'bfy_ai_tasks': {
+        downloadType: 'bfy_ai_tasks',
+        displayName: 'AI Tasks',
+        isCore: true,
+    },
+    'bfy_state_machines': {
+        downloadType: 'bfy_state_machines',
+        displayName: 'State Machines',
+        isCore: true,
+    },
+    'pages': {
+        downloadType: 'pages',
+        displayName: 'Pages',
+        isCore: true,
+    },
+    'bfy_cronjobs': {
+        downloadType: 'bfy_cronjobs',
+        displayName: 'Cron Jobs',
+        isCore: true,
+    },
+    'cms_email_templates': {
+        downloadType: 'cms_email_templates',
+        displayName: 'Email Templates',
+        isCore: true,
+    },
+    'pdf_templates': {
+        downloadType: 'pdf_templates',
+        displayName: 'PDF Templates',
+        isCore: true,
+    },
+    'cms_email_layouts': {
+        downloadType: 'cms_email_layouts',
+        displayName: 'Email Layouts',
+        isCore: true,
+    },
+    'bfy_workflows': {
+        downloadType: 'bfy_workflows',
+        displayName: 'Workflows',
+        isCore: true,
+    },
+    'webservices': {
+        downloadType: 'webservices',
+        displayName: 'Webservices',
+        isCore: true,
+    },
+};
+export const SUB_ENTITY_TABLES = {
+    'object_specs': {
+        parentTable: 'objects',
+        foreignKey: 'object_id',
+        displayName: 'Object Specs',
+        isCore: false,
+    },
+    'cms_report_specs': {
+        parentTable: 'cms_reports',
+        foreignKey: 'cms_report_id',
+        displayName: 'Report Specs',
+        isCore: false,
+    },
+    'cms_report_queries': {
+        parentTable: 'cms_reports',
+        foreignKey: 'cms_report_id',
+        displayName: 'Report Queries',
+        isCore: false,
+    },
+    'cms_report_categories': {
+        parentTable: 'cms_reports',
+        foreignKey: 'cms_report_id',
+        displayName: 'Report Categories',
+        isCore: false,
+    },
+    'bfy_state_machine_states': {
+        parentTable: 'bfy_state_machines',
+        foreignKey: 'bfy_state_machine_id',
+        displayName: 'State Machine States',
+        isCore: false,
+    },
+    'bfy_state_machine_roles': {
+        parentTable: 'bfy_state_machines',
+        foreignKey: 'bfy_state_machine_id',
+        displayName: 'State Machine Roles',
+        isCore: false,
+    },
+    'bfy_state_machine_transitions': {
+        parentTable: 'bfy_state_machines',
+        foreignKey: 'bfy_state_machine_id',
+        displayName: 'State Machine Transitions',
+        isCore: false,
+    },
+    'bfy_state_machine_transition_specs': {
+        parentTable: 'bfy_state_machine_transitions',
+        foreignKey: 'bfy_state_machine_transition_id',
+        displayName: 'Transition Specs',
+        isCore: false,
+    },
+    'bfy_sm_actions': {
+        parentTable: 'bfy_state_machines',
+        foreignKey: 'bfy_state_machine_id',
+        displayName: 'State Machine Actions',
+        isCore: false,
+    },
+    'bfy_sm_action_specs': {
+        parentTable: 'bfy_sm_actions',
+        foreignKey: 'bfy_sm_action_id',
+        displayName: 'Action Specs',
+        isCore: false,
+    },
+    'bfy_sm_transition_actions': {
+        parentTable: 'bfy_state_machine_transitions',
+        foreignKey: 'bfy_state_machine_transition_id',
+        displayName: 'Transition Actions',
+        isCore: false,
+    },
+    'bfy_workflow_versions': {
+        parentTable: 'bfy_workflows',
+        foreignKey: 'bfy_workflow_id',
+        displayName: 'Workflow Versions',
+        isCore: false,
+    },
+    'bfy_workflow_nodes': {
+        parentTable: 'bfy_workflow_versions',
+        foreignKey: 'bfy_workflow_version_id',
+        displayName: 'Workflow Nodes',
+        isCore: false,
+    },
+    'bfy_workflow_connections': {
+        parentTable: 'bfy_workflow_nodes',
+        foreignKey: 'source_node_id',
+        displayName: 'Workflow Connections',
+        isCore: false,
+    },
+};
+export const TABLE_CONFIG = {
+    ...CORE_TABLES,
+    ...SUB_ENTITY_TABLES,
+};
+export function isCoreTable(tableName) {
+    return tableName in CORE_TABLES;
+}
+export function isSubEntity(tableName) {
+    return tableName in SUB_ENTITY_TABLES;
+}
+export function getTableConfig(tableName) {
+    return TABLE_CONFIG[tableName];
+}
+export function getRootParentInfo(tableName) {
+    if (isCoreTable(tableName)) {
+        const config = CORE_TABLES[tableName];
+        return {
+            rootTable: tableName,
+            downloadType: config.downloadType,
+            foreignKeyChain: [],
+        };
+    }
+    if (!isSubEntity(tableName)) {
+        return null;
+    }
+    const chain = [];
+    let currentTable = tableName;
+    while (isSubEntity(currentTable)) {
+        const config = SUB_ENTITY_TABLES[currentTable];
+        chain.push({
+            table: currentTable,
+            foreignKey: config.foreignKey,
+        });
+        currentTable = config.parentTable;
+    }
+    if (isCoreTable(currentTable)) {
+        const coreConfig = CORE_TABLES[currentTable];
+        return {
+            rootTable: currentTable,
+            downloadType: coreConfig.downloadType,
+            foreignKeyChain: chain,
+        };
+    }
+    return null;
+}
+export function getParentTable(tableName) {
+    if (isSubEntity(tableName)) {
+        return SUB_ENTITY_TABLES[tableName].parentTable;
+    }
+    return null;
+}
+export function getForeignKey(tableName) {
+    if (isSubEntity(tableName)) {
+        return SUB_ENTITY_TABLES[tableName].foreignKey;
+    }
+    return null;
+}
+export function shouldAutoDownload(tableName) {
+    return isCoreTable(tableName) || isSubEntity(tableName);
+}
+export function getCoreTableNames() {
+    return Object.keys(CORE_TABLES);
+}
+export function getSubEntityTableNames() {
+    return Object.keys(SUB_ENTITY_TABLES);
+}
+//# sourceMappingURL=resourceMapping.js.map

package/dist/utils/singleResourceDownload.d.ts

@@ -0,0 +1,14 @@
+import { ButterflyAPI } from './api.js';
+interface DownloadResult {
+    success: boolean;
+    message: string;
+    downloadedResource?: {
+        type: string;
+        id: number;
+        name?: string;
+    };
+}
+export declare function downloadSingleResource(api: ButterflyAPI, outputPath: string, tableName: string, recordId: number, recordData?: Record<string, any>): Promise<DownloadResult>;
+export declare function shouldTriggerDownload(tableName: string): boolean;
+export {};
+//# sourceMappingURL=singleResourceDownload.d.ts.map

package/dist/utils/singleResourceDownload.js

@@ -0,0 +1,261 @@
+import { saveObjectWithSpecs, saveReportData, saveAiTask, saveTableRecord, saveStateMachineData, saveWorkflowData, } from './files.js';
+import { isCoreTable, isSubEntity, getRootParentInfo, SUB_ENTITY_TABLES, CORE_TABLES, } from './resourceMapping.js';
+async function resolveToRootParentId(api, tableName, recordId, recordData) {
+    const rootInfo = getRootParentInfo(tableName);
+    if (!rootInfo) {
+        return null;
+    }
+    if (isCoreTable(tableName)) {
+        return {
+            rootTable: tableName,
+            rootId: recordId,
+            downloadType: rootInfo.downloadType,
+        };
+    }
+    let currentTable = tableName;
+    let currentId = recordId;
+    let currentData = recordData;
+    while (isSubEntity(currentTable)) {
+        const subEntityConfig = SUB_ENTITY_TABLES[currentTable];
+        const foreignKey = subEntityConfig.foreignKey;
+        let parentId;
+        if (currentData && currentData[foreignKey]) {
+            parentId = currentData[foreignKey];
+        }
+        else {
+            const records = await api.fetchTableAdvanced(currentTable, {
+                column: 'id',
+                value: String(currentId),
+            });
+            if (records.length === 0) {
+                return null;
+            }
+            parentId = records[0][foreignKey];
+        }
+        if (!parentId) {
+            return null;
+        }
+        currentTable = subEntityConfig.parentTable;
+        currentId = parentId;
+        currentData = undefined;
+    }
+    if (isCoreTable(currentTable)) {
+        return {
+            rootTable: currentTable,
+            rootId: currentId,
+            downloadType: CORE_TABLES[currentTable].downloadType,
+        };
+    }
+    return null;
+}
+async function downloadSingleObject(api, outputPath, objectId) {
+    const objects = await api.fetchTableAdvanced('objects', {
+        column: 'id',
+        value: String(objectId),
+    });
+    if (objects.length === 0) {
+        return { success: false, message: `Object with ID ${objectId} not found` };
+    }
+    const object = objects[0];
+    const specs = await api.fetchTableAdvanced('object_specs', {
+        column: 'object_id',
+        value: String(objectId),
+    });
+    await saveObjectWithSpecs(outputPath, object.table_name, object, specs);
+    return {
+        success: true,
+        message: `Downloaded object: ${object.name} (${object.table_name})`,
+        downloadedResource: {
+            type: 'objects',
+            id: objectId,
+            name: object.table_name,
+        },
+    };
+}
+async function downloadSingleReport(api, outputPath, reportId) {
+    const reports = await api.fetchTableAdvanced('cms_reports', {
+        column: 'id',
+        value: String(reportId),
+    });
+    if (reports.length === 0) {
+        return { success: false, message: `Report with ID ${reportId} not found` };
+    }
+    const report = reports[0];
+    const [specs, queries, categories] = await Promise.all([
+        api.fetchTableAdvanced('cms_report_specs', {
+            column: 'cms_report_id',
+            value: String(reportId),
+        }),
+        api.fetchTableAdvanced('cms_report_queries', {
+            column: 'cms_report_id',
+            value: String(reportId),
+        }),
+        api.fetchTable('cms_report_categories'),
+    ]);
+    await saveReportData(outputPath, report, specs, queries, categories);
+    return {
+        success: true,
+        message: `Downloaded report: ${report.name || report.alias}`,
+        downloadedResource: {
+            type: 'reports',
+            id: reportId,
+            name: report.alias || report.name,
+        },
+    };
+}
+async function downloadSingleStateMachine(api, outputPath, stateMachineId) {
+    const [stateMachines, allStates, allRoles, allTransitions, allTransitionSpecs, allActions, allActionSpecs, allTransitionActions,] = await Promise.all([
+        api.fetchTableAdvanced('bfy_state_machines', {
+            column: 'id',
+            value: String(stateMachineId),
+        }),
+        api.fetchTableAdvanced('bfy_state_machine_states', {
+            column: 'bfy_state_machine_id',
+            value: String(stateMachineId),
+        }),
+        api.fetchTableAdvanced('bfy_state_machine_roles', {
+            column: 'bfy_state_machine_id',
+            value: String(stateMachineId),
+        }),
+        api.fetchTableAdvanced('bfy_state_machine_transitions', {
+            column: 'bfy_state_machine_id',
+            value: String(stateMachineId),
+        }),
+        api.fetchTable('bfy_state_machine_transition_specs'),
+        api.fetchTableAdvanced('bfy_sm_actions', {
+            column: 'bfy_state_machine_id',
+            value: String(stateMachineId),
+        }),
+        api.fetchTable('bfy_sm_action_specs'),
+        api.fetchTable('bfy_sm_transition_actions'),
+    ]);
+    if (stateMachines.length === 0) {
+        return {
+            success: false,
+            message: `State machine with ID ${stateMachineId} not found`,
+        };
+    }
+    const stateMachine = stateMachines[0];
+    const transitionIds = allTransitions.map((t) => t.id);
+    const actionIds = allActions.map((a) => a.id);
+    const relatedTransitionSpecs = allTransitionSpecs.filter((spec) => transitionIds.includes(spec.bfy_state_machine_transition_id));
+    const relatedActionSpecs = allActionSpecs.filter((spec) => actionIds.includes(spec.bfy_sm_action_id));
+    const relatedTransitionActions = allTransitionActions.filter((ta) => transitionIds.includes(ta.bfy_state_machine_transition_id) &&
+        actionIds.includes(ta.bfy_sm_action_id));
+    await saveStateMachineData(outputPath, stateMachine, allStates, allRoles, allTransitions, relatedTransitionSpecs, allActions, relatedActionSpecs, relatedTransitionActions);
+    return {
+        success: true,
+        message: `Downloaded state machine: ${stateMachine.name}`,
+        downloadedResource: {
+            type: 'bfy_state_machines',
+            id: stateMachineId,
+            name: stateMachine.name,
+        },
+    };
+}
+async function downloadSingleWorkflow(api, outputPath, workflowId) {
+    const [workflows, allVersions, allNodes, allConnections] = await Promise.all([
+        api.fetchTableAdvanced('bfy_workflows', {
+            column: 'id',
+            value: String(workflowId),
+        }),
+        api.fetchTableAdvanced('bfy_workflow_versions', {
+            column: 'bfy_workflow_id',
+            value: String(workflowId),
+        }),
+        api.fetchTable('bfy_workflow_nodes'),
+        api.fetchTable('bfy_workflow_connections'),
+    ]);
+    if (workflows.length === 0) {
+        return { success: false, message: `Workflow with ID ${workflowId} not found` };
+    }
+    const workflow = workflows[0];
+    const versionIds = allVersions.map((v) => v.id);
+    const relatedNodes = allNodes.filter((n) => versionIds.includes(n.bfy_workflow_version_id));
+    const nodeIds = relatedNodes.map((n) => n.id);
+    const relatedConnections = allConnections.filter((c) => nodeIds.includes(c.source_node_id) || nodeIds.includes(c.target_node_id));
+    await saveWorkflowData(outputPath, workflow, allVersions, relatedNodes, relatedConnections);
+    return {
+        success: true,
+        message: `Downloaded workflow: ${workflow.name}`,
+        downloadedResource: {
+            type: 'bfy_workflows',
+            id: workflowId,
+            name: workflow.name,
+        },
+    };
+}
+async function downloadSingleTableRecord(api, outputPath, tableName, recordId) {
+    const records = await api.fetchTableAdvanced(tableName, {
+        column: 'id',
+        value: String(recordId),
+    });
+    if (records.length === 0) {
+        return {
+            success: false,
+            message: `Record with ID ${recordId} not found in ${tableName}`,
+        };
+    }
+    const record = records[0];
+    if (tableName === 'bfy_ai_tasks') {
+        await saveAiTask(outputPath, record);
+    }
+    else {
+        await saveTableRecord(outputPath, tableName, record);
+    }
+    const nameField = record.name || record.system_name || record.title || record.alias;
+    return {
+        success: true,
+        message: `Downloaded ${tableName}: ${nameField || `ID ${recordId}`}`,
+        downloadedResource: {
+            type: tableName,
+            id: recordId,
+            name: nameField,
+        },
+    };
+}
+export async function downloadSingleResource(api, outputPath, tableName, recordId, recordData) {
+    try {
+        const resolved = await resolveToRootParentId(api, tableName, recordId, recordData);
+        if (!resolved) {
+            return {
+                success: true,
+                message: `Table ${tableName} is not a tracked resource, skipping download`,
+            };
+        }
+        const { rootTable, rootId, downloadType } = resolved;
+        switch (downloadType) {
+            case 'objects':
+                return await downloadSingleObject(api, outputPath, rootId);
+            case 'reports':
+                return await downloadSingleReport(api, outputPath, rootId);
+            case 'bfy_state_machines':
+                return await downloadSingleStateMachine(api, outputPath, rootId);
+            case 'bfy_workflows':
+                return await downloadSingleWorkflow(api, outputPath, rootId);
+            case 'bfy_ai_tasks':
+            case 'pages':
+            case 'bfy_cronjobs':
+            case 'cms_email_templates':
+            case 'pdf_templates':
+            case 'cms_email_layouts':
+            case 'webservices':
+                return await downloadSingleTableRecord(api, outputPath, rootTable, rootId);
+            default:
+                return {
+                    success: false,
+                    message: `Unknown download type: ${downloadType}`,
+                };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: error instanceof Error ? error.message : 'Unknown error during download',
+        };
+    }
+}
+export function shouldTriggerDownload(tableName) {
+    return isCoreTable(tableName) || isSubEntity(tableName);
+}
+//# sourceMappingURL=singleResourceDownload.js.map

package/dist/utils/summaryGenerator.d.ts

@@ -0,0 +1,2 @@
+export declare function generateTableSummary(outputPath: string): Promise<void>;
+//# sourceMappingURL=summaryGenerator.d.ts.map