@rglabs/butterfly 2.0.1

package/dist/utils/summaryGenerator.js

@@ -0,0 +1,183 @@
+import { join } from 'path';
+import { readdir, readFile, writeFile, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+function parseFieldConfig(fieldType, val1, val3) {
+    const result = { val1, val3 };
+    if (!val1)
+        return result;
+    if (fieldType === 'from_list') {
+        if (val1.includes('|') && val1.includes(':')) {
+            result.options = val1;
+        }
+        return result;
+    }
+    if (fieldType === 'dropdown' || fieldType == 'autocomplete') {
+        result.sourceTable = val1;
+        if (val3) {
+            result.displayColumn = val3;
+        }
+        return result;
+    }
+    return result;
+}
+function formatColumnType(spec) {
+    const baseType = spec.type || 'text';
+    switch (baseType) {
+        case 'from_list':
+        case 'autocomplete':
+        case 'dropdown':
+            const dropdownConfig = parseFieldConfig(spec.type, spec.val_1, spec.val_3);
+            return {
+                type: baseType,
+                dropdownConfig
+            };
+        case 'custom':
+            return { type: 'custom field' };
+        case 'nested':
+            return { type: 'structured data' };
+        case 'calculated':
+            return { type: 'calculated' };
+        case 'textarea':
+            return { type: 'text area' };
+        default:
+            return { type: baseType };
+    }
+}
+async function parseObjectDirectory(objectPath) {
+    try {
+        const objectJsonPath = join(objectPath, 'object.json');
+        if (!existsSync(objectJsonPath))
+            return null;
+        const objectData = JSON.parse(await readFile(objectJsonPath, 'utf-8'));
+        const columns = [];
+        const items = await readdir(objectPath, { withFileTypes: true });
+        const specDirs = items.filter(item => item.isDirectory());
+        for (const specDir of specDirs) {
+            const specPath = join(objectPath, specDir.name, 'spec.json');
+            if (existsSync(specPath)) {
+                const specData = JSON.parse(await readFile(specPath, 'utf-8'));
+                const { type, dropdownConfig } = formatColumnType(specData);
+                columns.push({
+                    columnName: specData.column_name || specDir.name,
+                    name: specData.name || specDir.name,
+                    type,
+                    required: Boolean(specData.required),
+                    description: specData.description,
+                    dropdownConfig
+                });
+            }
+        }
+        columns.sort((a, b) => {
+            return a.columnName.localeCompare(b.columnName);
+        });
+        return {
+            tableName: objectData.table_name,
+            name: objectData.name || objectData.table_name,
+            description: objectData.description,
+            isCmsObject: Boolean(objectData.is_cms_object),
+            databaseAlias: objectData.database_alias,
+            columns
+        };
+    }
+    catch (error) {
+        console.error(`Error parsing object directory ${objectPath}:`, error);
+        return null;
+    }
+}
+function generateObjectMarkdown(obj) {
+    let markdown = `# ${obj.name}\n\n`;
+    markdown += `**Table Name:** ${obj.tableName}\n\n`;
+    if (obj.description) {
+        markdown += `**Description:** ${obj.description}\n\n`;
+    }
+    if (obj.databaseAlias) {
+        markdown += `**Database Alias:** ${obj.databaseAlias}\n\n`;
+    }
+    markdown += '## Columns\n\n';
+    markdown += '| Column | Type | Required | Details |\n';
+    markdown += '|--------|------|----------|----------|\n';
+    obj.columns.forEach(col => {
+        let details = '';
+        if (col.dropdownConfig) {
+            const parts = [];
+            if (col.dropdownConfig.options) {
+                parts.push(`Options: ${col.dropdownConfig.options}`);
+            }
+            if (col.dropdownConfig.sourceTable) {
+                parts.push(`Source Table: ${col.dropdownConfig.sourceTable}`);
+            }
+            if (col.dropdownConfig.displayColumn) {
+                parts.push(`Display Column: ${col.dropdownConfig.displayColumn}`);
+            }
+            if (col.dropdownConfig.valueColumns) {
+                parts.push(`Value Columns: ${col.dropdownConfig.valueColumns.join(', ')}`);
+            }
+            details = parts.join(' | ');
+        }
+        if (col.description && !details) {
+            details = col.description;
+        }
+        markdown += `| ${col.columnName} | ${col.type} | ${col.required ? 'Yes' : 'No'} | ${details} |\n`;
+    });
+    return markdown;
+}
+function generateMarkdownSummary(objects) {
+    const appObjects = objects.filter(obj => !obj.isCmsObject);
+    const cmsObjects = objects.filter(obj => obj.isCmsObject);
+    let markdown = '# Database Tables Summary\n\n';
+    markdown += `Generated on: ${new Date().toISOString()}\n\n`;
+    if (appObjects.length > 0) {
+        markdown += '## Application Tables\n\n';
+        appObjects.forEach(obj => {
+            markdown += `- [${obj.name}](./docs/app/${obj.tableName}.md) (${obj.tableName})\n`;
+        });
+        markdown += '\n';
+    }
+    if (cmsObjects.length > 0) {
+        markdown += '## CMS/Core Tables\n\n';
+        cmsObjects.forEach(obj => {
+            markdown += `- [${obj.name}](./docs/butterfly/${obj.tableName}.md) (${obj.tableName})\n`;
+        });
+        markdown += '\n';
+    }
+    return markdown;
+}
+export async function generateTableSummary(outputPath) {
+    const objectsPath = join(outputPath, 'objects');
+    if (!existsSync(objectsPath)) {
+        console.log('No objects directory found, skipping summary generation');
+        return;
+    }
+    const objects = [];
+    const docsPath = join(outputPath, 'docs');
+    const appDocsPath = join(docsPath, 'app');
+    const butterflyDocsPath = join(docsPath, 'butterfly');
+    await mkdir(docsPath, { recursive: true });
+    await mkdir(appDocsPath, { recursive: true });
+    await mkdir(butterflyDocsPath, { recursive: true });
+    const subdirs = await readdir(objectsPath, { withFileTypes: true });
+    for (const subdir of subdirs.filter(item => item.isDirectory())) {
+        const subdirPath = join(objectsPath, subdir.name);
+        const tableItems = await readdir(subdirPath, { withFileTypes: true });
+        for (const item of tableItems.filter(item => item.isDirectory())) {
+            const objectSummary = await parseObjectDirectory(join(subdirPath, item.name));
+            if (objectSummary) {
+                objects.push(objectSummary);
+                const targetDocsPath = objectSummary.isCmsObject ? butterflyDocsPath : appDocsPath;
+                const objectMarkdown = generateObjectMarkdown(objectSummary);
+                const objectMdPath = join(targetDocsPath, `${objectSummary.tableName}.md`);
+                await writeFile(objectMdPath, objectMarkdown, 'utf-8');
+            }
+        }
+    }
+    if (objects.length === 0) {
+        console.log('No objects found to summarize');
+        return;
+    }
+    const markdown = generateMarkdownSummary(objects);
+    const summaryPath = join(outputPath, 'tables-summary.md');
+    await writeFile(summaryPath, markdown, 'utf-8');
+    console.log(`\nTable summary generated: ${summaryPath}`);
+    console.log(`Individual object docs created in: ${docsPath}`);
+}
+//# sourceMappingURL=summaryGenerator.js.map

package/dist/utils/uploadHandler.d.ts

@@ -0,0 +1,31 @@
+import { ButterflyAPI } from './api.js';
+export interface UploadResult {
+    success: boolean;
+    message: string;
+    resourceId?: number;
+}
+export interface UploadOptions {
+    onProgress?: (message: string, type: 'info' | 'success' | 'error') => void;
+}
+export declare class UploadHandler {
+    private api;
+    private options;
+    constructor(api: ButterflyAPI, options?: UploadOptions);
+    private log;
+    private handleResult;
+    private getContainerFileIfPartFile;
+    uploadFile(filePath: string): Promise<UploadResult>;
+    private handleWorkflowFile;
+    private handleWebserviceFile;
+    private handlePdfTemplateFile;
+    private handleCronjobFile;
+    private handleEmailTemplateFile;
+    private handleEmailLayoutFile;
+    private handleObjectFile;
+    private handlePageFile;
+    private handleStateMachineFile;
+    private handleAiTaskFile;
+    private handleReportFile;
+    private handleTranslationFile;
+}
+//# sourceMappingURL=uploadHandler.d.ts.map

package/dist/utils/uploadHandler.js

@@ -0,0 +1,263 @@
+import { basename, normalize } from 'path';
+import { promises as fs } from 'fs';
+import { getContainerPathFromPartFile } from './bfySplitter.js';
+import { handleWorkflowJson, handleWorkflowVersionJson, handleWorkflowNodeJson, handleWorkflowNodeCode, handleWorkflowNodeParams, handleWorkflowConnections, handleWebserviceJson, handleWebservicePageCode, handlePdfTemplateJson, handlePdfTemplateTwig, handleCronjobJson, handleCronjobCode, handleEmailTemplateJson, handleEmailTemplateBfy, handleEmailLayoutJson, handleEmailLayoutBfy, handleObjectJson, handleObjectSpecJson, handleObjectListingQuery, handleObjectSpecCodeFile, handlePageJson, handleStateMachineJson, handleStateMachineStateJson, handleStateMachineRoleJson, handleStateMachineRoleCode, handleStateMachineTransitionJson, handleStateMachineTransitionCode, handleStateMachineActionJson, handleStateMachineActionCode, handleTransitionActionJson, handleStateMachineSpecJson, handleAiTaskJson, handleAiTaskCodeFile, handleReportJson, handleReportSpecJson, handleReportSpecCode, handleReportQueryJson, handleReportQueryCode, handleReportMainQuery, handleTranslationYaml, } from './resourceHandlers.js';
+const AI_TASK_FILE_MAPPINGS = {
+    'prompt.bfy': 'prompt',
+    'output_format.json': 'output_format',
+    'system_message.bfy': 'system_message',
+    'action_code.bfy': 'action_code',
+    'action_preview_code.bfy': 'action_preview_code',
+    'initial_code.bfy': 'initial_code'
+};
+const OBJECT_SPEC_CODE_FILES = [
+    'code.bfy', 'template_code.bfy', 'processing_code.bfy',
+    'filter_code.bfy', 'configuration.yaml', 'code.js', 'style.css'
+];
+export class UploadHandler {
+    api;
+    options;
+    constructor(api, options = {}) {
+        this.api = api;
+        this.options = options;
+    }
+    log(message, type = 'info') {
+        if (this.options.onProgress) {
+            this.options.onProgress(message, type);
+        }
+    }
+    handleResult(result) {
+        this.log(result.success ? `✓ ${result.message}` : `✗ ${result.message}`, result.success ? 'success' : 'error');
+        return result;
+    }
+    async getContainerFileIfPartFile(filePath) {
+        if (!filePath.endsWith('.bfy')) {
+            return null;
+        }
+        const containerPath = getContainerPathFromPartFile(filePath);
+        if (!containerPath) {
+            return null;
+        }
+        try {
+            await fs.access(containerPath);
+            return containerPath;
+        }
+        catch {
+            return null;
+        }
+    }
+    async uploadFile(filePath) {
+        try {
+            const containerPath = await this.getContainerFileIfPartFile(filePath);
+            if (containerPath) {
+                this.log(`Part file detected, uploading container: ${basename(containerPath)}`, 'info');
+                filePath = containerPath;
+            }
+            const parts = filePath.split('/');
+            const resourcesIndex = parts.findIndex(part => part === 'butterfly-resources');
+            if (resourcesIndex === -1 || parts.length < resourcesIndex + 2) {
+                return { success: false, message: 'Invalid file path structure' };
+            }
+            const resourceType = parts[resourcesIndex + 1];
+            const fileName = basename(filePath);
+            const normalizedPath = normalize(filePath);
+            switch (resourceType) {
+                case 'bfy_workflows':
+                    return this.handleResult(await this.handleWorkflowFile(filePath, fileName, normalizedPath));
+                case 'webservices':
+                    return this.handleResult(await this.handleWebserviceFile(filePath, fileName));
+                case 'pdf_templates':
+                    return this.handleResult(await this.handlePdfTemplateFile(filePath, fileName));
+                case 'bfy_cronjobs':
+                    return this.handleResult(await this.handleCronjobFile(filePath, fileName));
+                case 'cms_email_templates':
+                    return this.handleResult(await this.handleEmailTemplateFile(filePath, fileName));
+                case 'cms_email_layouts':
+                    return this.handleResult(await this.handleEmailLayoutFile(filePath, fileName));
+                case 'objects':
+                    return this.handleResult(await this.handleObjectFile(filePath, fileName));
+                case 'pages':
+                    return this.handleResult(await this.handlePageFile(filePath, fileName));
+                case 'bfy_state_machines':
+                    return this.handleResult(await this.handleStateMachineFile(filePath, fileName, normalizedPath));
+                case 'bfy_ai_tasks':
+                    return this.handleResult(await this.handleAiTaskFile(filePath, fileName));
+                case 'reports':
+                    return this.handleResult(await this.handleReportFile(filePath, fileName, normalizedPath));
+                case 'translations':
+                    return this.handleResult(await this.handleTranslationFile(filePath, fileName));
+                default:
+                    return { success: false, message: `Unsupported resource type: ${resourceType}` };
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            this.log(`Error uploading file: ${message}`, 'error');
+            return { success: false, message };
+        }
+    }
+    async handleWorkflowFile(filePath, fileName, normalizedPath) {
+        if (fileName === 'workflow.json') {
+            return handleWorkflowJson(this.api, filePath);
+        }
+        else if (fileName === 'version.json') {
+            return handleWorkflowVersionJson(this.api, filePath);
+        }
+        else if (fileName === 'node.json') {
+            return handleWorkflowNodeJson(this.api, filePath);
+        }
+        else if (fileName === 'code.bfy' && normalizedPath.includes('/nodes/')) {
+            return handleWorkflowNodeCode(this.api, filePath);
+        }
+        else if (fileName === 'params.yaml' && normalizedPath.includes('/nodes/')) {
+            return handleWorkflowNodeParams(this.api, filePath);
+        }
+        else if (fileName === 'connections.json') {
+            return handleWorkflowConnections(this.api, filePath);
+        }
+        return { success: false, message: `Unsupported workflow file type: ${fileName}` };
+    }
+    async handleWebserviceFile(filePath, fileName) {
+        if (fileName === 'webservice.json') {
+            return handleWebserviceJson(this.api, filePath);
+        }
+        else if (fileName === 'page_code.bfy') {
+            return handleWebservicePageCode(this.api, filePath);
+        }
+        return { success: false, message: `Unsupported webservice file type: ${fileName}` };
+    }
+    async handlePdfTemplateFile(filePath, fileName) {
+        if (fileName === 'pdf_template.json') {
+            return handlePdfTemplateJson(this.api, filePath);
+        }
+        else if (fileName === 'template.twig') {
+            return handlePdfTemplateTwig(this.api, filePath);
+        }
+        return { success: false, message: `Unsupported PDF template file type: ${fileName}` };
+    }
+    async handleCronjobFile(filePath, fileName) {
+        if (fileName === 'cronjob.json') {
+            return handleCronjobJson(this.api, filePath);
+        }
+        else if (fileName === 'code.bfy') {
+            return handleCronjobCode(this.api, filePath);
+        }
+        return { success: false, message: `Unsupported cronjob file type: ${fileName}` };
+    }
+    async handleEmailTemplateFile(filePath, fileName) {
+        if (fileName === 'template.json') {
+            return handleEmailTemplateJson(this.api, filePath);
+        }
+        else if (fileName.endsWith('.bfy')) {
+            return handleEmailTemplateBfy(this.api, filePath);
+        }
+        return { success: false, message: `Unsupported email template file type: ${fileName}` };
+    }
+    async handleEmailLayoutFile(filePath, fileName) {
+        if (fileName === 'layout.json') {
+            return handleEmailLayoutJson(this.api, filePath);
+        }
+        else if (fileName.endsWith('.bfy')) {
+            return handleEmailLayoutBfy(this.api, filePath);
+        }
+        return { success: false, message: `Unsupported email layout file type: ${fileName}` };
+    }
+    async handleObjectFile(filePath, fileName) {
+        if (fileName === 'object.json') {
+            return handleObjectJson(this.api, filePath);
+        }
+        else if (fileName === 'spec.json') {
+            return handleObjectSpecJson(this.api, filePath);
+        }
+        else if (fileName === 'listing_query.bfy') {
+            return handleObjectListingQuery(this.api, filePath);
+        }
+        else if (OBJECT_SPEC_CODE_FILES.includes(fileName)) {
+            return handleObjectSpecCodeFile(this.api, filePath);
+        }
+        return { success: false, message: `Unsupported object file type: ${fileName}` };
+    }
+    async handlePageFile(filePath, fileName) {
+        if (fileName === 'page.json') {
+            return handlePageJson(this.api, filePath);
+        }
+        return { success: false, message: `Unsupported page file type: ${fileName}` };
+    }
+    async handleStateMachineFile(filePath, fileName, normalizedPath) {
+        if (fileName === 'state_machine.json') {
+            return handleStateMachineJson(this.api, filePath);
+        }
+        else if (normalizedPath.includes('/states/') && fileName === 'state.json') {
+            return handleStateMachineStateJson(this.api, filePath);
+        }
+        else if (normalizedPath.includes('/roles/') && fileName === 'role.json') {
+            return handleStateMachineRoleJson(this.api, filePath);
+        }
+        else if (normalizedPath.includes('/roles/') && fileName === 'validation_code.bfy') {
+            return handleStateMachineRoleCode(this.api, filePath);
+        }
+        else if (normalizedPath.includes('/transitions/') && fileName === 'transition.json') {
+            return handleStateMachineTransitionJson(this.api, filePath);
+        }
+        else if (normalizedPath.includes('/transitions/') && fileName === 'action_code.bfy') {
+            return handleStateMachineTransitionCode(this.api, filePath, 'action_code');
+        }
+        else if (normalizedPath.includes('/transitions/') && fileName === 'validation_code.bfy') {
+            return handleStateMachineTransitionCode(this.api, filePath, 'validation_code');
+        }
+        else if (normalizedPath.includes('/actions/') && fileName === 'action.json') {
+            return handleStateMachineActionJson(this.api, filePath);
+        }
+        else if (normalizedPath.includes('/actions/') && fileName === 'code.bfy') {
+            return handleStateMachineActionCode(this.api, filePath);
+        }
+        else if (normalizedPath.includes('/transition_actions/') && fileName.endsWith('.json')) {
+            return handleTransitionActionJson(this.api, filePath);
+        }
+        else if (normalizedPath.includes('/specs/') && fileName === 'spec.json') {
+            return handleStateMachineSpecJson(this.api, filePath);
+        }
+        return { success: false, message: `Unsupported state machine file type: ${fileName}` };
+    }
+    async handleAiTaskFile(filePath, fileName) {
+        if (fileName === 'task.json') {
+            return handleAiTaskJson(this.api, filePath);
+        }
+        const fieldName = AI_TASK_FILE_MAPPINGS[fileName];
+        if (fieldName) {
+            return handleAiTaskCodeFile(this.api, filePath, fieldName);
+        }
+        return { success: false, message: `Unsupported AI task file type: ${fileName}` };
+    }
+    async handleReportFile(filePath, fileName, normalizedPath) {
+        if (fileName === 'report.json') {
+            return handleReportJson(this.api, filePath);
+        }
+        else if (normalizedPath.includes('/specs/') && fileName === 'spec.json') {
+            return handleReportSpecJson(this.api, filePath);
+        }
+        else if (normalizedPath.includes('/specs/') && fileName === 'code.js') {
+            return handleReportSpecCode(this.api, filePath);
+        }
+        else if (normalizedPath.includes('/queries/') && fileName === 'query.json') {
+            return handleReportQueryJson(this.api, filePath);
+        }
+        else if (normalizedPath.includes('/queries/') && fileName === 'query_code.bfy') {
+            return handleReportQueryCode(this.api, filePath, 'query');
+        }
+        else if (normalizedPath.includes('/queries/') && fileName === 'script.js') {
+            return handleReportQueryCode(this.api, filePath, 'js_code');
+        }
+        else if (fileName === 'main_query.bfy') {
+            return handleReportMainQuery(this.api, filePath);
+        }
+        return { success: false, message: `Unsupported report file type: ${fileName}` };
+    }
+    async handleTranslationFile(filePath, fileName) {
+        if (fileName.endsWith('.yaml') || fileName.endsWith('.yml')) {
+            return handleTranslationYaml(this.api, filePath);
+        }
+        return { success: false, message: `Unsupported translation file type: ${fileName}` };
+    }
+}
+//# sourceMappingURL=uploadHandler.js.map

package/docs/AI_API.md

@@ -0,0 +1,93 @@
+# AI API Documentation
+
+## Endpoint
+
+```
+POST /admin/ai/gpt/chat
+```
+
+## Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `systemMessage` | string | AI instructions and output format |
+| `previousMessages` | array | Conversation context (optional) |
+| `task` | string | `bfy_ai_task` system_name (optional) |
+
+## JavaScript Usage
+
+### With Custom System Message
+
+```javascript
+rg_confirm_ajax_with_prompt({
+    url: '/admin/ai/gpt/chat',
+    title: 'Dialog Title',
+    text: 'Input placeholder',
+    data: {
+        systemMessage: 'You are an API. Respond in JSON: {"field": "value"}',
+        previousMessages: []
+    },
+    callback: function(data) {
+        console.log(data.message.field);
+    }
+});
+```
+
+### With Predefined Task
+
+```javascript
+$.post('/admin/ai/gpt/chat', {
+    task: 'task-system-name',
+    prompt: 'User input'
+}, function(data) {
+    if (data.success) {
+        console.log(data.message);
+    }
+});
+```
+
+## Twig Usage (Server-Side)
+
+```twig
+{% set response = ai()
+    .task('task-system-name')
+    .prompt('Generate something')
+    .execute()
+%}
+
+{# Or with custom system message #}
+{% set response = ai()
+    .systemMessage('Respond in JSON.')
+    .prompt('User input')
+    .execute()
+%}
+```
+
+## AI Task Structure (`bfy_ai_tasks`)
+
+Tasks stored in `butterfly-resources/bfy_ai_tasks/[system_name]/`:
+
+```
+[system-name]/
+├── task.json           # Metadata
+├── system_message.bfy  # AI instructions
+├── output_format.json  # Expected response schema
+├── action_code.bfy     # Post-response server action
+└── action_preview_code.bfy  # Preview template
+```
+
+### Key Task Fields
+
+| Field | Description |
+|-------|-------------|
+| `system_name` | Unique identifier |
+| `response_type` | `json` or `text` |
+| `system_message` | AI instructions |
+| `output_format` | JSON schema for response |
+
+## Helper Functions
+
+| Function | Description |
+|----------|-------------|
+| `rg_confirm_ajax_with_prompt({...})` | Show prompt dialog + AJAX |
+| `rG_Admin.getObjectSpec('field')` | Get field element |