eventmodeler 0.5.0 → 0.6.1

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

@@ -1,15 +0,0 @@
-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

@@ -1,208 +0,0 @@
-import { appendEvent } from '../../lib/file-loader.js';
-import { findElementOrExit, excludeLinkedCopies } from '../../lib/element-lookup.js';
-function findFieldByName(fields, fieldName) {
-    const nameLower = fieldName.toLowerCase();
-    for (const field of fields) {
-        if (field.name.toLowerCase() === nameLower) {
-            return field;
-        }
-        // Check subfields for Custom types
-        if (field.fieldType === 'Custom' && field.subfields) {
-            // Check for dot notation path (e.g., "address.street")
-            if (fieldName.toLowerCase().startsWith(field.name.toLowerCase() + '.')) {
-                const subPath = fieldName.slice(field.name.length + 1);
-                const subField = findFieldByName(field.subfields, subPath);
-                if (subField)
-                    return subField;
-            }
-            // Also check direct match in subfields
-            const subField = findFieldByName(field.subfields, fieldName);
-            if (subField)
-                return subField;
-        }
-    }
-    return undefined;
-}
-function createUpdatedField(original, updates) {
-    return {
-        ...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, options.screen, options.processor].filter(Boolean).length;
-    if (entityCount === 0) {
-        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, --read-model, --screen, or --processor');
-        process.exit(1);
-    }
-    if (options.command) {
-        updateCommandField(model, filePath, options.command, fieldName, updates);
-    }
-    else if (options.event) {
-        updateEventField(model, filePath, options.event, 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');
-    const field = findFieldByName(command.fields, fieldName);
-    if (!field) {
-        console.error(`Error: Field "${fieldName}" not found on command "${command.name}"`);
-        if (command.fields.length > 0) {
-            console.error('Available fields:');
-            for (const f of command.fields) {
-                console.error(`  - ${f.name}`);
-            }
-        }
-        process.exit(1);
-    }
-    const updatedField = createUpdatedField(field, updates);
-    appendEvent(filePath, {
-        type: 'CommandFieldAdjusted',
-        data: {
-            commandStickyId: command.id,
-            fieldId: field.id,
-            field: updatedField,
-            timestamp: Date.now(),
-        },
-    });
-    console.log(`Updated field "${field.name}" on command "${command.name}"`);
-    logUpdates(updates);
-}
-function updateEventField(model, filePath, eventName, fieldName, updates) {
-    // Exclude linked copies - they share fields with their canonical original
-    const event = findElementOrExit(excludeLinkedCopies(model.events), eventName, 'event');
-    const field = findFieldByName(event.fields, fieldName);
-    if (!field) {
-        console.error(`Error: Field "${fieldName}" not found on event "${event.name}"`);
-        if (event.fields.length > 0) {
-            console.error('Available fields:');
-            for (const f of event.fields) {
-                console.error(`  - ${f.name}`);
-            }
-        }
-        process.exit(1);
-    }
-    const updatedField = createUpdatedField(field, updates);
-    appendEvent(filePath, {
-        type: 'EventFieldAdjusted',
-        data: {
-            eventStickyId: event.id,
-            fieldId: field.id,
-            field: updatedField,
-            timestamp: Date.now(),
-        },
-    });
-    console.log(`Updated field "${field.name}" on event "${event.name}"`);
-    logUpdates(updates);
-}
-function updateReadModelField(model, filePath, readModelName, fieldName, updates) {
-    // Exclude linked copies - they share fields with their canonical original
-    const readModel = findElementOrExit(excludeLinkedCopies(model.readModels), readModelName, 'read model');
-    const field = findFieldByName(readModel.fields, fieldName);
-    if (!field) {
-        console.error(`Error: Field "${fieldName}" not found on read model "${readModel.name}"`);
-        if (readModel.fields.length > 0) {
-            console.error('Available fields:');
-            for (const f of readModel.fields) {
-                console.error(`  - ${f.name}`);
-            }
-        }
-        process.exit(1);
-    }
-    const updatedField = createUpdatedField(field, updates);
-    appendEvent(filePath, {
-        type: 'ReadModelFieldAdjusted',
-        data: {
-            readModelStickyId: readModel.id,
-            fieldId: field.id,
-            field: updatedField,
-            timestamp: Date.now(),
-        },
-    });
-    console.log(`Updated field "${field.name}" on read model "${readModel.name}"`);
-    logUpdates(updates);
-}
-function updateScreenField(model, filePath, screenName, fieldName, updates) {
-    // Exclude linked copies - they share fields with their canonical original
-    const screen = findElementOrExit(excludeLinkedCopies(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',
-        data: {
-            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',
-        data: {
-            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}`);
-    }
-    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/dist/slices/whoami/index.d.ts

@@ -1,2 +0,0 @@
-import type { OutputFormat } from '../../api/index.js';
-export declare function whoami(format: OutputFormat): void;

package/dist/slices/whoami/index.js

@@ -1,44 +0,0 @@
-import { isAuthenticated, getAuthTokens, getBackendUrl, getKeycloakUrl } from '../../lib/config.js';
-import { XMLBuilder } from 'fast-xml-parser';
-const xmlBuilder = new XMLBuilder({
-    ignoreAttributes: false,
-    attributeNamePrefix: '@_',
-    suppressEmptyNode: true,
-    format: false,
-});
-export function whoami(format) {
-    const tokens = getAuthTokens();
-    const backendUrl = getBackendUrl();
-    const keycloakUrl = getKeycloakUrl();
-    if (!tokens) {
-        if (format === 'json') {
-            console.log(JSON.stringify({ authenticated: false, backendUrl, keycloakUrl }, null, 2));
-        }
-        else {
-            console.log(xmlBuilder.build({ auth: { '@_authenticated': 'false', '@_backendUrl': backendUrl, '@_keycloakUrl': keycloakUrl } }));
-        }
-        return;
-    }
-    const isValid = isAuthenticated();
-    if (format === 'json') {
-        console.log(JSON.stringify({
-            authenticated: isValid,
-            email: tokens.email,
-            userId: tokens.userId,
-            backendUrl,
-            keycloakUrl,
-            expiresAt: new Date(tokens.expiresAt).toISOString(),
-        }, null, 2));
-    }
-    else {
-        const attrs = {
-            '@_authenticated': String(isValid),
-            '@_email': tokens.email,
-            '@_backendUrl': backendUrl,
-        };
-        if (!isValid) {
-            attrs['@_reason'] = 'token_expired';
-        }
-        console.log(xmlBuilder.build({ auth: attrs }));
-    }
-}

package/dist/types.d.ts

@@ -1,195 +0,0 @@
-export interface Field {
-    id: string;
-    name: string;
-    fieldType: 'UUID' | 'Boolean' | 'Double' | 'Decimal' | 'Date' | 'DateTime' | 'Long' | 'Int' | 'String' | 'Custom';
-    isList: boolean;
-    isGenerated: boolean;
-    isOptional?: boolean;
-    isUserInput?: boolean;
-    subfields?: Field[];
-}
-export type SliceStatus = 'created' | 'in-progress' | 'blocked' | 'done';
-export interface EventReference {
-    eventStickyId: string;
-    fieldValues?: Record<string, unknown>;
-}
-export interface CommandReference {
-    commandStickyId: string;
-    fieldValues?: Record<string, unknown>;
-}
-export interface ReadModelAssertion {
-    readModelStickyId: string;
-    givenEvents: EventReference[];
-    expectedFieldValues: Record<string, unknown>;
-}
-export type ScenarioThenType = 'error' | 'events' | 'readModelAssertion' | 'command' | 'noCommand';
-export interface ScenarioThen {
-    type: ScenarioThenType;
-    errorMessage?: string;
-    errorType?: string;
-    expectedEvents?: EventReference[];
-    readModelAssertion?: ReadModelAssertion;
-    expectedCommand?: CommandReference;
-}
-export interface FieldMapping {
-    sourceFieldId: string;
-    targetFieldId: string;
-}
-export interface CommandSticky {
-    id: string;
-    name: string;
-    fields: Field[];
-    position: {
-        x: number;
-        y: number;
-    };
-    width: number;
-    height: number;
-}
-export interface EventSticky {
-    id: string;
-    name: string;
-    fields: Field[];
-    position: {
-        x: number;
-        y: number;
-    };
-    width: number;
-    height: number;
-    canonicalId?: string;
-    originalNodeId?: string;
-}
-export interface ReadModelSticky {
-    id: string;
-    name: string;
-    fields: Field[];
-    position: {
-        x: number;
-        y: number;
-    };
-    width: number;
-    height: number;
-    canonicalId?: string;
-    originalNodeId?: string;
-}
-export interface Screen {
-    id: string;
-    name: string;
-    fields: Field[];
-    position: {
-        x: number;
-        y: number;
-    };
-    width: number;
-    height: number;
-    canonicalId?: string;
-    originalNodeId?: string;
-}
-export interface Processor {
-    id: string;
-    name: string;
-    fields: Field[];
-    position: {
-        x: number;
-        y: number;
-    };
-    width: number;
-    height: number;
-}
-export interface Slice {
-    id: string;
-    name: string;
-    status: SliceStatus;
-    position: {
-        x: number;
-        y: number;
-    };
-    size: {
-        width: number;
-        height: number;
-    };
-    nodeIds: string[];
-}
-export interface Chapter {
-    id: string;
-    name: string;
-    position: {
-        x: number;
-        y: number;
-    };
-    size: {
-        width: number;
-        height: number;
-    };
-}
-export interface Aggregate {
-    id: string;
-    name: string;
-    position: {
-        x: number;
-        y: number;
-    };
-    size: {
-        width: number;
-        height: number;
-    };
-    eventIds: string[];
-    aggregateIdFieldName?: string;
-    aggregateIdFieldType?: Field['fieldType'];
-}
-export interface Actor {
-    id: string;
-    name: string;
-    position: {
-        x: number;
-        y: number;
-    };
-    size: {
-        width: number;
-        height: number;
-    };
-    screenIds: string[];
-}
-export interface Scenario {
-    id: string;
-    sliceId: string;
-    name: string;
-    description: string;
-    position: {
-        x: number;
-        y: number;
-    };
-    width: number;
-    height: number;
-    givenEvents: EventReference[];
-    whenCommand: CommandReference | null;
-    whenEvents: EventReference[];
-    then: ScenarioThen;
-}
-export type FlowType = 'CommandToEvent' | 'EventToReadModel' | 'ReadModelToScreen' | 'ReadModelToProcessor' | 'ScreenToCommand' | 'ProcessorToCommand';
-export interface Flow {
-    id: string;
-    flowType: FlowType;
-    sourceId: string;
-    targetId: string;
-    fieldMappings: FieldMapping[];
-}
-export interface EventModel {
-    modelId: string;
-    name: string;
-    commands: Map<string, CommandSticky>;
-    events: Map<string, EventSticky>;
-    readModels: Map<string, ReadModelSticky>;
-    screens: Map<string, Screen>;
-    processors: Map<string, Processor>;
-    slices: Map<string, Slice>;
-    chapters: Map<string, Chapter>;
-    aggregates: Map<string, Aggregate>;
-    actors: Map<string, Actor>;
-    scenarios: Map<string, Scenario>;
-    flows: Map<string, Flow>;
-}
-export interface RawEvent {
-    type: string;
-    data: Record<string, unknown>;
-}

package/dist/types.js

@@ -1 +0,0 @@
-export {};