@rglabs/butterfly 2.0.1

package/dist/components/RecordPreview.js

@@ -0,0 +1,91 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+function formatValue(value, maxLength = 100) {
+    if (value === null)
+        return '<null>';
+    if (value === undefined)
+        return '<undefined>';
+    if (typeof value === 'object') {
+        const json = JSON.stringify(value);
+        if (json.length > maxLength) {
+            return json.substring(0, maxLength) + `... (${json.length} chars)`;
+        }
+        return json;
+    }
+    const str = String(value);
+    if (str.length > maxLength) {
+        return str.substring(0, maxLength) + `... (${str.length} chars)`;
+    }
+    return str;
+}
+function getChanges(existingRecord, newData) {
+    const changes = [];
+    for (const [key, newValue] of Object.entries(newData)) {
+        if (key === 'id')
+            continue;
+        const oldValue = existingRecord[key];
+        if (JSON.stringify(oldValue) !== JSON.stringify(newValue)) {
+            changes.push({ field: key, oldValue, newValue });
+        }
+    }
+    return changes;
+}
+export const RecordPreview = ({ operation, table, data, existingRecord }) => {
+    const operationColors = {
+        get: 'cyan',
+        add: 'green',
+        edit: 'yellow',
+        delete: 'red'
+    };
+    const changes = operation === 'edit' && existingRecord
+        ? getChanges(existingRecord, data)
+        : null;
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true }, "Operation: "),
+            React.createElement(Text, { color: operationColors[operation], bold: true }, operation.toUpperCase())),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true }, "Table: "),
+            React.createElement(Text, { color: "cyan" }, table)),
+        data.id && (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true }, "Record ID: "),
+            React.createElement(Text, null, data.id))),
+        operation === 'add' && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+            React.createElement(Text, { bold: true, underline: true }, "New Record Data:"),
+            Object.entries(data).map(([key, value]) => (React.createElement(Box, { key: key, marginLeft: 2 },
+                React.createElement(Text, { color: "green" },
+                    "+ ",
+                    key,
+                    ": "),
+                React.createElement(Text, null, formatValue(value))))))),
+        operation === 'edit' && changes && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+            React.createElement(Text, { bold: true, underline: true }, "Changes:"),
+            changes.length === 0 ? (React.createElement(Box, { marginLeft: 2 },
+                React.createElement(Text, { color: "gray" }, "No changes detected"))) : (changes.map(({ field, oldValue, newValue }) => (React.createElement(Box, { key: field, flexDirection: "column", marginLeft: 2 },
+                React.createElement(Text, { bold: true },
+                    field,
+                    ":"),
+                React.createElement(Box, { marginLeft: 2 },
+                    React.createElement(Text, { color: "red" },
+                        "- ",
+                        formatValue(oldValue))),
+                React.createElement(Box, { marginLeft: 2 },
+                    React.createElement(Text, { color: "green" },
+                        "+ ",
+                        formatValue(newValue))))))))),
+        operation === 'delete' && existingRecord && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+            React.createElement(Text, { bold: true, underline: true, color: "red" }, "Record to Delete:"),
+            Object.entries(existingRecord).slice(0, 15).map(([key, value]) => (React.createElement(Box, { key: key, marginLeft: 2 },
+                React.createElement(Text, { color: "red" },
+                    "- ",
+                    key,
+                    ": "),
+                React.createElement(Text, null, formatValue(value))))),
+            Object.keys(existingRecord).length > 15 && (React.createElement(Box, { marginLeft: 2 },
+                React.createElement(Text, { color: "gray" },
+                    "... and ",
+                    Object.keys(existingRecord).length - 15,
+                    " more fields")))))));
+};
+export default RecordPreview;
+//# sourceMappingURL=RecordPreview.js.map

package/dist/components/SetupForm.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { AuthConfig } from '../types/index.js';
+interface SetupFormProps {
+    onSubmit: (config: AuthConfig) => void;
+}
+declare const SetupForm: React.FC<SetupFormProps>;
+export { SetupForm };
+//# sourceMappingURL=SetupForm.d.ts.map

package/dist/components/SetupForm.js

@@ -0,0 +1,56 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+const SetupForm = ({ onSubmit }) => {
+    const [step, setStep] = useState(0);
+    const [endpoint, setEndpoint] = useState('');
+    const [email, setEmail] = useState('');
+    const [password, setPassword] = useState('');
+    const [core, setCore] = useState(false);
+    const handleSubmit = () => {
+        if (step === 0 && endpoint) {
+            setStep(1);
+        }
+        else if (step === 1 && email) {
+            setStep(2);
+        }
+        else if (step === 2 && password) {
+            setStep(3);
+        }
+        else if (step === 3) {
+            onSubmit({ endpoint, email, password, core });
+        }
+    };
+    const handleCoreToggle = () => {
+        setCore(!core);
+    };
+    useInput((input, key) => {
+        if (step === 3) {
+            if (input === ' ') {
+                handleCoreToggle();
+            }
+            else if (key.return) {
+                handleSubmit();
+            }
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, { color: "green" }, "Butterfly CLI Setup"),
+        React.createElement(Text, null, " "),
+        step >= 0 && (React.createElement(Box, null,
+            React.createElement(Text, null, "Endpoint: "),
+            step === 0 ? (React.createElement(TextInput, { value: endpoint, onChange: setEndpoint, onSubmit: handleSubmit })) : (React.createElement(Text, { color: "cyan" }, endpoint)))),
+        step >= 1 && (React.createElement(Box, null,
+            React.createElement(Text, null, "Email: "),
+            step === 1 ? (React.createElement(TextInput, { value: email, onChange: setEmail, onSubmit: handleSubmit })) : (React.createElement(Text, { color: "cyan" }, email)))),
+        step >= 2 && (React.createElement(Box, null,
+            React.createElement(Text, null, "Password: "),
+            step === 2 ? (React.createElement(TextInput, { value: password, onChange: setPassword, onSubmit: handleSubmit, mask: "*" })) : (React.createElement(Text, { color: "cyan" }, '*'.repeat(password.length))))),
+        step >= 3 && (React.createElement(Box, null,
+            React.createElement(Text, null, "Enable Core Features: "),
+            React.createElement(Text, { color: core ? "green" : "gray" },
+                core ? "[✓] Yes" : "[ ] No",
+                React.createElement(Text, { color: "gray" }, " (Press space to toggle, enter to continue)"))))));
+};
+export { SetupForm };
+//# sourceMappingURL=SetupForm.js.map

package/dist/components/UploadProgress.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+interface UploadProgressProps {
+    current: number;
+    total: number;
+    currentFile: string;
+    status: 'uploading' | 'complete' | 'error';
+    error?: string;
+    succeeded?: number;
+    failed?: number;
+}
+declare const UploadProgress: React.FC<UploadProgressProps>;
+export { UploadProgress };
+//# sourceMappingURL=UploadProgress.d.ts.map

package/dist/components/UploadProgress.js

@@ -0,0 +1,42 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+const UploadProgress = ({ current, total, currentFile, status, error, succeeded = 0, failed = 0, }) => {
+    return (React.createElement(Box, null,
+        status === 'uploading' && (React.createElement(React.Fragment, null,
+            React.createElement(Text, { color: "cyan" },
+                React.createElement(Spinner, { type: "dots" })),
+            React.createElement(Text, null,
+                " Uploading (",
+                current,
+                "/",
+                total,
+                ")",
+                currentFile ? `: ${currentFile}` : ''))),
+        status === 'complete' && failed === 0 && (React.createElement(Text, { color: "green" },
+            "\u2713 Uploaded ",
+            succeeded,
+            " file",
+            succeeded !== 1 ? 's' : '')),
+        status === 'complete' && failed > 0 && succeeded > 0 && (React.createElement(Text, null,
+            React.createElement(Text, { color: "yellow" },
+                "\u26A0 Uploaded ",
+                succeeded,
+                " file",
+                succeeded !== 1 ? 's' : '',
+                ", "),
+            React.createElement(Text, { color: "red" },
+                failed,
+                " failed"))),
+        status === 'complete' && failed > 0 && succeeded === 0 && (React.createElement(Text, { color: "red" },
+            "\u2717 All ",
+            failed,
+            " upload",
+            failed !== 1 ? 's' : '',
+            " failed")),
+        status === 'error' && (React.createElement(Text, { color: "red" },
+            "\u2717 ",
+            error))));
+};
+export { UploadProgress };
+//# sourceMappingURL=UploadProgress.js.map

package/dist/diff/adapters/index.d.ts

@@ -0,0 +1,8 @@
+export { ResourceAdapter, LocalResource, RemoteResource } from './types.js';
+export { ObjectsAdapter } from './objectsAdapter.js';
+export { ReportsAdapter } from './reportsAdapter.js';
+import { ResourceAdapter } from './types.js';
+export declare function getAdapters(): Map<string, ResourceAdapter>;
+export declare function getAdapter(resourceType: string): ResourceAdapter | undefined;
+export declare function getSupportedTypes(): string[];
+//# sourceMappingURL=index.d.ts.map

package/dist/diff/adapters/index.js

@@ -0,0 +1,18 @@
+export { ObjectsAdapter } from './objectsAdapter.js';
+export { ReportsAdapter } from './reportsAdapter.js';
+import { ObjectsAdapter } from './objectsAdapter.js';
+import { ReportsAdapter } from './reportsAdapter.js';
+export function getAdapters() {
+    const adapters = new Map();
+    adapters.set('objects', new ObjectsAdapter());
+    adapters.set('reports', new ReportsAdapter());
+    return adapters;
+}
+export function getAdapter(resourceType) {
+    const adapters = getAdapters();
+    return adapters.get(resourceType);
+}
+export function getSupportedTypes() {
+    return Array.from(getAdapters().keys());
+}
+//# sourceMappingURL=index.js.map

package/dist/diff/adapters/objectsAdapter.d.ts

@@ -0,0 +1,13 @@
+import { ButterflyAPI } from '../../utils/api.js';
+import { ResourceAdapter, LocalResource, RemoteResource } from './types.js';
+import { ResourceDiff } from '../types.js';
+export declare class ObjectsAdapter implements ResourceAdapter {
+    readonly resourceType = "objects";
+    loadLocal(basePath: string): Promise<Map<number, LocalResource>>;
+    private loadLocalSpecs;
+    fetchRemote(api: ButterflyAPI): Promise<Map<number, RemoteResource>>;
+    compare(local: LocalResource | null, remote: RemoteResource | null, localPath?: string): ResourceDiff;
+    private compareSpecs;
+    getDisplayName(data: Record<string, any>): string;
+}
+//# sourceMappingURL=objectsAdapter.d.ts.map

package/dist/diff/adapters/objectsAdapter.js

@@ -0,0 +1,177 @@
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { restoreFieldsFromFiles } from '../../utils/files.js';
+import { compareFields } from '../types.js';
+export class ObjectsAdapter {
+    resourceType = 'objects';
+    async loadLocal(basePath) {
+        const objects = new Map();
+        const objectsPath = join(basePath, 'objects');
+        let subfolders = [];
+        try {
+            subfolders = await fs.readdir(objectsPath);
+        }
+        catch {
+            return objects;
+        }
+        for (const subfolder of subfolders) {
+            const subPath = join(objectsPath, subfolder);
+            let stat;
+            try {
+                stat = await fs.stat(subPath);
+            }
+            catch {
+                continue;
+            }
+            if (!stat.isDirectory())
+                continue;
+            let tables = [];
+            try {
+                tables = await fs.readdir(subPath);
+            }
+            catch {
+                continue;
+            }
+            for (const tableName of tables) {
+                const tablePath = join(subPath, tableName);
+                const objectJsonPath = join(tablePath, 'object.json');
+                try {
+                    const objectContent = await fs.readFile(objectJsonPath, 'utf-8');
+                    const objectData = JSON.parse(objectContent);
+                    const restored = await restoreFieldsFromFiles(tablePath, objectData);
+                    const specs = await this.loadLocalSpecs(tablePath);
+                    objects.set(restored.id, {
+                        main: restored,
+                        children: { specs },
+                        path: tablePath
+                    });
+                }
+                catch {
+                }
+            }
+        }
+        return objects;
+    }
+    async loadLocalSpecs(tablePath) {
+        const specs = [];
+        let entries = [];
+        try {
+            entries = await fs.readdir(tablePath);
+        }
+        catch {
+            return specs;
+        }
+        for (const entry of entries) {
+            if (entry === 'object.json' || entry === 'listing_query.bfy')
+                continue;
+            const entryPath = join(tablePath, entry);
+            let stat;
+            try {
+                stat = await fs.stat(entryPath);
+            }
+            catch {
+                continue;
+            }
+            if (!stat.isDirectory())
+                continue;
+            const specJsonPath = join(entryPath, 'spec.json');
+            try {
+                const specContent = await fs.readFile(specJsonPath, 'utf-8');
+                const specData = JSON.parse(specContent);
+                const restored = await restoreFieldsFromFiles(entryPath, specData);
+                specs.push(restored);
+            }
+            catch {
+            }
+        }
+        return specs;
+    }
+    async fetchRemote(api) {
+        const objects = new Map();
+        const allObjects = await api.fetchTable('objects');
+        const allSpecs = await api.fetchTable('object_specs');
+        const specsByObjectId = new Map();
+        for (const spec of allSpecs) {
+            const list = specsByObjectId.get(spec.object_id) || [];
+            list.push(spec);
+            specsByObjectId.set(spec.object_id, list);
+        }
+        for (const obj of allObjects) {
+            objects.set(obj.id, {
+                main: obj,
+                children: {
+                    specs: specsByObjectId.get(obj.id) || []
+                }
+            });
+        }
+        return objects;
+    }
+    compare(local, remote, localPath) {
+        const resourceId = local?.main?.id || remote?.main?.id || 0;
+        const resourceName = this.getDisplayName(local?.main || remote?.main || {});
+        let status;
+        if (!local && remote) {
+            status = 'remote_only';
+        }
+        else if (local && !remote) {
+            status = 'local_only';
+        }
+        else if (local && remote) {
+            const fieldDiffs = compareFields(local.main, remote.main);
+            status = fieldDiffs.length > 0 ? 'modified' : 'unchanged';
+        }
+        else {
+            status = 'unchanged';
+        }
+        const fieldDiffs = compareFields(local?.main || null, remote?.main || null);
+        const childDiffs = this.compareSpecs(local?.children?.specs || [], remote?.children?.specs || []);
+        if (childDiffs.length > 0 && status === 'unchanged') {
+            status = 'modified';
+        }
+        return {
+            resourceType: this.resourceType,
+            resourceName,
+            resourceId,
+            localPath: localPath || local?.path,
+            status,
+            fieldDiffs,
+            children: childDiffs
+        };
+    }
+    compareSpecs(localSpecs, remoteSpecs) {
+        const diffs = [];
+        const localById = new Map(localSpecs.map(s => [s.id, s]));
+        const remoteById = new Map(remoteSpecs.map(s => [s.id, s]));
+        const allIds = new Set([...localById.keys(), ...remoteById.keys()]);
+        for (const specId of allIds) {
+            const localSpec = localById.get(specId);
+            const remoteSpec = remoteById.get(specId);
+            let status;
+            if (!localSpec && remoteSpec) {
+                status = 'remote_only';
+            }
+            else if (localSpec && !remoteSpec) {
+                status = 'local_only';
+            }
+            else {
+                const fieldDiffs = compareFields(localSpec, remoteSpec);
+                status = fieldDiffs.length > 0 ? 'modified' : 'unchanged';
+            }
+            if (status !== 'unchanged') {
+                const specName = localSpec?.column_name || remoteSpec?.column_name || `spec_${specId}`;
+                diffs.push({
+                    resourceType: 'object_specs',
+                    resourceName: specName,
+                    resourceId: specId,
+                    status,
+                    fieldDiffs: compareFields(localSpec || null, remoteSpec || null)
+                });
+            }
+        }
+        return diffs;
+    }
+    getDisplayName(data) {
+        return data.table_name || data.name || `object_${data.id}`;
+    }
+}
+//# sourceMappingURL=objectsAdapter.js.map

package/dist/diff/adapters/reportsAdapter.d.ts

@@ -0,0 +1,14 @@
+import { ButterflyAPI } from '../../utils/api.js';
+import { ResourceAdapter, LocalResource, RemoteResource } from './types.js';
+import { ResourceDiff } from '../types.js';
+export declare class ReportsAdapter implements ResourceAdapter {
+    readonly resourceType = "reports";
+    loadLocal(basePath: string): Promise<Map<number, LocalResource>>;
+    private loadLocalQueries;
+    private loadLocalSpecs;
+    fetchRemote(api: ButterflyAPI): Promise<Map<number, RemoteResource>>;
+    compare(local: LocalResource | null, remote: RemoteResource | null, localPath?: string): ResourceDiff;
+    private compareChildren;
+    getDisplayName(data: Record<string, any>): string;
+}
+//# sourceMappingURL=reportsAdapter.d.ts.map

package/dist/diff/adapters/reportsAdapter.js

@@ -0,0 +1,212 @@
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { restoreFieldsFromFiles } from '../../utils/files.js';
+import { compareFields } from '../types.js';
+export class ReportsAdapter {
+    resourceType = 'reports';
+    async loadLocal(basePath) {
+        const reports = new Map();
+        const reportsPath = join(basePath, 'reports');
+        let reportFolders = [];
+        try {
+            reportFolders = await fs.readdir(reportsPath);
+        }
+        catch {
+            return reports;
+        }
+        for (const folder of reportFolders) {
+            if (folder === 'categories.json')
+                continue;
+            const reportPath = join(reportsPath, folder);
+            let stat;
+            try {
+                stat = await fs.stat(reportPath);
+            }
+            catch {
+                continue;
+            }
+            if (!stat.isDirectory())
+                continue;
+            const reportJsonPath = join(reportPath, 'report.json');
+            try {
+                const reportContent = await fs.readFile(reportJsonPath, 'utf-8');
+                const reportData = JSON.parse(reportContent);
+                const restored = await restoreFieldsFromFiles(reportPath, reportData);
+                const queries = await this.loadLocalQueries(reportPath);
+                const specs = await this.loadLocalSpecs(reportPath);
+                reports.set(restored.id, {
+                    main: restored,
+                    children: { queries, specs },
+                    path: reportPath
+                });
+            }
+            catch {
+            }
+        }
+        return reports;
+    }
+    async loadLocalQueries(reportPath) {
+        const queries = [];
+        const queriesPath = join(reportPath, 'queries');
+        let queryFolders = [];
+        try {
+            queryFolders = await fs.readdir(queriesPath);
+        }
+        catch {
+            return queries;
+        }
+        for (const folder of queryFolders) {
+            const queryPath = join(queriesPath, folder);
+            let stat;
+            try {
+                stat = await fs.stat(queryPath);
+            }
+            catch {
+                continue;
+            }
+            if (!stat.isDirectory())
+                continue;
+            const queryJsonPath = join(queryPath, 'query.json');
+            try {
+                const queryContent = await fs.readFile(queryJsonPath, 'utf-8');
+                const queryData = JSON.parse(queryContent);
+                const restored = await restoreFieldsFromFiles(queryPath, queryData);
+                queries.push(restored);
+            }
+            catch {
+            }
+        }
+        return queries;
+    }
+    async loadLocalSpecs(reportPath) {
+        const specs = [];
+        const specsPath = join(reportPath, 'specs');
+        let specFolders = [];
+        try {
+            specFolders = await fs.readdir(specsPath);
+        }
+        catch {
+            return specs;
+        }
+        for (const folder of specFolders) {
+            const specPath = join(specsPath, folder);
+            let stat;
+            try {
+                stat = await fs.stat(specPath);
+            }
+            catch {
+                continue;
+            }
+            if (!stat.isDirectory())
+                continue;
+            const specJsonPath = join(specPath, 'spec.json');
+            try {
+                const specContent = await fs.readFile(specJsonPath, 'utf-8');
+                const specData = JSON.parse(specContent);
+                const restored = await restoreFieldsFromFiles(specPath, specData);
+                specs.push(restored);
+            }
+            catch {
+            }
+        }
+        return specs;
+    }
+    async fetchRemote(api) {
+        const reports = new Map();
+        const allReports = await api.fetchTable('cms_reports');
+        const allSpecs = await api.fetchTable('cms_report_specs');
+        const allQueries = await api.fetchTable('cms_report_queries');
+        const specsByReportId = new Map();
+        for (const spec of allSpecs) {
+            const list = specsByReportId.get(spec.cms_report_id) || [];
+            list.push(spec);
+            specsByReportId.set(spec.cms_report_id, list);
+        }
+        const queriesByReportId = new Map();
+        for (const query of allQueries) {
+            const list = queriesByReportId.get(query.cms_report_id) || [];
+            list.push(query);
+            queriesByReportId.set(query.cms_report_id, list);
+        }
+        for (const report of allReports) {
+            reports.set(report.id, {
+                main: report,
+                children: {
+                    specs: specsByReportId.get(report.id) || [],
+                    queries: queriesByReportId.get(report.id) || []
+                }
+            });
+        }
+        return reports;
+    }
+    compare(local, remote, localPath) {
+        const resourceId = local?.main?.id || remote?.main?.id || 0;
+        const resourceName = this.getDisplayName(local?.main || remote?.main || {});
+        let status;
+        if (!local && remote) {
+            status = 'remote_only';
+        }
+        else if (local && !remote) {
+            status = 'local_only';
+        }
+        else if (local && remote) {
+            const fieldDiffs = compareFields(local.main, remote.main);
+            status = fieldDiffs.length > 0 ? 'modified' : 'unchanged';
+        }
+        else {
+            status = 'unchanged';
+        }
+        const fieldDiffs = compareFields(local?.main || null, remote?.main || null);
+        const queryDiffs = this.compareChildren(local?.children?.queries || [], remote?.children?.queries || [], 'cms_report_queries', (q) => q.name || q.system_name || `query_${q.id}`);
+        const specDiffs = this.compareChildren(local?.children?.specs || [], remote?.children?.specs || [], 'cms_report_specs', (s) => s.field_name || `spec_${s.id}`);
+        const children = [...queryDiffs, ...specDiffs];
+        if (children.length > 0 && status === 'unchanged') {
+            status = 'modified';
+        }
+        return {
+            resourceType: this.resourceType,
+            resourceName,
+            resourceId,
+            localPath: localPath || local?.path,
+            status,
+            fieldDiffs,
+            children
+        };
+    }
+    compareChildren(localItems, remoteItems, childType, getDisplayName) {
+        const diffs = [];
+        const localById = new Map(localItems.map(s => [s.id, s]));
+        const remoteById = new Map(remoteItems.map(s => [s.id, s]));
+        const allIds = new Set([...localById.keys(), ...remoteById.keys()]);
+        for (const itemId of allIds) {
+            const localItem = localById.get(itemId);
+            const remoteItem = remoteById.get(itemId);
+            let status;
+            if (!localItem && remoteItem) {
+                status = 'remote_only';
+            }
+            else if (localItem && !remoteItem) {
+                status = 'local_only';
+            }
+            else {
+                const fieldDiffs = compareFields(localItem, remoteItem);
+                status = fieldDiffs.length > 0 ? 'modified' : 'unchanged';
+            }
+            if (status !== 'unchanged') {
+                const itemName = getDisplayName(localItem || remoteItem);
+                diffs.push({
+                    resourceType: childType,
+                    resourceName: itemName,
+                    resourceId: itemId,
+                    status,
+                    fieldDiffs: compareFields(localItem || null, remoteItem || null)
+                });
+            }
+        }
+        return diffs;
+    }
+    getDisplayName(data) {
+        return data.alias || data.title || `report_${data.id}`;
+    }
+}
+//# sourceMappingURL=reportsAdapter.js.map