@adminide-stack/form-builder-core 5.1.4-alpha.81 → 6.0.1-alpha.0

package/src/inngest/README_AUTOCOMPLETE.md

@@ -1,380 +0,0 @@
-# JavaScript Autocomplete Integration for Inngest Steps
-
-Complete integration of intelligent JavaScript autocompletion in step function editors.
-
-## Overview
-
-This integration connects Monaco Editor with the `js-autocomplete-extension` to provide:
-
--   Context-aware JavaScript completions using Tern.js
--   Type information on hover
--   Step-specific completions for Inngest workflows
--   Library support (lodash, moment, etc.)
--   Dynamic completions based on execution context
-
-## Architecture
-
-```
-┌─────────────────────────────────────────────────┐
-│         CodeEditor Component                     │
-│  (Monaco Editor Instance)                        │
-└──────────────────┬──────────────────────────────┘
-                   │
-                   │ User types code
-                   │
-┌──────────────────▼──────────────────────────────┐
-│    monacoAutocompleteIntegration.ts             │
-│  - setupMonacoAutocomplete()                    │
-│  - setupStepAutocomplete()                      │
-└──────────────────┬──────────────────────────────┘
-                   │
-                   │ services.commands.executeCommand()
-                   │
-┌──────────────────▼──────────────────────────────┐
-│       js-autocomplete-extension                  │
-│  - jsAutocomplete.getCompletions                │
-│  - jsAutocomplete.getTypeInfo                   │
-│  - jsAutocomplete.installLibrary                │
-└──────────────────┬──────────────────────────────┘
-                   │
-                   │ code.javascript.* API
-                   │
-┌──────────────────▼──────────────────────────────┐
-│    JavaScript Worker (Tern.js)                  │
-│  - Type inference                                │
-│  - Library definitions                           │
-│  - Scope analysis                                │
-└──────────────────────────────────────────────────┘
-```
-
-## Files Created
-
-### 1. `stepGenerator.ts` (Updated)
-
-Added completion support functions:
-
--   `getStepCompletionScope()` - Returns available scope variables
--   `getStepTypeDefinitions()` - Returns TypeScript definitions for Inngest API
--   `getStepTypeCompletions()` - Returns step-type-specific completions
--   `extractVariablesFromCode()` - Extracts variables from code for context
--   `getStepCompletionContext()` - Gets complete completion context for a step
-
-### 2. `monacoAutocompleteIntegration.ts` (New)
-
-Monaco Editor integration layer:
-
--   `setupMonacoAutocomplete()` - Setup general JS/TS autocomplete
--   `setupStepAutocomplete()` - Setup step-specific autocomplete
--   `installLibraryForAutocomplete()` - Install library definitions
--   `updateAutocompleteConfig()` - Update autocomplete settings
--   `getAvailableDefinitions()` - Get loaded type definitions
-
-Uses your command execution pattern:
-
-```typescript
-await services.commands.executeCommand({
-    command: 'jsAutocomplete.getCompletions',
-    arguments: [text, position, scope],
-});
-```
-
-## Usage in CodeEditor
-
-### Basic Integration
-
-```tsx
-import { setupMonacoAutocomplete } from '@form-builder/core/inngest/monacoAutocompleteIntegration';
-
-const CodeEditor: React.FC<CodeEditorProps> = ({ value, onChange, services }) => {
-    const handleEditorWillMount = async (monaco: any) => {
-        // Setup autocomplete
-        if (services?.commands) {
-            await setupMonacoAutocomplete(
-                monaco,
-                {
-                    enableInngestContext: true,
-                    customScope: ['step', 'event'],
-                    enableHoverInfo: true,
-                    commandService: services.commands,
-                },
-                services.commands,
-            );
-        }
-
-        // Rest of your setup...
-    };
-
-    return <Editor beforeMount={handleEditorWillMount} />;
-};
-```
-
-### Step-Specific Integration
-
-```tsx
-import { setupStepAutocomplete } from '@form-builder/core/inngest/monacoAutocompleteIntegration';
-
-const handleEditorWillMount = async (monaco: any) => {
-    if (services?.commands && currentStep) {
-        // Provides step-type-specific completions
-        await setupStepAutocomplete(monaco, currentStep, code, services.commands);
-    }
-};
-```
-
-## Extension Commands
-
-All extension commands follow your command execution pattern:
-
-### Get Completions
-
-```typescript
-const result = await services.commands.executeCommand({
-    command: 'jsAutocomplete.getCompletions',
-    arguments: [
-        text, // Full source code
-        position, // Cursor offset
-        ['step', 'event', 'myVar'], // Optional scope
-    ],
-});
-
-// Returns:
-// {
-//     completions: [
-//         { name: 'run', type: 'fn(id: string, fn: function): Promise', doc: '...' },
-//         { name: 'sleep', type: 'fn(id: string, duration: string): Promise', doc: '...' }
-//     ],
-//     isIncomplete: false
-// }
-```
-
-### Get Type Info
-
-```typescript
-const typeInfo = await services.commands.executeCommand({
-    command: 'jsAutocomplete.getTypeInfo',
-    arguments: ['step', ['event', 'step']],
-});
-
-// Returns:
-// {
-//     type: 'object with methods run, sleep, sendEvent, waitForEvent',
-//     doc: 'Inngest step API for workflow orchestration',
-//     url: 'https://docs.inngest.com'
-// }
-```
-
-### Install Library
-
-```typescript
-await services.commands.executeCommand({
-    command: 'jsAutocomplete.installLibrary',
-    arguments: ['https://cdn.jsdelivr.net/npm/@types/lodash/index.d.ts', ['_', 'lodash']],
-});
-```
-
-### Update Configuration
-
-```typescript
-await services.commands.executeCommand({
-    command: 'jsAutocomplete.updateConfig',
-    arguments: [
-        {
-            includeDefaults: true,
-            includeLibraries: true,
-            enableDynamicLibraries: true,
-            customDefinitions: ['lodash', 'moment'],
-        },
-    ],
-});
-```
-
-## Step-Specific Completions
-
-The integration provides context-aware completions based on step type:
-
-### Sleep Step
-
-```javascript
-step.sleep('step-id', '5s'); // Completions show duration formats: "5s", "1m", "1h"
-```
-
-### Send Event Step
-
-```javascript
-step.sendEvent('step-id', {
-    name: 'my.event', // Completions suggest event patterns
-    data: {}, // Type-aware data completions
-});
-```
-
-### Wait For Event Step
-
-```javascript
-step.waitForEvent('step-id', {
-    event: '', // Event name completions
-    timeout: '', // Duration completions
-});
-```
-
-### Run Step
-
-```javascript
-step.run('step-id', async (event, step) => {
-    event.   // Completions for event properties
-    step.    // Completions for step methods
-})
-```
-
-## Type Definitions
-
-The integration includes comprehensive type definitions:
-
-```typescript
-declare const step: {
-    run<T>(id: string, fn: (event: any, step: any) => Promise<T> | T): Promise<T>;
-    sendEvent(id: string, input: { name: string; data?: any }): Promise<void>;
-    waitForEvent<T = any>(id: string, opts: { event: string; timeout?: string | number }): Promise<T>;
-    sleep(id: string, ms: string | number): Promise<void>;
-};
-
-declare const event: {
-    data: any;
-    id: string;
-    name: string;
-    ts: number;
-};
-```
-
-## Features
-
-### 1. Context-Aware Completions
-
--   Knows about `step`, `event`, and local variables
--   Provides method completions based on type inference
--   Suggests relevant APIs for current step type
-
-### 2. Hover Type Information
-
--   Hover over any symbol to see its type
--   View documentation inline
--   Links to external documentation
-
-### 3. Library Support
-
--   Automatically includes installed libraries
--   Dynamic library detection from execution context
--   Custom library definitions
-
-### 4. Scope Analysis
-
--   Extracts variables from code
--   Maintains scope context across edits
--   Provides completions for local variables
-
-### 5. Snippets Integration
-
--   Works alongside your existing Monaco snippets
--   Doesn't conflict with manual completions
--   Combines template snippets with intelligent completions
-
-## Configuration
-
-Users can configure autocomplete behavior:
-
-```typescript
-{
-    "jsAutocomplete.includeDefaults": true,        // ECMAScript definitions
-    "jsAutocomplete.includeLibraries": true,       // Installed libraries
-    "jsAutocomplete.enableDynamicLibraries": true, // Runtime detection
-    "jsAutocomplete.customDefinitions": []         // Custom type defs
-}
-```
-
-## Testing
-
-### Test Extension Availability
-
-```typescript
-React.useEffect(() => {
-    if (services?.commands) {
-        services.commands
-            .executeCommand({
-                command: 'jsAutocomplete.getAvailableDefinitions',
-                arguments: [],
-            })
-            .then((defs) => {
-                console.log('Extension loaded, definitions:', defs);
-            })
-            .catch((err) => {
-                console.error('Extension not available:', err);
-            });
-    }
-}, [services]);
-```
-
-### Test Completions
-
-```typescript
-const testCompletions = async () => {
-    const result = await services.commands.executeCommand({
-        command: 'jsAutocomplete.getCompletions',
-        arguments: ['step.', 5, ['step', 'event']],
-    });
-
-    console.log('Completions:', result.completions);
-    // Should show: run, sleep, sendEvent, waitForEvent
-};
-```
-
-## Troubleshooting
-
-### No Completions Showing
-
-1. ✅ Check extension is activated in console
-2. ✅ Verify `services.commands` is available
-3. ✅ Test command execution manually
-4. ✅ Check Monaco provider was registered
-
-### Wrong Completions
-
-1. ✅ Verify scope context is correct
-2. ✅ Check step type is properly set
-3. ✅ Try resetting context: `jsAutocomplete.resetContext`
-
-### Type Info Not Showing
-
-1. ✅ Ensure `enableHoverInfo: true`
-2. ✅ Check hover provider is registered
-3. ✅ Test `getTypeInfo` command manually
-
-## Performance
-
--   **Lazy Loading**: Type definitions loaded on-demand
--   **Caching**: Tern.js caches type information
--   **Incremental**: Updates as code changes
--   **Worker-Based**: Runs in separate thread
-
-## Future Enhancements
-
--   [ ] Signature help for function parameters
--   [ ] Definition provider (Go to Definition)
--   [ ] References provider (Find All References)
--   [ ] Rename provider
--   [ ] Code actions (quick fixes)
--   [ ] Import statement generation
--   [ ] JSDoc parsing and display
--   [ ] Multi-step context awareness
-
-## Benefits
-
-✅ **Intelligent Completions** - Context-aware suggestions using Tern.js  
-✅ **Type Information** - Hover to see types and documentation  
-✅ **Library Support** - Completions for installed libraries  
-✅ **Step-Specific** - Tailored completions for each step type  
-✅ **Works with Existing Code** - Integrates with your snippets  
-✅ **Command Pattern** - Uses your existing command execution  
-✅ **Performance** - Worker-based, doesn't block UI
-
-## License
-
-MIT

package/src/inngest/generateFunctionCode.ts

@@ -1,151 +0,0 @@
-/* eslint-disable no-use-before-define */
-import type {
-    InngestFunctionDef,
-    InngestStep,
-    ExtractedFunction,
-    StepFunction,
-    GeneratedFunctionResult,
-} from './interfaces/types';
-import {
-    cleanStepCode,
-    extractStepVarName,
-    generateFromExtractedFunctions,
-    extractFunctionBody,
-} from './stepGenerator';
-
-// Re-export utilities for backward compatibility
-export { cleanStepCode, extractStepVarName } from './stepGenerator';
-
-// Check if code contains direct step operations (sleep, sendEvent, etc)
-function hasDirectStepOperations(code: string): boolean {
-    return /step\.(sleep|sendEvent|waitForEvent|run)\s*\(/.test(code);
-}
-
-function getDefaultDirectBody(type: string, id: string, label?: string): string {
-    switch (type) {
-        case 'sleep':
-            return `const ${id}_result = await step.sleep('${id}', '5s');`;
-        case 'sendEvent':
-            return `const ${id}_result = await step.sendEvent('${id}', { name: 'my.custom.event', data: { source: '${
-                label || id
-            }', ts: new Date().toISOString() } });`;
-        case 'waitForEvent':
-            return `const ${id}_result = await step.waitForEvent('${id}', { event: 'my.waited.event', timeout: '60s' });`;
-        default:
-            return `// not supported`;
-    }
-}
-
-function indent(s: string, spaces: number): string {
-    const pad = ' '.repeat(spaces);
-    return s
-        .split('\n')
-        .map((l) => (l ? pad + l : l))
-        .join('\n');
-}
-
-// Simple code formatter
-function formatCode(code: string): string {
-    // Basic formatting - in production, you'd use a proper formatter
-    return code
-        .split('\n')
-        .map((line) => line.trimEnd())
-        .join('\n')
-        .replace(/\n{3,}/g, '\n\n'); // Remove excessive blank lines
-}
-
-function generateStepBlock(step: InngestStep, position: number): string {
-    const stepVar = (step.code || '').match(/const\s+(\w+)\s*=/)?.[1] || `step_${position}`;
-
-    // If caller supplied code, embed it inside step.run wrapper by default for consistency
-    if (step.type === 'sleep' || step.type === 'sendEvent' || step.type === 'waitForEvent') {
-        // Execute directly (these typically call step.* helpers)
-        const body = extractFunctionBody(step.code || '') || getDefaultDirectBody(step.type, stepVar, step.name);
-        return `// ${step.description || step.name || `Step ${position}`}
-${body}`;
-    }
-
-    const inner = extractFunctionBody(step.code || '') || 'return { success: true };';
-    return `// ${step.description || step.name || `Step ${position}`}
-const ${stepVar}_result = await step.run('${stepVar}', async (event, step) => {
-${indent(inner, 2)}
-});`;
-}
-
-// Minimal shared generator. Replace internals by moving editor logic here incrementally.
-export function generateFunctionCode(def: InngestFunctionDef): string {
-    const eventsString = def.events.length > 0 ? def.events.map((e) => `'${e}'`).join(', ') : `'app.event'`;
-    const safeId = def.id.replace(/[^a-zA-Z0-9]/g, '') || 'function';
-    const body = generateHandlerBody(def);
-    return `const ${safeId}Function = inngest.createFunction(
-  { id: '${def.id}' },
-  { event: [${eventsString}] },
-  async ({ event, step }) => {
-${indent(body, 4)}
-  }
-);`;
-}
-
-// New: return only the handler body that backend executes and editor displays
-export function generateHandlerBody(def: InngestFunctionDef): string {
-    const stepBlocks = def.steps.map((step, index) => generateStepBlock(step, index + 1)).join('\n');
-    // Footer removed: callers should append their own consolidated return as needed
-    return `${stepBlocks}`;
-}
-
-// Generate Inngest function from database-extracted functions
-export function generateStepFunctionsFromDB(
-    functionId: string,
-    events: string[],
-    extractedFunctions: ExtractedFunction[],
-): GeneratedFunctionResult {
-    if (!extractedFunctions || extractedFunctions.length === 0) {
-        throw new Error('No functions provided to generate');
-    }
-
-    // Use the new unified generator
-    const code = generateFromExtractedFunctions(extractedFunctions);
-
-    return {
-        code: formatCode(code),
-        functionId,
-        stepCount: extractedFunctions.length,
-    };
-}
-
-// Wrap multiple step functions in a single Inngest function
-export function wrapStepsInInngestFunction(functionDef: InngestFunctionDef, stepFunctions: StepFunction[]): string {
-    const extractedFunctions: ExtractedFunction[] = stepFunctions.map((sf) => ({
-        id: sf.id,
-        name: sf.name,
-        code: sf.code,
-        description: sf.description,
-    }));
-
-    const result = generateStepFunctionsFromDB(functionDef.id, functionDef.events, extractedFunctions);
-
-    return result.code;
-}
-
-// Generate a single step from an extracted function
-export function generateStepFromFunction(stepFunction: StepFunction, index: number): string {
-    const stepVar = extractStepVarName(stepFunction.code) || `step_${index}`;
-    const functionBody = extractFunctionBody(stepFunction.code);
-
-    if (!functionBody) {
-        return `// ${
-            stepFunction.name || `Step ${index}`
-        }\nconst ${stepVar}_result = { success: false, error: 'Invalid function format' };`;
-    }
-
-    const hasDirectOps = hasDirectStepOperations(stepFunction.code);
-    const cleanedBody = cleanStepCode(functionBody);
-
-    if (hasDirectOps) {
-        return `// ${stepFunction.name || `Step ${index}`}\n${cleanedBody}`;
-    }
-
-    return `// ${
-        stepFunction.name || `Step ${index}`
-    }\nconst ${stepVar}_result = await step.run('${stepVar}', async (event, step) => {\n${indent(cleanedBody, 2)}\n});`;
-}

package/src/inngest/interfaces/index.ts

@@ -1 +0,0 @@
-export * from './types';

package/src/inngest/interfaces/types.ts

@@ -1,63 +0,0 @@
-export type InngestStepType =
-    | 'run'
-    | 'sleep'
-    | 'sendEvent'
-    | 'waitForEvent'
-    | 'retrieveData'
-    | 'parallel'
-    | 'validateForm';
-
-export interface InngestStep {
-    id: string;
-    name: string;
-    type: InngestStepType;
-    code?: string;
-    description?: string;
-    // Loose optional fields to avoid coupling; extend in callers as needed
-    [key: string]: unknown;
-}
-
-export interface InngestFunctionDef {
-    id: string;
-    name: string;
-    description?: string;
-    events: string[];
-    steps: InngestStep[];
-    concurrency?: number;
-    retries?: number;
-    timeout?: string | number;
-    // Extra passthrough metadata
-    [key: string]: unknown;
-}
-
-// New interfaces for database-extracted functions
-export interface ExtractedFunction {
-    id: string;
-    name: string;
-    code?: string; // The complete async function code
-    extensionId?: string;
-    extensionName?: string;
-    generatedCode?: string;
-    steps?: StepDefinition[];
-    originalStepName?: string;
-}
-
-export interface StepFunction {
-    id: string;
-    name: string;
-    code: string;
-    type?: InngestStepType;
-    description?: string;
-}
-
-export interface StepDefinition {
-    id: string;
-    name: string;
-    code: string;
-}
-
-export interface GeneratedFunctionResult {
-    code: string;
-    functionId: string;
-    stepCount: number;
-}