eventmodeler 0.2.10 → 0.3.1

package/dist/index.js

@@ -80,18 +80,18 @@ COMMANDS:
 
   add scenario --slice <name> --json|--xml <data>
                                  Add a scenario to a slice
-  add field --command|--event|--read-model <name> --json|--xml <data>
+  add field --command|--event|--read-model|--screen|--processor <name> --json|--xml <data>
                                  Add a field to an entity
 
   remove scenario <name> [--slice <name>]
                                  Remove a scenario by name
-  remove field --command|--event|--read-model <name> --field <name>
+  remove field --command|--event|--read-model|--screen|--processor <name> --field <name>
                                  Remove a field from an entity
 
   map fields --flow <source→target> --json|--xml <mappings>
                                  Set field mappings on a flow
 
-  update field --command|--event|--read-model <name> --field <name> [--optional true|false] [--generated true|false]
+  update field --command|--event|--read-model|--screen|--processor <name> --field <name> [--optional true|false] [--generated true|false] [--user-input true|false (screen only)]
                                  Update field properties
 
   create state-change-slice --xml <data>
@@ -332,15 +332,17 @@ async function main() {
                     const commandArg = getNamedArg(filteredArgs, '--command');
                     const eventArg = getNamedArg(filteredArgs, '--event');
                     const readModelArg = getNamedArg(filteredArgs, '--read-model');
+                    const screenArg = getNamedArg(filteredArgs, '--screen');
+                    const processorArg = getNamedArg(filteredArgs, '--processor');
                     const jsonArg = getNamedArg(filteredArgs, '--json');
                     const xmlArg = getNamedArg(filteredArgs, '--xml');
                     const inputData = jsonArg ?? xmlArg;
                     if (!inputData) {
                         console.error('Error: --json or --xml is required');
-                        console.error('Usage: eventmodeler add field --command|--event|--read-model <name> --json|--xml <data>');
+                        console.error('Usage: eventmodeler add field --command|--event|--read-model|--screen|--processor <name> --json|--xml <data>');
                         process.exit(1);
                     }
-                    addField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg }, inputData);
+                    addField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg, screen: screenArg, processor: processorArg }, inputData);
                     break;
                 }
                 default:
@@ -365,13 +367,15 @@ async function main() {
                     const commandArg = getNamedArg(filteredArgs, '--command');
                     const eventArg = getNamedArg(filteredArgs, '--event');
                     const readModelArg = getNamedArg(filteredArgs, '--read-model');
+                    const screenArg = getNamedArg(filteredArgs, '--screen');
+                    const processorArg = getNamedArg(filteredArgs, '--processor');
                     const fieldArg = getNamedArg(filteredArgs, '--field');
                     if (!fieldArg) {
                         console.error('Error: --field is required');
-                        console.error('Usage: eventmodeler remove field --command|--event|--read-model <name> --field <field-name>');
+                        console.error('Usage: eventmodeler remove field --command|--event|--read-model|--screen|--processor <name> --field <field-name>');
                         process.exit(1);
                     }
-                    removeField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg }, fieldArg);
+                    removeField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg, screen: screenArg, processor: processorArg }, fieldArg);
                     break;
                 }
                 default:
@@ -412,13 +416,21 @@ async function main() {
                     const commandArg = getNamedArg(filteredArgs, '--command');
                     const eventArg = getNamedArg(filteredArgs, '--event');
                     const readModelArg = getNamedArg(filteredArgs, '--read-model');
+                    const screenArg = getNamedArg(filteredArgs, '--screen');
+                    const processorArg = getNamedArg(filteredArgs, '--processor');
                     const fieldArg = getNamedArg(filteredArgs, '--field');
                     const optionalArg = getNamedArg(filteredArgs, '--optional');
                     const generatedArg = getNamedArg(filteredArgs, '--generated');
+                    const userInputArg = getNamedArg(filteredArgs, '--user-input');
                     const typeArg = getNamedArg(filteredArgs, '--type');
                     if (!fieldArg) {
                         console.error('Error: --field is required');
-                        console.error('Usage: eventmodeler update field --command|--event|--read-model <name> --field <field-name> [--optional true|false] [--generated true|false]');
+                        console.error('Usage: eventmodeler update field --command|--event|--read-model|--screen|--processor <name> --field <field-name> [--optional true|false] [--generated true|false] [--user-input true|false (screen only)]');
+                        process.exit(1);
+                    }
+                    // --user-input is only valid for screens
+                    if (userInputArg !== undefined && !screenArg) {
+                        console.error('Error: --user-input can only be used with --screen');
                         process.exit(1);
                     }
                     const updates = {};
@@ -428,14 +440,17 @@ async function main() {
                     if (generatedArg !== undefined) {
                         updates.generated = generatedArg === 'true';
                     }
+                    if (userInputArg !== undefined) {
+                        updates.userInput = userInputArg === 'true';
+                    }
                     if (typeArg !== undefined) {
                         updates.type = typeArg;
                     }
                     if (Object.keys(updates).length === 0) {
-                        console.error('Error: Must specify at least one update (--optional, --generated, or --type)');
+                        console.error('Error: Must specify at least one update (--optional, --generated, --user-input, or --type)');
                         process.exit(1);
                     }
-                    updateField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg }, fieldArg, updates);
+                    updateField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg, screen: screenArg, processor: processorArg }, fieldArg, updates);
                     break;
                 }
                 default:

package/dist/slices/add-field/index.d.ts

@@ -3,4 +3,6 @@ export declare function addField(model: EventModel, filePath: string, options: {
     command?: string;
     event?: string;
     readModel?: string;
+    screen?: string;
+    processor?: string;
 }, input: string): void;

package/dist/slices/add-field/index.js

@@ -36,6 +36,7 @@ function parseXmlInput(input) {
         isList: getBoolAttr(fieldMatch[1], 'isList'),
         isGenerated: getBoolAttr(fieldMatch[1], 'isGenerated'),
         isOptional: getBoolAttr(fieldMatch[1], 'isOptional'),
+        isUserInput: getBoolAttr(fieldMatch[1], 'isUserInput'),
     };
     // Parse nested subfields for Custom type
     if (type === 'Custom' && fieldMatch[2]) {
@@ -63,18 +64,19 @@ function createFieldFromInput(input) {
         isList: input.isList ?? false,
         isGenerated: input.isGenerated ?? false,
         isOptional: input.isOptional,
+        isUserInput: input.isUserInput,
         subfields: input.subfields?.map(createFieldFromInput),
     };
 }
 export function addField(model, filePath, options, input) {
     // Determine which entity type
-    const entityCount = [options.command, options.event, options.readModel].filter(Boolean).length;
+    const entityCount = [options.command, options.event, options.readModel, options.screen, options.processor].filter(Boolean).length;
     if (entityCount === 0) {
-        console.error('Error: Must specify one of --command, --event, or --read-model');
+        console.error('Error: Must specify one of --command, --event, --read-model, --screen, or --processor');
         process.exit(1);
     }
     if (entityCount > 1) {
-        console.error('Error: Can only specify one of --command, --event, or --read-model');
+        console.error('Error: Can only specify one of --command, --event, --read-model, --screen, or --processor');
         process.exit(1);
     }
     // Parse input
@@ -107,6 +109,12 @@ export function addField(model, filePath, options, input) {
     else if (options.readModel) {
         addFieldToReadModel(model, filePath, options.readModel, fieldInput);
     }
+    else if (options.screen) {
+        addFieldToScreen(model, filePath, options.screen, fieldInput);
+    }
+    else if (options.processor) {
+        addFieldToProcessor(model, filePath, options.processor, fieldInput);
+    }
 }
 function addFieldToCommand(model, filePath, commandName, fieldInput) {
     const command = findElementOrExit(model.commands, commandName, 'command');
@@ -156,3 +164,35 @@ function addFieldToReadModel(model, filePath, readModelName, fieldInput) {
     });
     console.log(`Added field "${field.name}" to read model "${readModel.name}"`);
 }
+function addFieldToScreen(model, filePath, screenName, fieldInput) {
+    const screen = findElementOrExit(model.screens, screenName, 'screen');
+    // Check for duplicate field name
+    if (screen.fields.some(f => f.name.toLowerCase() === fieldInput.name.toLowerCase())) {
+        console.error(`Error: Field "${fieldInput.name}" already exists on screen "${screen.name}"`);
+        process.exit(1);
+    }
+    const field = createFieldFromInput(fieldInput);
+    appendEvent(filePath, {
+        type: 'ScreenFieldAdded',
+        screenId: screen.id,
+        field,
+        timestamp: Date.now(),
+    });
+    console.log(`Added field "${field.name}" to screen "${screen.name}"`);
+}
+function addFieldToProcessor(model, filePath, processorName, fieldInput) {
+    const processor = findElementOrExit(model.processors, processorName, 'processor');
+    // Check for duplicate field name
+    if (processor.fields.some(f => f.name.toLowerCase() === fieldInput.name.toLowerCase())) {
+        console.error(`Error: Field "${fieldInput.name}" already exists on processor "${processor.name}"`);
+        process.exit(1);
+    }
+    const field = createFieldFromInput(fieldInput);
+    appendEvent(filePath, {
+        type: 'ProcessorFieldAdded',
+        processorId: processor.id,
+        field,
+        timestamp: Date.now(),
+    });
+    console.log(`Added field "${field.name}" to processor "${processor.name}"`);
+}

package/dist/slices/remove-field/index.d.ts

@@ -3,4 +3,6 @@ export declare function removeField(model: EventModel, filePath: string, options
     command?: string;
     event?: string;
     readModel?: string;
+    screen?: string;
+    processor?: string;
 }, fieldName: string): void;

package/dist/slices/remove-field/index.js

@@ -2,13 +2,13 @@ import { appendEvent } from '../../lib/file-loader.js';
 import { findElementOrExit } from '../../lib/element-lookup.js';
 export function removeField(model, filePath, options, fieldName) {
     // Determine which entity type
-    const entityCount = [options.command, options.event, options.readModel].filter(Boolean).length;
+    const entityCount = [options.command, options.event, options.readModel, options.screen, options.processor].filter(Boolean).length;
     if (entityCount === 0) {
-        console.error('Error: Must specify one of --command, --event, or --read-model');
+        console.error('Error: Must specify one of --command, --event, --read-model, --screen, or --processor');
         process.exit(1);
     }
     if (entityCount > 1) {
-        console.error('Error: Can only specify one of --command, --event, or --read-model');
+        console.error('Error: Can only specify one of --command, --event, --read-model, --screen, or --processor');
         process.exit(1);
     }
     if (options.command) {
@@ -20,6 +20,12 @@ export function removeField(model, filePath, options, fieldName) {
     else if (options.readModel) {
         removeFieldFromReadModel(model, filePath, options.readModel, fieldName);
     }
+    else if (options.screen) {
+        removeFieldFromScreen(model, filePath, options.screen, fieldName);
+    }
+    else if (options.processor) {
+        removeFieldFromProcessor(model, filePath, options.processor, fieldName);
+    }
 }
 function removeFieldFromCommand(model, filePath, commandName, fieldName) {
     const command = findElementOrExit(model.commands, commandName, 'command');
@@ -96,3 +102,53 @@ function removeFieldFromReadModel(model, filePath, readModelName, fieldName) {
     });
     console.log(`Removed field "${field.name}" from read model "${readModel.name}"`);
 }
+function removeFieldFromScreen(model, filePath, screenName, fieldName) {
+    const screen = findElementOrExit(model.screens, screenName, 'screen');
+    const fieldNameLower = fieldName.toLowerCase();
+    const field = screen.fields.find(f => f.name.toLowerCase() === fieldNameLower);
+    if (!field) {
+        console.error(`Error: Field "${fieldName}" not found on screen "${screen.name}"`);
+        if (screen.fields.length > 0) {
+            console.error('Available fields:');
+            for (const f of screen.fields) {
+                console.error(`  - ${f.name} (${f.fieldType})`);
+            }
+        }
+        else {
+            console.error('This screen has no fields.');
+        }
+        process.exit(1);
+    }
+    appendEvent(filePath, {
+        type: 'ScreenFieldRemoved',
+        screenId: screen.id,
+        fieldId: field.id,
+        timestamp: Date.now(),
+    });
+    console.log(`Removed field "${field.name}" from screen "${screen.name}"`);
+}
+function removeFieldFromProcessor(model, filePath, processorName, fieldName) {
+    const processor = findElementOrExit(model.processors, processorName, 'processor');
+    const fieldNameLower = fieldName.toLowerCase();
+    const field = processor.fields.find(f => f.name.toLowerCase() === fieldNameLower);
+    if (!field) {
+        console.error(`Error: Field "${fieldName}" not found on processor "${processor.name}"`);
+        if (processor.fields.length > 0) {
+            console.error('Available fields:');
+            for (const f of processor.fields) {
+                console.error(`  - ${f.name} (${f.fieldType})`);
+            }
+        }
+        else {
+            console.error('This processor has no fields.');
+        }
+        process.exit(1);
+    }
+    appendEvent(filePath, {
+        type: 'ProcessorFieldRemoved',
+        processorId: processor.id,
+        fieldId: field.id,
+        timestamp: Date.now(),
+    });
+    console.log(`Removed field "${field.name}" from processor "${processor.name}"`);
+}

package/dist/slices/update-field/index.d.ts

@@ -2,11 +2,14 @@ import type { EventModel } from '../../types.js';
 interface UpdateOptions {
     optional?: boolean;
     generated?: boolean;
+    userInput?: boolean;
     type?: string;
 }
 export declare function updateField(model: EventModel, filePath: string, options: {
     command?: string;
     event?: string;
     readModel?: string;
+    screen?: string;
+    processor?: string;
 }, fieldName: string, updates: UpdateOptions): void;
 export {};

package/dist/slices/update-field/index.js

@@ -28,18 +28,19 @@ function createUpdatedField(original, updates) {
         ...original,
         isOptional: updates.optional !== undefined ? updates.optional : original.isOptional,
         isGenerated: updates.generated !== undefined ? updates.generated : original.isGenerated,
+        isUserInput: updates.userInput !== undefined ? updates.userInput : original.isUserInput,
         fieldType: updates.type !== undefined ? updates.type : original.fieldType,
     };
 }
 export function updateField(model, filePath, options, fieldName, updates) {
     // Determine which entity type
-    const entityCount = [options.command, options.event, options.readModel].filter(Boolean).length;
+    const entityCount = [options.command, options.event, options.readModel, options.screen, options.processor].filter(Boolean).length;
     if (entityCount === 0) {
-        console.error('Error: Must specify one of --command, --event, or --read-model');
+        console.error('Error: Must specify one of --command, --event, --read-model, --screen, or --processor');
         process.exit(1);
     }
     if (entityCount > 1) {
-        console.error('Error: Can only specify one of --command, --event, or --read-model');
+        console.error('Error: Can only specify one of --command, --event, --read-model, --screen, or --processor');
         process.exit(1);
     }
     if (options.command) {
@@ -51,6 +52,12 @@ export function updateField(model, filePath, options, fieldName, updates) {
     else if (options.readModel) {
         updateReadModelField(model, filePath, options.readModel, fieldName, updates);
     }
+    else if (options.screen) {
+        updateScreenField(model, filePath, options.screen, fieldName, updates);
+    }
+    else if (options.processor) {
+        updateProcessorField(model, filePath, options.processor, fieldName, updates);
+    }
 }
 function updateCommandField(model, filePath, commandName, fieldName, updates) {
     const command = findElementOrExit(model.commands, commandName, 'command');
@@ -124,6 +131,54 @@ function updateReadModelField(model, filePath, readModelName, fieldName, updates
     console.log(`Updated field "${field.name}" on read model "${readModel.name}"`);
     logUpdates(updates);
 }
+function updateScreenField(model, filePath, screenName, fieldName, updates) {
+    const screen = findElementOrExit(model.screens, screenName, 'screen');
+    const field = findFieldByName(screen.fields, fieldName);
+    if (!field) {
+        console.error(`Error: Field "${fieldName}" not found on screen "${screen.name}"`);
+        if (screen.fields.length > 0) {
+            console.error('Available fields:');
+            for (const f of screen.fields) {
+                console.error(`  - ${f.name}`);
+            }
+        }
+        process.exit(1);
+    }
+    const updatedField = createUpdatedField(field, updates);
+    appendEvent(filePath, {
+        type: 'ScreenFieldAdjusted',
+        screenId: screen.id,
+        fieldId: field.id,
+        field: updatedField,
+        timestamp: Date.now(),
+    });
+    console.log(`Updated field "${field.name}" on screen "${screen.name}"`);
+    logUpdates(updates);
+}
+function updateProcessorField(model, filePath, processorName, fieldName, updates) {
+    const processor = findElementOrExit(model.processors, processorName, 'processor');
+    const field = findFieldByName(processor.fields, fieldName);
+    if (!field) {
+        console.error(`Error: Field "${fieldName}" not found on processor "${processor.name}"`);
+        if (processor.fields.length > 0) {
+            console.error('Available fields:');
+            for (const f of processor.fields) {
+                console.error(`  - ${f.name}`);
+            }
+        }
+        process.exit(1);
+    }
+    const updatedField = createUpdatedField(field, updates);
+    appendEvent(filePath, {
+        type: 'ProcessorFieldAdjusted',
+        processorId: processor.id,
+        fieldId: field.id,
+        field: updatedField,
+        timestamp: Date.now(),
+    });
+    console.log(`Updated field "${field.name}" on processor "${processor.name}"`);
+    logUpdates(updates);
+}
 function logUpdates(updates) {
     if (updates.optional !== undefined) {
         console.log(`  isOptional: ${updates.optional}`);
@@ -131,6 +186,9 @@ function logUpdates(updates) {
     if (updates.generated !== undefined) {
         console.log(`  isGenerated: ${updates.generated}`);
     }
+    if (updates.userInput !== undefined) {
+        console.log(`  isUserInput: ${updates.userInput}`);
+    }
     if (updates.type !== undefined) {
         console.log(`  fieldType: ${updates.type}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eventmodeler",
-  "version": "0.2.10",
+  "version": "0.3.1",
   "description": "CLI tool for interacting with Event Model files - query, update, and export event models from the terminal",
   "type": "module",
   "bin": {