eventmodeler 0.4.4 → 0.4.6

package/dist/api/index.d.ts

@@ -0,0 +1,282 @@
+export interface ModelInfo {
+    modelId: string;
+    name: string;
+    updatedAt: number;
+    permission: string;
+}
+export declare function listModels(): Promise<ModelInfo[]>;
+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;
+    chapterId?: string;
+    chapterName?: string;
+    sliceId?: string;
+    sliceName?: string;
+    sliceStatus?: string;
+    parentChapterId?: string;
+    parentChapterName?: 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 interface FieldInput {
+    name: string;
+    fieldType: string;
+    isList?: boolean;
+    isOptional?: boolean;
+    isGenerated?: boolean;
+    isUserInput?: boolean;
+    subfields?: FieldInput[];
+}
+export declare function addField(modelId: string, elementName: string, field: FieldInput): Promise<{
+    success: boolean;
+}>;
+export declare function removeField(modelId: string, 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, 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?: Array<{
+        event: string;
+        fieldValues?: Record<string, unknown>;
+    }>;
+    when?: {
+        command?: {
+            command: string;
+            fieldValues?: Record<string, unknown>;
+        };
+        events?: Array<{
+            event: string;
+            fieldValues?: Record<string, unknown>;
+        }>;
+    };
+    then: {
+        type: 'events' | 'error' | 'command' | 'readModelAssertion' | 'noCommand';
+        events?: Array<{
+            event: string;
+            fieldValues?: Record<string, unknown>;
+        }>;
+        errorMessage?: string;
+        errorType?: string;
+        command?: {
+            command: string;
+            fieldValues?: Record<string, unknown>;
+        };
+        readModelAssertion?: {
+            readModel: string;
+            givenEvents?: Array<{
+                event: string;
+                fieldValues?: Record<string, unknown>;
+            }>;
+            expectedFieldValues?: Record<string, unknown>;
+        };
+    };
+}
+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;
+    subfields?: CompoundFieldInput[];
+}
+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 interface CodegenChapterEventsField {
+    name: string;
+    type: string;
+    list?: boolean;
+    generated?: boolean;
+    optional?: boolean;
+    userInput?: boolean;
+    subfields?: CodegenChapterEventsField[];
+}
+export interface CodegenChapterEventsChapter {
+    id: string;
+    name: string;
+    parent?: CodegenChapterEventsChapter | null;
+}
+export interface CodegenChapterEventsSlice {
+    id: string;
+    name: string;
+    sliceType: string;
+}
+export interface CodegenChapterEventsEvent {
+    id: string;
+    name: string;
+    fields: CodegenChapterEventsField[];
+    aggregate?: string;
+    sourceSlices: string[];
+}
+export interface CodegenChapterEventsResponse {
+    chapter: CodegenChapterEventsChapter | null;
+    sliceCount: number;
+    eventCount: number;
+    slices: CodegenChapterEventsSlice[];
+    events: CodegenChapterEventsEvent[];
+}
+export declare function codegenEvents(modelId: string, chapterName?: string): Promise<CodegenChapterEventsResponse>;
+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 showElementCompleteness(modelId: string, elementName: string, format?: OutputFormat): Promise<string>;
+export declare function showInformationCompleteness(modelId: string, format?: OutputFormat, sliceName?: string, chapterName?: string): 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/api/index.js

@@ -0,0 +1,320 @@
+// API client — 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(() => '');
+    const errorDetail = extractErrorDetail(text);
+    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}`);
+    }
+}
+const GENERIC_ERROR_MESSAGES = new Set([
+    'internal server error',
+    'bad request',
+    'unauthorized',
+    'forbidden',
+    'not found',
+]);
+function isGenericErrorMessage(value) {
+    return GENERIC_ERROR_MESSAGES.has(value.trim().toLowerCase());
+}
+function toStringValue(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function collectCandidateMessages(node, out) {
+    if (!node || typeof node !== 'object')
+        return;
+    const obj = node;
+    // Prefer richer fields before generic "error".
+    for (const key of ['message', 'detail', 'reason', 'description', 'title', 'error']) {
+        const value = toStringValue(obj[key]);
+        if (value)
+            out.push(value);
+    }
+    const errors = obj.errors;
+    if (Array.isArray(errors)) {
+        for (const entry of errors) {
+            if (typeof entry === 'string') {
+                const value = entry.trim();
+                if (value)
+                    out.push(value);
+            }
+            else if (entry && typeof entry === 'object') {
+                collectCandidateMessages(entry, out);
+            }
+        }
+    }
+    const cause = obj.cause;
+    if (cause && typeof cause === 'object') {
+        collectCandidateMessages(cause, out);
+    }
+}
+function extractErrorDetail(text) {
+    const body = text.trim();
+    if (!body)
+        return '';
+    try {
+        const parsed = JSON.parse(body);
+        if (typeof parsed === 'string') {
+            return parsed.trim();
+        }
+        const candidates = [];
+        collectCandidateMessages(parsed, candidates);
+        if (candidates.length > 0) {
+            const specific = candidates.find((value) => !isGenericErrorMessage(value));
+            return specific ?? candidates[0];
+        }
+    }
+    catch {
+        // Not JSON. Fall back to plain text below.
+    }
+    // Avoid dumping entire HTML pages from reverse proxies.
+    if (body.startsWith('<')) {
+        const title = body.match(/<title>([^<]+)<\/title>/i)?.[1]?.trim();
+        return title && !isGenericErrorMessage(title) ? title : '';
+    }
+    return body;
+}
+async function cliGet(path, params) {
+    const backendUrl = getBackendUrl();
+    const accessToken = await getValidAccessToken();
+    // Build query string manually using encodeURIComponent (uses %20 for spaces, not +)
+    const queryParts = Object.entries(params)
+        .filter(([_, value]) => value !== undefined)
+        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+    const queryString = queryParts.length > 0 ? `?${queryParts.join('&')}` : '';
+    const fullUrl = `${backendUrl}${path}${queryString}`;
+    const response = await fetch(fullUrl, {
+        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}`);
+    }
+}
+export async function listModels() {
+    return cliGet('/cli/list-models', {});
+}
+// =============================================================================
+// 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, elementName, field) {
+    return cliPost('/cli/add-field', { modelId, elementName, field });
+}
+export async function removeField(modelId, elementName, fieldName) {
+    return cliPost('/cli/remove-field', { modelId, elementName, fieldName });
+}
+export async function updateField(modelId, elementName, fieldName, updates) {
+    return cliPost('/cli/update-field', { modelId, 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();
+    // Build query string manually using encodeURIComponent (uses %20 for spaces, not +)
+    // Some servers don't decode + as space in query parameters
+    const queryParts = Object.entries(params)
+        .filter(([_, value]) => value !== undefined)
+        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+    const queryString = queryParts.length > 0 ? `?${queryParts.join('&')}` : '';
+    const fullUrl = `${backendUrl}${path}${queryString}`;
+    const response = await fetch(fullUrl, {
+        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 codegenEvents(modelId, chapterName) {
+    const params = { modelId };
+    if (chapterName)
+        params.chapter = chapterName;
+    return cliGet('/cli/codegen-events', params);
+}
+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 showElementCompleteness(modelId, elementName, format = 'xml') {
+    return cliGetText('/cli/show-element-completeness', { modelId, name: elementName }, format);
+}
+export async function showInformationCompleteness(modelId, format = 'xml', sliceName, chapterName) {
+    const params = { modelId };
+    if (sliceName)
+        params.sliceName = sliceName;
+    if (chapterName)
+        params.chapterName = chapterName;
+    return cliGetText('/cli/show-information-completeness', params, 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);
+}