hammerkit 1.4.0-beta.6 → 1.5.0-alpha.0

package/dist/parser/parse-label-arguments.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLabelArguments = void 0;
+function parseLabelArguments(args) {
+    const labels = {};
+    for (const arg of args) {
+        const labelParts = arg.split('=');
+        if (labelParts.length !== 2) {
+            throw new Error(`invalid label ${arg}`);
+        }
+        const key = labelParts[0];
+        const value = labelParts[1];
+        if (!labels[key]) {
+            labels[key] = [value];
+        }
+        else if (labels[key].indexOf(value) === -1) {
+            labels[key].push(value);
+        }
+    }
+    return labels;
+}
+exports.parseLabelArguments = parseLabelArguments;
+//# sourceMappingURL=parse-label-arguments.js.map

package/dist/parser/parse-service-selector.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseServiceSelector = void 0;
+const parse_context_1 = require("./parse-context");
+const parse_string_1 = require("./parse-string");
+function parseServiceSelector(ctx, value, optional) {
+    if (value === null || value === undefined) {
+        if (optional) {
+            return null;
+        }
+        else {
+            throw new Error(`${(0, parse_context_1.parseContextDescription)(ctx)} missing selector`);
+        }
+    }
+    if (typeof value !== 'object') {
+        throw new Error(`${(0, parse_context_1.parseContextDescription)(ctx)} invalid selector, expecting map`);
+    }
+    const result = { type: '', name: '' };
+    for (const [key, prop] of Object.entries(value || {})) {
+        if (key === 'type') {
+            result.type = (0, parse_string_1.parseString)(ctx, 'selector type', prop, false);
+        }
+        else if (key === 'name') {
+            result.name = (0, parse_string_1.parseString)(ctx, 'selector name', prop, false);
+        }
+        else {
+            throw new Error(`${(0, parse_context_1.parseContextDescription)(ctx)} unknown property ${key} in healthcheck`);
+        }
+    }
+    if (!result.type) {
+        throw new Error(`${(0, parse_context_1.parseContextDescription)(ctx)} invalid selector, missing type property`);
+    }
+    if (!result.name) {
+        throw new Error(`${(0, parse_context_1.parseContextDescription)(ctx)} invalid selector, missing name property`);
+    }
+    return result;
+}
+exports.parseServiceSelector = parseServiceSelector;
+//# sourceMappingURL=parse-service-selector.js.map

package/dist/parser/parse-string-array.js

@@ -1,18 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseStringArray = void 0;
-function parseStringArray(fileName, taskName, valueName, value) {
+const parse_context_1 = require("./parse-context");
+function parseStringArray(ctx, valueName, value) {
     if (!value) {
         return null;
     }
     if (value instanceof Array) {
-        if (!value.every((v) => typeof v === 'string')) {
-            throw new Error(`${fileName} task ${taskName} ${valueName} needs to be a string array`);
+        if (!value.every((v) => typeof v === 'string' || typeof v === 'number')) {
+            throw new Error(`${(0, parse_context_1.parseContextDescription)(ctx)} ${valueName} needs to be a string array`);
         }
-        return value;
+        return value.map((v) => `${v}`);
     }
     else {
-        throw new Error(`${fileName} task ${taskName} ${valueName} needs to be a string array`);
+        throw new Error(`${(0, parse_context_1.parseContextDescription)(ctx)} ${valueName} needs to be a string array`);
     }
 }
 exports.parseStringArray = parseStringArray;

package/dist/parser/parse-string-map.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStringMap = void 0;
+const parse_context_1 = require("./parse-context");
+function parseStringMap(ctx, valueName, value) {
+    if (value === null || value === undefined) {
+        return {};
+    }
+    if (typeof value !== 'object') {
+        throw new Error(`${(0, parse_context_1.parseContextDescription)(ctx)} ${valueName} needs to be a string map`);
+    }
+    if (!value) {
+        return {};
+    }
+    const map = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (typeof item === 'string') {
+            map[key] = item;
+        }
+        else if (typeof item === 'number') {
+            map[key] = item.toString();
+        }
+        else {
+            throw new Error(`${(0, parse_context_1.parseContextDescription)(ctx)} ${valueName} ${key} should be a string value`);
+        }
+    }
+    return map;
+}
+exports.parseStringMap = parseStringMap;
+//# sourceMappingURL=parse-string-map.js.map

package/dist/parser/parse-string.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseString = void 0;
+const parse_context_1 = require("./parse-context");
+function parseString(ctx, keyName, value, optional) {
+    if (value === null || value === undefined) {
+        if (optional) {
+            return null;
+        }
+        else {
+            throw new Error(`${(0, parse_context_1.parseContextDescription)(ctx)} -> ${keyName} is missing`);
+        }
+    }
+    if (typeof value === 'string' || typeof value === 'number') {
+        return `${value}`;
+    }
+    throw new Error(`${(0, parse_context_1.parseContextDescription)(ctx)} -> ${keyName} is not a valid string`);
+}
+exports.parseString = parseString;
+//# sourceMappingURL=parse-string.js.map

package/dist/parser/read-build-file.js

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readBuildFile = exports.read = void 0;
+exports.readBuildFile = exports.read = exports.write = void 0;
 const yaml_1 = require("yaml");
 const parse_build_file_1 = require("./parse-build-file");
+async function write(filename, content, context) {
+    await context.file.writeFile(filename, (0, yaml_1.stringify)(content));
+}
+exports.write = write;
 async function read(fileName, context) {
-    // context.console.debug(`read ${fileName} build file`)
+    context.status
+        .context({ type: 'cli', id: 'general', name: 'hammerkit' })
+        .write('debug', `read ${fileName} build file`);
     let content;
     try {
         content = await context.file.read(fileName);
@@ -13,10 +19,15 @@ async function read(fileName, context) {
         throw new Error(`unable to read ${fileName}`);
     }
     try {
-        return yaml_1.parse(content);
+        return (0, yaml_1.parse)(content);
     }
     catch (e) {
-        throw new Error(`unable to parse ${fileName}: ${e.message}`);
+        if (e instanceof Error) {
+            throw new Error(`unable to parse ${fileName}: ${e.message}`);
+        }
+        else {
+            throw e;
+        }
     }
 }
 exports.read = read;
@@ -25,7 +36,7 @@ async function readBuildFile(fileName, files, context) {
         return files[fileName];
     }
     const input = await read(fileName, context);
-    return parse_build_file_1.parseBuildFile(fileName, files, input, context);
+    return (0, parse_build_file_1.parseBuildFile)(fileName, files, input, context);
 }
 exports.readBuildFile = readBuildFile;
 //# sourceMappingURL=read-build-file.js.map

package/dist/parser/read-env-file.js

@@ -2,24 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readEnvFile = void 0;
 const path_1 = require("path");
-async function readEnvFile(path, baseEnv, context) {
-    const directory = path_1.join(path, '.env');
+async function readEnvFile(path, baseEnv, environment) {
+    const directory = (0, path_1.join)(path, '.env');
     let envs = { ...baseEnv };
-    if (path_1.basename(path) !== path) {
-        envs = { ...(await readEnvFile(path_1.basename(path), envs, context)) };
+    if ((0, path_1.basename)(path) !== path) {
+        envs = { ...(await readEnvFile((0, path_1.basename)(path), envs, environment)) };
     }
-    const exists = await context.file.exists(directory);
+    const exists = await environment.file.exists(directory);
     if (!exists) {
         return envs;
     }
-    const envFile = (await context.file.read(directory)).split(/\r?\n/);
+    const envFile = (await environment.file.read(directory)).split(/\r?\n/);
     for (const envVar of envFile) {
         const index = envVar.indexOf('=');
         if (index > 0) {
             const key = envVar.substr(0, index);
             const value = envVar.substr(index + 1);
             if (!envs[key]) {
-                context.console.debug(`load env variable ${key} from ${directory} file`);
+                environment.console.debug(`load env variable ${key} from ${directory} file`);
                 envs[key] = value;
             }
         }

package/dist/planner/utils/get-container-mounts.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContainerMounts = void 0;
+function getContainerMounts(task, workMount) {
+    const result = [
+        ...task.src.map((source) => ({
+            localPath: source.absolutePath,
+            containerPath: source.absolutePath,
+        })),
+        ...workMount,
+    ];
+    for (const volume of result) {
+        const otherVolumes = result.filter((v) => v.containerPath === volume.containerPath && v.localPath !== volume.localPath);
+        if (otherVolumes.length > 0) {
+            throw new Error(`duplicate container mount with different sources ${[
+                volume.localPath,
+                ...otherVolumes.map((ov) => ov.localPath),
+            ].join(', ')}`);
+        }
+    }
+    return result.filter((v, i) => result.findIndex((iv) => iv.containerPath == v.containerPath) === i);
+}
+exports.getContainerMounts = getContainerMounts;
+//# sourceMappingURL=get-container-mounts.js.map

package/dist/planner/utils/normalize-path.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePath = void 0;
+const path_1 = require("path");
+function normalizePath(cwd, pwd, path) {
+    if (path.startsWith('/')) {
+        return path;
+    }
+    else if (path.startsWith('$PWD')) {
+        return (0, path_1.join)(pwd, path.substr('$PWD'.length));
+    }
+    else {
+        return (0, path_1.join)(cwd, path);
+    }
+}
+exports.normalizePath = normalizePath;
+//# sourceMappingURL=normalize-path.js.map

package/dist/planner/utils/parse-work-node-mount.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseWorkNodeMount = void 0;
-const path_1 = require("path");
 const os_1 = require("os");
+const normalize_path_1 = require("./normalize-path");
 function parseWorkNodeMount(cwd, dir) {
     const parts = dir.split(':');
     if (parts.length === 1) {
@@ -16,21 +16,10 @@ function parseWorkNodeMount(cwd, dir) {
     }
 }
 exports.parseWorkNodeMount = parseWorkNodeMount;
-function normalizePath(cwd, pwd, path) {
-    if (path.startsWith('/')) {
-        return path;
-    }
-    else if (path.startsWith('$PWD')) {
-        return path_1.join(pwd, path.substr('$PWD'.length));
-    }
-    else {
-        return path_1.join(cwd, path);
-    }
-}
 function parseLocalMount(cwd, localPath, containerPath) {
     return {
-        localPath: normalizePath(cwd, os_1.homedir(), localPath),
-        containerPath: normalizePath(cwd, cwd, containerPath),
+        localPath: (0, normalize_path_1.normalizePath)(cwd, (0, os_1.homedir)(), localPath),
+        containerPath: (0, normalize_path_1.normalizePath)(cwd, cwd, containerPath),
     };
 }
 //# sourceMappingURL=parse-work-node-mount.js.map

package/dist/planner/utils/parse-work-node-mount.spec.js

@@ -8,49 +8,49 @@ function normalizePath(val) {
 }
 describe('parse-work-node-mount', () => {
     it('should parse "subdir"', () => {
-        expect(parse_work_node_mount_1.parseWorkNodeMount('/home/test', 'subdir')).toEqual({
+        expect((0, parse_work_node_mount_1.parseWorkNodeMount)('/home/test', 'subdir')).toEqual({
             localPath: normalizePath('/home/test/subdir'),
             containerPath: normalizePath('/home/test/subdir'),
         });
     });
     it('should parse "./subdir"', () => {
-        expect(parse_work_node_mount_1.parseWorkNodeMount('/home/test', './subdir')).toEqual({
+        expect((0, parse_work_node_mount_1.parseWorkNodeMount)('/home/test', './subdir')).toEqual({
             localPath: normalizePath('/home/test/subdir'),
             containerPath: normalizePath('/home/test/subdir'),
         });
     });
     it('should parse "./subdir:./otherdir"', () => {
-        expect(parse_work_node_mount_1.parseWorkNodeMount('/home/test', './subdir:./otherdir')).toEqual({
+        expect((0, parse_work_node_mount_1.parseWorkNodeMount)('/home/test', './subdir:./otherdir')).toEqual({
             localPath: normalizePath('/home/test/subdir'),
             containerPath: normalizePath('/home/test/otherdir'),
         });
     });
     it('should parse "$PWD/subdir:/subdir"', () => {
-        expect(parse_work_node_mount_1.parseWorkNodeMount('/home/test', '$PWD/subdir:/subdir')).toEqual({
-            localPath: path_1.join(os_1.homedir(), 'subdir'),
+        expect((0, parse_work_node_mount_1.parseWorkNodeMount)('/home/test', '$PWD/subdir:/subdir')).toEqual({
+            localPath: (0, path_1.join)((0, os_1.homedir)(), 'subdir'),
             containerPath: '/subdir',
         });
     });
     it('should parse "$PWD/subdir:$PWD/subdir"', () => {
-        expect(parse_work_node_mount_1.parseWorkNodeMount('/home/test', '$PWD/subdir:$PWD/subdir')).toEqual({
-            localPath: path_1.join(os_1.homedir(), 'subdir'),
+        expect((0, parse_work_node_mount_1.parseWorkNodeMount)('/home/test', '$PWD/subdir:$PWD/subdir')).toEqual({
+            localPath: (0, path_1.join)((0, os_1.homedir)(), 'subdir'),
             containerPath: normalizePath('/home/test/subdir'),
         });
     });
     it('should parse "/subdir:/otherdir"', () => {
-        expect(parse_work_node_mount_1.parseWorkNodeMount('/home/test', '/subdir:/otherdir')).toEqual({
+        expect((0, parse_work_node_mount_1.parseWorkNodeMount)('/home/test', '/subdir:/otherdir')).toEqual({
             localPath: '/subdir',
             containerPath: '/otherdir',
         });
     });
     it('should parse "/subdir:otherdir"', () => {
-        expect(parse_work_node_mount_1.parseWorkNodeMount('/home/test', '/subdir:otherdir')).toEqual({
+        expect((0, parse_work_node_mount_1.parseWorkNodeMount)('/home/test', '/subdir:otherdir')).toEqual({
             localPath: '/subdir',
             containerPath: normalizePath('/home/test/otherdir'),
         });
     });
     it('should parse "subdir:/otherdir"', () => {
-        expect(parse_work_node_mount_1.parseWorkNodeMount('/home/test', 'subdir:/otherdir')).toEqual({
+        expect((0, parse_work_node_mount_1.parseWorkNodeMount)('/home/test', 'subdir:/otherdir')).toEqual({
             localPath: normalizePath('/home/test/subdir'),
             containerPath: '/otherdir',
         });

package/dist/planner/utils/parse-work-service-volume.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWorkServiceVolume = void 0;
+const normalize_path_1 = require("./normalize-path");
+function parseWorkServiceVolume(cwd, dir) {
+    const parts = dir.split(':');
+    if (parts.length === 2) {
+        return parseVolume(cwd, parts[0], parts[1]);
+    }
+    else {
+        throw new Error(`invalid volume ${dir}`);
+    }
+}
+exports.parseWorkServiceVolume = parseWorkServiceVolume;
+function parseVolume(cwd, name, containerPath) {
+    return {
+        name,
+        containerPath: (0, normalize_path_1.normalizePath)(cwd, cwd, containerPath),
+    };
+}
+//# sourceMappingURL=parse-work-service-volume.js.map

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

@@ -11,7 +11,7 @@ function planWorkCommand(cmds, workingDir) {
         else {
             result.push({
                 cmd: cmd.cmd,
-                path: path_1.join(workingDir, cmd.path || ''),
+                path: (0, path_1.join)(workingDir, cmd.path || ''),
             });
         }
     }

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

@@ -1,33 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.planWorkDependency = void 0;
-const plan_work_node_1 = require("./plan-work-node");
-function planWorkDependency(build, node, taskName, dep, nodes, context) {
-    const depNode = plan_work_node_1.planWorkNode(build, dep, nodes, {
-        ...context,
-        idPrefix: null,
-    });
-    if (!depNode) {
-        throw new Error(`unable to find dependency ${dep} for task ${taskName} in ${build.path}`);
-    }
-    node.deps.push(depNode);
-    for (const src of depNode.src) {
-        if (node.src.indexOf(src) === -1) {
-            node.src.push(src);
+const work_node_1 = require("../work-node");
+const plan_work_volume_1 = require("./plan-work-volume");
+function planWorkDependency(deps, node) {
+    for (const depNode of deps) {
+        if (node.deps.some((d) => d.id === depNode.id)) {
+            continue;
         }
-    }
-    for (const generate of depNode.generates) {
-        if (node.generates.indexOf(generate) === -1) {
-            node.generates.push(generate);
+        node.deps.push(depNode);
+        for (const src of depNode.src) {
+            if (node.src.indexOf(src) === -1) {
+                node.src.push(src);
+                if ((0, work_node_1.isContainerWorkNode)(node)) {
+                    node.mounts.push({
+                        localPath: src.absolutePath,
+                        containerPath: src.absolutePath,
+                    });
+                }
+            }
         }
-    }
-    if (!node.status.pendingDependencies[depNode.id]) {
-        node.status.pendingDependencies[depNode.id] = depNode;
-    }
-    for (const dep of depNode.deps) {
-        if (!node.status.pendingDependencies[dep.id]) {
-            node.status.pendingDependencies[dep.id] = dep;
+        for (const generate of depNode.generates) {
+            if (!node.generates.some((g) => g.path === generate.path)) {
+                node.generates.push({ path: generate.path, inherited: true });
+                if ((0, work_node_1.isContainerWorkNode)(node)) {
+                    const name = (0, plan_work_volume_1.getVolumeName)(generate.path);
+                    node.volumes.push({
+                        name,
+                        containerPath: generate.path,
+                    });
+                }
+            }
         }
+        planWorkDependency(depNode.deps, node);
     }
 }
 exports.planWorkDependency = planWorkDependency;