@kapeta/local-cluster-service 0.43.3 → 0.45.0

package/dist/esm/src/storm/event-parser.js

@@ -0,0 +1,543 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StormEventParser = exports.resolveOptions = void 0;
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const kaplang_core_1 = require("@kapeta/kaplang-core");
+const node_uuid_1 = __importDefault(require("node-uuid"));
+const definitionsManager_1 = require("../definitionsManager");
+async function resolveOptions() {
+    // Predefined types for now - TODO: Allow user to select / change
+    const blockTypeService = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/block-type-service');
+    const blockTypeFrontend = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/block-type-frontend');
+    const blockTypeDesktop = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/block-type-desktop');
+    const blockTypeCli = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/block-type-cli');
+    const blockTypeGateway = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/block-type-gateway-http');
+    const postgresResource = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-postgresql');
+    const webPageResource = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-web-page');
+    const webFragmentResource = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-web-fragment');
+    const restApiResource = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-rest-api');
+    const restClientResource = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-rest-client');
+    const javaLanguage = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/language-target-java-spring-boot');
+    const reactLanguage = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/language-target-react-ts');
+    const nodejsLanguage = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/language-target-nodejs');
+    const blockTypePubsub = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/block-type-pubsub');
+    const resourceTypePubsubSubscriber = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-pubsub-subscriber');
+    const resourceTypePubsubSubscription = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-pubsub-subscription');
+    const resourceTypePubsubTopic = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-pubsub-topic');
+    const resourceTypePubsubPublisher = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-pubsub-publisher');
+    const jwtProvider = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-auth-jwt-provider');
+    const jwtConsumer = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-auth-jwt-consumer');
+    const smtpClient = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-smtp-client');
+    const externalService = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/resource-type-external-services');
+    if (!blockTypeService ||
+        !blockTypeFrontend ||
+        !blockTypeDesktop ||
+        !blockTypeGateway ||
+        !postgresResource ||
+        !javaLanguage ||
+        !reactLanguage ||
+        !webPageResource ||
+        !restApiResource ||
+        !restClientResource ||
+        !webFragmentResource ||
+        !blockTypePubsub ||
+        !resourceTypePubsubSubscriber ||
+        !resourceTypePubsubSubscription ||
+        !resourceTypePubsubTopic ||
+        !resourceTypePubsubPublisher ||
+        !jwtProvider ||
+        !jwtConsumer ||
+        !smtpClient ||
+        !externalService ||
+        !blockTypeCli ||
+        !nodejsLanguage) {
+        throw new Error('Missing definitions');
+    }
+    return {
+        serviceKind: (0, nodejs_utils_1.normalizeKapetaUri)(`${blockTypeService.definition.metadata.name}:${blockTypeService.version}`),
+        serviceLanguage: (0, nodejs_utils_1.normalizeKapetaUri)('kapeta/language-target-java-spring-boot:local'), //normalizeKapetaUri(`${javaLanguage.definition.metadata.name}:${javaLanguage.version}`),
+        frontendKind: (0, nodejs_utils_1.normalizeKapetaUri)(`${blockTypeFrontend.definition.metadata.name}:${blockTypeFrontend.version}`),
+        frontendLanguage: (0, nodejs_utils_1.normalizeKapetaUri)('kapeta/language-target-react-ts:local'), // normalizeKapetaUri(`${reactLanguage.definition.metadata.name}:${reactLanguage.version}`),
+        cliKind: (0, nodejs_utils_1.normalizeKapetaUri)(`${blockTypeCli.definition.metadata.name}:${blockTypeCli.version}`),
+        cliLanguage: (0, nodejs_utils_1.normalizeKapetaUri)(`${nodejsLanguage.definition.metadata.name}:${nodejsLanguage.version}`),
+        desktopKind: (0, nodejs_utils_1.normalizeKapetaUri)(`${blockTypeDesktop.definition.metadata.name}:${blockTypeDesktop.version}`),
+        desktopLanguage: (0, nodejs_utils_1.normalizeKapetaUri)(`${reactLanguage.definition.metadata.name}:${reactLanguage.version}`),
+        gatewayKind: (0, nodejs_utils_1.normalizeKapetaUri)(`${blockTypeGateway.definition.metadata.name}:${blockTypeGateway.version}`),
+        mqKind: (0, nodejs_utils_1.normalizeKapetaUri)(`${blockTypePubsub.definition.metadata.name}:${blockTypePubsub.version}`),
+        exchangeKind: (0, nodejs_utils_1.normalizeKapetaUri)(`${resourceTypePubsubTopic.definition.metadata.name}:${resourceTypePubsubTopic.version}`),
+        queueKind: (0, nodejs_utils_1.normalizeKapetaUri)(`${resourceTypePubsubSubscription.definition.metadata.name}:${resourceTypePubsubSubscription.version}`),
+        publisherKind: (0, nodejs_utils_1.normalizeKapetaUri)(`${resourceTypePubsubPublisher.definition.metadata.name}:${resourceTypePubsubPublisher.version}`),
+        subscriberKind: (0, nodejs_utils_1.normalizeKapetaUri)(`${resourceTypePubsubSubscriber.definition.metadata.name}:${resourceTypePubsubSubscriber.version}`),
+        databaseKind: (0, nodejs_utils_1.normalizeKapetaUri)(`${postgresResource.definition.metadata.name}:${postgresResource.version}`),
+        apiKind: (0, nodejs_utils_1.normalizeKapetaUri)(`${restApiResource.definition.metadata.name}:${restApiResource.version}`),
+        clientKind: (0, nodejs_utils_1.normalizeKapetaUri)(`${restClientResource.definition.metadata.name}:${restClientResource.version}`),
+        webPageKind: (0, nodejs_utils_1.normalizeKapetaUri)(`${webPageResource.definition.metadata.name}:${webPageResource.version}`),
+        webFragmentKind: (0, nodejs_utils_1.normalizeKapetaUri)(`${webFragmentResource.definition.metadata.name}:${webFragmentResource.version}`),
+        jwtProviderKind: (0, nodejs_utils_1.normalizeKapetaUri)(`${jwtProvider.definition.metadata.name}:${jwtProvider.version}`),
+        jwtConsumerKind: (0, nodejs_utils_1.normalizeKapetaUri)(`${jwtConsumer.definition.metadata.name}:${jwtConsumer.version}`),
+        smtpKind: (0, nodejs_utils_1.normalizeKapetaUri)(`${smtpClient.definition.metadata.name}:${smtpClient.version}`),
+        externalApiKind: (0, nodejs_utils_1.normalizeKapetaUri)(`${externalService.definition.metadata.name}:${externalService.version}`),
+    };
+}
+exports.resolveOptions = resolveOptions;
+class StormEventParser {
+    events = [];
+    planName = '';
+    planDescription = '';
+    blocks = {};
+    connections = [];
+    failed = false;
+    error = '';
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    reset() {
+        this.planDescription = '';
+        this.planName = '';
+        this.blocks = {};
+        this.connections = [];
+    }
+    addEvent(evt) {
+        console.log('Processing storm event', evt);
+        this.events.push(evt);
+        switch (evt.type) {
+            case 'CREATE_PLAN_PROPERTIES':
+                this.planName = evt.payload.name;
+                this.planDescription = evt.payload.description;
+                break;
+            case 'CREATE_BLOCK':
+                this.blocks[evt.payload.name] = {
+                    ...evt.payload,
+                    apis: [],
+                    models: [],
+                    types: [],
+                    screens: [],
+                };
+                break;
+            case 'PLAN_RETRY':
+                this.reset();
+                break;
+            case 'PLAN_RETRY_FAILED':
+                this.failed = true;
+                this.error = evt.payload.error;
+                break;
+            case 'CREATE_API':
+                this.blocks[evt.payload.blockName].apis.push(evt.payload.content);
+                break;
+            case 'CREATE_TYPE':
+                this.blocks[evt.payload.blockName].types.push(evt.payload.content);
+                break;
+            case 'CREATE_MODEL':
+                this.blocks[evt.payload.blockName].models.push(evt.payload.content);
+                break;
+            case 'CREATE_CONNECTION':
+                this.connections.push(evt.payload);
+                break;
+            case 'SCREEN':
+                this.blocks[evt.payload.blockName].screens.push({
+                    name: evt.payload.name,
+                    description: evt.payload.description,
+                    url: evt.payload.url,
+                    template: evt.payload.template,
+                });
+                break;
+            default:
+            case 'SCREEN_CANDIDATE':
+            case 'FILE':
+                console.warn('Unhandled event: %s', evt.type, evt);
+                break;
+        }
+    }
+    getEvents() {
+        return this.events;
+    }
+    isValid() {
+        return !this.failed;
+    }
+    getError() {
+        return this.error;
+    }
+    applyLayoutToBlocks(result) {
+        return result;
+    }
+    toResult(handle) {
+        const planRef = this.toRef(handle, this.planName);
+        const blockDefinitions = this.toBlockDefinitions(handle);
+        const refIdMap = {};
+        const screens = {};
+        const blocks = Object.entries(blockDefinitions).map(([ref, block]) => {
+            const id = node_uuid_1.default.v4();
+            refIdMap[ref] = id;
+            return {
+                id,
+                block: {
+                    ref,
+                },
+                name: block.content.metadata.title ?? block.content.metadata.name,
+                dimensions: {
+                    left: 0,
+                    top: 0,
+                    width: 200,
+                    height: 200,
+                },
+            };
+        });
+        Object.values(this.blocks).forEach((blockInfo) => {
+            const blockRef = this.toRef(handle, blockInfo.name);
+            const block = blockDefinitions[blockRef.toNormalizedString()];
+            if (!block) {
+                console.warn('Block not found: %s', blockInfo.name);
+                return;
+            }
+            screens[blockRef.fullName] = blockInfo.screens;
+        });
+        // Copy API methods from API provider to CLIENT consumer
+        this.connections
+            .filter((connection) => connection.fromResourceType === 'API' && connection.toResourceType === 'CLIENT')
+            .forEach((apiConnection) => {
+            const apiProviderRef = this.toRef(handle, apiConnection.fromComponent);
+            const clientConsumerRef = this.toRef(handle, apiConnection.toComponent);
+            const apiProviderBlock = blockDefinitions[apiProviderRef.toNormalizedString()];
+            if (!apiProviderBlock) {
+                console.warn('API provider not found: %s', apiConnection.fromComponent);
+                return;
+            }
+            const clientConsumerBlock = blockDefinitions[clientConsumerRef.toNormalizedString()];
+            if (!clientConsumerBlock) {
+                console.warn('Client consumer not found: %s', apiConnection.toComponent);
+                return;
+            }
+            const apiResource = apiProviderBlock.content.spec.providers?.find((p) => p.kind === this.options.apiKind && p.metadata.name === apiConnection.fromResource);
+            if (!apiResource) {
+                console.warn('API resource not found: %s on %s', apiConnection.fromResource, apiProviderRef.toNormalizedString());
+                return;
+            }
+            const clientResource = clientConsumerBlock.content.spec.consumers?.find((clientResource) => {
+                if (clientResource.kind !== this.options.clientKind) {
+                    return;
+                }
+                if (clientResource.metadata.name !== apiConnection.toResource) {
+                    return;
+                }
+            });
+            if (!clientResource) {
+                console.warn('Client resource not found: %s on %s', apiConnection.toResource, clientConsumerRef.toNormalizedString());
+                return;
+            }
+            clientResource.spec.methods = apiResource.spec.methods;
+            clientResource.spec.source = apiResource.spec.source;
+        });
+        const connections = this.connections.map((connection) => {
+            const fromRef = this.toRef(handle, connection.fromComponent);
+            const toRef = this.toRef(handle, connection.toComponent);
+            return {
+                port: {
+                    type: this.toPortType(connection.fromResourceType),
+                },
+                consumer: {
+                    blockId: refIdMap[toRef.toNormalizedString()],
+                    resourceName: connection.toResource,
+                },
+                provider: {
+                    blockId: refIdMap[fromRef.toNormalizedString()],
+                    resourceName: connection.fromResource,
+                },
+                mapping: {
+                //TODO: Add mapping
+                },
+            };
+        });
+        const plan = {
+            kind: 'core/plan',
+            metadata: {
+                name: planRef.fullName,
+                title: this.planName,
+                description: this.planDescription,
+            },
+            spec: {
+                blocks,
+                connections,
+            },
+        };
+        return this.applyLayoutToBlocks({
+            plan,
+            blocks: Object.values(blockDefinitions),
+        });
+    }
+    toSafeName(name) {
+        return name.toLowerCase().replace(/[^0-9a-z-]/gi, '');
+    }
+    toRef(handle, name) {
+        return (0, nodejs_utils_1.parseKapetaUri)(handle + '/' + this.toSafeName(name) + ':local');
+    }
+    toBlockDefinitions(handle) {
+        const result = {};
+        Object.entries(this.blocks).forEach(([, blockInfo]) => {
+            const blockRef = this.toRef(handle, blockInfo.name);
+            const blockDefinitionInfo = {
+                uri: blockRef,
+                content: {
+                    kind: this.toBlockKind(blockInfo.type),
+                    metadata: {
+                        title: blockInfo.name,
+                        name: blockRef.fullName,
+                        description: blockInfo.description,
+                    },
+                    spec: {
+                        entities: {
+                            types: [],
+                            source: {
+                                type: kaplang_core_1.KAPLANG_ID,
+                                version: kaplang_core_1.KAPLANG_VERSION,
+                                value: '',
+                            },
+                        },
+                        target: this.toBlockTarget(handle, blockInfo.type),
+                        providers: [],
+                        consumers: [],
+                    },
+                },
+                screens: blockInfo.screens,
+            };
+            const blockSpec = blockDefinitionInfo.content.spec;
+            let apiResource = undefined;
+            let dbResource = undefined;
+            blockInfo.resources.forEach((resource) => {
+                const port = {
+                    type: this.toPortType(resource.type),
+                };
+                switch (resource.type) {
+                    case 'API':
+                        if (apiResource) {
+                            break;
+                        }
+                        apiResource = {
+                            kind: this.toResourceKind(resource.type),
+                            metadata: {
+                                name: resource.name,
+                                description: resource.description,
+                            },
+                            spec: {
+                                port,
+                                methods: {},
+                                source: {
+                                    type: kaplang_core_1.KAPLANG_ID,
+                                    version: kaplang_core_1.KAPLANG_VERSION,
+                                    value: '',
+                                },
+                            },
+                        };
+                        blockSpec.providers.push(apiResource);
+                        break;
+                    case 'CLIENT':
+                        blockSpec.consumers.push({
+                            kind: this.toResourceKind(resource.type),
+                            metadata: {
+                                name: resource.name,
+                                description: resource.description,
+                            },
+                            spec: {
+                                port,
+                                methods: {},
+                                source: {
+                                    type: kaplang_core_1.KAPLANG_ID,
+                                    version: kaplang_core_1.KAPLANG_VERSION,
+                                    value: '',
+                                },
+                            },
+                        });
+                        break;
+                    case 'EXTERNAL_API':
+                        break;
+                    case 'EXCHANGE':
+                        break;
+                    case 'PUBLISHER':
+                        break;
+                    case 'QUEUE':
+                        break;
+                    case 'SUBSCRIBER':
+                        break;
+                    case 'JWTPROVIDER':
+                    case 'WEBPAGE':
+                        blockSpec.providers.push({
+                            kind: this.toResourceKind(resource.type),
+                            metadata: {
+                                name: resource.name,
+                                description: resource.description,
+                            },
+                            spec: {
+                                port,
+                            },
+                        });
+                        break;
+                    case 'DATABASE':
+                        if (dbResource) {
+                            break;
+                        }
+                        dbResource = {
+                            kind: this.toResourceKind(resource.type),
+                            metadata: {
+                                name: resource.name,
+                                description: resource.description,
+                            },
+                            spec: {
+                                port,
+                                models: [],
+                                source: {
+                                    type: kaplang_core_1.KAPLANG_ID,
+                                    version: kaplang_core_1.KAPLANG_VERSION,
+                                    value: '',
+                                },
+                            },
+                        };
+                        blockSpec.providers.push(dbResource);
+                        break;
+                    case 'JWTCONSUMER':
+                    case 'WEBFRAGMENT':
+                    case 'SMTPCLIENT':
+                        blockSpec.consumers.push({
+                            kind: this.toResourceKind(resource.type),
+                            metadata: {
+                                name: resource.name,
+                                description: resource.description,
+                            },
+                            spec: {
+                                port,
+                            },
+                        });
+                }
+            });
+            if (apiResource) {
+                blockInfo.apis.forEach((api) => {
+                    apiResource.spec.source.value += api + '\n\n';
+                });
+            }
+            blockInfo.types.forEach((type) => {
+                blockSpec.entities.source.value += type + '\n';
+            });
+            if (dbResource) {
+                blockInfo.models.forEach((model) => {
+                    dbResource.spec.source.value += model + '\n';
+                });
+            }
+            result[blockRef.toNormalizedString()] = blockDefinitionInfo;
+        });
+        return result;
+    }
+    toResourceKind(type) {
+        //TODO: Handle support for multiple resource types and versions
+        switch (type) {
+            case 'API':
+                return this.options.apiKind;
+            case 'CLIENT':
+                return this.options.clientKind;
+            case 'DATABASE':
+                return this.options.databaseKind;
+            case 'JWTPROVIDER':
+                return this.options.jwtProviderKind;
+            case 'JWTCONSUMER':
+                return this.options.jwtConsumerKind;
+            case 'WEBFRAGMENT':
+                return this.options.webFragmentKind;
+            case 'WEBPAGE':
+                return this.options.webPageKind;
+            case 'SMTPCLIENT':
+                return this.options.smtpKind;
+            case 'EXTERNAL_API':
+                return this.options.externalApiKind;
+            case 'SUBSCRIBER':
+                return this.options.subscriberKind;
+            case 'PUBLISHER':
+                return this.options.publisherKind;
+            case 'QUEUE':
+                return this.options.queueKind;
+            case 'EXCHANGE':
+                return this.options.exchangeKind;
+        }
+        return '';
+    }
+    toBlockKind(type) {
+        switch (type) {
+            case 'BACKEND':
+                return this.options.serviceKind;
+            case 'FRONTEND':
+                return this.options.frontendKind;
+            case 'CLI':
+                return this.options.cliKind;
+            case 'DESKTOP':
+                return this.options.desktopKind;
+            case 'GATEWAY':
+                return this.options.gatewayKind;
+            case 'MQ':
+                return this.options.mqKind;
+        }
+        return '';
+    }
+    toPortType(type) {
+        switch (type) {
+            case 'API':
+            case 'CLIENT':
+                return 'rest';
+            case 'JWTPROVIDER':
+            case 'JWTCONSUMER':
+                return 'http';
+            case 'WEBFRAGMENT':
+            case 'WEBPAGE':
+                return 'web';
+            case 'SUBSCRIBER':
+            case 'PUBLISHER':
+            case 'QUEUE':
+            case 'EXCHANGE':
+                // PubSub uses http. TODO: Handle support for multiple MQ types
+                return 'http';
+            case 'SMTPCLIENT':
+                return 'smtp';
+            case 'DATABASE':
+                //TODO: Handle support for multiple DB types
+                return 'postgres';
+        }
+        return 'http';
+    }
+    toBlockTarget(handle, type) {
+        const kind = this.toBlockTargetKind(type);
+        if (!kind) {
+            return undefined;
+        }
+        let options = {};
+        if (kind.includes('java')) {
+            const groupId = `ai.${this.toSafeName(handle)}`;
+            const artifactId = this.toSafeName(this.planName);
+            options = {
+                groupId,
+                artifactId,
+                basePackage: `${groupId}.${artifactId}`,
+            };
+        }
+        return {
+            kind,
+            options,
+        };
+    }
+    toBlockTargetKind(type) {
+        switch (type) {
+            case 'BACKEND':
+                return this.options.serviceLanguage;
+            case 'CLI':
+                return this.options.cliLanguage;
+            case 'FRONTEND':
+                return this.options.frontendLanguage;
+            case 'DESKTOP':
+                return this.options.desktopLanguage;
+        }
+        return undefined;
+    }
+}
+exports.StormEventParser = StormEventParser;

package/dist/esm/src/storm/events.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+export type StormResourceType = 'API' | 'DATABASE' | 'CLIENT' | 'JWTPROVIDER' | 'JWTCONSUMER' | 'WEBFRAGMENT' | 'WEBPAGE' | 'SMTPCLIENT' | 'EXTERNAL_API' | 'SUBSCRIBER' | 'PUBLISHER' | 'QUEUE' | 'EXCHANGE';
+export type StormBlockType = 'BACKEND' | 'FRONTEND' | 'GATEWAY' | 'MQ' | 'CLI' | 'DESKTOP';
+export interface StormBlockInfo {
+    type: StormBlockType;
+    name: string;
+    description: string;
+    resources: {
+        type: StormResourceType;
+        name: string;
+        description: string;
+    }[];
+}
+export interface StormBlockInfoFilled extends StormBlockInfo {
+    apis: string[];
+    types: string[];
+    models: string[];
+    screens: ScreenTemplate[];
+}
+export interface StormEventCreateBlock {
+    type: 'CREATE_BLOCK';
+    reason: string;
+    created: number;
+    payload: StormBlockInfo;
+}
+export interface StormConnection {
+    fromComponent: string;
+    fromResource: string;
+    fromResourceType: StormResourceType;
+    toComponent: string;
+    toResource: string;
+    toResourceType: StormResourceType;
+}
+export interface StormEventCreateConnection {
+    type: 'CREATE_CONNECTION';
+    reason: string;
+    created: number;
+    payload: StormConnection;
+}
+export interface StormEventCreatePlanProperties {
+    type: 'CREATE_PLAN_PROPERTIES';
+    reason: string;
+    created: number;
+    payload: {
+        name: string;
+        description: string;
+    };
+}
+export interface StormEventInvalidResponse {
+    type: 'INVALID_RESPONSE';
+    reason: string;
+    created: number;
+    payload: {
+        error: string;
+    };
+}
+export interface StormEventPlanRetry {
+    type: 'PLAN_RETRY' | 'PLAN_RETRY_FAILED';
+    reason: string;
+    created: number;
+    payload: {
+        error: string;
+    };
+}
+export interface StormEventCreateDSL {
+    type: 'CREATE_API' | 'CREATE_TYPE' | 'CREATE_MODEL';
+    reason: string;
+    created: number;
+    payload: {
+        blockName: string;
+        content: string;
+    };
+}
+export interface StormEventError {
+    type: 'INVALID_RESPONSE' | 'ERROR_INTERNAL';
+    reason: string;
+    created: number;
+    payload: {
+        error: string;
+    };
+}
+export interface ScreenTemplate {
+    name: string;
+    template: string;
+    description: string;
+    url: string;
+}
+export interface StormEventScreen {
+    type: 'SCREEN';
+    reason: string;
+    created: number;
+    payload: {
+        blockName: string;
+        name: string;
+        template: string;
+        description: string;
+        url: string;
+    };
+}
+export interface StormEventScreenCandidate {
+    type: 'SCREEN_CANDIDATE';
+    reason: string;
+    created: number;
+    payload: {
+        name: string;
+        description: string;
+        url: string;
+    };
+}
+export interface StormEventFile {
+    type: 'FILE';
+    reason: string;
+    created: number;
+    payload: {
+        filename: string;
+        content: string;
+        blockRef: string;
+    };
+}
+export interface StormEventDone {
+    type: 'DONE';
+    created: number;
+}
+export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFile | StormEventDone;

package/dist/esm/src/storm/events.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/src/storm/routes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+/// <reference types="express" />
+declare const router: import("express").Router;
+export default router;