@kapeta/local-cluster-service 0.30.1 → 0.32.0

package/src/ai/routes.ts

@@ -0,0 +1,39 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import Router from 'express-promise-router';
+import { Response } from 'express';
+
+import { corsHandler } from '../middleware/cors';
+
+import { stringBody, StringBodyRequest } from '../middleware/stringBody';
+import { aiClient, AIRequest } from './aiClient';
+import { KapetaBodyRequest } from '../types';
+import YAML from 'yaml';
+
+const router = Router();
+
+router.use('/', corsHandler);
+router.use('/', stringBody);
+
+router.post('/prompt/:handle', async (req: KapetaBodyRequest, res: Response) => {
+    const handle = req.params.handle;
+    try {
+        const aiRequest: AIRequest = JSON.parse(req.stringBody ?? '{}');
+        const result = await aiClient.sendPrompt(handle, aiRequest);
+        if (req.accepts('application/yaml')) {
+            res.set('Content-Type', 'application/yaml');
+            res.send(YAML.stringify(result));
+        } else {
+            res.json(result);
+        }
+    } catch (err: any) {
+        console.error('Failed to send prompt', err);
+        res.status(400).send({ error: err.message });
+        return;
+    }
+});
+
+export default router;

package/src/ai/transform.ts

@@ -0,0 +1,275 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { BlockDefinition, Plan } from '@kapeta/schemas';
+import { Application } from './types';
+import { definitionsManager } from '../definitionsManager';
+import { normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
+import uuid from 'node-uuid';
+
+export type PlanContext = {
+    plan: Plan;
+    blocks: BlockDefinition[];
+};
+
+async function getFreeName(name: string) {
+    let currentName = name;
+    let iteration = 1;
+    do {
+        const found = await definitionsManager.getLatestDefinition(currentName);
+        if (!found) {
+            return currentName;
+        }
+        currentName = name + '_' + iteration++;
+    } while (true);
+}
+
+export const transformToPlan = async (handle: string, application: Application): Promise<PlanContext> => {
+    const blockTypeService = await definitionsManager.getLatestDefinition('kapeta/block-type-service');
+    const blockTypeFrontend = await definitionsManager.getLatestDefinition('kapeta/block-type-frontend');
+    const mongoDbResource = await definitionsManager.getLatestDefinition('kapeta/resource-type-mongodb');
+    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 nodejsLanguage = await definitionsManager.getLatestDefinition('kapeta/language-target-nodejs');
+    const reactLanguage = await definitionsManager.getLatestDefinition('kapeta/language-target-react-ts');
+
+    if (
+        !blockTypeService ||
+        !blockTypeFrontend ||
+        !mongoDbResource ||
+        !postgresResource ||
+        !javaLanguage ||
+        !nodejsLanguage ||
+        !reactLanguage ||
+        !webPageResource ||
+        !restApiResource ||
+        !restClientResource ||
+        !webFragmentResource
+    ) {
+        throw new Error('Missing definitions');
+    }
+
+    const plan: Plan = {
+        kind: 'core/plan',
+        metadata: {
+            name: await getFreeName(`${handle}/${application.name}`),
+            title: application.title,
+            description: application.description,
+            visibility: 'private',
+        },
+        spec: {
+            blocks: [],
+            connections: [],
+        },
+    };
+
+    const blocks: BlockDefinition[] = [];
+
+    const addToPlan = (ref: string, name: string) => {
+        const top = 100 + Math.floor(plan.spec.blocks.length / 3) * 300;
+        const left = 200 + (plan.spec.blocks.length % 3) * 450;
+
+        plan.spec.blocks.push({
+            block: {
+                ref,
+            },
+            name,
+            id: uuid.v4(),
+            dimensions: {
+                top,
+                left,
+                width: -1,
+                height: -1,
+            },
+        });
+    };
+
+    const nameMapper = new Map<string, string>();
+
+    for (const backend of application.backends) {
+        const blockName = `${handle}/${backend.name}`;
+        const blockRealName = await getFreeName(blockName);
+        nameMapper.set(blockName, blockRealName);
+
+        const language = backend.targetLanguage === 'java' ? javaLanguage : nodejsLanguage;
+        const databaseInfo = backend.databases?.[0];
+        const database = databaseInfo?.type === 'mongodb' ? mongoDbResource : postgresResource;
+
+        const blockRef = normalizeKapetaUri(blockRealName + ':local');
+        let targetOptions = {};
+        if (backend.targetLanguage === 'java') {
+            targetOptions = {
+                basePackage: `${handle}.${application.name}`.toLowerCase().replace(/-/g, '_'),
+                groupId: `${handle}.${application.name}`.toLowerCase().replace(/-/g, '_'),
+                artifactId: backend.name.toLowerCase().replace(/-/g, '_'),
+            };
+        }
+        blocks.push({
+            kind: normalizeKapetaUri(`${blockTypeService.definition.metadata.name}:${blockTypeService.version}`),
+            metadata: {
+                name: blockRealName,
+                title: backend.title,
+                description: backend.description,
+                visibility: 'private',
+            },
+            spec: {
+                target: {
+                    kind: normalizeKapetaUri(`${language.definition.metadata.name}:${language.version}`),
+                    options: targetOptions,
+                },
+                consumers: [
+                    {
+                        kind: normalizeKapetaUri(`${database.definition.metadata.name}:${database.version}`),
+                        metadata: {
+                            name: (databaseInfo?.name ?? 'main').replace(/-/g, ''),
+                        },
+                        spec: {
+                            port: {
+                                type: database.definition.spec.ports[0].type,
+                            },
+                        },
+                    },
+                ],
+                providers: [
+                    {
+                        kind: normalizeKapetaUri(
+                            `${restApiResource.definition.metadata.name}:${restApiResource.version}`
+                        ),
+                        metadata: {
+                            name: 'main',
+                        },
+                        spec: {
+                            port: {
+                                type: restApiResource.definition.spec.ports[0].type,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+
+        addToPlan(blockRef, backend.name);
+    }
+
+    for (const frontend of application.frontends) {
+        const blockName = `${handle}/${frontend.name}`;
+        const blockRealName = await getFreeName(blockName);
+        nameMapper.set(blockName, blockRealName);
+
+        const language = reactLanguage;
+
+        const blockRef = normalizeKapetaUri(blockRealName + ':local');
+        blocks.push({
+            kind: normalizeKapetaUri(`${blockTypeFrontend.definition.metadata.name}:${blockTypeFrontend.version}`),
+            metadata: {
+                name: blockRealName,
+                title: frontend.title,
+                description: frontend.description,
+                visibility: 'private',
+            },
+            spec: {
+                target: {
+                    kind: normalizeKapetaUri(`${language.definition.metadata.name}:${language.version}`),
+                    options: {},
+                },
+                consumers: [],
+                providers: [
+                    {
+                        kind: normalizeKapetaUri(
+                            `${webPageResource.definition.metadata.name}:${webPageResource.version}`
+                        ),
+                        metadata: {
+                            name: 'main',
+                        },
+                        spec: {
+                            port: {
+                                type: webPageResource.definition.spec.ports[0].type,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+
+        addToPlan(blockRef, frontend.name);
+    }
+
+    application.connections?.forEach((connection) => {
+        const fullProviderName = nameMapper.get(`${handle}/${connection.provider.name}`) as string;
+        const fullConsumerName = nameMapper.get(`${handle}/${connection.consumer.name}`) as string;
+        const consumerResourceName = connection.provider.name;
+        const providerRef = normalizeKapetaUri(`${fullProviderName}:local`);
+        const consumerRef = normalizeKapetaUri(`${fullConsumerName}:local`);
+
+        const instanceProvider = plan.spec.blocks.find((b) => b.block.ref === providerRef)!;
+        const instanceConsumer = plan.spec.blocks.find((b) => b.block.ref === consumerRef)!;
+        const consumerBlock = blocks.find((block) => block.metadata.name === fullConsumerName);
+        const providerBlock = blocks.find((block) => block.metadata.name === fullProviderName);
+        if (!consumerBlock) {
+            throw new Error('Missing consumer block: ' + fullConsumerName);
+        }
+
+        if (!providerBlock) {
+            throw new Error('Missing provider block: ' + fullProviderName);
+        }
+
+        const portType = parseKapetaUri(providerBlock.kind).fullName === 'kapeta/block-type-service' ? 'rest' : 'web';
+
+        if (portType === 'rest') {
+            consumerBlock.spec.consumers!.push({
+                kind: normalizeKapetaUri(
+                    `${restClientResource.definition.metadata.name}:${restClientResource.version}`
+                ),
+                metadata: {
+                    name: consumerResourceName,
+                },
+                spec: {
+                    port: {
+                        type: 'rest',
+                    },
+                },
+            });
+        } else {
+            consumerBlock.spec.consumers!.push({
+                kind: normalizeKapetaUri(
+                    `${webFragmentResource.definition.metadata.name}:${webFragmentResource.version}`
+                ),
+                metadata: {
+                    name: consumerResourceName,
+                },
+                spec: {
+                    port: {
+                        type: 'web',
+                    },
+                },
+            });
+        }
+
+        plan.spec.connections.push({
+            provider: {
+                blockId: instanceProvider.id,
+                resourceName: 'main',
+                port: {
+                    type: portType,
+                },
+            },
+            consumer: {
+                blockId: instanceConsumer.id,
+                resourceName: consumerResourceName,
+                port: {
+                    type: portType,
+                },
+            },
+        });
+    });
+
+    return {
+        plan,
+        blocks,
+    };
+};

package/src/ai/types.ts

@@ -0,0 +1,45 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+export interface Database {
+    name: string;
+    type: 'mongodb' | 'postgres';
+}
+
+export interface BackendService {
+    name: string;
+    title: string;
+    description: string;
+    targetLanguage: 'java' | 'node';
+    databases: Database[] | null;
+}
+
+export interface FrontendService {
+    name: string;
+    title: string;
+    description: string;
+    targetLanguage: 'react';
+}
+
+export interface Endpoint {
+    type: 'backend' | 'frontend';
+    name: string;
+}
+
+export interface Connection {
+    provider: Endpoint;
+    consumer: Endpoint;
+}
+
+export interface Application {
+    kind: 'core/plan';
+    name: string;
+    title: string;
+    description: string;
+    backends: BackendService[];
+    frontends: FrontendService[];
+    connections: Connection[];
+    explanation: string;
+    response: string;
+}

package/src/codeGeneratorManager.ts

@@ -9,7 +9,7 @@ import { BlockDefinition } from '@kapeta/schemas';
 import { definitionsManager } from './definitionsManager';
 import { Definition } from '@kapeta/local-cluster-config';
 import { assetManager } from './assetManager';
-import { normalizeKapetaUri } from '@kapeta/nodejs-utils';
+import { normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
 import { repositoryManager } from './repositoryManager';
 
 const TARGET_KIND = 'core/language-target';
@@ -61,16 +61,18 @@ class CodeGeneratorManager {
     }
 
     async canGenerateCode(yamlContent: Definition): Promise<boolean> {
-        if (!yamlContent.spec.target?.kind) {
+        if (!yamlContent.spec?.target?.kind || !yamlContent.kind) {
             //Not all block types have targets
             return false;
         }
 
+        const kindUri = parseKapetaUri(yamlContent.kind);
+
         const blockTypes = await definitionsManager.getDefinitions(BLOCK_TYPE_KIND);
         const blockTypeKinds = blockTypes.map(
-            (blockType) => blockType.definition.metadata.name.toLowerCase() + ':' + blockType.version
+            (blockType) => parseKapetaUri(blockType.definition.metadata.name).fullName
         );
-        return !!(yamlContent && yamlContent.kind && blockTypeKinds.indexOf(yamlContent.kind.toLowerCase()) > -1);
+        return blockTypeKinds.includes(kindUri.fullName);
     }
 
     async generate(yamlFile: string, yamlContent: Definition) {

package/src/containerManager.ts

@@ -166,11 +166,17 @@ class ContainerManager {
                   ];
         for (const opts of connectOptions) {
             try {
+                const testClient = new Docker({
+                    ...opts,
+                    timeout: 1000, // 1 secs should be enough for a ping
+                });
+                await testClient.ping();
+                // If we get here - we have a working connection
+                // Now create a client with a longer timeout for all other operations
                 const client = new Docker({
                     ...opts,
                     timeout: 15 * 60 * 1000, //15 minutes should be enough for any operation
                 });
-                await client.ping();
                 this._docker = client;
                 const versionInfo: any = await client.version();
                 this._version = versionInfo.Server?.Version ?? versionInfo.Version;

package/src/filesystem/routes.ts

@@ -50,6 +50,28 @@ router.post('/release-channel', (req: StringBodyRequest, res: Response) => {
     res.sendStatus(204);
 });
 
+router.get('/show-pixel-grid', (req: Request, res: Response) => {
+    res.send(filesystemManager.getShowPixelGrid());
+});
+
+router.use('/show-pixel-grid', stringBody);
+
+router.post('/show-pixel-grid', (req: StringBodyRequest, res: Response) => {
+    filesystemManager.setShowPixelGrid(req?.stringBody === 'true' ?? false);
+    res.sendStatus(204);
+});
+
+router.get('/snap-to-pixel-grid', (req: Request, res: Response) => {
+    res.send(filesystemManager.getSnapToPixelGrid());
+});
+
+router.use('/snap-to-pixel-grid', stringBody);
+
+router.post('/snap-to-pixel-grid', (req: StringBodyRequest, res: Response) => {
+    filesystemManager.setSnapToPixelGrid(req?.stringBody === 'true' ?? false);
+    res.sendStatus(204);
+});
+
 router.use('/', (req: Request, res: Response, next: NextFunction) => {
     if (!req.query.path) {
         res.status(400).send({ error: 'Missing required query parameter "path"' });

package/src/filesystemManager.ts

@@ -12,6 +12,8 @@ const SECTION_ID = 'filesystem';
 const PROJECT_ROOT = 'project_root';
 const EDITOR = 'editor';
 const RELEASE_CHANNEL = 'release_channel';
+const SHOW_PIXEL_GRID = 'show_pixel_grid';
+const SNAP_TO_PIXEL_GRID = 'snap_to_pixel_grid';
 
 function isFile(path: string) {
     try {
@@ -110,6 +112,22 @@ class FilesystemManager {
     setReleaseChannel(channel: string) {
         storageService.put('app', RELEASE_CHANNEL, channel);
     }
+
+    getShowPixelGrid() {
+        return storageService.get<boolean>('app', SHOW_PIXEL_GRID, false);
+    }
+
+    setShowPixelGrid(show: boolean) {
+        storageService.put('app', SHOW_PIXEL_GRID, show);
+    }
+
+    getSnapToPixelGrid() {
+        return storageService.get<boolean>('app', SNAP_TO_PIXEL_GRID, false);
+    }
+
+    setSnapToPixelGrid(snap: boolean) {
+        storageService.put('app', SNAP_TO_PIXEL_GRID, snap);
+    }
 }
 
 export const filesystemManager = new FilesystemManager();

package/src/utils/utils.ts

@@ -10,11 +10,17 @@ import md5 from 'md5';
 import { EntityList } from '@kapeta/schemas';
 import _ from 'lodash';
 import { AnyMap } from '../types';
+import ClusterConfiguration from '@kapeta/local-cluster-config';
 
 export function getBlockInstanceContainerName(systemId: string, instanceId: string) {
     return `kapeta-block-instance-${md5(systemId + instanceId)}`;
 }
 
+export function getRemoteUrl(id: string, defautValue: string) {
+    const remoteConfig = ClusterConfiguration.getClusterConfig().remote;
+    return remoteConfig?.[id] ?? defautValue;
+}
+
 export function readYML(path: string) {
     const rawYaml = FS.readFileSync(path);