@livingdata/pipex 0.0.8 → 0.0.10

package/dist/cli/__tests__/dag.js

@@ -0,0 +1,154 @@
+import test from 'ava';
+import { CyclicDependencyError, ValidationError } from '../../errors.js';
+import { buildGraph, validateGraph, topologicalLevels, subgraph, leafNodes } from '../dag.js';
+function makeStep(id, inputs) {
+    return {
+        id,
+        image: 'alpine:3.20',
+        cmd: ['echo', id],
+        inputs: inputs?.map(i => ({ step: i.step, optional: i.optional }))
+    };
+}
+// -- buildGraph --------------------------------------------------------------
+test('buildGraph: linear pipeline', t => {
+    const steps = [makeStep('a'), makeStep('b', [{ step: 'a' }]), makeStep('c', [{ step: 'b' }])];
+    const graph = buildGraph(steps);
+    t.deepEqual([...graph.get('a')], []);
+    t.deepEqual([...graph.get('b')], ['a']);
+    t.deepEqual([...graph.get('c')], ['b']);
+});
+test('buildGraph: diamond', t => {
+    const steps = [
+        makeStep('a'),
+        makeStep('b', [{ step: 'a' }]),
+        makeStep('c', [{ step: 'a' }]),
+        makeStep('d', [{ step: 'b' }, { step: 'c' }])
+    ];
+    const graph = buildGraph(steps);
+    t.is(graph.get('a').size, 0);
+    t.deepEqual([...graph.get('d')].sort(), ['b', 'c']);
+});
+test('buildGraph: step without inputs has empty deps', t => {
+    const steps = [makeStep('a'), makeStep('b')];
+    const graph = buildGraph(steps);
+    t.is(graph.get('a').size, 0);
+    t.is(graph.get('b').size, 0);
+});
+// -- validateGraph -----------------------------------------------------------
+test('validateGraph: detects cycle', t => {
+    const steps = [
+        makeStep('a', [{ step: 'b' }]),
+        makeStep('b', [{ step: 'a' }])
+    ];
+    const graph = buildGraph(steps);
+    t.throws(() => {
+        validateGraph(graph, steps);
+    }, { instanceOf: CyclicDependencyError });
+});
+test('validateGraph: detects missing ref', t => {
+    const steps = [makeStep('a', [{ step: 'missing' }])];
+    const graph = buildGraph(steps);
+    t.throws(() => {
+        validateGraph(graph, steps);
+    }, { instanceOf: ValidationError, message: /unknown step 'missing'/ });
+});
+test('validateGraph: optional ref to unknown step is OK', t => {
+    const steps = [makeStep('a', [{ step: 'missing', optional: true }])];
+    const graph = buildGraph(steps);
+    t.notThrows(() => {
+        validateGraph(graph, steps);
+    });
+});
+test('validateGraph: valid DAG passes', t => {
+    const steps = [
+        makeStep('a'),
+        makeStep('b', [{ step: 'a' }]),
+        makeStep('c', [{ step: 'a' }]),
+        makeStep('d', [{ step: 'b' }, { step: 'c' }])
+    ];
+    const graph = buildGraph(steps);
+    t.notThrows(() => {
+        validateGraph(graph, steps);
+    });
+});
+// -- topologicalLevels -------------------------------------------------------
+test('topologicalLevels: linear → one per level', t => {
+    const steps = [makeStep('a'), makeStep('b', [{ step: 'a' }]), makeStep('c', [{ step: 'b' }])];
+    const graph = buildGraph(steps);
+    const levels = topologicalLevels(graph);
+    t.is(levels.length, 3);
+    t.deepEqual(levels[0], ['a']);
+    t.deepEqual(levels[1], ['b']);
+    t.deepEqual(levels[2], ['c']);
+});
+test('topologicalLevels: diamond → 3 levels', t => {
+    const steps = [
+        makeStep('a'),
+        makeStep('b', [{ step: 'a' }]),
+        makeStep('c', [{ step: 'a' }]),
+        makeStep('d', [{ step: 'b' }, { step: 'c' }])
+    ];
+    const graph = buildGraph(steps);
+    const levels = topologicalLevels(graph);
+    t.is(levels.length, 3);
+    t.deepEqual(levels[0], ['a']);
+    t.deepEqual(levels[1].sort(), ['b', 'c']);
+    t.deepEqual(levels[2], ['d']);
+});
+test('topologicalLevels: independent steps → all level 0', t => {
+    const steps = [makeStep('a'), makeStep('b'), makeStep('c')];
+    const graph = buildGraph(steps);
+    const levels = topologicalLevels(graph);
+    t.is(levels.length, 1);
+    t.deepEqual(levels[0].sort(), ['a', 'b', 'c']);
+});
+// -- subgraph ----------------------------------------------------------------
+test('subgraph: targeting leaf includes all ancestors', t => {
+    const steps = [makeStep('a'), makeStep('b', [{ step: 'a' }]), makeStep('c', [{ step: 'b' }])];
+    const graph = buildGraph(steps);
+    const result = subgraph(graph, ['c']);
+    t.deepEqual([...result].sort(), ['a', 'b', 'c']);
+});
+test('subgraph: targeting root includes only root', t => {
+    const steps = [makeStep('a'), makeStep('b', [{ step: 'a' }]), makeStep('c', [{ step: 'b' }])];
+    const graph = buildGraph(steps);
+    const result = subgraph(graph, ['a']);
+    t.deepEqual([...result], ['a']);
+});
+test('subgraph: diamond targeting d includes all', t => {
+    const steps = [
+        makeStep('a'),
+        makeStep('b', [{ step: 'a' }]),
+        makeStep('c', [{ step: 'a' }]),
+        makeStep('d', [{ step: 'b' }, { step: 'c' }])
+    ];
+    const graph = buildGraph(steps);
+    const result = subgraph(graph, ['d']);
+    t.deepEqual([...result].sort(), ['a', 'b', 'c', 'd']);
+});
+// -- leafNodes ---------------------------------------------------------------
+test('leafNodes: linear → last step', t => {
+    const steps = [makeStep('a'), makeStep('b', [{ step: 'a' }]), makeStep('c', [{ step: 'b' }])];
+    const graph = buildGraph(steps);
+    t.deepEqual(leafNodes(graph), ['c']);
+});
+test('leafNodes: diamond → d', t => {
+    const steps = [
+        makeStep('a'),
+        makeStep('b', [{ step: 'a' }]),
+        makeStep('c', [{ step: 'a' }]),
+        makeStep('d', [{ step: 'b' }, { step: 'c' }])
+    ];
+    const graph = buildGraph(steps);
+    t.deepEqual(leafNodes(graph), ['d']);
+});
+test('leafNodes: two independent chains → two leaves', t => {
+    const steps = [
+        makeStep('a'),
+        makeStep('b', [{ step: 'a' }]),
+        makeStep('c'),
+        makeStep('d', [{ step: 'c' }])
+    ];
+    const graph = buildGraph(steps);
+    t.deepEqual(leafNodes(graph).sort(), ['b', 'd']);
+});

package/dist/cli/__tests__/pipeline-loader.js

@@ -0,0 +1,267 @@
+import test from 'ava';
+import { CyclicDependencyError, ValidationError } from '../../errors.js';
+import { PipelineLoader, slugify, parsePipelineFile, mergeEnv, mergeCaches, mergeMounts } from '../pipeline-loader.js';
+// ---------------------------------------------------------------------------
+// slugify
+// ---------------------------------------------------------------------------
+test('slugify converts accented characters', t => {
+    t.is(slugify('Étape numéro un'), 'etape-numero-un');
+});
+test('slugify replaces spaces with hyphens', t => {
+    t.is(slugify('hello world'), 'hello-world');
+});
+test('slugify replaces special characters', t => {
+    t.is(slugify('build@v2!'), 'build-v2');
+    t.is(slugify('build@v2!final'), 'build-v2-final');
+});
+test('slugify collapses double hyphens', t => {
+    t.is(slugify('a--b'), 'a-b');
+});
+test('slugify strips leading and trailing hyphens', t => {
+    t.is(slugify('-hello-'), 'hello');
+});
+// ---------------------------------------------------------------------------
+// parsePipelineFile
+// ---------------------------------------------------------------------------
+test('parsePipelineFile parses valid JSON', t => {
+    const result = parsePipelineFile('{"id": "test"}', 'pipeline.json');
+    t.is(result.id, 'test');
+});
+test('parsePipelineFile parses YAML for .yaml extension', t => {
+    const result = parsePipelineFile('id: test', 'pipeline.yaml');
+    t.is(result.id, 'test');
+});
+test('parsePipelineFile parses YAML for .yml extension', t => {
+    const result = parsePipelineFile('id: test', 'pipeline.yml');
+    t.is(result.id, 'test');
+});
+test('parsePipelineFile throws on invalid JSON', t => {
+    t.throws(() => parsePipelineFile('{invalid', 'pipeline.json'));
+});
+// ---------------------------------------------------------------------------
+// mergeEnv
+// ---------------------------------------------------------------------------
+test('mergeEnv returns undefined when both are undefined', t => {
+    t.is(mergeEnv(undefined, undefined), undefined);
+});
+test('mergeEnv returns kit env when user is undefined', t => {
+    t.deepEqual(mergeEnv({ A: '1' }, undefined), { A: '1' });
+});
+test('mergeEnv returns user env when kit is undefined', t => {
+    t.deepEqual(mergeEnv(undefined, { B: '2' }), { B: '2' });
+});
+test('mergeEnv user overrides kit', t => {
+    t.deepEqual(mergeEnv({ A: '1' }, { A: '2' }), { A: '2' });
+});
+test('mergeEnv merges both', t => {
+    t.deepEqual(mergeEnv({ A: '1' }, { B: '2' }), { A: '1', B: '2' });
+});
+// ---------------------------------------------------------------------------
+// mergeCaches
+// ---------------------------------------------------------------------------
+test('mergeCaches returns undefined when both are undefined', t => {
+    t.is(mergeCaches(undefined, undefined), undefined);
+});
+test('mergeCaches concatenates non-overlapping caches', t => {
+    const result = mergeCaches([{ name: 'a', path: '/a' }], [{ name: 'b', path: '/b' }]);
+    t.deepEqual(result, [
+        { name: 'a', path: '/a' },
+        { name: 'b', path: '/b' }
+    ]);
+});
+test('mergeCaches user wins on same name', t => {
+    const result = mergeCaches([{ name: 'x', path: '/kit' }], [{ name: 'x', path: '/user' }]);
+    t.deepEqual(result, [{ name: 'x', path: '/user' }]);
+});
+// ---------------------------------------------------------------------------
+// mergeMounts
+// ---------------------------------------------------------------------------
+test('mergeMounts returns undefined when both are undefined', t => {
+    t.is(mergeMounts(undefined, undefined), undefined);
+});
+test('mergeMounts concatenates mounts', t => {
+    const result = mergeMounts([{ host: 'a', container: '/a' }], [{ host: 'b', container: '/b' }]);
+    t.deepEqual(result, [
+        { host: 'a', container: '/a' },
+        { host: 'b', container: '/b' }
+    ]);
+});
+// ---------------------------------------------------------------------------
+// PipelineLoader.parse
+// ---------------------------------------------------------------------------
+const loader = new PipelineLoader();
+test('parse: valid pipeline with raw steps', t => {
+    const pipeline = loader.parse(JSON.stringify({
+        id: 'my-pipeline',
+        steps: [{
+                id: 'step1',
+                image: 'alpine',
+                cmd: ['echo', 'hello']
+            }]
+    }), 'p.json');
+    t.is(pipeline.id, 'my-pipeline');
+    t.is(pipeline.steps.length, 1);
+    t.is(pipeline.steps[0].id, 'step1');
+});
+test('parse: derives id from name via slugify', t => {
+    const pipeline = loader.parse(JSON.stringify({
+        name: 'Mon Pipeline',
+        steps: [{
+                name: 'Première Étape',
+                image: 'alpine',
+                cmd: ['echo']
+            }]
+    }), 'p.json');
+    t.is(pipeline.id, 'mon-pipeline');
+    t.is(pipeline.steps[0].id, 'premiere-etape');
+});
+test('parse: throws ValidationError when neither id nor name on pipeline', t => {
+    const error = t.throws(() => loader.parse(JSON.stringify({
+        steps: [{ id: 's', image: 'alpine', cmd: ['echo'] }]
+    }), 'p.json'), { message: /at least one of "id" or "name"/ });
+    t.true(error instanceof ValidationError);
+});
+test('parse: throws ValidationError when neither id nor name on step', t => {
+    const error = t.throws(() => loader.parse(JSON.stringify({
+        id: 'p',
+        steps: [{ image: 'alpine', cmd: ['echo'] }]
+    }), 'p.json'), { message: /at least one of "id" or "name"/ });
+    t.true(error instanceof ValidationError);
+});
+test('parse: throws ValidationError on empty steps array', t => {
+    const error = t.throws(() => loader.parse(JSON.stringify({
+        id: 'p', steps: []
+    }), 'p.json'), { message: /steps must be a non-empty array/ });
+    t.true(error instanceof ValidationError);
+});
+test('parse: throws on invalid identifier with path traversal', t => {
+    t.throws(() => loader.parse(JSON.stringify({
+        id: 'p',
+        steps: [{ id: '../bad', image: 'alpine', cmd: ['echo'] }]
+    }), 'p.json'), { message: /must contain only alphanumeric/ });
+});
+test('parse: throws on invalid identifier with special chars', t => {
+    t.throws(() => loader.parse(JSON.stringify({
+        id: 'p',
+        steps: [{ id: 'hello world', image: 'alpine', cmd: ['echo'] }]
+    }), 'p.json'), { message: /must contain only alphanumeric/ });
+});
+test('parse: throws when step has no image', t => {
+    t.throws(() => loader.parse(JSON.stringify({
+        id: 'p',
+        steps: [{ id: 's', cmd: ['echo'] }]
+    }), 'p.json'), { message: /image is required/ });
+});
+test('parse: throws when step has no cmd', t => {
+    t.throws(() => loader.parse(JSON.stringify({
+        id: 'p',
+        steps: [{ id: 's', image: 'alpine' }]
+    }), 'p.json'), { message: /cmd must be a non-empty array/ });
+});
+test('parse: throws ValidationError on duplicate step ids', t => {
+    const error = t.throws(() => loader.parse(JSON.stringify({
+        id: 'p',
+        steps: [
+            { id: 's', image: 'alpine', cmd: ['echo'] },
+            { id: 's', image: 'alpine', cmd: ['echo'] }
+        ]
+    }), 'p.json'), { message: /Duplicate step id/ });
+    t.true(error instanceof ValidationError);
+});
+test('parse: validates mount host must be relative', t => {
+    t.throws(() => loader.parse(JSON.stringify({
+        id: 'p',
+        steps: [{
+                id: 's', image: 'alpine', cmd: ['echo'],
+                mounts: [{ host: '/absolute', container: '/c' }]
+            }]
+    }), 'p.json'), { message: /must be a relative path/ });
+});
+test('parse: validates mount host no ..', t => {
+    t.throws(() => loader.parse(JSON.stringify({
+        id: 'p',
+        steps: [{
+                id: 's', image: 'alpine', cmd: ['echo'],
+                mounts: [{ host: '../escape', container: '/c' }]
+            }]
+    }), 'p.json'), { message: /must not contain '\.\.'/ });
+});
+test('parse: validates mount container must be absolute', t => {
+    t.throws(() => loader.parse(JSON.stringify({
+        id: 'p',
+        steps: [{
+                id: 's', image: 'alpine', cmd: ['echo'],
+                mounts: [{ host: 'src', container: 'relative' }]
+            }]
+    }), 'p.json'), { message: /must be an absolute path/ });
+});
+test('parse: validates cache path must be absolute', t => {
+    t.throws(() => loader.parse(JSON.stringify({
+        id: 'p',
+        steps: [{
+                id: 's', image: 'alpine', cmd: ['echo'],
+                caches: [{ name: 'c', path: 'relative' }]
+            }]
+    }), 'p.json'), { message: /must be an absolute path/ });
+});
+test('parse: validates cache name is a valid identifier', t => {
+    t.throws(() => loader.parse(JSON.stringify({
+        id: 'p',
+        steps: [{
+                id: 's', image: 'alpine', cmd: ['echo'],
+                caches: [{ name: 'bad name!', path: '/cache' }]
+            }]
+    }), 'p.json'), { message: /must contain only alphanumeric/ });
+});
+test('parse: resolves kit step (uses → image/cmd)', t => {
+    const pipeline = loader.parse(JSON.stringify({
+        id: 'p',
+        steps: [{
+                id: 'b',
+                uses: 'shell',
+                with: { run: 'echo hello' }
+            }]
+    }), 'p.json');
+    t.is(pipeline.steps[0].image, 'alpine:3.20');
+    t.deepEqual(pipeline.steps[0].cmd, ['sh', '-c', 'echo hello']);
+});
+// ---------------------------------------------------------------------------
+// DAG validation
+// ---------------------------------------------------------------------------
+test('parse: detects cycle → CyclicDependencyError', t => {
+    const error = t.throws(() => loader.parse(JSON.stringify({
+        id: 'p',
+        steps: [
+            { id: 'a', image: 'alpine', cmd: ['echo'], inputs: [{ step: 'b' }] },
+            { id: 'b', image: 'alpine', cmd: ['echo'], inputs: [{ step: 'a' }] }
+        ]
+    }), 'p.json'), { message: /cycle/ });
+    t.true(error instanceof CyclicDependencyError);
+});
+test('parse: missing input ref → error', t => {
+    t.throws(() => loader.parse(JSON.stringify({
+        id: 'p',
+        steps: [
+            { id: 'a', image: 'alpine', cmd: ['echo'], inputs: [{ step: 'missing' }] }
+        ]
+    }), 'p.json'), { message: /unknown step 'missing'/ });
+});
+test('parse: optional input to unknown step → OK', t => {
+    t.notThrows(() => loader.parse(JSON.stringify({
+        id: 'p',
+        steps: [
+            { id: 'a', image: 'alpine', cmd: ['echo'], inputs: [{ step: 'missing', optional: true }] }
+        ]
+    }), 'p.json'));
+});
+test('parse: valid DAG diamond → OK', t => {
+    t.notThrows(() => loader.parse(JSON.stringify({
+        id: 'p',
+        steps: [
+            { id: 'a', image: 'alpine', cmd: ['echo'] },
+            { id: 'b', image: 'alpine', cmd: ['echo'], inputs: [{ step: 'a' }] },
+            { id: 'c', image: 'alpine', cmd: ['echo'], inputs: [{ step: 'a' }] },
+            { id: 'd', image: 'alpine', cmd: ['echo'], inputs: [{ step: 'b' }, { step: 'c' }] }
+        ]
+    }), 'p.json'));
+});