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

package/dist/esm/src/utils/InternalConfigProvider.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { BlockInstanceDetails, ConfigProvider, DefaultCredentials, DefaultResourceOptions, InstanceOperator, ResourceInfo } from '@kapeta/sdk-config';
+import { Definition, DefinitionInfo } from '@kapeta/local-cluster-config';
+import { BlockDefinition, Plan } from '@kapeta/schemas';
+import { AnyMap, EnvironmentType } from '../types';
+/**
+ * A configuration provider that does the same as the LocalConfigProvider
+ * but without calling the API of the local cluster service (since it's running in the same process)
+ */
+export declare class InternalConfigProvider implements ConfigProvider {
+    private readonly info;
+    private readonly systemId;
+    private readonly instanceId;
+    private readonly config;
+    private readonly environment;
+    constructor(systemId: string, instanceId: string, info: DefinitionInfo, config: AnyMap, environment?: EnvironmentType);
+    getBlockDefinition(): Definition;
+    getBlockReference(): string;
+    getSystemId(): string;
+    getInstanceId(): string;
+    getServerPort(portType?: string | undefined): Promise<string>;
+    getServiceAddress(serviceName: string, portType: string): Promise<string | null>;
+    getResourceInfo<Options = DefaultResourceOptions, Credentials = DefaultCredentials>(resourceType: string, portType: string, resourceName: string): Promise<ResourceInfo<Options, Credentials> | null>;
+    getInstanceHost(instanceId: string): Promise<string | null>;
+    getServerHost(): Promise<string>;
+    getProviderId(): string;
+    getOrDefault<T = any>(path: string, defaultValue: T): T;
+    get<T = any>(path: string): T | undefined;
+    getInstanceOperator<Options = any, Credentials extends DefaultCredentials = DefaultCredentials>(instanceId: string): Promise<InstanceOperator<Options, Credentials> | null>;
+    getInstanceForConsumer<BlockType = BlockDefinition>(resourceName: string): Promise<BlockInstanceDetails<BlockType> | null>;
+    getInstancesForProvider<BlockType = BlockDefinition>(resourceName: string): Promise<BlockInstanceDetails<BlockType>[]>;
+    getBlock(ref: any): Promise<Definition>;
+    getPlan(): Promise<Plan>;
+}
+export declare function createInternalConfigProvider(systemId: string, instanceId: string, info: DefinitionInfo): Promise<InternalConfigProvider>;

package/dist/esm/src/utils/InternalConfigProvider.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInternalConfigProvider = exports.InternalConfigProvider = void 0;
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const configManager_1 = require("../configManager");
+const lodash_1 = __importDefault(require("lodash"));
+const serviceManager_1 = require("../serviceManager");
+const operatorManager_1 = require("../operatorManager");
+const instanceManager_1 = require("../instanceManager");
+const definitionsManager_1 = require("../definitionsManager");
+const utils_1 = require("./utils");
+/**
+ * A configuration provider that does the same as the LocalConfigProvider
+ * but without calling the API of the local cluster service (since it's running in the same process)
+ */
+class InternalConfigProvider {
+    info;
+    systemId;
+    instanceId;
+    config;
+    environment;
+    constructor(systemId, instanceId, info, config, environment = 'docker') {
+        this.info = info;
+        this.systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        this.instanceId = instanceId;
+        this.config = config;
+        this.environment = environment;
+    }
+    getBlockDefinition() {
+        return this.info.definition;
+    }
+    getBlockReference() {
+        return (0, nodejs_utils_1.normalizeKapetaUri)(this.info.definition.metadata.name + ':' + this.info.version);
+    }
+    getSystemId() {
+        return this.systemId;
+    }
+    getInstanceId() {
+        return this.instanceId;
+    }
+    getServerPort(portType) {
+        return serviceManager_1.serviceManager.ensureServicePort(this.systemId, this.instanceId, portType);
+    }
+    async getServiceAddress(serviceName, portType) {
+        return serviceManager_1.serviceManager.getConsumerAddress(this.systemId, this.instanceId, serviceName, portType, this.environment);
+    }
+    getResourceInfo(resourceType, portType, resourceName) {
+        return operatorManager_1.operatorManager.getConsumerResourceInfo(this.systemId, this.instanceId, resourceType, portType, resourceName, this.environment, false);
+    }
+    async getInstanceHost(instanceId) {
+        const instance = instanceManager_1.instanceManager.getInstance(this.systemId, instanceId);
+        return instance?.address ?? null;
+    }
+    async getServerHost() {
+        return (0, utils_1.getBindAddressForEnvironment)(this.environment);
+    }
+    getProviderId() {
+        return 'internal';
+    }
+    getOrDefault(path, defaultValue) {
+        return this.get(path) ?? defaultValue;
+    }
+    get(path) {
+        return lodash_1.default.get(this.config, path);
+    }
+    getInstanceOperator(instanceId) {
+        return instanceManager_1.instanceManager.getInstanceOperator(this.systemId, instanceId, this.environment, false);
+    }
+    async getInstanceForConsumer(resourceName) {
+        const plan = await this.getPlan();
+        if (!plan) {
+            throw new Error('Could not find plan');
+        }
+        const instanceId = this.getInstanceId();
+        const connection = plan.spec.connections.find((connection) => connection.consumer.blockId === instanceId && connection.consumer.resourceName === resourceName);
+        if (!connection) {
+            throw new Error(`Could not find connection for consumer ${resourceName}`);
+        }
+        const instance = plan.spec.blocks.find((b) => b.id === connection.provider.blockId);
+        if (!instance) {
+            throw new Error(`Could not find instance ${connection.provider.blockId} in plan`);
+        }
+        const block = await this.getBlock(instance.block.ref);
+        if (!block) {
+            throw new Error(`Could not find block ${instance.block.ref} in plan`);
+        }
+        return {
+            instanceId: connection.provider.blockId,
+            connections: [connection],
+            block: block,
+        };
+    }
+    async getInstancesForProvider(resourceName) {
+        const plan = await this.getPlan();
+        if (!plan) {
+            throw new Error('Could not find plan');
+        }
+        const instanceId = this.getInstanceId();
+        const blockDetails = {};
+        const connections = plan.spec.connections.filter((connection) => connection.provider.blockId === instanceId && connection.provider.resourceName === resourceName);
+        for (const connection of connections) {
+            const blockInstanceId = connection.consumer.blockId;
+            if (blockDetails[blockInstanceId]) {
+                blockDetails[blockInstanceId].connections.push(connection);
+                continue;
+            }
+            const instance = plan.spec.blocks.find((b) => b.id === blockInstanceId);
+            if (!instance) {
+                throw new Error(`Could not find instance ${blockInstanceId} in plan`);
+            }
+            const block = await this.getBlock(instance.block.ref);
+            if (!block) {
+                throw new Error(`Could not find block ${instance.block.ref} in plan`);
+            }
+            blockDetails[blockInstanceId] = {
+                instanceId: blockInstanceId,
+                connections: [connection],
+                block: block,
+            };
+        }
+        return Object.values(blockDetails);
+    }
+    async getBlock(ref) {
+        const definition = await definitionsManager_1.definitionsManager.getDefinition(ref);
+        if (!definition) {
+            throw new Error(`Could not find definition for ${ref}`);
+        }
+        return definition.definition;
+    }
+    async getPlan() {
+        const definition = await definitionsManager_1.definitionsManager.getDefinition(this.systemId);
+        if (!definition) {
+            throw new Error(`Could not find plan ${this.systemId}`);
+        }
+        return definition.definition;
+    }
+}
+exports.InternalConfigProvider = InternalConfigProvider;
+async function createInternalConfigProvider(systemId, instanceId, info) {
+    const config = await configManager_1.configManager.getConfigForBlockInstance(systemId, instanceId);
+    return new InternalConfigProvider(systemId, instanceId, info, config);
+}
+exports.createInternalConfigProvider = createInternalConfigProvider;

package/dist/esm/src/utils/LogData.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { LogEntry, LogLevel, LogSource } from '../types';
+export declare class LogData {
+    static readonly MAX_LINES = 1000;
+    private readonly entries;
+    constructor();
+    /**
+     *
+     * @param {string} msg
+     * @param {string} [level]
+     * @param {string} [source]
+     */
+    addLog(msg: string, level?: LogLevel, source?: LogSource): void;
+    /**
+     *
+     * @return {LogEntry[]}
+     */
+    getLogs(): LogEntry[];
+    toString(): string;
+}

package/dist/esm/src/utils/LogData.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogData = void 0;
+const MAX_LINES = 1000;
+class LogData {
+    static MAX_LINES = MAX_LINES;
+    entries = [];
+    constructor() { }
+    /**
+     *
+     * @param {string} msg
+     * @param {string} [level]
+     * @param {string} [source]
+     */
+    addLog(msg, level = 'INFO', source = 'stdout') {
+        while (this.entries.length > MAX_LINES) {
+            this.entries.shift();
+        }
+        if (!msg.endsWith('\n')) {
+            msg += '\n';
+        }
+        this.entries.push({
+            time: Date.now(),
+            message: msg,
+            level,
+            source,
+        });
+    }
+    /**
+     *
+     * @return {LogEntry[]}
+     */
+    getLogs() {
+        return this.entries;
+    }
+    toString() {
+        return this.getLogs()
+            .map((entry) => entry.message)
+            .join('\n');
+    }
+}
+exports.LogData = LogData;

package/dist/esm/src/utils/commandLineUtils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { Task } from '../taskManager';
+export declare function hasCLI(): Promise<boolean>;
+export declare function ensureCLI(): Promise<Task<void> | null>;
+export declare function ensureCLICommands(): Promise<void>;

package/dist/esm/src/utils/commandLineUtils.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureCLICommands = exports.ensureCLI = exports.hasCLI = void 0;
+const nodejs_process_1 = require("@kapeta/nodejs-process");
+const taskManager_1 = require("../taskManager");
+async function hasCLI() {
+    return (0, nodejs_process_1.hasApp)('kap');
+}
+exports.hasCLI = hasCLI;
+async function ensureCLI() {
+    if (await hasCLI()) {
+        return null;
+    }
+    return taskManager_1.taskManager.add(`cli:install`, (task) => {
+        const process = (0, nodejs_process_1.spawn)('npm', ['install', '-g', '@kapeta/kap'], {
+            shell: true,
+        });
+        process.process.stdout?.on('data', (data) => {
+            task.addLog(data.toString(), 'INFO');
+        });
+        process.process.stderr?.on('data', (data) => {
+            task.addLog(data.toString(), 'ERROR');
+        });
+        return process.wait();
+    }, {
+        name: `Installing Kapeta CLI`,
+    });
+}
+exports.ensureCLI = ensureCLI;
+function ensureCLICommands() {
+    console.log('Run `kap init` to ensure default commands are installed');
+    const process = (0, nodejs_process_1.spawn)('kap', ['init'], { shell: true });
+    return process.wait();
+}
+exports.ensureCLICommands = ensureCLICommands;

package/dist/esm/src/utils/pathTemplateParser.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { StringMap } from '../types';
+/**
+ * A path template is a string that can be used to match a path and extract variables from it.
+ *
+ * E.g. /foo/{bar}/baz
+ *
+ * Would match /foo/123/baz and extract bar=123
+ *
+ * You can also specify a regex for the variable:
+ *  /foo/{bar:[0-9]+}/baz
+ *
+ */
+export declare class PathTemplate {
+    private _path;
+    private _parts;
+    constructor(pathTemplate: string);
+    get path(): string;
+    matches(path: string): boolean;
+    parse(path: string): StringMap | null;
+    create(variables: StringMap): string;
+    toString(): string;
+}
+/**
+ * Parses a path into a RESTPath
+ */
+export declare function pathTemplateParser(path: string): PathTemplate;

package/dist/esm/src/utils/pathTemplateParser.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathTemplateParser = exports.PathTemplate = void 0;
+const TYPE_VARIABLE = 'variable';
+const TYPE_PATH = 'path';
+function normalizePath(path) {
+    if (!path.startsWith('/')) {
+        path = '/' + path;
+    }
+    if (path.includes('#')) {
+        path = path.split('#')[0];
+    }
+    if (path.includes('?')) {
+        path = path.split('?')[0];
+    }
+    return path;
+}
+/**
+ * A path template is a string that can be used to match a path and extract variables from it.
+ *
+ * E.g. /foo/{bar}/baz
+ *
+ * Would match /foo/123/baz and extract bar=123
+ *
+ * You can also specify a regex for the variable:
+ *  /foo/{bar:[0-9]+}/baz
+ *
+ */
+class PathTemplate {
+    _path;
+    _parts = [];
+    constructor(pathTemplate) {
+        if (!pathTemplate.startsWith('/')) {
+            pathTemplate = '/' + pathTemplate;
+        }
+        this._path = pathTemplate;
+        const variableRegex = /{([^}]+)}/g;
+        let match, offset = 0;
+        this._parts = [];
+        while ((match = variableRegex.exec(pathTemplate)) !== null) {
+            if (match.index > offset) {
+                this._parts.push({
+                    type: TYPE_PATH,
+                    value: pathTemplate.substring(offset, match.index),
+                });
+            }
+            let regex;
+            let value = match[1];
+            [value, regex] = value.split(/:/, 2);
+            if (regex) {
+                regex = new RegExp('^' + regex);
+            }
+            else {
+                regex = /^[^\/]+/;
+            }
+            this._parts.push({
+                type: TYPE_VARIABLE,
+                value,
+                regex,
+            });
+            offset = match.index + match[0].length;
+        }
+        if (offset < pathTemplate.length) {
+            this._parts.push({
+                type: TYPE_PATH,
+                value: pathTemplate.substring(offset),
+            });
+        }
+    }
+    get path() {
+        return this._path;
+    }
+    matches(path) {
+        return this.parse(path) !== null;
+    }
+    parse(path) {
+        path = normalizePath(path);
+        const values = {};
+        for (let i = 0; i < this._parts.length; i++) {
+            const part = this._parts[i];
+            switch (part.type) {
+                case TYPE_PATH:
+                    if (!path.startsWith(part.value)) {
+                        return null;
+                    }
+                    path = path.substring(part.value.length);
+                    break;
+                case TYPE_VARIABLE:
+                    if (!part.regex?.test(path)) {
+                        return null;
+                    }
+                    const newPath = path.replace(part.regex, '');
+                    const value = path.substr(0, path.length - newPath.length);
+                    values[part.value] = value;
+                    path = newPath;
+                    break;
+            }
+        }
+        if (path && path !== '/') {
+            //We did not match all of it
+            return null;
+        }
+        return values;
+    }
+    create(variables) {
+        return this._parts
+            .map((part) => {
+            switch (part.type) {
+                case TYPE_PATH:
+                    return part.value;
+                case TYPE_VARIABLE:
+                    if (variables[part.value] === undefined || variables[part.value] === null) {
+                        return '';
+                    }
+                    return variables[part.value];
+            }
+        })
+            .join('');
+    }
+    toString() {
+        return 'tmpl: ' + this.path;
+    }
+}
+exports.PathTemplate = PathTemplate;
+/**
+ * Parses a path into a RESTPath
+ */
+function pathTemplateParser(path) {
+    return new PathTemplate(path);
+}
+exports.pathTemplateParser = pathTemplateParser;

package/dist/esm/src/utils/utils.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { EntityList, LocalInstance, LocalInstancePort } from '@kapeta/schemas';
+import { AnyMap, EnvironmentType } from '../types';
+export declare function getBlockInstanceContainerName(systemId: string, instanceId: string, blockType?: string): Promise<string>;
+export declare function toPortInfo(port: LocalInstancePort): LocalInstancePort | {
+    port: number;
+    type: string;
+};
+export declare function getOperatorInstancePorts(systemId: string, operatorId: string, local: LocalInstance): Promise<{
+    portType: string;
+    port: number | undefined;
+    hostPort: any;
+    protocol: string | undefined;
+}[]>;
+/**
+ * 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 declare function getRemoteHostForEnvironment(environment: EnvironmentType | undefined): string;
+/**
+ * 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 declare function getBindAddressForEnvironment(environment: EnvironmentType | undefined, preferredHost?: string): string;
+/**
+ * Get the docker host IP address for port binding.
+ */
+export declare function getDockerHostIp(preferredHost?: string): string;
+export declare function getRemoteUrl(id: string, defautValue: string): any;
+export declare function readYML(path: string): any;
+export declare function isWindows(): boolean;
+export declare function isMac(): boolean;
+export declare function isLinux(): boolean;
+export declare function getResolvedConfiguration(entities?: EntityList, config?: AnyMap, globalConfiguration?: AnyMap): AnyMap;

package/dist/esm/src/utils/utils.js

@@ -0,0 +1,148 @@
+"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 });
+exports.getResolvedConfiguration = exports.isLinux = exports.isMac = exports.isWindows = exports.readYML = exports.getRemoteUrl = exports.getDockerHostIp = exports.getBindAddressForEnvironment = exports.getRemoteHostForEnvironment = exports.getOperatorInstancePorts = exports.toPortInfo = exports.getBlockInstanceContainerName = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const yaml_1 = __importDefault(require("yaml"));
+const md5_1 = __importDefault(require("md5"));
+const schemas_1 = require("@kapeta/schemas");
+const lodash_1 = __importDefault(require("lodash"));
+const types_1 = require("../types");
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const definitionsManager_1 = require("../definitionsManager");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const assetManager_1 = require("../assetManager");
+const serviceManager_1 = require("../serviceManager");
+const clusterService_1 = require("../clusterService");
+async function getBlockInstanceContainerName(systemId, instanceId, blockType) {
+    if (!blockType) {
+        const instance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
+        if (!instance) {
+            throw new Error(`Instance ${instanceId} not found in plan ${systemId}`);
+        }
+        const block = await assetManager_1.assetManager.getAsset(instance.block.ref);
+        if (!block) {
+            throw new Error(`Block ${instance.block.ref} not found`);
+        }
+        blockType = block.data.kind;
+    }
+    const typeDefinition = await definitionsManager_1.definitionsManager.getDefinition(blockType);
+    if (!typeDefinition) {
+        throw new Error(`Block type ${blockType} not found`);
+    }
+    if ((0, nodejs_utils_1.parseKapetaUri)(typeDefinition.definition.kind).fullName === types_1.KIND_BLOCK_TYPE_OPERATOR &&
+        typeDefinition.definition.spec?.local?.singleton) {
+        return `kapeta-instance-operator-${(0, md5_1.default)((0, nodejs_utils_1.normalizeKapetaUri)(systemId) + (0, nodejs_utils_1.normalizeKapetaUri)(blockType))}`;
+    }
+    return `kapeta-block-instance-${(0, md5_1.default)((0, nodejs_utils_1.normalizeKapetaUri)(systemId) + instanceId)}`;
+}
+exports.getBlockInstanceContainerName = getBlockInstanceContainerName;
+function toPortInfo(port) {
+    if (typeof port === 'number' || typeof port === 'string') {
+        return { port: parseInt(`${port}`), type: 'tcp' };
+    }
+    if (!port.type) {
+        port.type = schemas_1.LocalInstancePortType.TCP;
+    }
+    return port;
+}
+exports.toPortInfo = toPortInfo;
+async function getOperatorInstancePorts(systemId, operatorId, local) {
+    const localPorts = local.ports ?? {};
+    const promises = Object.entries(localPorts).map(async ([portType, value]) => {
+        const portInfo = toPortInfo(value);
+        const hostPort = await serviceManager_1.serviceManager.ensureServicePort(systemId, operatorId, portType);
+        return {
+            portType,
+            port: portInfo.port,
+            hostPort,
+            protocol: portInfo.type,
+        };
+    });
+    return await Promise.all(promises);
+}
+exports.getOperatorInstancePorts = getOperatorInstancePorts;
+/**
+ * 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.
+ */
+function getRemoteHostForEnvironment(environment) {
+    return environment === 'docker' ? types_1.DOCKER_HOST_INTERNAL : clusterService_1.clusterService.getClusterServiceHost();
+}
+exports.getRemoteHostForEnvironment = getRemoteHostForEnvironment;
+/**
+ * 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)
+ */
+function getBindAddressForEnvironment(environment, preferredHost = '127.0.0.1') {
+    return environment === 'docker' ? '0.0.0.0' : preferredHost;
+}
+exports.getBindAddressForEnvironment = getBindAddressForEnvironment;
+/**
+ * Get the docker host IP address for port binding.
+ */
+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;
+}
+exports.getDockerHostIp = getDockerHostIp;
+function getRemoteUrl(id, defautValue) {
+    const remoteConfig = local_cluster_config_1.default.getClusterConfig().remote;
+    return remoteConfig?.[id] ?? defautValue;
+}
+exports.getRemoteUrl = getRemoteUrl;
+function readYML(path) {
+    const rawYaml = node_fs_1.default.readFileSync(path);
+    try {
+        return yaml_1.default.parse(rawYaml.toString());
+    }
+    catch (err) {
+        throw new Error(`Failed to parse plan YAML: ${err}`);
+    }
+}
+exports.readYML = readYML;
+function isWindows() {
+    return 'win32' === process.platform;
+}
+exports.isWindows = isWindows;
+function isMac() {
+    return 'darwin' === process.platform;
+}
+exports.isMac = isMac;
+function isLinux() {
+    return !isWindows() && !isMac();
+}
+exports.isLinux = isLinux;
+function getResolvedConfiguration(entities, config, globalConfiguration) {
+    if (!entities || !globalConfiguration) {
+        return config || {};
+    }
+    const mergedConfig = config ? lodash_1.default.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 ? lodash_1.default.get(globalConfiguration, configPath) : undefined;
+            if (!lodash_1.default.has(mergedConfig, configPath)) {
+                lodash_1.default.set(mergedConfig, configPath, defaultValue);
+            }
+        });
+    });
+    return mergedConfig;
+}
+exports.getResolvedConfiguration = getResolvedConfiguration;

package/dist/esm/start.d.ts

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

package/dist/esm/start.js

@@ -0,0 +1,17 @@
+"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 index_1 = __importDefault(require("./index"));
+index_1.default
+    .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);
+});