eventmodeler 0.4.0 → 0.4.1

package/dist/cloud/slices/index.d.ts

@@ -0,0 +1,215 @@
+export declare function listSlices(modelId: string, format?: OutputFormat, chapterFilter?: string): Promise<string>;
+export declare function listEvents(modelId: string, format?: OutputFormat): Promise<string>;
+export declare function listCommands(modelId: string, format?: OutputFormat): Promise<string>;
+export declare function listChapters(modelId: string, format?: OutputFormat): Promise<string>;
+export declare function listActors(modelId: string, format?: OutputFormat): Promise<string>;
+export interface SearchResult {
+    type: string;
+    id: string;
+    name: string;
+}
+export interface SearchResponse {
+    query: string;
+    count: number;
+    results: SearchResult[];
+}
+export declare function search(modelId: string, term: string): Promise<SearchResponse>;
+export interface ModelSummary {
+    modelName: string;
+    slices: {
+        total: number;
+        byStatus: {
+            created: number;
+            inProgress: number;
+            blocked: number;
+            done: number;
+        };
+        byType: {
+            stateChange: number;
+            automation: number;
+            stateView: number;
+            unknown: number;
+        };
+    };
+    events: number;
+    commands: number;
+    readModels: number;
+    screens: number;
+    processors: number;
+    chapters: number;
+    aggregates: number;
+    actors: number;
+    flows: number;
+    scenarios: number;
+}
+export declare function getSummary(modelId: string): Promise<ModelSummary>;
+export type SliceStatus = 'created' | 'in-progress' | 'blocked' | 'done';
+export declare function markSliceStatus(modelId: string, sliceName: string, status: SliceStatus): Promise<{
+    success: boolean;
+}>;
+export type ElementType = 'command' | 'event' | 'readModel' | 'screen' | 'processor';
+export interface FieldInput {
+    name: string;
+    fieldType: string;
+    isList?: boolean;
+    isOptional?: boolean;
+    isGenerated?: boolean;
+    isUserInput?: boolean;
+    subfields?: FieldInput[];
+}
+export declare function addField(modelId: string, elementType: ElementType, elementName: string, field: FieldInput): Promise<{
+    success: boolean;
+}>;
+export declare function removeField(modelId: string, elementType: ElementType, elementName: string, fieldName: string): Promise<{
+    success: boolean;
+}>;
+export interface FieldUpdates {
+    name?: string;
+    fieldType?: string;
+    isList?: boolean;
+    isOptional?: boolean;
+    isGenerated?: boolean;
+    isUserInput?: boolean;
+}
+export declare function updateField(modelId: string, elementType: ElementType, elementName: string, fieldName: string, updates: FieldUpdates): Promise<{
+    success: boolean;
+}>;
+export interface FieldMappingInput {
+    from: string;
+    to: string;
+}
+export declare function mapFields(modelId: string, sourceName: string, targetName: string, mappings: FieldMappingInput[]): Promise<{
+    success: boolean;
+}>;
+export interface ScenarioInput {
+    name: string;
+    description?: string;
+    given?: {
+        type: 'events';
+        events: string[];
+    };
+    when?: {
+        type: 'command' | 'events';
+        command?: string;
+        events?: string[];
+    };
+    then: {
+        type: 'events' | 'error' | 'command';
+        events?: string[];
+        errorMessage?: string;
+        errorType?: string;
+        command?: string;
+    };
+}
+export declare function createScenario(modelId: string, sliceName: string, scenario: ScenarioInput): Promise<{
+    success: boolean;
+    scenarioId: string;
+}>;
+export declare function removeScenario(modelId: string, scenarioName: string, sliceName?: string): Promise<{
+    success: boolean;
+}>;
+export declare function createFlow(modelId: string, fromName: string, toName: string): Promise<{
+    success: boolean;
+}>;
+export interface CompoundFieldInput {
+    name: string;
+    fieldType: string;
+    isList?: boolean;
+    isOptional?: boolean;
+    isGenerated?: boolean;
+    isUserInput?: boolean;
+}
+export interface StateChangeSliceInput {
+    sliceName: string;
+    after?: string;
+    before?: string;
+    screen: {
+        name: string;
+        fields: CompoundFieldInput[];
+    };
+    command: {
+        name: string;
+        fields: CompoundFieldInput[];
+    };
+    event: {
+        name: string;
+        fields: CompoundFieldInput[];
+    };
+}
+export interface StateChangeSliceResult {
+    success: boolean;
+    sliceId: string;
+    screenId: string;
+    commandId: string;
+    eventId: string;
+    screenToCommandMappings: number;
+    commandToEventMappings: number;
+}
+export declare function createStateChangeSlice(modelId: string, input: StateChangeSliceInput): Promise<StateChangeSliceResult>;
+export interface AutomationSliceInput {
+    sliceName: string;
+    after?: string;
+    before?: string;
+    readModel: {
+        name: string;
+        fields: CompoundFieldInput[];
+    };
+    processor: {
+        name: string;
+    };
+    command: {
+        name: string;
+        fields: CompoundFieldInput[];
+    };
+    event: {
+        name: string;
+        fields: CompoundFieldInput[];
+    };
+}
+export interface AutomationSliceResult {
+    success: boolean;
+    sliceId: string;
+    readModelId: string;
+    processorId: string;
+    commandId: string;
+    eventId: string;
+    readModelToCommandMappings: number;
+    commandToEventMappings: number;
+}
+export declare function createAutomationSlice(modelId: string, input: AutomationSliceInput): Promise<AutomationSliceResult>;
+export interface StateViewSliceInput {
+    sliceName: string;
+    after?: string;
+    before?: string;
+    readModel: {
+        name: string;
+        fields: CompoundFieldInput[];
+    };
+}
+export interface StateViewSliceResult {
+    success: boolean;
+    sliceId: string;
+    readModelId: string;
+}
+export declare function createStateViewSlice(modelId: string, input: StateViewSliceInput): Promise<StateViewSliceResult>;
+export type OutputFormat = 'xml' | 'json';
+export declare function showSlice(modelId: string, sliceName: string, format?: OutputFormat): Promise<string>;
+export declare function showEvent(modelId: string, eventName: string, format?: OutputFormat): Promise<string>;
+export declare function showCommand(modelId: string, commandName: string, format?: OutputFormat): Promise<string>;
+export declare function showChapter(modelId: string, chapterName: string, format?: OutputFormat): Promise<string>;
+export declare function showActor(modelId: string, actorName: string, format?: OutputFormat): Promise<string>;
+export declare function exportJson(modelId: string): Promise<string>;
+export declare function codegenSlice(modelId: string, sliceName: string): Promise<string>;
+export declare function listAggregates(modelId: string, format?: OutputFormat): Promise<string>;
+export declare function listReadModels(modelId: string, format?: OutputFormat): Promise<string>;
+export declare function listScreens(modelId: string, format?: OutputFormat): Promise<string>;
+export declare function listProcessors(modelId: string, format?: OutputFormat): Promise<string>;
+export declare function showCompleteness(modelId: string, elementName: string, format?: OutputFormat): Promise<string>;
+export declare function showModelCompleteness(modelId: string, format?: OutputFormat): Promise<string>;
+export declare function showAggregateCompleteness(modelId: string, aggregateName: string, format?: OutputFormat): Promise<string>;
+export declare function showReadModel(modelId: string, name: string, format?: OutputFormat): Promise<string>;
+export declare function showScreen(modelId: string, name: string, format?: OutputFormat): Promise<string>;
+export declare function showProcessor(modelId: string, name: string, format?: OutputFormat): Promise<string>;
+export declare function showAggregate(modelId: string, name: string, format?: OutputFormat): Promise<string>;
+export declare function showScenario(modelId: string, name: string, format?: OutputFormat): Promise<string>;
+export declare function listScenarios(modelId: string, format?: OutputFormat): Promise<string>;

package/dist/cloud/slices/index.js

@@ -0,0 +1,247 @@
+// Cloud slice implementations - thin wrappers that call backend CLI endpoints
+// The backend does all the heavy lifting (name resolution, data denormalization)
+import { getBackendUrl } from '../../lib/config.js';
+import { getValidAccessToken } from '../../lib/auth.js';
+// =============================================================================
+// HTTP Client for CLI endpoints
+// =============================================================================
+/**
+ * Handle HTTP error responses with user-friendly messages.
+ * Tries to extract error detail from response body, falls back to status-based messages.
+ */
+async function handleHttpError(response, path) {
+    const text = await response.text().catch(() => '');
+    let errorDetail = '';
+    if (text.trim()) {
+        try {
+            const parsed = JSON.parse(text);
+            errorDetail = parsed.error ?? parsed.message ?? '';
+        }
+        catch {
+            // Response body isn't JSON (could be HTML error page, etc.)
+        }
+    }
+    switch (response.status) {
+        case 401:
+            throw new Error(`Authentication required. Run 'eventmodeler login' to authenticate.` +
+                (errorDetail ? `\n\nOriginal error: ${errorDetail}` : ''));
+        case 403:
+            throw new Error(`Permission denied. You may not have access to this model, or you need editor permission for this action.` +
+                (errorDetail ? `\n\nOriginal error: ${errorDetail}` : ''));
+        case 404:
+            throw new Error(errorDetail || `Not found: ${path}`);
+        default:
+            throw new Error(errorDetail || `HTTP ${response.status}: ${response.statusText}`);
+    }
+}
+async function cliGet(path, params) {
+    const backendUrl = getBackendUrl();
+    const accessToken = await getValidAccessToken();
+    const url = new URL(`${backendUrl}${path}`);
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined) {
+            url.searchParams.set(key, value);
+        }
+    }
+    const response = await fetch(url.toString(), {
+        method: 'GET',
+        headers: {
+            Accept: 'application/json',
+            ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
+        },
+    });
+    if (!response.ok) {
+        await handleHttpError(response, path);
+    }
+    const text = await response.text();
+    if (!text.trim()) {
+        throw new Error(`Empty response from ${path}`);
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const snippet = text.slice(0, 200);
+        throw new Error(`Invalid JSON from ${path}: ${message}. Body: ${snippet}`);
+    }
+}
+async function cliPost(path, body) {
+    const backendUrl = getBackendUrl();
+    const accessToken = await getValidAccessToken();
+    const response = await fetch(`${backendUrl}${path}`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+            ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
+        },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        await handleHttpError(response, path);
+    }
+    const text = await response.text();
+    if (!text.trim()) {
+        throw new Error(`Empty response from ${path}`);
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const snippet = text.slice(0, 200);
+        throw new Error(`Invalid JSON from ${path}: ${message}. Body: ${snippet}`);
+    }
+}
+// =============================================================================
+// Query Functions (read-only, return denormalized data)
+// =============================================================================
+export async function listSlices(modelId, format = 'xml', chapterFilter) {
+    const params = { modelId };
+    if (chapterFilter)
+        params.chapter = chapterFilter;
+    return cliGetText('/cli/list-slices', params, format);
+}
+export async function listEvents(modelId, format = 'xml') {
+    return cliGetText('/cli/list-events', { modelId }, format);
+}
+export async function listCommands(modelId, format = 'xml') {
+    return cliGetText('/cli/list-commands', { modelId }, format);
+}
+export async function listChapters(modelId, format = 'xml') {
+    return cliGetText('/cli/list-chapters', { modelId }, format);
+}
+export async function listActors(modelId, format = 'xml') {
+    return cliGetText('/cli/list-actors', { modelId }, format);
+}
+export async function search(modelId, term) {
+    return cliGet('/cli/search', { modelId, term });
+}
+export async function getSummary(modelId) {
+    return cliGet('/cli/summary', { modelId });
+}
+export async function markSliceStatus(modelId, sliceName, status) {
+    return cliPost('/cli/mark-slice-status', { modelId, sliceName, status });
+}
+export async function addField(modelId, elementType, elementName, field) {
+    return cliPost('/cli/add-field', { modelId, elementType, elementName, field });
+}
+export async function removeField(modelId, elementType, elementName, fieldName) {
+    return cliPost('/cli/remove-field', { modelId, elementType, elementName, fieldName });
+}
+export async function updateField(modelId, elementType, elementName, fieldName, updates) {
+    return cliPost('/cli/update-field', { modelId, elementType, elementName, fieldName, updates });
+}
+export async function mapFields(modelId, sourceName, targetName, mappings) {
+    return cliPost('/cli/map-fields', { modelId, sourceName, targetName, mappings });
+}
+export async function createScenario(modelId, sliceName, scenario) {
+    return cliPost('/cli/create-scenario', { modelId, sliceName, scenario });
+}
+export async function removeScenario(modelId, scenarioName, sliceName) {
+    return cliPost('/cli/remove-scenario', { modelId, scenarioName, sliceName });
+}
+export async function createFlow(modelId, fromName, toName) {
+    return cliPost('/cli/create-flow', { modelId, fromName, toName });
+}
+export async function createStateChangeSlice(modelId, input) {
+    return cliPost('/cli/create-state-change-slice', { modelId, ...input });
+}
+export async function createAutomationSlice(modelId, input) {
+    return cliPost('/cli/create-automation-slice', { modelId, ...input });
+}
+export async function createStateViewSlice(modelId, input) {
+    return cliPost('/cli/create-state-view-slice', { modelId, ...input });
+}
+// =============================================================================
+// View Functions (read-only, return formatted XML/JSON strings)
+// =============================================================================
+// Maps format to Accept header media type for content negotiation with the backend
+function formatToMediaType(format) {
+    return format === 'xml' ? 'application/xml' : 'application/json';
+}
+// Helper for view queries that return text (XML or JSON string).
+// Uses Accept header for content negotiation instead of a format query param.
+async function cliGetText(path, params, format) {
+    const backendUrl = getBackendUrl();
+    const accessToken = await getValidAccessToken();
+    const url = new URL(`${backendUrl}${path}`);
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined) {
+            url.searchParams.set(key, value);
+        }
+    }
+    const response = await fetch(url.toString(), {
+        method: 'GET',
+        headers: {
+            Accept: formatToMediaType(format),
+            ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
+        },
+    });
+    if (!response.ok) {
+        await handleHttpError(response, path);
+    }
+    const text = await response.text();
+    return text.trimEnd();
+}
+export async function showSlice(modelId, sliceName, format = 'xml') {
+    return cliGetText('/cli/show-slice', { modelId, name: sliceName }, format);
+}
+export async function showEvent(modelId, eventName, format = 'xml') {
+    return cliGetText('/cli/show-event', { modelId, name: eventName }, format);
+}
+export async function showCommand(modelId, commandName, format = 'xml') {
+    return cliGetText('/cli/show-command', { modelId, name: commandName }, format);
+}
+export async function showChapter(modelId, chapterName, format = 'xml') {
+    return cliGetText('/cli/show-chapter', { modelId, name: chapterName }, format);
+}
+export async function showActor(modelId, actorName, format = 'xml') {
+    return cliGetText('/cli/show-actor', { modelId, name: actorName }, format);
+}
+export async function exportJson(modelId) {
+    return cliGetText('/cli/export-json', { modelId });
+}
+export async function codegenSlice(modelId, sliceName) {
+    return cliGetText('/cli/codegen-slice', { modelId, name: sliceName });
+}
+export async function listAggregates(modelId, format = 'xml') {
+    return cliGetText('/cli/list-aggregates', { modelId }, format);
+}
+export async function listReadModels(modelId, format = 'xml') {
+    return cliGetText('/cli/list-readmodels', { modelId }, format);
+}
+export async function listScreens(modelId, format = 'xml') {
+    return cliGetText('/cli/list-screens', { modelId }, format);
+}
+export async function listProcessors(modelId, format = 'xml') {
+    return cliGetText('/cli/list-processors', { modelId }, format);
+}
+export async function showCompleteness(modelId, elementName, format = 'xml') {
+    return cliGetText('/cli/show-completeness', { modelId, name: elementName }, format);
+}
+export async function showModelCompleteness(modelId, format = 'xml') {
+    return cliGetText('/cli/show-model-completeness', { modelId }, format);
+}
+export async function showAggregateCompleteness(modelId, aggregateName, format = 'xml') {
+    return cliGetText('/cli/show-aggregate-completeness', { modelId, name: aggregateName }, format);
+}
+export async function showReadModel(modelId, name, format = 'xml') {
+    return cliGetText('/cli/show-readmodel', { modelId, name }, format);
+}
+export async function showScreen(modelId, name, format = 'xml') {
+    return cliGetText('/cli/show-screen', { modelId, name }, format);
+}
+export async function showProcessor(modelId, name, format = 'xml') {
+    return cliGetText('/cli/show-processor', { modelId, name }, format);
+}
+export async function showAggregate(modelId, name, format = 'xml') {
+    return cliGetText('/cli/show-aggregate', { modelId, name }, format);
+}
+export async function showScenario(modelId, name, format = 'xml') {
+    return cliGetText('/cli/show-scenario', { modelId, name }, format);
+}
+export async function listScenarios(modelId, format = 'xml') {
+    return cliGetText('/cli/list-scenarios', { modelId }, format);
+}