hammerkit 1.5.0 → 1.6.0-alpha.1

package/dist/planner/validate.js

@@ -1,23 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkIfContextExists = exports.hasCycle = exports.validate = void 0;
+exports.checkIfContextExists = exports.hasDependencyCycle = exports.hasNeedCycle = exports.hasMixedCycle = exports.validate = void 0;
 const read_build_file_1 = require("../parser/read-build-file");
+const plan_work_tasks_1 = require("./utils/plan-work-tasks");
 async function* validate(workTree, context) {
-    const cycleNodes = [];
-    for (const service of Object.values(workTree.services)) {
+    const cycleItems = [];
+    for (const item of (0, plan_work_tasks_1.iterateWorkServices)(workTree)) {
+        const service = item.data;
         if (!service.description) {
-            yield { type: 'warn', message: `missing description`, node: service };
+            yield { type: 'warn', message: `missing description`, item: service };
         }
         if (service.type === 'container-service') {
             if (!service.healthcheck) {
-                yield { type: 'warn', message: 'missing healthcheck', node: service };
+                yield { type: 'warn', message: 'missing healthcheck', item: 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,
+                        item: service,
                     };
                 }
             }
@@ -27,71 +29,102 @@ async function* validate(workTree, context) {
                 yield {
                     type: 'warn',
                     message: `kubeconfig ${service.kubeconfig} does not exist`,
-                    node: service,
+                    item: service,
                 };
             }
             else if (!(await checkIfContextExists(service, context))) {
                 yield {
                     type: 'warn',
                     message: `context ${service.context} does not exist in kubeconfig ${service.kubeconfig}`,
-                    node: service,
+                    item: 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 };
+    for (const item of (0, plan_work_tasks_1.iterateWorkTasks)(workTree)) {
+        const task = item.data;
+        if (!task.description) {
+            yield { type: 'warn', message: `missing description`, item: task };
         }
-        if ((!node.cmds || node.cmds.length === 0) && (!node.deps || node.deps.length === 0)) {
-            yield { type: 'warn', message: `task is empty`, node: node };
+        if ((!task.cmds || task.cmds.length === 0) && (!item.deps || item.deps.length === 0)) {
+            yield { type: 'warn', message: `task is empty`, item: task };
         }
-        for (const src of node.src) {
+        for (const src of task.src) {
             if (!(await context.file.exists(src.absolutePath))) {
                 yield {
                     type: 'warn',
                     message: `src ${src.absolutePath} does not exist`,
-                    node: node,
+                    item: task,
                 };
             }
         }
-        for (const key of Object.keys(node.plannedTask.buildTask.unknownProps)) {
-            yield {
-                type: 'warn',
-                message: `${key} is an unknown configuration`,
-                node: node,
-            };
+        if (cycleItems.indexOf(item) === -1) {
+            const cyclePath = hasDependencyCycle(item, []);
+            if (cyclePath) {
+                cycleItems.push(...cyclePath);
+                yield { type: 'error', message: `task cycle detected ${cyclePath.map((n) => n.name).join(' -> ')}`, item: task };
+            }
         }
-        if (cycleNodes.indexOf(node) === -1) {
-            const cyclePath = hasCycle(node, []);
+        if (cycleItems.indexOf(item) === -1) {
+            const cyclePath = hasMixedCycle(item, []);
             if (cyclePath) {
-                cycleNodes.push(...cyclePath);
-                yield { type: 'error', message: `task cycle detected ${cyclePath.map((n) => n.name).join(' -> ')}`, node: node };
+                cycleItems.push(...cyclePath);
+                yield {
+                    type: 'error',
+                    message: `cycle detected across deps/needs ${cyclePath.map((n) => n.name).join(' -> ')}`,
+                    item: task,
+                };
             }
         }
     }
 }
 exports.validate = validate;
-function hasCycle(node, currentPath) {
-    if (currentPath.indexOf(node) >= 0) {
-        return [...currentPath, node];
+function hasMixedCycle(item, currentPath) {
+    if (currentPath.indexOf(item) >= 0) {
+        return [...currentPath, item];
+    }
+    const nextPath = [...currentPath, item];
+    for (const dep of item.deps) {
+        const cycle = hasMixedCycle(dep, nextPath);
+        if (cycle) {
+            return cycle;
+        }
+    }
+    for (const need of item.needs) {
+        const cycle = hasMixedCycle(need.service, nextPath);
+        if (cycle) {
+            return cycle;
+        }
+    }
+    return null;
+}
+exports.hasMixedCycle = hasMixedCycle;
+function hasNeedCycle(item, currentPath) {
+    if (currentPath.indexOf(item) >= 0) {
+        return [...currentPath, item];
+    }
+    for (const dep of item.needs) {
+        const depHasCycle = hasNeedCycle(dep.service, [...currentPath, item]);
+        if (depHasCycle) {
+            return depHasCycle;
+        }
+    }
+    return null;
+}
+exports.hasNeedCycle = hasNeedCycle;
+function hasDependencyCycle(item, currentPath) {
+    if (currentPath.indexOf(item) >= 0) {
+        return [...currentPath, item];
     }
-    for (const dep of node.deps) {
-        const depHasCycle = hasCycle(dep, [...currentPath, node]);
+    for (const dep of item.deps) {
+        const depHasCycle = hasDependencyCycle(dep, [...currentPath, item]);
         if (depHasCycle) {
             return depHasCycle;
         }
     }
     return null;
 }
-exports.hasCycle = hasCycle;
+exports.hasDependencyCycle = hasDependencyCycle;
 async function checkIfContextExists(service, context) {
     const kubeconfig = await (0, read_build_file_1.read)(service.kubeconfig, context);
     if (kubeconfig.contexts && kubeconfig.contexts instanceof Array) {

package/dist/planner/validate.spec.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validate_1 = require("./validate");
+function makeTask(name) {
+    const item = {
+        id: () => name,
+        name,
+        status: {},
+        data: { type: 'local-task', name },
+        needs: [],
+        deps: [],
+        requiredBy: [],
+        state: {},
+        runtime: {},
+    };
+    return item;
+}
+function makeService(name) {
+    const item = {
+        id: () => name,
+        name,
+        status: {},
+        data: { type: 'container-service', name },
+        needs: [],
+        deps: [],
+        requiredBy: [],
+        state: {},
+        runtime: {},
+    };
+    return item;
+}
+describe('validate', () => {
+    describe('hasDependencyCycle', () => {
+        it('returns null for an item with no deps', () => {
+            const t = makeTask('a');
+            expect((0, validate_1.hasDependencyCycle)(t, [])).toBeNull();
+        });
+        it('returns null for a linear chain', () => {
+            const a = makeTask('a');
+            const b = makeTask('b');
+            const c = makeTask('c');
+            a.deps.push(b);
+            b.deps.push(c);
+            expect((0, validate_1.hasDependencyCycle)(a, [])).toBeNull();
+        });
+        it('detects a direct self-cycle', () => {
+            const a = makeTask('a');
+            a.deps.push(a);
+            const cycle = (0, validate_1.hasDependencyCycle)(a, []);
+            expect(cycle).not.toBeNull();
+            expect(cycle.map((i) => i.name)).toEqual(['a', 'a']);
+        });
+        it('detects an indirect cycle', () => {
+            const a = makeTask('a');
+            const b = makeTask('b');
+            const c = makeTask('c');
+            a.deps.push(b);
+            b.deps.push(c);
+            c.deps.push(a);
+            const cycle = (0, validate_1.hasDependencyCycle)(a, []);
+            expect(cycle).not.toBeNull();
+            expect(cycle.map((i) => i.name)).toEqual(['a', 'b', 'c', 'a']);
+        });
+        it('does not flag a diamond as a cycle', () => {
+            const root = makeTask('root');
+            const left = makeTask('left');
+            const right = makeTask('right');
+            const leaf = makeTask('leaf');
+            root.deps.push(left, right);
+            left.deps.push(leaf);
+            right.deps.push(leaf);
+            expect((0, validate_1.hasDependencyCycle)(root, [])).toBeNull();
+        });
+    });
+    describe('hasNeedCycle', () => {
+        it('returns null when no needs', () => {
+            const s = makeService('db');
+            expect((0, validate_1.hasNeedCycle)(s, [])).toBeNull();
+        });
+        it('detects a need cycle across services', () => {
+            const a = makeService('a');
+            const b = makeService('b');
+            a.needs.push({ name: 'b', service: b });
+            b.needs.push({ name: 'a', service: a });
+            const cycle = (0, validate_1.hasNeedCycle)(a, []);
+            expect(cycle).not.toBeNull();
+            expect(cycle.map((i) => i.name)).toEqual(['a', 'b', 'a']);
+        });
+        it('detects a self-need cycle', () => {
+            const a = makeService('a');
+            a.needs.push({ name: 'a', service: a });
+            const cycle = (0, validate_1.hasNeedCycle)(a, []);
+            expect(cycle).not.toBeNull();
+            expect(cycle.map((i) => i.name)).toEqual(['a', 'a']);
+        });
+    });
+    describe('hasMixedCycle', () => {
+        it('returns null for an acyclic task → service → task chain', () => {
+            const t1 = makeTask('build');
+            const s = makeService('db');
+            const t2 = makeTask('migrate');
+            t1.needs.push({ name: 'db', service: s });
+            s.deps.push(t2);
+            expect((0, validate_1.hasMixedCycle)(t1, [])).toBeNull();
+        });
+        it('detects a cycle that alternates deps and needs', () => {
+            const t = makeTask('api-build');
+            const s = makeService('api');
+            t.needs.push({ name: 'api', service: s });
+            s.deps.push(t);
+            const cycle = (0, validate_1.hasMixedCycle)(t, []);
+            expect(cycle).not.toBeNull();
+            expect(cycle.map((i) => i.name)).toEqual(['api-build', 'api', 'api-build']);
+        });
+        it('detects a long mixed cycle', () => {
+            const a = makeTask('a');
+            const b = makeService('b');
+            const c = makeTask('c');
+            const d = makeService('d');
+            a.needs.push({ name: 'b', service: b });
+            b.deps.push(c);
+            c.needs.push({ name: 'd', service: d });
+            d.deps.push(a);
+            const cycle = (0, validate_1.hasMixedCycle)(a, []);
+            expect(cycle).not.toBeNull();
+            expect(cycle.map((i) => i.name)).toEqual(['a', 'b', 'c', 'd', 'a']);
+        });
+    });
+});
+function taskItem(name, data) {
+    const item = {
+        id: () => name,
+        name,
+        status: {},
+        data: { type: 'local-task', name, description: 'a task', cmds: [{}], src: [], ...data },
+        needs: [],
+        deps: [],
+        requiredBy: [],
+        state: {},
+        runtime: {},
+    };
+    return item;
+}
+function serviceItem(name, data) {
+    const item = {
+        id: () => name,
+        name,
+        status: {},
+        data: { type: 'container-service', name, description: 'a service', healthcheck: {}, mounts: [], ...data },
+        needs: [],
+        deps: [],
+        requiredBy: [],
+        state: {},
+        runtime: {},
+    };
+    return item;
+}
+function workTree(items) {
+    return {
+        tasks: Object.fromEntries((items.tasks ?? []).map((t) => [t.name, t])),
+        services: Object.fromEntries((items.services ?? []).map((s) => [s.name, s])),
+        environment: {},
+    };
+}
+// Environment whose file.exists only returns true for the listed paths.
+function fakeEnv(existing = []) {
+    return { file: { exists: vi.fn(async (p) => existing.includes(p)) } };
+}
+async function collect(gen) {
+    const out = [];
+    for await (const v of gen) {
+        out.push(v);
+    }
+    return out;
+}
+describe('validate (generator)', () => {
+    it('warns about a task without a description', async () => {
+        const tree = workTree({ tasks: [taskItem('build', { description: null })] });
+        const result = await collect((0, validate_1.validate)(tree, fakeEnv()));
+        expect(result).toContainEqual(expect.objectContaining({ type: 'warn', message: 'missing description' }));
+    });
+    it('warns about an empty task (no cmds and no deps)', async () => {
+        const tree = workTree({ tasks: [taskItem('noop', { cmds: [] })] });
+        const result = await collect((0, validate_1.validate)(tree, fakeEnv()));
+        expect(result).toContainEqual(expect.objectContaining({ type: 'warn', message: 'task is empty' }));
+    });
+    it('warns about a missing src path', async () => {
+        const tree = workTree({ tasks: [taskItem('build', { src: [{ absolutePath: '/nope' }] })] });
+        const result = await collect((0, validate_1.validate)(tree, fakeEnv([])));
+        expect(result).toContainEqual(expect.objectContaining({ type: 'warn', message: 'src /nope does not exist' }));
+    });
+    it('does not warn when the src path exists', async () => {
+        const tree = workTree({ tasks: [taskItem('build', { src: [{ absolutePath: '/yes' }] })] });
+        const result = await collect((0, validate_1.validate)(tree, fakeEnv(['/yes'])));
+        expect(result.map((r) => r.message)).not.toContain('src /yes does not exist');
+    });
+    it('emits a cycle error through the generator', async () => {
+        const a = taskItem('a', {});
+        a.deps.push(a);
+        const tree = workTree({ tasks: [a] });
+        const result = await collect((0, validate_1.validate)(tree, fakeEnv()));
+        expect(result).toContainEqual(expect.objectContaining({ type: 'error', message: 'task cycle detected a -> a' }));
+    });
+    it('warns about a container service missing a healthcheck', async () => {
+        const tree = workTree({ services: [serviceItem('db', { healthcheck: null })] });
+        const result = await collect((0, validate_1.validate)(tree, fakeEnv()));
+        expect(result).toContainEqual(expect.objectContaining({ type: 'warn', message: 'missing healthcheck' }));
+    });
+    it('warns about a container service mount that does not exist', async () => {
+        const tree = workTree({
+            services: [serviceItem('db', { mounts: [{ localPath: '/data' }] })],
+        });
+        const result = await collect((0, validate_1.validate)(tree, fakeEnv([])));
+        expect(result).toContainEqual(expect.objectContaining({ type: 'warn', message: 'mount /data does not exist' }));
+    });
+    it('warns when a kubernetes service kubeconfig is missing', async () => {
+        const tree = workTree({
+            services: [
+                serviceItem('cluster', {
+                    type: 'kubernetes-service',
+                    kubeconfig: '/missing/kubeconfig',
+                    context: 'prod',
+                }),
+            ],
+        });
+        const result = await collect((0, validate_1.validate)(tree, fakeEnv([])));
+        expect(result).toContainEqual(expect.objectContaining({ type: 'warn', message: 'kubeconfig /missing/kubeconfig does not exist' }));
+    });
+});
+describe('checkIfContextExists', () => {
+    function kubeconfigEnv(yaml) {
+        return {
+            file: { read: vi.fn(async () => yaml) },
+            status: { context: () => ({ write: vi.fn() }) },
+        };
+    }
+    const service = { kubeconfig: '/kube/config', context: 'prod' };
+    it('is true when the context is present', async () => {
+        const env = kubeconfigEnv('contexts:\n  - name: prod\n  - name: dev\n');
+        expect(await (0, validate_1.checkIfContextExists)(service, env)).toBe(true);
+    });
+    it('is false when the context is absent', async () => {
+        const env = kubeconfigEnv('contexts:\n  - name: dev\n');
+        expect(await (0, validate_1.checkIfContextExists)(service, env)).toBe(false);
+    });
+    it('is false when there are no contexts', async () => {
+        const env = kubeconfigEnv('clusters:\n  - name: c1\n');
+        expect(await (0, validate_1.checkIfContextExists)(service, env)).toBe(false);
+    });
+});
+//# sourceMappingURL=validate.spec.js.map

package/dist/planner/work-cache-id.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkTaskId = void 0;
+const crypto_1 = require("crypto");
+const work_task_cache_description_1 = require("../optimizer/work-task-cache-description");
+function getWorkTaskId(task) {
+    const description = (0, work_task_cache_description_1.getWorkTaskCacheDescription)(task);
+    const jsonData = JSON.stringify(description);
+    return (0, crypto_1.createHash)('sha1').update(jsonData).digest('hex');
+}
+exports.getWorkTaskId = getWorkTaskId;
+//# sourceMappingURL=work-cache-id.js.map

package/dist/planner/work-cache-id.spec.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_case_1 = require("../testing/test-case");
+const program_1 = require("../program");
+const path_1 = require("path");
+async function compareTasks(first, second, taskName, expectEqual) {
+    const testCase = (0, test_case_1.createTestCase)('work-task-id', {
+        'first.yaml': first,
+        'second.yaml': second,
+    });
+    await testCase.setup(async (cwd, environment) => {
+        const firstCli = await (0, program_1.createCli)((0, path_1.join)(cwd, 'first.yaml'), environment, { taskName });
+        const secondCli = await (0, program_1.createCli)((0, path_1.join)(cwd, 'second.yaml'), environment, { taskName });
+        const firstTask = firstCli.task(taskName);
+        const secondTask = secondCli.task(taskName);
+        if (expectEqual) {
+            expect(firstTask.id()).toEqual(secondTask.id());
+        }
+        else {
+            expect(firstTask.id()).not.toEqual(secondTask.id());
+        }
+    });
+}
+describe('work-cache-id', () => {
+    it('should be the same for different mount order', async () => {
+        await compareTasks({
+            tasks: {
+                example: {
+                    image: 'node',
+                    mounts: ['$PWD/.npm:/.npm', '$PWD/.config:/.config'],
+                },
+            },
+        }, {
+            tasks: {
+                example: {
+                    image: 'node',
+                    mounts: ['$PWD/.config:/.config', '$PWD/.npm:/.npm'],
+                },
+            },
+        }, 'example', true);
+    });
+    it('should be the same for different object key order', async () => {
+        await compareTasks({
+            tasks: {
+                example: {
+                    image: 'node:alpine',
+                    cmds: ['npm ci'],
+                },
+            },
+        }, {
+            tasks: {
+                example: {
+                    cmds: ['npm ci'],
+                    image: 'node:alpine',
+                },
+            },
+        }, 'example', true);
+    });
+    it('should be the same with additional description', async () => {
+        await compareTasks({
+            tasks: {
+                example: {
+                    image: 'node:alpine',
+                    cmds: ['npm ci'],
+                },
+            },
+        }, {
+            tasks: {
+                example: {
+                    image: 'node:alpine',
+                    cmds: ['npm ci'],
+                    description: 'should not matter',
+                },
+            },
+        }, 'example', true);
+    });
+    it('should be not be the same for different images', async () => {
+        await compareTasks({
+            tasks: {
+                example: {
+                    image: 'node:alpine',
+                },
+            },
+        }, {
+            tasks: {
+                example: {
+                    image: 'node',
+                },
+            },
+        }, 'example', false);
+    });
+    it('should be not be the same for different cmd order', async () => {
+        await compareTasks({
+            tasks: {
+                example: {
+                    cmds: ['npm ci', 'npm run build'],
+                },
+            },
+        }, {
+            tasks: {
+                example: {
+                    cmds: ['npm run build', 'npm ci'],
+                },
+            },
+        }, 'example', false);
+    });
+    it('should be be the same for different env key order', async () => {
+        await compareTasks({
+            tasks: {
+                example: {
+                    envs: {
+                        NODE_VERSION: '16.6.0',
+                        NPM_VERSION: '6.0.0',
+                    },
+                    cmds: ['npm ci', 'npm run build'],
+                },
+            },
+        }, {
+            tasks: {
+                example: {
+                    envs: {
+                        NPM_VERSION: '6.0.0',
+                        NODE_VERSION: '16.6.0',
+                    },
+                    cmds: ['npm ci', 'npm run build'],
+                },
+            },
+        }, 'example', true);
+    });
+    it('should be be the same for deps in different order', async () => {
+        await compareTasks({
+            tasks: {
+                install: {
+                    cmds: ['npm install'],
+                },
+                build: {
+                    cmds: ['tsc'],
+                },
+                example: {
+                    deps: ['install', 'build'],
+                },
+            },
+        }, {
+            tasks: {
+                install: {
+                    cmds: ['npm install'],
+                },
+                build: {
+                    cmds: ['tsc'],
+                },
+                example: {
+                    deps: ['build', 'install'],
+                },
+            },
+        }, 'example', true);
+    });
+    it('should be be the same for sources in different order', async () => {
+        await compareTasks({
+            tasks: {
+                example: {
+                    src: ['package.json', 'package-lock.json'],
+                },
+            },
+        }, {
+            tasks: {
+                example: {
+                    src: ['package-lock.json', 'package.json'],
+                },
+            },
+        }, 'example', true);
+    });
+});
+//# sourceMappingURL=work-cache-id.spec.js.map

package/dist/planner/work-command.js

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

package/dist/planner/work-environment.js

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

package/dist/planner/work-healthcheck.js

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