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

package/src/utils/utils.ts

@@ -0,0 +1,155 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import FS from 'node:fs';
+import YAML from 'yaml';
+import md5 from 'md5';
+import { EntityList, LocalInstance, LocalInstancePort, LocalInstancePortType } from '@kapeta/schemas';
+import _ from 'lodash';
+import { AnyMap, DOCKER_HOST_INTERNAL, EnvironmentType, KIND_BLOCK_TYPE_OPERATOR } from '../types';
+import ClusterConfiguration from '@kapeta/local-cluster-config';
+import { definitionsManager } from '../definitionsManager';
+import { normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
+import { assetManager } from '../assetManager';
+import { serviceManager } from '../serviceManager';
+import { clusterService } from '../clusterService';
+
+export async function getBlockInstanceContainerName(systemId: string, instanceId: string, blockType?: string) {
+    if (!blockType) {
+        const instance = await assetManager.getBlockInstance(systemId, instanceId);
+        if (!instance) {
+            throw new Error(`Instance ${instanceId} not found in plan ${systemId}`);
+        }
+        const block = await assetManager.getAsset(instance.block.ref);
+        if (!block) {
+            throw new Error(`Block ${instance.block.ref} not found`);
+        }
+        blockType = block.data.kind;
+    }
+    const typeDefinition = await definitionsManager.getDefinition(blockType);
+    if (!typeDefinition) {
+        throw new Error(`Block type ${blockType} not found`);
+    }
+    if (
+        parseKapetaUri(typeDefinition.definition.kind).fullName === KIND_BLOCK_TYPE_OPERATOR &&
+        typeDefinition.definition.spec?.local?.singleton
+    ) {
+        return `kapeta-instance-operator-${md5(normalizeKapetaUri(systemId) + normalizeKapetaUri(blockType))}`;
+    }
+
+    return `kapeta-block-instance-${md5(normalizeKapetaUri(systemId) + instanceId)}`;
+}
+
+export function toPortInfo(port: LocalInstancePort) {
+    if (typeof port === 'number' || typeof port === 'string') {
+        return { port: parseInt(`${port}`), type: 'tcp' };
+    }
+
+    if (!port.type) {
+        port.type = LocalInstancePortType.TCP;
+    }
+
+    return port;
+}
+
+export async function getOperatorInstancePorts(systemId: string, operatorId: string, local: LocalInstance) {
+    const localPorts = local.ports ?? {};
+
+    const promises = Object.entries(localPorts).map(async ([portType, value]) => {
+        const portInfo = toPortInfo(value);
+        const hostPort = await serviceManager.ensureServicePort(systemId, operatorId, portType);
+        return {
+            portType,
+            port: portInfo.port,
+            hostPort,
+            protocol: portInfo.type,
+        };
+    });
+    return await Promise.all(promises);
+}
+
+/**
+ * Gets the hostname where all services are available - including the cluster service.
+ *
+ * For docker this is the internal docker host - otherwise it's the local machine
+ * Assumed to be the same address as the cluster service outside docker.
+ */
+export function getRemoteHostForEnvironment(environment: EnvironmentType | undefined): string {
+    return environment === 'docker' ? DOCKER_HOST_INTERNAL : clusterService.getClusterServiceHost();
+}
+
+/**
+ * Get the bind address for the given environment.
+ *
+ * Outside of docker we bind to 127.0.0.1 - inside we bind to everything (0.0.0.0)
+ */
+export function getBindAddressForEnvironment(
+    environment: EnvironmentType | undefined,
+    preferredHost = '127.0.0.1'
+): string {
+    return environment === 'docker' ? '0.0.0.0' : preferredHost;
+}
+
+/**
+ * Get the docker host IP address for port binding.
+ */
+export function getDockerHostIp(preferredHost = '127.0.0.1') {
+    // On Linux we need to bind to 0.0.0.0 to be able to connect to it from docker containers.
+    // TODO: This might pose a security risk - so we should authenticate all requests using a shared secret/nonce that we pass around.
+    return isLinux() ? '0.0.0.0' : preferredHost;
+}
+
+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);
+
+    try {
+        return YAML.parse(rawYaml.toString());
+    } catch (err) {
+        throw new Error(`Failed to parse plan YAML: ${err}`);
+    }
+}
+
+export function isWindows() {
+    return 'win32' === process.platform;
+}
+
+export function isMac() {
+    return 'darwin' === process.platform;
+}
+
+export function isLinux() {
+    return !isWindows() && !isMac();
+}
+
+export function getResolvedConfiguration(entities?: EntityList, config?: AnyMap, globalConfiguration?: AnyMap): AnyMap {
+    if (!entities || !globalConfiguration) {
+        return config || {};
+    }
+
+    const mergedConfig = config ? _.cloneDeep(config) : {};
+    entities.types?.forEach((type) => {
+        if (!type.properties) {
+            return;
+        }
+        Object.entries(type.properties).forEach(([propertyName, property]) => {
+            if (!property.global) {
+                return;
+            }
+
+            const configPath = type.name + '.' + propertyName;
+            const defaultValue = globalConfiguration ? _.get(globalConfiguration, configPath) : undefined;
+            if (!_.has(mergedConfig, configPath)) {
+                _.set(mergedConfig, configPath, defaultValue);
+            }
+        });
+    });
+
+    return mergedConfig;
+}

package/start.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import localClusterService from './index';
+
+localClusterService
+    .start()
+    .then(({ host, port }) => console.log('Listening on port %s:%s', host, port))
+    .catch((e) => {
+        console.error('Failed to start local cluster due to an error:\n\t - %s', e);
+        process.exit(1);
+    });

package/test/proxy/types/rest.test.ts

@@ -0,0 +1,54 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import { getRestMethodId } from '../../../src/proxy/types/rest';
+import { Resource, ResourceMetadata } from '@kapeta/schemas';
+
+describe('getRestMethodId', () => {
+    it('should match @Query in url', () => {
+        const restResource = new TestResource();
+
+        const restMethodId = getRestMethodId(restResource, 'POST', '/names?name=Ib');
+        expect(restMethodId).toBeDefined();
+    });
+});
+
+class TestResource implements Resource {
+    kind = '';
+    metadata = new TestResourceMetaData();
+
+    get spec(): { [p: string]: any } {
+        return {
+            methods: [
+                {
+                    responseType: {
+                        ref: 'Name[]',
+                    },
+                    method: 'GET',
+                    path: '/names',
+                    arguments: {},
+                },
+                {
+                    responseType: {
+                        ref: 'Name',
+                    },
+                    method: 'POST',
+                    path: '/names',
+                    arguments: {
+                        name: {
+                            type: 'string',
+                            transport: 'QUERY',
+                        },
+                    },
+                },
+            ],
+        };
+    }
+}
+
+class TestResourceMetaData implements ResourceMetadata {
+    [property: string]: any;
+    name: string = '';
+}

package/test/utils/pathTemplateParser.test.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import { PathTemplate } from '../../src/utils/pathTemplateParser';
+
+describe('pathTemplateParser', () => {
+    it('must return parameters for query parameters from parse', () => {
+        const template = new PathTemplate('/names');
+        const parse = template.parse('/names?name=Ib#test');
+        console.log(parse);
+        expect(parse).toBeTruthy();
+    });
+
+    it('must return parameters defined in url', () => {
+        const template = new PathTemplate('/names/{identityId}');
+        const parse = template.parse('/names/idn_xxyyzz');
+        expect(parse).toBeTruthy();
+        expect(parse).toMatchObject({ identityId: 'idn_xxyyzz' });
+    });
+
+    it('must return parameters defined in url regardless of query parameters', () => {
+        const template = new PathTemplate('/names/{identityId}');
+        const parse = template.parse('/names/idn_xxyyzz?name=Ib#test');
+        expect(parse).toBeTruthy();
+        expect(parse).toMatchObject({ identityId: 'idn_xxyyzz' });
+    });
+});

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "extends": "@tsconfig/node18/tsconfig.json",
+    "compilerOptions": {
+        "module": "node16",
+        "moduleResolution": "node16",
+        "outDir": "./dist",
+        "declaration": true,
+        "strict": true
+    },
+    "ts-node": {
+        "files": true
+    },
+    "include": ["definitions.d.ts", "src/**/*", "index.ts", "start.ts", "test/**/*.ts"],
+    "exclude": ["node_modules", "dist"]
+}