@kapeta/local-cluster-service 0.54.11 → 0.55.0

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

@@ -3,12 +3,17 @@
  * 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 = exports.createPhaseEvent = exports.createPhaseEndEvent = exports.createPhaseStartEvent = void 0;
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const kaplang_core_1 = require("@kapeta/kaplang-core");
 const uuid_1 = require("uuid");
 const definitionsManager_1 = require("../definitionsManager");
+const predefined_1 = require("./predefined");
+const lodash_1 = __importDefault(require("lodash"));
 function prettifyKaplang(source) {
     if (!source || !source.trim()) {
         return '';
@@ -156,7 +161,7 @@ class StormEventParser {
     /**
      * Builds plan and block definitions - and enriches events with relevant refs and ids
      */
-    processEvent(handle, evt) {
+    async processEvent(handle, evt) {
         let blockInfo;
         this.events.push(evt);
         switch (evt.type) {
@@ -222,7 +227,7 @@ class StormEventParser {
                 });
                 break;
         }
-        return this.toResult(handle);
+        return await this.toResult(handle);
     }
     getEvents() {
         return this.events;
@@ -236,9 +241,9 @@ class StormEventParser {
     getError() {
         return this.error;
     }
-    toResult(handle) {
+    async toResult(handle) {
         const planRef = StormEventParser.toRef(handle, this.planName || 'undefined');
-        const blockDefinitions = this.toBlockDefinitions(handle);
+        const blockDefinitions = await this.toBlockDefinitions(handle);
         const refIdMap = {};
         const blocks = Object.entries(blockDefinitions).map(([ref, block]) => {
             // Create a deterministic uuid
@@ -354,180 +359,190 @@ class StormEventParser {
             blocks: Object.values(blockDefinitions),
         };
     }
-    toBlockDefinitions(handle) {
+    async toBlockDefinitions(handle) {
         const result = {};
-        Object.entries(this.blocks).forEach(([, blockInfo]) => {
+        for (const [, blockInfo] of Object.entries(this.blocks)) {
             const blockRef = StormEventParser.toRef(handle, blockInfo.name);
-            const blockDefinitionInfo = {
-                uri: blockRef.toNormalizedString(),
-                aiName: blockInfo.name,
-                content: {
-                    kind: this.toBlockKind(blockInfo.type),
-                    metadata: {
-                        title: blockInfo.name,
-                        name: blockRef.fullName,
-                        description: blockInfo.description,
+            let blockDefinitionInfo;
+            if (blockInfo.archetype) {
+                blockDefinitionInfo = await this.resolveArchetypeBlockDefinition(blockRef, blockInfo);
+            }
+            else {
+                blockDefinitionInfo = this.createBlockDefinitionInfo(blockRef, blockInfo, handle);
+            }
+            result[blockRef.toNormalizedString()] = blockDefinitionInfo;
+        }
+        return result;
+    }
+    createBlockDefinitionInfo(blockRef, blockInfo, handle) {
+        const blockDefinitionInfo = {
+            uri: blockRef.toNormalizedString(),
+            aiName: blockInfo.name,
+            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: '',
+                        },
                     },
-                    spec: {
-                        entities: {
-                            types: [],
+                    target: this.toBlockTarget(handle, blockInfo.type),
+                    providers: [],
+                    consumers: [],
+                },
+            },
+        };
+        const blockSpec = blockDefinitionInfo.content.spec;
+        const apiResources = {};
+        let dbResource = undefined;
+        (blockInfo.resources || []).forEach((resource) => {
+            const port = {
+                type: this.toPortType(resource.type),
+            };
+            switch (resource.type) {
+                case 'API': {
+                    const 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: '',
                             },
                         },
-                        target: this.toBlockTarget(handle, blockInfo.type),
-                        providers: [],
-                        consumers: [],
-                    },
-                },
-            };
-            const blockSpec = blockDefinitionInfo.content.spec;
-            const apiResources = {};
-            let dbResource = undefined;
-            (blockInfo.resources || []).forEach((resource) => {
-                const port = {
-                    type: this.toPortType(resource.type),
-                };
-                switch (resource.type) {
-                    case 'API': {
-                        const 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: '',
-                                },
+                    };
+                    apiResources[resource.name] = apiResource;
+                    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: '',
                             },
-                        };
-                        apiResources[resource.name] = apiResource;
-                        blockSpec.providers.push(apiResource);
+                        },
+                    });
+                    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;
                     }
-                    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.consumers.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,
+                    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.consumers.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,
+                        },
+                    });
+            }
+        });
+        blockInfo.apis.forEach((api) => {
+            const dslApi = kaplang_core_1.DSLAPIParser.parse(api, {
+                ignoreSemantics: true,
             });
-            blockInfo.apis.forEach((api) => {
-                const dslApi = kaplang_core_1.DSLAPIParser.parse(api, {
-                    ignoreSemantics: true,
-                });
-                let exactMatch = false;
-                if (dslApi[0] && dslApi[0].type == kaplang_core_1.DSLEntityType.CONTROLLER) {
-                    const name = dslApi[0].name.toLowerCase();
-                    const apiResourceName = Object.keys(apiResources).find((key) => key.indexOf(name) > -1);
-                    if (apiResourceName) {
-                        const exactResource = apiResources[apiResourceName];
-                        exactResource.spec.source.value += api + '\n\n';
-                        exactMatch = true;
-                    }
+            let exactMatch = false;
+            if (dslApi[0] && dslApi[0].type == kaplang_core_1.DSLEntityType.CONTROLLER) {
+                const name = dslApi[0].name.toLowerCase();
+                const apiResourceName = Object.keys(apiResources).find((key) => key.indexOf(name) > -1);
+                if (apiResourceName) {
+                    const exactResource = apiResources[apiResourceName];
+                    exactResource.spec.source.value += api + '\n\n';
+                    exactMatch = true;
                 }
-                if (!exactMatch) {
-                    // if we couldn't place the given api on the exact resource we just park it on the first
-                    // available rest resource
-                    const firstKey = Object.keys(apiResources)[0];
-                    const firstEntry = apiResources[firstKey];
-                    if (firstEntry) {
-                        firstEntry.spec.source.value += api + '\n\n';
-                    }
-                    else {
-                        console.warn('Unable to find resource for API', api);
-                    }
+            }
+            if (!exactMatch) {
+                // if we couldn't place the given api on the exact resource we just park it on the first
+                // available rest resource
+                const firstKey = Object.keys(apiResources)[0];
+                const firstEntry = apiResources[firstKey];
+                if (firstEntry) {
+                    firstEntry.spec.source.value += api + '\n\n';
+                }
+                else {
+                    console.warn('Unable to find resource for API', api);
                 }
-            });
-            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;
+        blockInfo.types.forEach((type) => {
+            blockSpec.entities.source.value += type + '\n';
+        });
+        if (dbResource) {
+            blockInfo.models.forEach((model) => {
+                dbResource.spec.source.value += model + '\n';
+            });
+        }
+        return blockDefinitionInfo;
     }
     toResourceKind(type) {
         //TODO: Handle support for multiple resource types and versions
@@ -663,5 +678,20 @@ class StormEventParser {
         }
         return undefined;
     }
+    async resolveArchetypeBlockDefinition(blockRef, blockInfo) {
+        const predefinedBlock = predefined_1.PREDEFINED_BLOCKS.get(blockInfo.archetype);
+        if (!predefinedBlock) {
+            throw new Error('Predefined block not found for archetype [' + blockInfo.archetype + ']');
+        }
+        const blockDefinition = await predefinedBlock.getBlockDefinition();
+        lodash_1.default.set(blockDefinition, ['metadata', 'name'], blockRef.fullName);
+        lodash_1.default.set(blockDefinition, ['metadata', 'title'], blockRef.name);
+        return {
+            uri: blockRef.toNormalizedString(),
+            aiName: blockInfo.name,
+            content: blockDefinition,
+            archetype: blockInfo.archetype,
+        };
+    }
 }
 exports.StormEventParser = StormEventParser;

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

@@ -16,6 +16,7 @@ export interface StormBlockInfo {
     }[];
     blockRef?: string;
     instanceId?: string;
+    archetype?: string;
 }
 export interface StormBlockInfoFilled extends StormBlockInfo {
     apis: string[];

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

@@ -0,0 +1,27 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { BlockDefinition } from '@kapeta/schemas';
+export declare class PredefinedBlock {
+    archetype: string;
+    kapetaYml: string;
+    gitRepo: {
+        owner: string;
+        repo: string;
+        path: string;
+    };
+    constructor(archetype: string, kapetaYml: string, gitRepo: {
+        owner: string;
+        repo: string;
+        path: string;
+    });
+    getGitRepo(): {
+        owner: string;
+        repo: string;
+        path: string;
+    };
+    private getKapetaYML;
+    getBlockDefinition(): Promise<BlockDefinition>;
+}
+export declare const PREDEFINED_BLOCKS: Map<string, PredefinedBlock>;

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

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PREDEFINED_BLOCKS = exports.PredefinedBlock = void 0;
+const yaml = __importStar(require("js-yaml"));
+class PredefinedBlock {
+    archetype;
+    kapetaYml;
+    gitRepo;
+    constructor(archetype, kapetaYml, gitRepo) {
+        this.archetype = archetype;
+        this.kapetaYml = kapetaYml;
+        this.gitRepo = gitRepo;
+    }
+    getGitRepo() {
+        return this.gitRepo;
+    }
+    async getKapetaYML() {
+        const response = await fetch(this.kapetaYml);
+        if (!response.ok) {
+            throw new Error(`HTTP error! Status: ${response.status}`);
+        }
+        return await response.text();
+    }
+    async getBlockDefinition() {
+        const kapetaYml = await this.getKapetaYML();
+        return yaml.load(kapetaYml);
+    }
+}
+exports.PredefinedBlock = PredefinedBlock;
+const predefinedBlocks = [
+    new PredefinedBlock('USER_SERVICE', 'https://raw.githubusercontent.com/kapetacom/everything/master/blocks/everything-user/kapeta.yml', {
+        owner: 'kapetacom',
+        repo: 'everything',
+        path: 'blocks/everything-user',
+    }),
+];
+exports.PREDEFINED_BLOCKS = new Map(predefinedBlocks.map((block) => [block.archetype, block]));

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

@@ -17,6 +17,7 @@ const event_parser_1 = require("./event-parser");
 const codegen_1 = require("./codegen");
 const assetManager_1 = require("../assetManager");
 const path_1 = __importDefault(require("path"));
+const lodash_1 = __importDefault(require("lodash"));
 const router = (0, express_promise_router_1.default)();
 router.use('/', cors_1.corsHandler);
 router.use('/', stringBody_1.stringBody);
@@ -35,21 +36,28 @@ router.post('/:handle/all', async (req, res) => {
         res.set('Access-Control-Expose-Headers', stormClient_1.ConversationIdHeader);
         res.set(stormClient_1.ConversationIdHeader, metaStream.getConversationId());
         let currentPhase = events_1.StormEventPhaseType.META;
-        metaStream.on('data', (data) => {
-            const result = eventParser.processEvent(req.params.handle, data);
-            switch (data.type) {
-                case 'CREATE_API':
-                case 'CREATE_MODEL':
-                case 'CREATE_TYPE':
-                    if (currentPhase !== events_1.StormEventPhaseType.DEFINITIONS) {
-                        sendEvent(res, (0, event_parser_1.createPhaseEndEvent)(events_1.StormEventPhaseType.META));
-                        currentPhase = events_1.StormEventPhaseType.DEFINITIONS;
-                        sendEvent(res, (0, event_parser_1.createPhaseStartEvent)(events_1.StormEventPhaseType.DEFINITIONS));
-                    }
-                    break;
+        // Helper to avoid sending the plan multiple times in a row
+        const sendUpdatedPlan = lodash_1.default.debounce(sendDefinitions, 50, { maxWait: 200 });
+        metaStream.on('data', async (data) => {
+            try {
+                const result = await eventParser.processEvent(handle, data);
+                switch (data.type) {
+                    case 'CREATE_API':
+                    case 'CREATE_MODEL':
+                    case 'CREATE_TYPE':
+                        if (currentPhase !== events_1.StormEventPhaseType.DEFINITIONS) {
+                            sendEvent(res, (0, event_parser_1.createPhaseEndEvent)(events_1.StormEventPhaseType.META));
+                            currentPhase = events_1.StormEventPhaseType.DEFINITIONS;
+                            sendEvent(res, (0, event_parser_1.createPhaseStartEvent)(events_1.StormEventPhaseType.DEFINITIONS));
+                        }
+                        break;
+                }
+                sendEvent(res, data);
+                sendUpdatedPlan(res, result);
+            }
+            catch (e) {
+                console.error('Failed to process event', e);
             }
-            sendEvent(res, data);
-            sendDefinitions(res, result);
         });
         try {
             sendEvent(res, (0, event_parser_1.createPhaseStartEvent)(events_1.StormEventPhaseType.META));
@@ -74,7 +82,7 @@ router.post('/:handle/all', async (req, res) => {
             res.end();
             return;
         }
-        const result = eventParser.toResult(handle);
+        const result = await eventParser.toResult(handle);
         if (metaStream.isAborted()) {
             return;
         }

package/dist/esm/test/storm/codegen.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+export {};

package/dist/esm/test/storm/codegen.test.js

@@ -0,0 +1,41 @@
+"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 });
+const predefined_user_events_json_1 = __importDefault(require("./predefined-user-events.json"));
+const event_parser_1 = require("../../src/storm/event-parser");
+const event_parser_test_1 = require("./event-parser.test");
+const codegen_1 = require("../../src/storm/codegen");
+const node_uuid_1 = __importDefault(require("node-uuid"));
+describe('codegen', () => {
+    it('predefined components', async () => {
+        const events = predefined_user_events_json_1.default;
+        const parser = new event_parser_1.StormEventParser(event_parser_test_1.parserOptions);
+        for (const event of events) {
+            await parser.processEvent('kapeta', event);
+        }
+        const result = await parser.toResult('kapeta');
+        const conversationId = node_uuid_1.default.v4().toString();
+        let codegen = new codegen_1.StormCodegen(conversationId, '', result.blocks, parser.getEvents());
+        let codegenPromise = consumeStream(codegen.getStream());
+        await codegen.process();
+        const stormEvents = await codegenPromise;
+        expect(stormEvents[0].type).toBe('FILE_DONE');
+        expect(stormEvents[stormEvents.length - 1].type).toBe('BLOCK_READY');
+    });
+});
+async function consumeStream(stream) {
+    const events = [];
+    return new Promise((resolve) => {
+        stream.on('data', (data) => {
+            events.push(data);
+        });
+        stream.waitForDone();
+        resolve(events);
+    });
+}

package/dist/esm/test/storm/event-parser.test.d.ts

@@ -2,4 +2,28 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-export {};
+export declare const parserOptions: {
+    serviceKind: string;
+    serviceLanguage: string;
+    frontendKind: string;
+    frontendLanguage: string;
+    cliKind: string;
+    cliLanguage: string;
+    desktopKind: string;
+    desktopLanguage: string;
+    gatewayKind: string;
+    mqKind: string;
+    exchangeKind: string;
+    queueKind: string;
+    publisherKind: string;
+    subscriberKind: string;
+    databaseKind: string;
+    apiKind: string;
+    clientKind: string;
+    webPageKind: string;
+    webFragmentKind: string;
+    jwtProviderKind: string;
+    jwtConsumerKind: string;
+    smtpKind: string;
+    externalApiKind: string;
+};