eventmodeler 0.2.10 → 0.3.0

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]
                                  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,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');
                     const optionalArg = getNamedArg(filteredArgs, '--optional');
                     const generatedArg = getNamedArg(filteredArgs, '--generated');
                     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]');
                         process.exit(1);
                     }
                     const updates = {};
@@ -435,7 +441,7 @@ async function main() {
                         console.error('Error: Must specify at least one update (--optional, --generated, 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

@@ -68,13 +68,13 @@ function createFieldFromInput(input) {
 }
 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 +107,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 +162,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

@@ -8,5 +8,7 @@ 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

@@ -33,13 +33,13 @@ function createUpdatedField(original, updates) {
 }
 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 +51,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 +130,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}`);

package/package.json

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