hammerkit 1.5.0 → 1.6.0-alpha.1

package/dist/planner/utils/append-work-service.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendWorkService = void 0;
+const work_service_id_1 = require("../work-service-id");
+const parse_work_ports_1 = require("./parse-work-ports");
+const template_value_1 = require("./template-value");
+const build_file_service_schema_1 = require("../../schema/build-file-service-schema");
+const get_default_kube_config_1 = require("./get-default-kube-config");
+const parse_work_command_1 = require("./parse-work-command");
+const parse_work_volume_1 = require("./parse-work-volume");
+const parse_work_mounts_1 = require("./parse-work-mounts");
+const parse_work_source_1 = require("./parse-work-source");
+const append_work_dependencies_1 = require("./append-work-dependencies");
+const append_work_needs_1 = require("./append-work-needs");
+const replace_env_variables_1 = require("../../environment/replace-env-variables");
+const state_1 = require("../../executer/state");
+const lazy_resolver_1 = require("../../executer/lazy-resolver");
+const get_work_runtime_1 = require("./get-work-runtime");
+const resolve_cache_1 = require("../../cache/resolve-cache");
+function appendWorkService(workTree, service, environment, context) {
+    const workService = parseService(workTree, service, environment, context);
+    if (!workTree.services[workService.name]) {
+        const workItem = {
+            id: (0, lazy_resolver_1.lazyResolver)(() => (0, work_service_id_1.getWorkServiceId)(workService)),
+            name: workService.name,
+            data: workService,
+            status: environment.status.from(workService),
+            deps: [],
+            needs: [],
+            requiredBy: [],
+        };
+        const workStateItem = {
+            ...workItem,
+            state: new state_1.State({
+                type: 'pending',
+                stateKey: null,
+            }),
+            runtime: (0, get_work_runtime_1.getWorkServiceRuntime)(workTree, workItem),
+        };
+        workTree.services[workItem.name] = workStateItem;
+        (0, append_work_dependencies_1.appendWorkDependencies)(workTree, service, workStateItem, environment, context);
+        (0, append_work_needs_1.appendWorkNeeds)(workTree, service, workStateItem, environment, context);
+        return workStateItem;
+    }
+    else {
+        return workTree.services[workService.name];
+    }
+}
+exports.appendWorkService = appendWorkService;
+function parseService(workTree, service, environment, context) {
+    const envs = (0, replace_env_variables_1.buildEnvironmentVariables)(service.envs, environment, context);
+    const workService = {
+        cwd: service.cwd,
+        name: service.relativeName,
+        ports: (0, parse_work_ports_1.parseWorkPorts)(service.schema, envs),
+        scope: service.scope,
+        labels: service.labels,
+        description: (0, template_value_1.templateValue)(service.schema.description || '', envs),
+    };
+    const caching = (0, resolve_cache_1.resolveCache)(null, context.caches, service.relativeName);
+    if ((0, build_file_service_schema_1.isBuildFileKubernetesServiceSchema)(service.schema)) {
+        const k8sEnv = workTree.environment.type === 'kubernetes' ? workTree.environment : undefined;
+        const kubeconfig = service.schema.kubeconfig ?? k8sEnv?.kubeConfig ?? (0, get_default_kube_config_1.getDefaultKubeConfig)();
+        const serviceContext = service.schema.context ? (0, template_value_1.templateValue)(service.schema.context, envs) : k8sEnv?.context;
+        if (!serviceContext) {
+            throw new Error(`kubernetes service ${service.relativeName} has no context: set "context" on the service or select a ` +
+                `kubernetes environment (environments.<name>.kubernetes.context) with --env`);
+        }
+        const namespace = service.schema.namespace
+            ? (0, template_value_1.templateValue)(service.schema.namespace, envs)
+            : k8sEnv?.namespace ?? 'default';
+        return {
+            type: 'kubernetes-service',
+            ...workService,
+            kubeconfig,
+            namespace,
+            selector: {
+                name: (0, template_value_1.templateValue)(service.schema.selector.name, envs),
+                type: (0, template_value_1.templateValue)(service.schema.selector.type, envs),
+            },
+            context: serviceContext,
+            src: [(0, parse_work_source_1.createSource)(kubeconfig)],
+            caching,
+        };
+    }
+    else {
+        return {
+            ...workService,
+            type: 'container-service',
+            continuous: service.schema.continuous ?? false,
+            healthcheck: service.schema.healthcheck
+                ? {
+                    cmd: (0, parse_work_command_1.parseWorkCommand)(service.cwd, service.schema.healthcheck, envs),
+                }
+                : null,
+            envs: (0, replace_env_variables_1.buildEnvironmentVariables)(service.envs, environment, context),
+            image: service.schema.image,
+            cwd: service.cwd,
+            cmd: service.schema.cmd ? (0, parse_work_command_1.parseWorkCommand)(service.cwd, service.schema.cmd, envs) : null,
+            volumes: (0, parse_work_volume_1.parseWorkVolumes)(service.cwd, service.schema.volumes, envs),
+            mounts: (0, parse_work_mounts_1.parseWorkMounts)(service.cwd, service.schema, envs),
+            src: (0, parse_work_source_1.parseWorkSource)(service.cwd, service.schema.src, envs),
+            caching,
+        };
+    }
+}
+//# sourceMappingURL=append-work-service.js.map

package/dist/planner/utils/append-work-service.spec.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const os_1 = require("os");
+const fs_1 = require("fs");
+const environment_mock_1 = require("../../executer/environment-mock");
+const schema_parser_1 = require("../../schema/schema-parser");
+const reference_parser_1 = require("../../schema/reference-parser");
+const work_scope_parser_1 = require("../../schema/work-scope-parser");
+describe('appendWorkService (kubernetes service env inheritance)', () => {
+    let scratch;
+    beforeEach(() => {
+        scratch = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'hammerkit-k8s-svc-'));
+    });
+    afterEach(() => {
+        (0, fs_1.rmSync)(scratch, { recursive: true, force: true });
+    });
+    async function parse(content, environmentName) {
+        const env = (0, environment_mock_1.environmentMock)(scratch);
+        const file = (0, path_1.join)(scratch, '.hammerkit.yaml');
+        (0, fs_1.writeFileSync)(file, content);
+        const { ctx, scope } = await (0, schema_parser_1.createParseContext)(file, env);
+        const referenced = await (0, reference_parser_1.parseReferences)(ctx, scope, env);
+        const workScope = { environmentName, filterLabels: {}, excludeLabels: {} };
+        return { referenced, env, workScope };
+    }
+    const envBlock = `environments:
+  prod:
+    kubernetes:
+      context: gke_prod
+      kubeconfig: ./prod-kube.yaml
+      namespace: databases
+`;
+    function postgres(extra = '') {
+        return `services:
+  postgres:
+${extra}    selector:
+      type: deployment
+      name: postgres
+    ports:
+      - 5432:5432
+`;
+    }
+    it('inherits context, kubeconfig and namespace from the selected environment', async () => {
+        const { referenced, env, workScope } = await parse(envBlock + postgres(), 'prod');
+        const work = (0, work_scope_parser_1.getWorkContext)(referenced, workScope, env);
+        const service = work.services['postgres'].data;
+        expect(service.type).toEqual('kubernetes-service');
+        expect(service.context).toEqual('gke_prod');
+        expect(service.kubeconfig).toEqual('./prod-kube.yaml');
+        expect(service.namespace).toEqual('databases');
+    });
+    it('lets a service override the namespace while inheriting the context', async () => {
+        const { referenced, env, workScope } = await parse(envBlock + postgres('    namespace: orders\n'), 'prod');
+        const work = (0, work_scope_parser_1.getWorkContext)(referenced, workScope, env);
+        const service = work.services['postgres'].data;
+        expect(service.namespace).toEqual('orders');
+        expect(service.context).toEqual('gke_prod');
+    });
+    it('keeps an explicit service context over the environment (backward compatible)', async () => {
+        const { referenced, env, workScope } = await parse(envBlock + postgres('    context: own-ctx\n'), 'prod');
+        const work = (0, work_scope_parser_1.getWorkContext)(referenced, workScope, env);
+        const service = work.services['postgres'].data;
+        expect(service.context).toEqual('own-ctx');
+    });
+    it('throws a descriptive error when no context can be resolved', async () => {
+        const { referenced, env, workScope } = await parse(postgres(), null);
+        expect(() => (0, work_scope_parser_1.getWorkContext)(referenced, workScope, env)).toThrow(/postgres has no context/);
+    });
+});
+//# sourceMappingURL=append-work-service.spec.js.map

package/dist/planner/utils/append-work-task.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendWorkTask = void 0;
+const parse_work_generate_1 = require("./parse-work-generate");
+const template_value_1 = require("./template-value");
+const parse_work_mounts_1 = require("./parse-work-mounts");
+const get_container_user_1 = require("./get-container-user");
+const build_file_task_schema_1 = require("../../schema/build-file-task-schema");
+const parse_work_command_1 = require("./parse-work-command");
+const parse_work_source_1 = require("./parse-work-source");
+const work_cache_id_1 = require("../work-cache-id");
+const append_work_dependencies_1 = require("./append-work-dependencies");
+const append_work_needs_1 = require("./append-work-needs");
+const state_1 = require("../../executer/state");
+const replace_env_variables_1 = require("../../environment/replace-env-variables");
+const lazy_resolver_1 = require("../../executer/lazy-resolver");
+const get_work_runtime_1 = require("./get-work-runtime");
+const resolve_cache_1 = require("../../cache/resolve-cache");
+function appendWorkTask(workTree, cwd, referenceTask, environment, context) {
+    const task = parseTask(cwd, referenceTask, environment, context);
+    if (!workTree.tasks[task.name]) {
+        const workItem = {
+            id: (0, lazy_resolver_1.lazyResolver)(() => (0, work_cache_id_1.getWorkTaskId)(task)),
+            name: task.name,
+            data: task,
+            status: environment.status.from(task),
+            needs: [],
+            deps: [],
+            requiredBy: [],
+        };
+        const workItemState = {
+            ...workItem,
+            state: new state_1.State({
+                type: 'pending',
+                stateKey: null,
+            }),
+            runtime: (0, get_work_runtime_1.getWorkTaskRuntime)(workTree, workItem),
+        };
+        workTree.tasks[task.name] = workItemState;
+        (0, append_work_dependencies_1.appendWorkDependencies)(workTree, referenceTask, workItemState, environment, context);
+        (0, append_work_needs_1.appendWorkNeeds)(workTree, referenceTask, workItemState, environment, context);
+        return workItemState;
+    }
+    else {
+        return workTree.tasks[task.name];
+    }
+}
+exports.appendWorkTask = appendWorkTask;
+function parseTask(cwd, task, environment, context) {
+    const envs = (0, replace_env_variables_1.buildEnvironmentVariables)(task.envs, environment, context);
+    const baseWorkNode = {
+        envs,
+        description: (0, template_value_1.templateValue)(task.schema.description || '', envs).trim(),
+        name: task.relativeName,
+        cwd,
+        cmds: (0, parse_work_command_1.parseWorkCommands)(cwd, task.schema.cmds || [], envs),
+        src: (0, parse_work_source_1.parseWorkSource)(cwd, task.schema.src, envs),
+        generates: (0, parse_work_generate_1.parseWorkGenerate)(cwd, task.schema, envs),
+        scope: task.scope,
+        labels: task.labels,
+        caching: (0, resolve_cache_1.resolveCache)(task.schema.cache ?? null, context.caches, task.relativeName),
+        shell: task.schema.shell ? (0, template_value_1.templateValue)(task.schema.shell, envs) : '/bin/sh',
+        continuous: task.schema.continuous ?? false,
+    };
+    if ((0, build_file_task_schema_1.isBuildFileContainerTaskSchema)(task.schema)) {
+        return {
+            ...baseWorkNode,
+            type: 'container-task',
+            user: (0, get_container_user_1.getContainerUser)(),
+            image: (0, template_value_1.templateValue)(task.schema.image, envs),
+            mounts: (0, parse_work_mounts_1.parseWorkMounts)(cwd, task.schema, envs),
+        };
+    }
+    else {
+        return {
+            ...baseWorkNode,
+            type: 'local-task',
+        };
+    }
+}
+//# sourceMappingURL=append-work-task.js.map

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContainerUser = void 0;
+const os_1 = require("os");
+function getContainerUser() {
+    return ((0, os_1.platform)() === 'linux' || (0, os_1.platform)() === 'freebsd' || (0, os_1.platform)() === 'openbsd' || (0, os_1.platform)() === 'sunos') &&
+        !!process &&
+        !!process.getuid &&
+        !!process.getgid
+        ? `${process.getuid()}:${process.getgid()}`
+        : null;
+}
+exports.getContainerUser = getContainerUser;
+//# sourceMappingURL=get-container-user.js.map

package/dist/planner/utils/get-container-user.spec.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+vi.mock('os', async () => ({ ...(await vi.importActual('os')), platform: vi.fn() }));
+const os_1 = require("os");
+const get_container_user_1 = require("./get-container-user");
+const mockedPlatform = os_1.platform;
+describe('getContainerUser', () => {
+    const originalGetuid = process.getuid;
+    const originalGetgid = process.getgid;
+    beforeEach(() => {
+        Object.assign(process, { getuid: () => 1234, getgid: () => 4321 });
+    });
+    afterEach(() => {
+        Object.assign(process, { getuid: originalGetuid, getgid: originalGetgid });
+    });
+    it.each(['linux', 'freebsd', 'openbsd', 'sunos'])('returns uid:gid on %s', (p) => {
+        mockedPlatform.mockReturnValue(p);
+        expect((0, get_container_user_1.getContainerUser)()).toBe('1234:4321');
+    });
+    it.each(['darwin', 'win32'])('returns null on %s', (p) => {
+        mockedPlatform.mockReturnValue(p);
+        expect((0, get_container_user_1.getContainerUser)()).toBeNull();
+    });
+    it('returns null on a unix platform when process.getuid is unavailable', () => {
+        mockedPlatform.mockReturnValue('linux');
+        process.getuid = undefined;
+        expect((0, get_container_user_1.getContainerUser)()).toBeNull();
+    });
+});
+//# sourceMappingURL=get-container-user.spec.js.map

package/dist/planner/utils/get-default-kube-config.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultKubeConfig = void 0;
+const path_1 = require("path");
+const os_1 = require("os");
+function getDefaultKubeConfig() {
+    return (0, path_1.join)((0, os_1.homedir)(), '.kube/config');
+}
+exports.getDefaultKubeConfig = getDefaultKubeConfig;
+//# sourceMappingURL=get-default-kube-config.js.map

package/dist/planner/utils/get-default-kube-config.spec.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const os_1 = require("os");
+const path_1 = require("path");
+const get_default_kube_config_1 = require("./get-default-kube-config");
+describe('getDefaultKubeConfig', () => {
+    it('returns ~/.kube/config', () => {
+        expect((0, get_default_kube_config_1.getDefaultKubeConfig)()).toBe((0, path_1.join)((0, os_1.homedir)(), '.kube/config'));
+    });
+});
+//# sourceMappingURL=get-default-kube-config.spec.js.map

package/dist/planner/utils/get-work-runtime.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkTaskRuntime = exports.getWorkServiceRuntime = void 0;
+const work_runtime_docker_1 = require("../work-runtime-docker");
+const work_runtime_kubernetes_1 = require("../work-runtime-kubernetes");
+const work_runtime_local_1 = require("../work-runtime-local");
+const work_item_1 = require("../work-item");
+function getWorkServiceRuntime(workTree, service) {
+    if ((0, work_item_1.isContainerWorkServiceItem)(service)) {
+        if (workTree.environment.type === 'kubernetes') {
+            return (0, work_runtime_kubernetes_1.kubernetesServiceRuntime)(service, workTree.environment);
+        }
+        else {
+            return (0, work_runtime_docker_1.dockerServiceRuntime)(service, workTree.environment);
+        }
+    }
+    else if ((0, work_item_1.isKubernetesWorkServiceItem)(service)) {
+        return (0, work_runtime_kubernetes_1.kubernetesForwardRuntime)(service);
+    }
+    else {
+        // TODO ensure else case is type safe
+        throw new Error(`unknown service runtime`);
+    }
+}
+exports.getWorkServiceRuntime = getWorkServiceRuntime;
+function getWorkTaskRuntime(workTree, task) {
+    if ((0, work_item_1.isLocalWorkTaskItem)(task)) {
+        return (0, work_runtime_local_1.getLocalWorkRuntime)(task);
+    }
+    else if ((0, work_item_1.isContainerWorkTaskItem)(task)) {
+        if (workTree.environment.type === 'kubernetes') {
+            return (0, work_runtime_kubernetes_1.kubernetesTaskRuntime)(task, workTree.environment);
+        }
+        else {
+            return (0, work_runtime_docker_1.dockerTaskRuntime)(task, workTree.environment);
+        }
+    }
+    else {
+        // TODO ensure else case is type safe
+        throw new Error(`unknown service runtime`);
+    }
+}
+exports.getWorkTaskRuntime = getWorkTaskRuntime;
+//# sourceMappingURL=get-work-runtime.js.map

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

@@ -7,7 +7,7 @@ function normalizePath(cwd, pwd, path) {
         return path;
     }
     else if (path.startsWith('$PWD')) {
-        return (0, path_1.join)(pwd, path.substr('$PWD'.length));
+        return (0, path_1.join)(pwd, path.substring('$PWD'.length));
     }
     else {
         return (0, path_1.join)(cwd, path);

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const normalize_path_1 = require("./normalize-path");
+const path_1 = require("path");
+// normalizePath uses the platform-native path.join, so expectations must use
+// the native separator too. Mirrors the helper in parse-work-mount.spec.ts.
+function toNative(val) {
+    return val.split(path_1.posix.sep).join(path_1.sep);
+}
+describe('normalize-path', () => {
+    it('should append src to cwd', () => {
+        const result = (0, normalize_path_1.normalizePath)('/home/user/proj', '/home/user', 'src');
+        expect(result).toEqual(toNative('/home/user/proj/src'));
+    });
+    it('should append .kube to pwd', () => {
+        const result = (0, normalize_path_1.normalizePath)('/home/user/proj', '/home/user', '$PWD/.kube');
+        expect(result).toEqual(toNative('/home/user/.kube'));
+    });
+    it('should append nothing to /usr/bin', () => {
+        const result = (0, normalize_path_1.normalizePath)('/home/user/proj', '/home/user', '/usr/bin');
+        expect(result).toEqual('/usr/bin');
+    });
+});
+//# sourceMappingURL=normalize-path.spec.js.map

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenizeCommand = exports.parseWorkCommand = exports.parseWorkCommands = void 0;
+const path_1 = require("path");
+const template_value_1 = require("./template-value");
+function parseWorkCommands(cwd, cmds, envs) {
+    return cmds.map((cmd) => parseWorkCommand(cwd, cmd, envs));
+}
+exports.parseWorkCommands = parseWorkCommands;
+function parseWorkCommand(cwd, cmd, envs) {
+    if (typeof cmd === 'string') {
+        return {
+            cwd,
+            ...parseCommand(cmd),
+        };
+    }
+    else {
+        return {
+            cwd: cmd.path ? (0, path_1.join)(cwd, (0, template_value_1.templateValue)(cmd.path, envs)) : cwd,
+            ...parseCommand(cmd.cmd),
+        };
+    }
+}
+exports.parseWorkCommand = parseWorkCommand;
+function parseCommand(cmd) {
+    const tokens = tokenizeCommand(cmd);
+    return {
+        parsed: {
+            command: tokens[0] ?? '',
+            args: tokens.slice(1),
+        },
+        cmd: cmd.trim(),
+    };
+}
+/**
+ * Split a command line into tokens the way a shell roughly would: whitespace
+ * separates arguments, but single/double quotes group one argument and are
+ * stripped. Needed because the parsed command/args feed exec-form targets
+ * (docker `Cmd`, k8s job args, the packaged image's `CMD [...]`), where a naive
+ * `split(' ')` turns `sh -c "echo hi && sleep 1"` into broken tokens like
+ * `"echo`, `hi`, `1"`. The raw `cmd` string is kept untouched for shell-form
+ * use (e.g. Dockerfile `RUN`).
+ */
+function tokenizeCommand(cmd) {
+    const tokens = [];
+    let current = '';
+    let inToken = false;
+    let quote = null;
+    for (const ch of cmd.trim()) {
+        if (quote) {
+            if (ch === quote) {
+                quote = null;
+            }
+            else {
+                current += ch;
+            }
+        }
+        else if (ch === '"' || ch === "'") {
+            quote = ch;
+            inToken = true;
+        }
+        else if (ch === ' ' || ch === '\t') {
+            if (inToken) {
+                tokens.push(current);
+                current = '';
+                inToken = false;
+            }
+        }
+        else {
+            current += ch;
+            inToken = true;
+        }
+    }
+    if (inToken) {
+        tokens.push(current);
+    }
+    return tokens;
+}
+exports.tokenizeCommand = tokenizeCommand;
+//# sourceMappingURL=parse-work-command.js.map

package/dist/planner/utils/parse-work-command.spec.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parse_work_command_1 = require("./parse-work-command");
+describe('tokenizeCommand', () => {
+    it('splits a plain command on whitespace', () => {
+        expect((0, parse_work_command_1.tokenizeCommand)('node server.js')).toEqual(['node', 'server.js']);
+    });
+    it('keeps a double-quoted argument as one token and strips the quotes', () => {
+        expect((0, parse_work_command_1.tokenizeCommand)('sh -c "echo hi && sleep 3600"')).toEqual(['sh', '-c', 'echo hi && sleep 3600']);
+    });
+    it('handles single quotes', () => {
+        expect((0, parse_work_command_1.tokenizeCommand)("sh -c 'echo hi'")).toEqual(['sh', '-c', 'echo hi']);
+    });
+    it('collapses repeated whitespace instead of emitting empty tokens', () => {
+        expect((0, parse_work_command_1.tokenizeCommand)('a   b\tc')).toEqual(['a', 'b', 'c']);
+    });
+    it('returns an empty list for a blank command', () => {
+        expect((0, parse_work_command_1.tokenizeCommand)('   ')).toEqual([]);
+    });
+});
+//# sourceMappingURL=parse-work-command.spec.js.map

package/dist/planner/utils/parse-work-generate.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapGenerate = exports.parseWorkGenerate = void 0;
+const path_1 = require("path");
+const template_value_1 = require("./template-value");
+const plan_work_volume_1 = require("./plan-work-volume");
+function parseWorkGenerate(cwd, schema, envs) {
+    if (!schema.generates) {
+        return [];
+    }
+    return schema.generates.map((g) => {
+        const generate = mapGenerate(g);
+        const filePath = (0, path_1.join)(cwd, (0, template_value_1.templateValue)(generate.path, envs));
+        return {
+            path: filePath,
+            volumeName: (0, plan_work_volume_1.getVolumeName)(filePath),
+            resetOnChange: generate.resetOnChange,
+            export: generate.export,
+            isFile: (0, path_1.extname)(generate.path).length > 1,
+            inherited: null,
+        };
+    });
+}
+exports.parseWorkGenerate = parseWorkGenerate;
+function mapGenerate(generate) {
+    if (typeof generate === 'string') {
+        return { path: generate, resetOnChange: false, export: false };
+    }
+    else {
+        return {
+            path: generate.path,
+            resetOnChange: generate.resetOnChange ?? false,
+            export: generate.export ?? false,
+        };
+    }
+}
+exports.mapGenerate = mapGenerate;
+//# sourceMappingURL=parse-work-generate.js.map

package/dist/planner/utils/parse-work-generate.spec.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const parse_work_generate_1 = require("./parse-work-generate");
+const plan_work_volume_1 = require("./plan-work-volume");
+const noEnvs = { variables: {}, replacements: [] };
+describe('mapGenerate', () => {
+    it('treats a bare string as path with defaults', () => {
+        expect((0, parse_work_generate_1.mapGenerate)('dist')).toEqual({ path: 'dist', resetOnChange: false, export: false });
+    });
+    it('preserves resetOnChange and export from an object', () => {
+        expect((0, parse_work_generate_1.mapGenerate)({ path: 'out', resetOnChange: true, export: true })).toEqual({
+            path: 'out',
+            resetOnChange: true,
+            export: true,
+        });
+    });
+    it('defaults resetOnChange and export to false when omitted', () => {
+        expect((0, parse_work_generate_1.mapGenerate)({ path: 'out' })).toEqual({ path: 'out', resetOnChange: false, export: false });
+    });
+});
+describe('parseWorkGenerate', () => {
+    it('returns [] when the task has no generates', () => {
+        expect((0, parse_work_generate_1.parseWorkGenerate)('/work', {}, noEnvs)).toEqual([]);
+    });
+    it('joins paths against cwd, templates env vars and marks files with an extension', () => {
+        const result = (0, parse_work_generate_1.parseWorkGenerate)('/work', { generates: ['dist', { path: 'out/$NAME.json' }] }, {
+            variables: { NAME: 'pkg' },
+            replacements: [],
+        });
+        expect(result[0]).toMatchObject({
+            path: (0, path_1.join)('/work', 'dist'),
+            isFile: false,
+            resetOnChange: false,
+            export: false,
+            inherited: null,
+        });
+        expect(result[0].volumeName).toBe((0, plan_work_volume_1.getVolumeName)((0, path_1.join)('/work', 'dist')));
+        expect(result[1]).toMatchObject({
+            path: (0, path_1.join)('/work', 'out/pkg.json'),
+            isFile: true,
+        });
+    });
+});
+//# sourceMappingURL=parse-work-generate.spec.js.map

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

@@ -1,25 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseWorkNodeMount = void 0;
+exports.parseWorkMount = void 0;
 const os_1 = require("os");
 const normalize_path_1 = require("./normalize-path");
-function parseWorkNodeMount(cwd, dir) {
+const path_1 = require("path");
+function parseWorkMount(cwd, dir) {
     const parts = dir.split(':');
     if (parts.length === 1) {
-        return parseLocalMount(cwd, dir, dir);
+        return parseLocalMount(cwd, dir, dir, dir);
     }
     else if (parts.length === 2) {
-        return parseLocalMount(cwd, parts[0], parts[1]);
+        return parseLocalMount(cwd, parts[0], parts[1], dir);
     }
     else {
         throw new Error(`invalid mount ${dir}`);
     }
 }
-exports.parseWorkNodeMount = parseWorkNodeMount;
-function parseLocalMount(cwd, localPath, containerPath) {
+exports.parseWorkMount = parseWorkMount;
+function parseLocalMount(cwd, localPath, containerPath, mount) {
     return {
         localPath: (0, normalize_path_1.normalizePath)(cwd, (0, os_1.homedir)(), localPath),
         containerPath: (0, normalize_path_1.normalizePath)(cwd, cwd, containerPath),
+        isFile: (0, path_1.extname)(localPath).length > 1,
+        mount,
     };
 }
-//# sourceMappingURL=parse-work-node-mount.js.map
+//# sourceMappingURL=parse-work-mount.js.map