@kapeta/local-cluster-service 0.44.0 → 0.45.0

package/src/storm/event-parser.ts

@@ -0,0 +1,688 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import {
+    ScreenTemplate,
+    StormBlockInfoFilled,
+    StormBlockType,
+    StormConnection,
+    StormEvent,
+    StormResourceType,
+} from './events';
+import {
+    BlockDefinition,
+    BlockInstance,
+    Connection,
+    LanguageTargetReference,
+    Plan,
+    Resource,
+    SourceCode,
+} from '@kapeta/schemas';
+import { KapetaURI, normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
+import { KAPLANG_ID, KAPLANG_VERSION, RESTMethod } from '@kapeta/kaplang-core';
+import uuid from 'node-uuid';
+import { definitionsManager } from '../definitionsManager';
+
+export interface BlockDefinitionInfo {
+    uri: KapetaURI;
+    content: BlockDefinition;
+    screens: ScreenTemplate[];
+}
+
+export interface ParsedResult {
+    plan: Plan;
+    blocks: BlockDefinitionInfo[];
+}
+
+export interface StormOptions {
+    databaseKind: string;
+    apiKind: string;
+    clientKind: string;
+    webPageKind: string;
+    webFragmentKind: string;
+    mqKind: string;
+    serviceKind: string;
+    serviceLanguage: string;
+    frontendKind: string;
+    frontendLanguage: string;
+    exchangeKind: string;
+    queueKind: string;
+    publisherKind: string;
+    subscriberKind: string;
+    jwtProviderKind: string;
+    jwtConsumerKind: string;
+    smtpKind: string;
+    externalApiKind: string;
+    cliKind: string;
+    cliLanguage: string;
+    desktopKind: string;
+    desktopLanguage: string;
+    gatewayKind: string;
+}
+
+export async function resolveOptions(): Promise<StormOptions> {
+    // Predefined types for now - TODO: Allow user to select / change
+
+    const blockTypeService = await definitionsManager.getLatestDefinition('kapeta/block-type-service');
+    const blockTypeFrontend = await definitionsManager.getLatestDefinition('kapeta/block-type-frontend');
+    const blockTypeDesktop = await definitionsManager.getLatestDefinition('kapeta/block-type-desktop');
+    const blockTypeCli = await definitionsManager.getLatestDefinition('kapeta/block-type-cli');
+    const blockTypeGateway = await definitionsManager.getLatestDefinition('kapeta/block-type-gateway-http');
+
+    const postgresResource = await definitionsManager.getLatestDefinition('kapeta/resource-type-postgresql');
+
+    const webPageResource = await definitionsManager.getLatestDefinition('kapeta/resource-type-web-page');
+    const webFragmentResource = await definitionsManager.getLatestDefinition('kapeta/resource-type-web-fragment');
+
+    const restApiResource = await definitionsManager.getLatestDefinition('kapeta/resource-type-rest-api');
+    const restClientResource = await definitionsManager.getLatestDefinition('kapeta/resource-type-rest-client');
+
+    const javaLanguage = await definitionsManager.getLatestDefinition('kapeta/language-target-java-spring-boot');
+    const reactLanguage = await definitionsManager.getLatestDefinition('kapeta/language-target-react-ts');
+    const nodejsLanguage = await definitionsManager.getLatestDefinition('kapeta/language-target-nodejs');
+
+    const blockTypePubsub = await definitionsManager.getLatestDefinition('kapeta/block-type-pubsub');
+    const resourceTypePubsubSubscriber = await definitionsManager.getLatestDefinition(
+        'kapeta/resource-type-pubsub-subscriber'
+    );
+    const resourceTypePubsubSubscription = await definitionsManager.getLatestDefinition(
+        'kapeta/resource-type-pubsub-subscription'
+    );
+    const resourceTypePubsubTopic = await definitionsManager.getLatestDefinition('kapeta/resource-type-pubsub-topic');
+    const resourceTypePubsubPublisher = await definitionsManager.getLatestDefinition(
+        'kapeta/resource-type-pubsub-publisher'
+    );
+
+    const jwtProvider = await definitionsManager.getLatestDefinition('kapeta/resource-type-auth-jwt-provider');
+    const jwtConsumer = await definitionsManager.getLatestDefinition('kapeta/resource-type-auth-jwt-consumer');
+
+    const smtpClient = await definitionsManager.getLatestDefinition('kapeta/resource-type-smtp-client');
+    const externalService = await 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: normalizeKapetaUri(`${blockTypeService.definition.metadata.name}:${blockTypeService.version}`),
+        serviceLanguage: normalizeKapetaUri('kapeta/language-target-java-spring-boot:local'), //normalizeKapetaUri(`${javaLanguage.definition.metadata.name}:${javaLanguage.version}`),
+
+        frontendKind: normalizeKapetaUri(`${blockTypeFrontend.definition.metadata.name}:${blockTypeFrontend.version}`),
+        frontendLanguage: normalizeKapetaUri('kapeta/language-target-react-ts:local'), // normalizeKapetaUri(`${reactLanguage.definition.metadata.name}:${reactLanguage.version}`),
+
+        cliKind: normalizeKapetaUri(`${blockTypeCli.definition.metadata.name}:${blockTypeCli.version}`),
+        cliLanguage: normalizeKapetaUri(`${nodejsLanguage.definition.metadata.name}:${nodejsLanguage.version}`),
+
+        desktopKind: normalizeKapetaUri(`${blockTypeDesktop.definition.metadata.name}:${blockTypeDesktop.version}`),
+        desktopLanguage: normalizeKapetaUri(`${reactLanguage.definition.metadata.name}:${reactLanguage.version}`),
+
+        gatewayKind: normalizeKapetaUri(`${blockTypeGateway.definition.metadata.name}:${blockTypeGateway.version}`),
+
+        mqKind: normalizeKapetaUri(`${blockTypePubsub.definition.metadata.name}:${blockTypePubsub.version}`),
+        exchangeKind: normalizeKapetaUri(
+            `${resourceTypePubsubTopic.definition.metadata.name}:${resourceTypePubsubTopic.version}`
+        ),
+        queueKind: normalizeKapetaUri(
+            `${resourceTypePubsubSubscription.definition.metadata.name}:${resourceTypePubsubSubscription.version}`
+        ),
+        publisherKind: normalizeKapetaUri(
+            `${resourceTypePubsubPublisher.definition.metadata.name}:${resourceTypePubsubPublisher.version}`
+        ),
+        subscriberKind: normalizeKapetaUri(
+            `${resourceTypePubsubSubscriber.definition.metadata.name}:${resourceTypePubsubSubscriber.version}`
+        ),
+
+        databaseKind: normalizeKapetaUri(`${postgresResource.definition.metadata.name}:${postgresResource.version}`),
+
+        apiKind: normalizeKapetaUri(`${restApiResource.definition.metadata.name}:${restApiResource.version}`),
+        clientKind: normalizeKapetaUri(`${restClientResource.definition.metadata.name}:${restClientResource.version}`),
+
+        webPageKind: normalizeKapetaUri(`${webPageResource.definition.metadata.name}:${webPageResource.version}`),
+        webFragmentKind: normalizeKapetaUri(
+            `${webFragmentResource.definition.metadata.name}:${webFragmentResource.version}`
+        ),
+
+        jwtProviderKind: normalizeKapetaUri(`${jwtProvider.definition.metadata.name}:${jwtProvider.version}`),
+        jwtConsumerKind: normalizeKapetaUri(`${jwtConsumer.definition.metadata.name}:${jwtConsumer.version}`),
+
+        smtpKind: normalizeKapetaUri(`${smtpClient.definition.metadata.name}:${smtpClient.version}`),
+        externalApiKind: normalizeKapetaUri(`${externalService.definition.metadata.name}:${externalService.version}`),
+    };
+}
+
+export class StormEventParser {
+    private events: StormEvent[] = [];
+    private planName: string = '';
+    private planDescription: string = '';
+    private blocks: { [key: string]: StormBlockInfoFilled } = {};
+    private connections: StormConnection[] = [];
+    private failed: boolean = false;
+    private error: string = '';
+    private options: StormOptions;
+
+    constructor(options: StormOptions) {
+        this.options = options;
+    }
+
+    private reset() {
+        this.planDescription = '';
+        this.planName = '';
+        this.blocks = {};
+        this.connections = [];
+    }
+
+    public addEvent(evt: StormEvent): void {
+        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;
+        }
+    }
+
+    public getEvents(): StormEvent[] {
+        return this.events;
+    }
+
+    public isValid(): boolean {
+        return !this.failed;
+    }
+
+    public getError(): string {
+        return this.error;
+    }
+
+    private applyLayoutToBlocks(result: ParsedResult): ParsedResult {
+        return result;
+    }
+
+    public toResult(handle: string): ParsedResult {
+        const planRef = this.toRef(handle, this.planName);
+        const blockDefinitions = this.toBlockDefinitions(handle);
+        const refIdMap: { [key: string]: string } = {};
+        const screens: { [key: string]: ScreenTemplate[] } = {};
+        const blocks = Object.entries(blockDefinitions).map(([ref, block]) => {
+            const id = uuid.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,
+                },
+            } satisfies BlockInstance;
+        });
+
+        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
+                },
+            } satisfies Connection;
+        });
+
+        const plan: 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),
+        });
+    }
+
+    private toSafeName(name: string): string {
+        return name.toLowerCase().replace(/[^0-9a-z-]/gi, '');
+    }
+
+    private toRef(handle: string, name: string) {
+        return parseKapetaUri(handle + '/' + this.toSafeName(name) + ':local');
+    }
+
+    public toBlockDefinitions(handle: string): { [key: string]: BlockDefinitionInfo } {
+        const result: { [key: string]: BlockDefinitionInfo } = {};
+
+        Object.entries(this.blocks).forEach(([, blockInfo]) => {
+            const blockRef = this.toRef(handle, blockInfo.name);
+
+            const blockDefinitionInfo: 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_ID,
+                                version: KAPLANG_VERSION,
+                                value: '',
+                            },
+                        },
+                        target: this.toBlockTarget(handle, blockInfo.type),
+                        providers: [],
+                        consumers: [],
+                    },
+                },
+                screens: blockInfo.screens,
+            };
+
+            const blockSpec = blockDefinitionInfo.content.spec;
+
+            let apiResource: Resource | undefined = undefined;
+            let dbResource: Resource | undefined = 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_ID,
+                                    version: KAPLANG_VERSION,
+                                    value: '',
+                                } satisfies SourceCode,
+                            },
+                        };
+                        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_ID,
+                                    version: KAPLANG_VERSION,
+                                    value: '',
+                                } satisfies SourceCode,
+                            },
+                        });
+                        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_ID,
+                                    version: KAPLANG_VERSION,
+                                    value: '',
+                                } satisfies SourceCode,
+                            },
+                        };
+                        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;
+    }
+
+    private toResourceKind(type: StormResourceType) {
+        //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 '';
+    }
+
+    private toBlockKind(type: StormBlockType) {
+        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 '';
+    }
+
+    private toPortType(type: StormResourceType) {
+        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';
+    }
+
+    private toBlockTarget(handle: string, type: StormBlockType): LanguageTargetReference | undefined {
+        const kind = this.toBlockTargetKind(type);
+        if (!kind) {
+            return undefined;
+        }
+
+        let options: { [key: string]: any } = {};
+
+        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,
+        };
+    }
+
+    private toBlockTargetKind(type: StormBlockType): string | undefined {
+        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;
+    }
+}