hammerkit 1.4.0 → 1.5.0-alpha.1

package/dist/planner/utils/plan-work-node.js

@@ -1,145 +1,162 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.planWorkNode = exports.getMergedBuildTask = void 0;
+exports.getAbsolutePaths = exports.mapSource = exports.parseWorkNodeNeeds = exports.parseContainerWorkNodePorts = exports.mapLabels = exports.getWorkNode = exports.findBuildTask = exports.planTask = void 0;
+const work_context_1 = require("../work-context");
 const template_value_1 = require("./template-value");
 const plan_work_command_1 = require("./plan-work-command");
 const split_name_1 = require("./split-name");
-const find_build_task_1 = require("./find-build-task");
 const parse_work_node_mount_1 = require("./parse-work-node-mount");
 const plan_work_dependency_1 = require("./plan-work-dependency");
 const path_1 = require("path");
-const work_node_status_1 = require("../work-node-status");
 const work_node_id_1 = require("../work-node-id");
 const parse_work_node_port_1 = require("./parse-work-node-port");
-function getMergedBuildTask(build, task) {
+const work_service_id_1 = require("../work-service-id");
+const os_1 = require("os");
+const parse_work_service_volume_1 = require("./parse-work-service-volume");
+const plan_work_volume_1 = require("./plan-work-volume");
+const get_container_mounts_1 = require("./get-container-mounts");
+function planTask(workContext, buildTaskResult) {
+    let extendedTask = null;
+    if (buildTaskResult.task.extend) {
+        extendedTask = findBuildTask(workContext, { taskName: buildTaskResult.task.extend });
+        if (extendedTask.task.extend) {
+            throw new Error(`nested extend ${extendedTask.name} is not allowed for task ${buildTaskResult.name}`);
+        }
+    }
     const envs = {
-        ...build.envs,
-        ...(task.envs || {}),
+        ...(extendedTask?.task?.envs || {}),
+        ...buildTaskResult.context.build.envs,
+        ...(buildTaskResult.task.envs || {}),
     };
-    if (task.extend) {
-        const extend = find_build_task_1.findBuildTask(build, task.extend);
-        const extendEnvs = {
-            ...extend.task.envs,
-            ...envs,
-        };
-        return {
-            task: {
-                image: task.image || extend.task.image,
-                envs: extendEnvs,
-                ports: task.ports || extend.task.ports || [],
-                cmds: task.cmds || extend.task.cmds || [],
-                description: task.description || extend.task.description,
-                shell: task.shell || extend.task.shell,
-                continuous: task.continuous || extend.task.continuous || false,
-                unknownProps: task.unknownProps,
-                src: [...(extend.task.src || []), ...(task.src || [])],
-                mounts: [...(extend.task.mounts || []), ...(task.mounts || [])],
-                generates: [...(extend.task.generates || []), ...(task.generates || [])],
-            },
-            deps: [
-                ...(extend.task.deps || []).map((d) => ({ name: d, build: extend.build })),
-                ...(task.deps || []).map((d) => ({ name: d, build: build })),
-            ],
-        };
-    }
-    else {
-        return {
-            task: {
-                image: task.image,
-                src: task.src || [],
-                cmds: task.cmds || [],
-                continuous: task.continuous || false,
-                generates: task.generates || [],
-                description: task.description,
-                shell: task.shell,
-                ports: task.ports || [],
-                unknownProps: task.unknownProps,
-                mounts: task.mounts || [],
-                envs,
-            },
-            deps: [...(task.deps || []).map((d) => ({ name: d, build: build }))],
-        };
-    }
-}
-exports.getMergedBuildTask = getMergedBuildTask;
-function planWorkNode(build, taskName, nodes, context) {
-    if (build.tasks[taskName]) {
-        const { task, deps } = getMergedBuildTask(build, build.tasks[taskName]);
-        const id = work_node_id_1.getWorkNodeId(context.currentWorkdir, task, deps);
-        if (nodes[id]) {
-            return nodes[id];
+    const getReferences = (task, prop) => {
+        if (!task) {
+            return [];
         }
-        const name = [...context.namePrefix, taskName].join(':');
-        const node = parseWorkNode({
-            envs: task.envs,
-            id,
-            continuous: task.continuous,
-            description: template_value_1.templateValue(task.description, task.envs),
-            name,
-            cwd: context.currentWorkdir,
-            cmds: parseWorkNodeCommand(task, context, task.envs),
-            deps: [],
-            unknownProps: task.unknownProps,
-            buildFile: build,
-            taskName: taskName,
-            src: parseLocalWorkNodeSource(task, context, task.envs),
-            generates: parseLocalWorkNodeGenerate(task, context, task.envs),
-            mergedDeps: deps,
-            mergedTask: task,
-            status: {
-                name,
-                state: { type: 'pending', pendingDependencies: {} },
-                defer: new AbortController(),
-                console: work_node_status_1.nodeConsole(),
-            },
-        }, task, context);
-        nodes[id] = node;
-        const depNodes = deps.map((dep) => {
-            const depName = template_value_1.templateValue(dep.name, dep.build.envs);
-            const depNode = planWorkNode(dep.build, depName, nodes, {
-                ...context,
-                idPrefix: null,
-            });
-            if (!depNode) {
-                throw new Error(`unable to find dependency ${dep} for task ${taskName} in ${dep.build.path}`);
-            }
-            return depNode;
-        });
-        plan_work_dependency_1.planWorkDependency(depNodes, node, taskName, nodes, context);
-        return node;
+        const value = task.task[prop];
+        if (!value) {
+            return [];
+        }
+        return value.map((d) => ({
+            name: d,
+            build: buildTaskResult.context.build,
+            context: task.context,
+        }));
+    };
+    const mergeReferences = (first, second) => {
+        return [...first, ...second];
+    };
+    return {
+        buildTask: buildTaskResult.task,
+        build: buildTaskResult.context.build,
+        name: buildTaskResult.name,
+        cache: buildTaskResult.task.cache ?? extendedTask?.task?.cache ?? null,
+        description: buildTaskResult.task.description ?? extendedTask?.task?.description ?? null,
+        cwd: workContext.cwd,
+        image: buildTaskResult.task.image ?? extendedTask?.task?.image ?? null,
+        platform: buildTaskResult.task.platform ?? extendedTask?.task?.platform ?? null,
+        mounts: buildTaskResult.task.mounts || extendedTask?.task?.mounts || [],
+        generates: buildTaskResult.task.generates || extendedTask?.task?.generates || [],
+        shell: buildTaskResult.task.shell ?? extendedTask?.task?.shell ?? null,
+        ports: buildTaskResult.task.ports || extendedTask?.task?.ports || [],
+        src: buildTaskResult.task.src || extendedTask?.task?.src || [],
+        cmds: buildTaskResult.task.cmds || extendedTask?.task?.cmds || [],
+        continuous: buildTaskResult.task.continuous ?? extendedTask?.task?.continuous ?? false,
+        labels: {
+            ...(extendedTask?.task?.labels || {}),
+            ...(buildTaskResult.task.labels || {}),
+        },
+        envs,
+        deps: mergeReferences(getReferences(extendedTask, 'deps'), getReferences(buildTaskResult, 'deps')),
+        needs: mergeReferences(getReferences(extendedTask, 'needs'), getReferences(buildTaskResult, 'needs')),
+    };
+}
+exports.planTask = planTask;
+function findBuildTask(context, selector) {
+    if (context.build.tasks[selector.taskName]) {
+        return { task: context.build.tasks[selector.taskName], context, name: selector.taskName };
     }
     else {
-        const ref = split_name_1.splitName(taskName);
+        const ref = (0, split_name_1.splitName)(selector.taskName);
         if (ref.prefix) {
-            if (build.references[ref.prefix]) {
-                return planWorkNode(build.references[ref.prefix], ref.taskName, nodes, {
-                    ...context,
-                    currentWorkdir: build.references[ref.prefix].path,
-                    idPrefix: null,
-                    namePrefix: [...context.namePrefix, ref.prefix],
-                });
+            if (context.build.references[ref.prefix]) {
+                return findBuildTask((0, work_context_1.createSubWorkContext)(context, {
+                    name: ref.prefix,
+                    type: 'references',
+                }), { taskName: ref.taskName });
             }
-            else if (build.includes[ref.prefix]) {
-                return planWorkNode(build.includes[ref.prefix], ref.taskName, nodes, {
-                    ...context,
-                    idPrefix: ref.prefix,
-                    namePrefix: [...context.namePrefix, ref.prefix],
+            else if (context.build.includes[ref.prefix]) {
+                return findBuildTask((0, work_context_1.createSubWorkContext)(context, {
+                    name: ref.prefix,
+                    type: 'includes',
+                }), {
+                    taskName: ref.taskName,
                 });
             }
         }
-        throw new Error(`unable to find ${taskName} in ${build.path}`);
+        throw new Error(`unable to find ${selector.taskName} in ${context.build.path}`);
+    }
+}
+exports.findBuildTask = findBuildTask;
+function getWorkNode(context, selector) {
+    const rootNode = findBuildTask(context, selector);
+    const plannedTask = planTask(rootNode.context, rootNode);
+    const id = (0, work_node_id_1.getWorkNodeId)(plannedTask);
+    if (context.workTree.nodes[id]) {
+        return context.workTree.nodes[id];
+    }
+    const node = parseWorkNode(id, plannedTask, rootNode.context);
+    context.workTree.nodes[id] = node;
+    const depNodes = [];
+    for (const plannedDep of plannedTask.deps) {
+        const depName = (0, template_value_1.templateValue)(plannedDep.name, plannedDep.build.envs);
+        const depNode = getWorkNode(plannedDep.context, { taskName: depName });
+        if (!depNodes.some((d) => d.id === depNode.id)) {
+            depNodes.push(depNode);
+        }
     }
+    (0, plan_work_dependency_1.planWorkDependency)(depNodes, node);
+    return node;
 }
-exports.planWorkNode = planWorkNode;
-function parseWorkNode(baseWorkNode, task, context) {
+exports.getWorkNode = getWorkNode;
+function mapLabels(labels) {
+    const result = {};
+    for (const [key, value] of Object.entries(labels)) {
+        result[key] = [value];
+    }
+    return result;
+}
+exports.mapLabels = mapLabels;
+function parseWorkNode(id, task, context) {
+    const name = [...context.namePrefix, task.name].join(':');
+    const baseWorkNode = {
+        envs: task.envs,
+        id,
+        description: (0, template_value_1.templateValue)(task.description, task.envs),
+        continuous: task.continuous,
+        name,
+        cwd: task.cwd,
+        cmds: parseWorkNodeCommand(task, context, task.envs),
+        deps: [],
+        buildFile: task.build,
+        taskName: task.name,
+        src: parseLocalWorkNodeSource(task, context, task.envs),
+        generates: parseLocalWorkNodeGenerate(task, context, task.envs),
+        plannedTask: task,
+        needs: parseWorkNodeNeeds(task.needs, context),
+        labels: mapLabels(task.labels),
+        caching: task.cache ?? null,
+    };
     if (task.image) {
+        const mounts = (0, get_container_mounts_1.getContainerMounts)(baseWorkNode, parseContainerWorkNodeMount(task, context, task.envs));
         return {
             ...baseWorkNode,
             type: 'container',
-            image: template_value_1.templateValue(task.image, task.envs),
-            shell: template_value_1.templateValue(task.shell, task.envs) || '/bin/sh',
-            mounts: parseContainerWorkNodeMount(task, context, task.envs),
+            user: getContainerUser(),
+            image: (0, template_value_1.templateValue)(task.image, task.envs),
+            shell: (0, template_value_1.templateValue)(task.shell, task.envs) || '/bin/sh',
+            mounts,
             ports: parseContainerWorkNodePorts(task, context, task.envs),
+            volumes: (0, plan_work_volume_1.getContainerVolumes)(baseWorkNode, mounts),
         };
     }
     else {
@@ -150,48 +167,106 @@ function parseWorkNode(baseWorkNode, task, context) {
     }
 }
 function parseContainerWorkNodePorts(task, context, envs) {
-    return task.ports.map((m) => template_value_1.templateValue(m, envs)).map((m) => parse_work_node_port_1.parseWorkNodePort(m));
+    return task.ports.map((m) => (0, template_value_1.templateValue)(m, envs)).map((m) => (0, parse_work_node_port_1.parseWorkNodePort)(m));
 }
+exports.parseContainerWorkNodePorts = parseContainerWorkNodePorts;
 function parseContainerWorkNodeMount(task, context, envs) {
-    return task.mounts.map((m) => template_value_1.templateValue(m, envs)).map((m) => parse_work_node_mount_1.parseWorkNodeMount(context.currentWorkdir, m));
+    return task.mounts.map((m) => (0, template_value_1.templateValue)(m, envs)).map((m) => (0, parse_work_node_mount_1.parseWorkNodeMount)(context.cwd, m));
 }
 function parseLocalWorkNodeGenerate(task, context, envs) {
-    return getAbsolutePaths(task.generates, context.currentWorkdir)
-        .map((g) => template_value_1.templateValue(g, envs))
+    return getAbsolutePaths(task.generates, context.cwd)
+        .map((g) => (0, template_value_1.templateValue)(g, envs))
         .map((path) => ({ path, inherited: false }));
 }
 function parseLocalWorkNodeSource(task, context, envs) {
     return task.src
         .map((src) => ({
-        relativePath: template_value_1.templateValue(src.relativePath, envs),
+        relativePath: (0, template_value_1.templateValue)(src.relativePath, envs),
         matcher: src.matcher,
     }))
-        .map((src) => mapSource(src, context.currentWorkdir));
+        .map((src) => mapSource(src, context.cwd));
+}
+function getContainerUser() {
+    return (0, os_1.platform)() === 'linux' || (0, os_1.platform)() === 'freebsd' || (0, os_1.platform)() === 'openbsd' || (0, os_1.platform)() === 'sunos'
+        ? `${process.getuid()}:${process.getgid()}`
+        : `0:0`;
+}
+function parseWorkNodeNeeds(needs, context) {
+    const result = [];
+    for (const need of needs) {
+        const service = need.build.services[need.name];
+        const id = (0, work_service_id_1.getWorkServiceId)(need.build, service);
+        if (!context.workTree.services[id]) {
+            const workService = {
+                id,
+                buildService: service,
+                name: need.name,
+                description: service.description,
+                ports: (service.ports || []).map((m) => (0, template_value_1.templateValue)(m, service.envs)).map((m) => (0, parse_work_node_port_1.parseWorkNodePort)(m)),
+            };
+            if (service.image) {
+                context.workTree.services[id] = {
+                    ...workService,
+                    type: 'container-service',
+                    cmd: service.cmd,
+                    envs: service.envs || {},
+                    image: service.image,
+                    // user: getContainerUser(),
+                    healthcheck: service.healthcheck,
+                    mounts: (service.mounts || [])
+                        .map((m) => (0, template_value_1.templateValue)(m, service.envs))
+                        .map((m) => (0, parse_work_node_mount_1.parseWorkNodeMount)(need.build.path, m)),
+                    volumes: (service.volumes || [])
+                        .map((m) => (0, template_value_1.templateValue)(m, service.envs))
+                        .map((m) => (0, parse_work_service_volume_1.parseWorkServiceVolume)(need.build.path, m)),
+                };
+            }
+            else if (!!service.context && !!service.selector) {
+                context.workTree.services[id] = {
+                    ...workService,
+                    context: service.context,
+                    selector: service.selector,
+                    kubeconfig: service.kubeconfig ?? getDefaultKubeConfig(),
+                    type: 'kubernetes-service',
+                };
+            }
+        }
+        if (!result.some((s) => s.id === id)) {
+            result.push(context.workTree.services[id]);
+        }
+    }
+    return result;
+}
+exports.parseWorkNodeNeeds = parseWorkNodeNeeds;
+function getDefaultKubeConfig() {
+    return (0, path_1.join)((0, os_1.homedir)(), '.kube/config');
 }
 function parseWorkNodeCommand(task, context, envs) {
-    return plan_work_command_1.planWorkCommand(task.cmds.map((cmd) => {
+    return (0, plan_work_command_1.planWorkCommand)(task.cmds.map((cmd) => {
         if (typeof cmd === 'string') {
-            return template_value_1.templateValue(cmd, envs);
+            return (0, template_value_1.templateValue)(cmd, envs);
         }
         else {
             return {
-                cmd: template_value_1.templateValue(cmd.cmd, envs),
-                path: template_value_1.templateValue(cmd.path, envs),
+                cmd: (0, template_value_1.templateValue)(cmd.cmd, envs),
+                path: (0, template_value_1.templateValue)(cmd.path, envs),
                 type: cmd.type,
             };
         }
-    }), context.currentWorkdir);
+    }), context.cwd);
 }
 function mapSource(src, workDir) {
     return {
         matcher: src.matcher,
-        absolutePath: path_1.join(workDir, src.relativePath),
+        absolutePath: (0, path_1.join)(workDir, src.relativePath),
     };
 }
+exports.mapSource = mapSource;
 function getAbsolutePaths(dirs, workingDir) {
     if (!dirs) {
         return [];
     }
-    return dirs.map((dir) => path_1.join(workingDir, dir));
+    return dirs.map((dir) => (0, path_1.join)(workingDir, dir));
 }
+exports.getAbsolutePaths = getAbsolutePaths;
 //# sourceMappingURL=plan-work-node.js.map

package/dist/planner/utils/plan-work-nodes.js

@@ -1,13 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.iterateWorkNodes = exports.planWorkNodes = void 0;
+exports.iterateWorkNodes = exports.iterateWorkServices = exports.planWorkNodes = void 0;
 const plan_work_node_1 = require("./plan-work-node");
-function planWorkNodes(build) {
-    const nodes = {};
-    addWorkNodes(build, nodes, [], []);
-    return nodes;
+const work_context_1 = require("../work-context");
+const label_values_1 = require("../../executer/label-values");
+function planWorkNodes(build, options) {
+    const context = (0, work_context_1.createWorkContext)(build);
+    addWorkNodes(context, []);
+    const nodesIdsToRemove = [];
+    for (const [nodeId, node] of Object.entries(context.workTree.nodes)) {
+        if (!(0, label_values_1.matchesAllLabels)(options.filterLabels, node, context.workTree.nodes) ||
+            (0, label_values_1.matchesAnyLabel)(options.excludeLabels, node)) {
+            nodesIdsToRemove.push(nodeId);
+        }
+    }
+    for (const nodeId of nodesIdsToRemove) {
+        removeNode(nodeId, context.workTree);
+    }
+    removeUnusedServices(context.workTree);
+    return context.workTree;
 }
 exports.planWorkNodes = planWorkNodes;
+function removeUnusedServices(workTree) {
+    const needs = new Set();
+    for (const node of Object.values(workTree.nodes)) {
+        for (const need of node.needs) {
+            needs.add(need.id);
+        }
+    }
+    const services = Object.values(workTree.services);
+    for (const service of services) {
+        if (!needs.has(service.id)) {
+            delete workTree.services[service.id];
+        }
+    }
+}
+function removeNode(nodeId, workTree) {
+    const node = workTree.nodes[nodeId];
+    if (node) {
+        delete workTree.nodes[nodeId];
+        for (const node of Object.values(workTree.nodes)) {
+            if (node.deps.some((d) => d.id === nodeId)) {
+                removeNode(node.id, workTree);
+            }
+        }
+    }
+}
+function* iterateWorkServices(services) {
+    for (const serviceId of Object.keys(services)) {
+        const service = services[serviceId];
+        yield service;
+    }
+}
+exports.iterateWorkServices = iterateWorkServices;
 function* iterateWorkNodes(nodes) {
     for (const nodeId of Object.keys(nodes)) {
         const node = nodes[nodeId];
@@ -15,19 +60,19 @@ function* iterateWorkNodes(nodes) {
     }
 }
 exports.iterateWorkNodes = iterateWorkNodes;
-function addWorkNodes(build, nodes, files, namePrefix) {
-    if (files.indexOf(build.fileName) !== -1) {
+function addWorkNodes(context, files) {
+    if (files.indexOf(context.build.fileName) !== -1) {
         return;
     }
-    files.push(build.fileName);
-    for (const taskId of Object.keys(build.tasks)) {
-        plan_work_node_1.planWorkNode(build, taskId, nodes, { currentWorkdir: build.path, idPrefix: null, namePrefix: namePrefix });
+    files.push(context.build.fileName);
+    for (const taskName of Object.keys(context.build.tasks)) {
+        (0, plan_work_node_1.getWorkNode)(context, { taskName });
     }
-    for (const key of Object.keys(build.references)) {
-        addWorkNodes(build.references[key], nodes, files, [...namePrefix, key]);
+    for (const name of Object.keys(context.build.references)) {
+        addWorkNodes((0, work_context_1.createSubWorkContext)(context, { type: 'references', name }), files);
     }
-    for (const key of Object.keys(build.includes)) {
-        addWorkNodes(build.includes[key], nodes, files, [...namePrefix, key]);
+    for (const name of Object.keys(context.build.includes)) {
+        addWorkNodes((0, work_context_1.createSubWorkContext)(context, { type: 'includes', name }), files);
     }
 }
 //# sourceMappingURL=plan-work-nodes.js.map

package/dist/planner/utils/plan-work-tree.js

@@ -2,10 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.planWorkTree = void 0;
 const plan_work_node_1 = require("./plan-work-node");
-function planWorkTree(build, taskName) {
-    const nodes = {};
-    const rootNode = plan_work_node_1.planWorkNode(build, taskName, nodes, { currentWorkdir: build.path, idPrefix: null, namePrefix: [] });
-    return { nodes, rootNode };
+const work_context_1 = require("../work-context");
+function planWorkTree(build, options) {
+    const context = (0, work_context_1.createWorkContext)(build);
+    const result = (0, plan_work_node_1.getWorkNode)(context, { taskName: options.taskName });
+    return {
+        ...context.workTree,
+        rootNode: result,
+    };
 }
 exports.planWorkTree = planWorkTree;
 //# sourceMappingURL=plan-work-tree.js.map

package/dist/planner/utils/plan-work-volume.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContainerVolumes = exports.getVolumeName = exports.generateId = void 0;
+const crypto_1 = require("crypto");
+function generateId(generate) {
+    return (0, crypto_1.createHash)('sha1').update(generate).digest('hex');
+}
+exports.generateId = generateId;
+function getVolumeName(generate) {
+    return `hammerkit-${generateId(generate)}`;
+}
+exports.getVolumeName = getVolumeName;
+function getContainerVolumes(task, mounts) {
+    const volumes = [];
+    for (const generate of task.generates) {
+        const hasMount = mounts.some((m) => m.containerPath === generate.path);
+        if (hasMount) {
+            continue;
+        }
+        const name = getVolumeName(generate.path);
+        volumes.push({
+            name,
+            containerPath: generate.path,
+        });
+    }
+    return volumes;
+}
+exports.getContainerVolumes = getContainerVolumes;
+//# sourceMappingURL=plan-work-volume.js.map

package/dist/planner/validate.js

@@ -1,13 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validate = void 0;
-const plan_work_nodes_1 = require("../planner/utils/plan-work-nodes");
-const plan_work_tree_1 = require("../planner/utils/plan-work-tree");
-async function* validate(buildFile, context, name) {
-    const tree = name ? plan_work_tree_1.planWorkTree(buildFile, name).nodes : plan_work_nodes_1.planWorkNodes(buildFile);
+exports.checkIfContextExists = exports.hasCycle = exports.validate = void 0;
+const read_build_file_1 = require("../parser/read-build-file");
+async function* validate(workTree, context) {
     const cycleNodes = [];
-    for (const key of Object.keys(tree)) {
-        const node = tree[key];
+    for (const service of Object.values(workTree.services)) {
+        if (!service.description) {
+            yield { type: 'warn', message: `missing description`, node: service };
+        }
+        if (service.type === 'container-service') {
+            if (!service.healthcheck) {
+                yield { type: 'warn', message: 'missing healthcheck', node: service };
+            }
+            for (const mount of service.mounts) {
+                if (!(await context.file.exists(mount.localPath))) {
+                    yield {
+                        type: 'warn',
+                        message: `mount ${mount.localPath} does not exist`,
+                        node: service,
+                    };
+                }
+            }
+        }
+        else {
+            if (!(await context.file.exists(service.kubeconfig))) {
+                yield {
+                    type: 'warn',
+                    message: `kubeconfig ${service.kubeconfig} does not exist`,
+                    node: service,
+                };
+            }
+            else if (!(await checkIfContextExists(service, context))) {
+                yield {
+                    type: 'warn',
+                    message: `context ${service.context} does not exist in kubeconfig ${service.kubeconfig}`,
+                    node: service,
+                };
+            }
+        }
+        for (const key of Object.keys(service.buildService.unknownProps)) {
+            yield {
+                type: 'warn',
+                message: `${key} is an unknown configuration`,
+                node: service,
+            };
+        }
+    }
+    for (const node of Object.values(workTree.nodes)) {
         if (!node.description) {
             yield { type: 'warn', message: `missing description`, node: node };
         }
@@ -23,7 +62,7 @@ async function* validate(buildFile, context, name) {
                 };
             }
         }
-        for (const key of Object.keys(node.unknownProps)) {
+        for (const key of Object.keys(node.plannedTask.buildTask.unknownProps)) {
             yield {
                 type: 'warn',
                 message: `${key} is an unknown configuration`,
@@ -52,4 +91,13 @@ function hasCycle(node, currentPath) {
     }
     return null;
 }
+exports.hasCycle = hasCycle;
+async function checkIfContextExists(service, context) {
+    const kubeconfig = await (0, read_build_file_1.read)(service.kubeconfig, context);
+    if (kubeconfig.contexts && kubeconfig.contexts instanceof Array) {
+        return kubeconfig.contexts.some((c) => c['name'] === service.context);
+    }
+    return false;
+}
+exports.checkIfContextExists = checkIfContextExists;
 //# sourceMappingURL=validate.js.map

package/dist/planner/work-context.js

@@ -1,3 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSubWorkContext = exports.createWorkContext = void 0;
+function createWorkContext(build) {
+    return {
+        cwd: build.path,
+        namePrefix: [],
+        build,
+        workTree: { nodes: {}, services: {} },
+    };
+}
+exports.createWorkContext = createWorkContext;
+function createSubWorkContext(context, options) {
+    const subBuildFile = context.build[options.type][options.name];
+    return {
+        build: subBuildFile,
+        workTree: context.workTree,
+        cwd: options.type === 'references' ? subBuildFile.path : context.cwd,
+        namePrefix: [...context.namePrefix, options.name],
+    };
+}
+exports.createSubWorkContext = createSubWorkContext;
 //# sourceMappingURL=work-context.js.map

package/dist/planner/work-mount.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=work-mount.js.map