@kapeta/local-cluster-service 0.0.0-96f91ef

package/src/definitionsManager.ts

@@ -0,0 +1,212 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import ClusterConfiguration, { DefinitionInfo } from '@kapeta/local-cluster-config';
+import { parseKapetaUri, normalizeKapetaUri, parseVersion } from '@kapeta/nodejs-utils';
+import { cacheManager, doCached } from './cacheManager';
+import { ExtendedIdentity, KapetaAPI } from '@kapeta/nodejs-api-client';
+import { Plan } from '@kapeta/schemas';
+import FS from 'fs-extra';
+import YAML from 'yaml';
+import { Actions } from '@kapeta/nodejs-registry-utils';
+import { ProgressListener } from './progressListener';
+import Path from 'path';
+
+export const SAMPLE_PLAN_NAME = 'kapeta/sample-java-chat-plan';
+
+function getRenamed(definition: DefinitionInfo, targetHandle: string) {
+    const originalUri = parseKapetaUri(definition.definition.metadata.name);
+    return `${targetHandle}/${originalUri.name}`;
+}
+function applyHandleChange(definition: DefinitionInfo, targetHandle: string) {
+    definition.definition.metadata.name = getRenamed(definition, targetHandle);
+    // We also change the visibility to private
+    definition.definition.metadata.visibility = 'private';
+    return definition;
+}
+
+function normalizeFilters(kindFilter?: string | string[]) {
+    let resolvedFilters: string[] = [];
+
+    if (kindFilter) {
+        if (Array.isArray(kindFilter)) {
+            resolvedFilters = [...kindFilter];
+        } else {
+            resolvedFilters = [kindFilter];
+        }
+    }
+
+    return resolvedFilters.map((k) => k.toLowerCase());
+}
+
+class DefinitionsManager {
+    private async resolveDefinitionsAndSamples() {
+        const definitions = ClusterConfiguration.getDefinitions();
+        const samplePlan = definitions.find(
+            (d) => d.version === 'local' && d.definition.metadata.name === SAMPLE_PLAN_NAME
+        );
+
+        if (!samplePlan) {
+            return definitions;
+        }
+
+        // We will only rewrite the sample plan once since we change the handle to be the users handle
+        const api = new KapetaAPI();
+        if (!api.hasToken()) {
+            // Not logged in yet, so we can't rewrite the sample plan
+            return definitions;
+        }
+
+        const profile = await api.getCurrentIdentity();
+        if (!profile) {
+            // Not logged in yet, so we can't rewrite the sample plan
+            return definitions;
+        }
+
+        try {
+            await this.prepareSample(definitions, samplePlan, profile);
+        } catch (e) {
+            console.warn('Failed to prepare sample plan', e);
+        }
+
+        // Return the rewritten definitions
+        return ClusterConfiguration.getDefinitions();
+    }
+
+    private async prepareSample(definitions: DefinitionInfo[], samplePlan: DefinitionInfo, profile: ExtendedIdentity) {
+        const newName = getRenamed(samplePlan, profile.handle);
+
+        if (definitions.some((d) => d.definition.metadata.name === newName && d.version === 'local')) {
+            // We already have a local version of the sample plan
+            return definitions;
+        }
+
+        console.log('Rewriting sample plan to use handle %s', profile.handle);
+        applyHandleChange(samplePlan, profile.handle);
+        const planDef = samplePlan.definition as Plan;
+
+        const blockRefs = new Set<string>();
+
+        planDef.spec.blocks.forEach((b) => {
+            const blockUri = parseKapetaUri(b.block.ref);
+            if (blockUri.version === 'local') {
+                blockRefs.add(blockUri.id);
+                b.block.ref = normalizeKapetaUri(`${profile.handle}/${blockUri.name}:local`);
+            }
+        });
+
+        // Rewrite all blocks that are referenced by the sample plan
+        const rewrittenBlocks = Array.from(blockRefs)
+            .map((ref) =>
+                definitions.find(
+                    (d) => normalizeKapetaUri(d.definition.metadata.name + ':' + d.version) === normalizeKapetaUri(ref)
+                )
+            )
+            .filter((d) => d !== undefined)
+            .map((d) => applyHandleChange(d!, profile.handle));
+
+        // Persist the rewritten assets
+        const progressListener = new ProgressListener();
+        const rewrittenAssets = [samplePlan, ...rewrittenBlocks];
+        const originalRefs = [`${SAMPLE_PLAN_NAME}:local`, ...Array.from(blockRefs)];
+
+        // Store the original paths on the assets - we'll need them later
+        for (const asset of rewrittenAssets) {
+            asset.path = await FS.readlink(asset.path);
+            asset.ymlPath = Path.join(asset.path, Path.basename(asset.ymlPath));
+        }
+
+        // Uninstall the original assets
+        // This removes the symlinks
+        console.log('Uninstalling original assets', originalRefs);
+        try {
+            await Actions.uninstall(progressListener, originalRefs);
+        } catch (err) {
+            console.warn('Failed to uninstall original assets', err);
+        }
+
+        for (const asset of rewrittenAssets) {
+            console.log('Updating %s ', asset.ymlPath);
+            await FS.writeFile(asset.ymlPath, YAML.stringify(asset.definition));
+
+            console.log('Linking %s ', asset.path);
+            await Actions.link(progressListener, asset.path);
+        }
+
+        console.log('Rewrite done for sample plan');
+    }
+
+    private applyFilters(definitions: DefinitionInfo[], kindFilter: string[]): DefinitionInfo[] {
+        if (kindFilter.length === 0) {
+            return definitions;
+        }
+
+        return definitions.filter((d) => {
+            return kindFilter.includes(d.definition.kind.toLowerCase());
+        });
+    }
+
+    public async getDefinitions(kindFilter?: string | string[]): Promise<DefinitionInfo[]> {
+        kindFilter = normalizeFilters(kindFilter);
+
+        const definitions = await doCached<Promise<DefinitionInfo[]>>('definitionsManager:all', () =>
+            this.resolveDefinitionsAndSamples()
+        );
+
+        return this.applyFilters(definitions, kindFilter);
+    }
+
+    public async exists(ref: string) {
+        return !!(await this.getDefinition(ref));
+    }
+
+    public async getProviderDefinitions(): Promise<DefinitionInfo[]> {
+        return doCached<DefinitionInfo[]>('definitionsManager:providers', () =>
+            ClusterConfiguration.getProviderDefinitions()
+        );
+    }
+
+    public async getDefinition(ref: string) {
+        const uri = parseKapetaUri(ref);
+        const definitions = await this.getDefinitions();
+        return definitions.find((d) => {
+            if (!uri.version) {
+                return d.definition.metadata.name.toLowerCase() === uri.fullName.toLowerCase();
+            }
+            return parseKapetaUri(`${d.definition.metadata.name}:${d.version}`).equals(uri);
+        });
+    }
+
+    public async getLatestDefinition(name: string) {
+        const definitions = await this.getDefinitions();
+        const allVersions = definitions.filter((d) => {
+            return d.version !== 'local' && d.definition.metadata.name === name;
+        });
+
+        if (allVersions.length === 0) {
+            return;
+        }
+
+        allVersions.sort((a, b) => {
+            return parseVersion(a.version).compareTo(parseVersion(b.version)) * -1;
+        });
+
+        return allVersions[0];
+    }
+
+    public async getVersions(assetName: string) {
+        const uri = parseKapetaUri(assetName);
+        const definitions = await this.getDefinitions();
+        return definitions.filter((d) => {
+            return d.definition.metadata.name === uri.fullName;
+        });
+    }
+
+    public clearCache() {
+        cacheManager.removePrefix('definitionsManager:');
+    }
+}
+
+export const definitionsManager = new DefinitionsManager();

package/src/filesystem/routes.ts

@@ -0,0 +1,123 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import Router from 'express-promise-router';
+import { stringBody, StringBodyRequest } from '../middleware/stringBody';
+import { filesystemManager } from '../filesystemManager';
+import { corsHandler } from '../middleware/cors';
+import { NextFunction, Request, Response } from 'express';
+
+let router = Router();
+
+router.use('/', corsHandler);
+
+router.get('/root', (req: Request, res: Response) => {
+    res.send(filesystemManager.getRootFolder());
+});
+
+router.get('/project/root', (req: Request, res: Response) => {
+    res.send(filesystemManager.getProjectRootFolder());
+});
+
+router.use('/project/root', stringBody);
+
+router.post('/project/root', (req: StringBodyRequest, res: Response) => {
+    filesystemManager.setProjectRootFolder(req.stringBody ?? '');
+    res.sendStatus(204);
+});
+
+router.get('/editor', (req: Request, res: Response) => {
+    res.send(filesystemManager.getEditor());
+});
+
+router.use('/editor', stringBody);
+
+router.post('/editor', (req: StringBodyRequest, res: Response) => {
+    filesystemManager.setEditor(req.stringBody ?? '');
+    res.sendStatus(204);
+});
+
+router.get('/release-channel', (req: Request, res: Response) => {
+    res.send(filesystemManager.getReleaseChannel());
+});
+
+router.use('/release-channel', stringBody);
+
+router.post('/release-channel', (req: StringBodyRequest, res: Response) => {
+    filesystemManager.setReleaseChannel(req.stringBody ?? '');
+    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"' });
+        return;
+    }
+    next();
+});
+
+router.get('/list', async (req: Request, res: Response) => {
+    let pathArg = req.query.path as string;
+
+    try {
+        res.send(await filesystemManager.readDirectory(pathArg));
+    } catch (err) {
+        res.status(400).send({ error: '' + err });
+    }
+});
+
+router.get('/readfile', async (req: Request, res: Response) => {
+    let pathArg = req.query.path as string;
+    try {
+        res.send(await filesystemManager.readFile(pathArg));
+    } catch (err) {
+        res.status(400).send({ error: '' + err });
+    }
+});
+
+router.put('/mkdir', async (req: Request, res: Response) => {
+    let pathArg = req.query.path as string;
+    try {
+        await filesystemManager.createFolder(pathArg);
+        res.sendStatus(204);
+    } catch (err) {
+        res.status(400).send({ error: '' + err });
+    }
+});
+
+router.use('/writefile', stringBody);
+router.post('/writefile', async (req: StringBodyRequest, res: Response) => {
+    let pathArg = req.query.path as string;
+    try {
+        await filesystemManager.writeFile(pathArg, req.stringBody ?? '');
+        res.sendStatus(204);
+    } catch (err) {
+        res.status(400).send({ error: '' + err });
+    }
+});
+
+export default router;

package/src/filesystemManager.ts

@@ -0,0 +1,133 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import Path from 'path';
+import FS from 'fs';
+import FSExtra from 'fs-extra';
+import { storageService } from './storageService';
+
+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 {
+        return FS.statSync(path).isFile();
+    } catch (error) {
+        return false;
+    }
+}
+
+class FilesystemManager {
+    async writeFile(path: string, data: string | Buffer) {
+        const dirName = Path.dirname(path);
+        if (!FS.existsSync(dirName)) {
+            FSExtra.mkdirpSync(dirName, {});
+        }
+        FS.writeFileSync(path, data);
+    }
+
+    async createFolder(path: string): Promise<void> {
+        return new Promise((resolve, reject) => {
+            FS.mkdir(path, (err) => {
+                if (err) {
+                    err.message += '. You can only create one single folder at a time.';
+                    reject(err.message);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+
+    async readDirectory(path: string): Promise<{ path: string; folder: boolean }[]> {
+        return new Promise((resolve, reject) => {
+            let response: { path: string; folder: boolean }[] = [];
+            FS.readdir(path, (err: any, files: string[]) => {
+                if (err) {
+                    reject(new Error(err));
+                    return;
+                }
+                files.forEach((file) => {
+                    response.push({
+                        path: Path.join(path, file),
+                        folder: FS.lstatSync(Path.join(path, file)).isDirectory(),
+                    });
+                });
+                resolve(response);
+            });
+        });
+    }
+
+    async readFile(path: string): Promise<Buffer> {
+        return new Promise((resolve, reject) => {
+            if (!isFile(path)) {
+                reject(
+                    new Error(
+                        'The path provided is invalid.Please check that the path and file name that were provided are spelled correctly. '
+                    )
+                );
+            } else {
+                FS.readFile(path, (err, data) => {
+                    if (err) {
+                        reject(new Error(err.message));
+                        return;
+                    }
+                    resolve(data);
+                });
+            }
+        });
+    }
+
+    getRootFolder(): string {
+        return require('os').homedir();
+    }
+
+    getProjectRootFolder(): string | undefined {
+        return storageService.get(SECTION_ID, PROJECT_ROOT);
+    }
+
+    setProjectRootFolder(folder: string) {
+        storageService.put(SECTION_ID, PROJECT_ROOT, folder);
+    }
+
+    getEditor(): string | undefined {
+        return storageService.get(SECTION_ID, EDITOR);
+    }
+
+    setEditor(editor: string) {
+        storageService.put(SECTION_ID, EDITOR, editor);
+    }
+
+    // Should we put this in its own manager service?
+    getReleaseChannel() {
+        return storageService.get<string>('app', RELEASE_CHANNEL);
+    }
+
+    setReleaseChannel(channel: string) {
+        storageService.put('app', RELEASE_CHANNEL, channel);
+    }
+
+    getShowPixelGrid() {
+        return storageService.get<boolean>('app', SHOW_PIXEL_GRID, true);
+    }
+
+    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/identities/routes.ts

@@ -0,0 +1,38 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import Router from 'express-promise-router';
+import { KapetaAPI } from '@kapeta/nodejs-api-client';
+
+import { corsHandler } from '../middleware/cors';
+import { Request, Response } from 'express';
+
+const router = Router();
+
+router.use('/', corsHandler);
+
+router.get('/current', async (req: Request, res: Response) => {
+    const api = new KapetaAPI();
+    if (api.hasToken()) {
+        try {
+            res.json(await api.getCurrentIdentity());
+            return;
+        } catch (e) {
+            console.error(e);
+        }
+    }
+    res.status(200).json(null);
+});
+
+router.get('/:identityId/memberships', async (req: Request, res: Response) => {
+    const api = new KapetaAPI();
+    if (api.hasToken()) {
+        res.send(await api.getMemberships(req.params.identityId));
+    } else {
+        res.send([]);
+    }
+});
+
+export default router;