hammerkit 1.27.0-next.20 → 1.27.0-next.21

package/build.schema.json

@@ -595,6 +595,24 @@
               {
                 "type": "string"
               },
+              {
+                "type": "object",
+                "properties": {
+                  "path": {
+                    "type": "string",
+                    "minLength": 1,
+                    "description": "Build file or directory, relative to the including file"
+                  },
+                  "with": {
+                    "$ref": "#/definitions/hammerkit/properties/envs",
+                    "description": "Environment values for the current build task\nhttps://hammerkit.dev/docs/build-file/environment-variables"
+                  }
+                },
+                "required": [
+                  "path"
+                ],
+                "additionalProperties": false
+              },
               {
                 "type": "object",
                 "properties": {

package/dist/executer/execution-steps.js

@@ -9,6 +9,7 @@ const work_task_1 = require("../planner/work-task");
 const work_service_1 = require("../planner/work-service");
 const get_container_binds_1 = require("./get-container-binds");
 const assert_item_paths_1 = require("../planner/utils/assert-item-paths");
+const log_1 = require("../log");
 // The files a server run works on: its checkout, or a sandbox. Somebody else wrote them.
 function hostedRoot(environment) {
     return environment.hosted ? environment.cwd : undefined;
@@ -66,10 +67,27 @@ async function prepareMounts(item, environment) {
             continue;
         }
         if ((0, path_1.extname)(mount.localPath)) {
-            await environment.file.writeFile(mount.localPath, '');
+            try {
+                await environment.file.writeFile(mount.localPath, '');
+            }
+            catch (e) {
+                // Docker would make a directory there
+                throw new Error(`mount ${mount.localPath} does not exist and can't be created (${(0, log_1.getErrorMessage)(e)})`);
+            }
         }
         else {
-            await environment.file.createDirectory(mount.localPath);
+            try {
+                await environment.file.createDirectory(mount.localPath);
+            }
+            catch (e) {
+                // on a server a root-owned directory in the run's files could break its cleanup
+                if (environment.hosted) {
+                    throw e;
+                }
+                // hammerkit may run in a container whose file system is not the one of the Docker
+                // host: Docker creates the missing directory of a bind on its own
+                item.status.write('warn', `can't create ${mount.localPath} (${(0, log_1.getErrorMessage)(e)}), Docker creates it on its host as root`);
+            }
         }
     }
     if ((0, work_task_1.isContainerWorkTask)(item.data)) {

package/dist/executer/reset-work-tree.js

@@ -5,6 +5,10 @@ const state_1 = require("./state");
 function resetWorkTree(workTree, type) {
     return {
         tasks: Object.entries(workTree.tasks).reduce((tasks, [key, task]) => {
+            // down only stops services: a task it selects names the services it needs
+            if (type === 'down') {
+                return tasks;
+            }
             task.state = new state_1.State({
                 type: 'pending',
                 stateKey: null,

package/dist/program.js

@@ -111,6 +111,18 @@ function getListJson(tasks, services) {
         })),
     };
 }
+// `up` and `down` select by name or by label, not both: a name outside the labels would
+// silently select nothing
+function parseWorkNameScope(names, options) {
+    const scope = parseWorkLabelScope(options);
+    if (names.length === 0) {
+        return scope;
+    }
+    if (scope.filterLabels || scope.excludeLabels) {
+        throw new Error('name tasks and services or select them with --filter/--exclude, not both');
+    }
+    return { ...scope, names };
+}
 function parseWorkLabelScope(options) {
     const scope = {
         environmentName: null,
@@ -587,9 +599,9 @@ async function getProgram(environment, argv) {
             }
         });
         program
-            .command('up')
-            .description("start services(s), with the arguments after -- appended to the selected service's cmd")
-            .usage('[options] [-- args...]')
+            .command('up [names...]')
+            .description("start services(s), all or the named tasks and services, with the arguments after -- appended to the selected service's cmd")
+            .usage('[options] [names...] [-- args...]')
             .addOption(new commander_1.Option('-f, --filter <labels...>', 'filter task and services with labels'))
             .addOption(new commander_1.Option('-e, --exclude <labels...>', 'exclude task and services with labels'))
             .addOption(new commander_1.Option('-c, --concurrency <number>', 'parallel worker count (default 4, unbounded when every task and service requests cpus and memory)').argParser(parseInt))
@@ -610,10 +622,10 @@ async function getProgram(environment, argv) {
             .addOption(new commander_1.Option('--timeout <duration>', 'fail tasks without their own timeout after this long (e.g. 10m)').argParser(units_1.parseDuration))
             .addOption(new commander_1.Option('--max-timeout <duration>', 'fail any task after this long, also one with a longer timeout of its own (e.g. 2m)').argParser(units_1.parseDuration))
             .addOption(new commander_1.Option('--network <level>', 'the most any task or service reaches besides its needs: none, open or allow:<host>,<host>').argParser(parseNetworkArgument))
-            .action(async (options, command) => {
+            .action(async (names, options, command) => {
             try {
                 const scope = {
-                    ...parseWorkLabelScope(options),
+                    ...parseWorkNameScope(names, options),
                     args: { values: passthrough, services: true, cache: keepsCache(command) },
                 };
                 const cli = await createCli(fileName, environment, scope);
@@ -646,14 +658,14 @@ async function getProgram(environment, argv) {
             }
         });
         program
-            .command('down')
-            .description('stop services(s)')
+            .command('down [names...]')
+            .description('stop services(s), all or the named services and the services the named tasks need')
             .addOption(new commander_1.Option('-f, --filter <labels...>', 'filter task and services with labels'))
             .addOption(new commander_1.Option('-e, --exclude <labels...>', 'exclude task and services with labels'))
             .addOption(new commander_1.Option('--env <name>', 'environment'))
-            .action(async (options) => {
+            .action(async (names, options) => {
             try {
-                const scope = parseWorkLabelScope(options);
+                const scope = { ...parseWorkNameScope(names, options), stop: true };
                 const cli = await createCli(fileName, environment, scope);
                 const result = await cli.runDown();
                 if (!result.success) {

package/dist/schema/build-file-include-schema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isGitSource = exports.buildFileIncludeSchema = exports.buildFileGitSourceSchema = void 0;
+exports.isGitSource = exports.buildFileIncludeSchema = exports.buildFileLocalSourceSchema = exports.buildFileGitSourceSchema = void 0;
 const zod_1 = require("zod");
 const envs_schema_1 = require("./envs-schema");
 // A repo URL or ref starting with `-` would be read by git as an option
@@ -22,10 +22,16 @@ exports.buildFileGitSourceSchema = (0, zod_1.object)({
     // overrides for the top-level `envs` the included file declares as its inputs
     with: envs_schema_1.envsSchema.optional(),
 }).strict();
-// A string is a local path; an object is a git source (ADR-0004).
-exports.buildFileIncludeSchema = (0, zod_1.union)([(0, zod_1.string)(), exports.buildFileGitSourceSchema]);
+// A local path with values for the inputs of the file it names, like `with` of a git
+// source. A value may pass on an `envs` value of the including file as `${NAME}`.
+exports.buildFileLocalSourceSchema = (0, zod_1.object)({
+    path: (0, zod_1.string)().min(1).describe('Build file or directory, relative to the including file'),
+    with: envs_schema_1.envsSchema.optional(),
+}).strict();
+// A string is a local path; an object is a local path with inputs, or a git source (ADR-0004).
+exports.buildFileIncludeSchema = (0, zod_1.union)([(0, zod_1.string)(), exports.buildFileLocalSourceSchema, exports.buildFileGitSourceSchema]);
 function isGitSource(include) {
-    return typeof include !== 'string';
+    return typeof include !== 'string' && 'git' in include;
 }
 exports.isGitSource = isGitSource;
 //# sourceMappingURL=build-file-include-schema.js.map

package/dist/schema/schema-parser.js

@@ -89,13 +89,45 @@ async function locateInclude(ctx, scope, include, base, environment) {
         if (!(0, resolve_git_source_1.isWithin)(remote.root, path)) {
             throw new Error(`${include.path} in ${include.git} points outside the repository`);
         }
-        return { fileName: await (0, default_build_file_1.getBuildFilename)(path, environment), remote, inputs: include.with };
+        return { fileName: await (0, default_build_file_1.getBuildFilename)(path, environment), remote, inputs: passEnvs(include.with, scope) };
     }
-    const path = (0, path_1.join)(base, include);
+    const localPath = typeof include === 'string' ? include : include.path;
+    const path = (0, path_1.join)(base, localPath);
     if (scope.remote && !(0, resolve_git_source_1.isWithin)(scope.remote.root, path)) {
-        throw new Error(`${include} in ${scope.fileName} points outside ${scope.remote.git}`);
+        throw new Error(`${localPath} in ${scope.fileName} points outside ${scope.remote.git}`);
     }
-    return { fileName: await (0, default_build_file_1.getBuildFilename)(path, environment), remote: scope.remote };
+    const inputs = typeof include === 'string' ? undefined : passEnvs(include.with, scope);
+    return { fileName: await (0, default_build_file_1.getBuildFilename)(path, environment), remote: scope.remote, inputs };
+}
+// `${NAME}` (or `${NAME:-default}`) in a `with` value reads as it does in the including
+// file: the environment or a `.env` file first, then that file's own `envs` value. So one
+// file holds a value such as NODE_VERSION for all it includes, and CI can still set it. A
+// name the file does not declare is left to the included file, which reads it the same way.
+function passEnvs(inputs, scope) {
+    if (!inputs) {
+        return undefined;
+    }
+    const envs = scope.schema.envs ?? {};
+    const result = {};
+    for (const [key, value] of Object.entries(inputs)) {
+        result[key] =
+            typeof value === 'string'
+                ? value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g, (match, name, fallback) => name in envs ? passEnv(name, `${envs[name]}`, fallback) : match)
+                : value;
+    }
+    return result;
+}
+// The including file's value as an interpolation the included file resolves in the same
+// order. A value built from other variables is passed on as it is written.
+function passEnv(name, value, fallback) {
+    const reference = /^\$([A-Za-z_][A-Za-z0-9_]*)$/.exec(value);
+    if (reference) {
+        return fallback === undefined ? `\${${reference[1]}}` : `\${${reference[1]}:-${fallback}}`;
+    }
+    if (value.includes('$') || value.includes('}')) {
+        return value;
+    }
+    return `\${${name}:-${value}}`;
 }
 // `includes pull` fetches each source once, however often the build files name it.
 async function resolveRemote(ctx, source, environment) {

package/dist/schema/work-scope-parser.js

@@ -47,19 +47,27 @@ function getWorkContext(context, scope, environment) {
     // its init task's need on it, which narrowing follows
     const tasks = Object.values(context.tasks).map((task) => (0, append_work_task_1.appendWorkTask)(workTree, task.cwd, task, environment, context));
     const services = Object.values(context.services).map((service) => (0, append_work_service_1.appendWorkService)(workTree, service, environment, context));
+    const apply = { servicesAlone: !(0, work_scope_1.isContextTaskFilter)(scope) && !!scope.names && !!scope.stop };
     const selectedTasks = [];
     const selectedServices = [];
     for (const item of tasks) {
         if (matchesTaskWorkScope(item, scope)) {
             requested.push(item.name);
             selectedTasks.push(item.data);
-            applyTask(filteredWorkTree, item);
+            applyTask(filteredWorkTree, item, apply);
         }
     }
     for (const item of services) {
         if (matchesServiceWorkScope(item.data, scope)) {
             selectedServices.push(item.data);
-            applyService(filteredWorkTree, item);
+            applyService(filteredWorkTree, item, apply);
+        }
+    }
+    if (!(0, work_scope_1.isContextTaskFilter)(scope) && scope.names) {
+        const known = new Set([...tasks.map((task) => task.name), ...services.map((service) => service.data.name)]);
+        const unknown = scope.names.filter((name) => !known.has(name));
+        if (unknown.length > 0) {
+            throw new Error(`no task or service named ${unknown.join(', ')}, see hammerkit ls`);
         }
     }
     if (scope.args) {
@@ -86,31 +94,34 @@ function keepRequirersInScope(workTree) {
         }
     }
 }
-function applyTask(workTree, item) {
+function applyTask(workTree, item, options) {
     if (workTree.tasks[item.name]) {
         return;
     }
     workTree.tasks[item.name] = item;
-    applyNeedsAndDeps(workTree, item);
+    applyNeedsAndDeps(workTree, item, options);
 }
-function applyService(workTree, need) {
+function applyService(workTree, need, options) {
     const item = (0, append_work_service_1.getPlannedService)(need);
     if (workTree.services[item.name]) {
         return;
     }
     workTree.services[item.name] = item;
-    applyNeedsAndDeps(workTree, item);
+    if (options.servicesAlone) {
+        return;
+    }
+    applyNeedsAndDeps(workTree, item, options);
     // a service in the run brings its init task, which runs once it is healthy
     if (item.data.type === 'container-service' && item.data.init) {
-        applyTask(workTree, item.data.init.task);
+        applyTask(workTree, item.data.init.task, options);
     }
 }
-function applyNeedsAndDeps(workTree, item) {
+function applyNeedsAndDeps(workTree, item, options) {
     for (const dep of item.deps) {
-        applyTask(workTree, dep);
+        applyTask(workTree, dep, options);
     }
     for (const need of item.needs) {
-        applyService(workTree, need.service);
+        applyService(workTree, need.service, options);
     }
 }
 function matchesTaskWorkScope(task, scope) {
@@ -120,6 +131,9 @@ function matchesTaskWorkScope(task, scope) {
     if (scope.serviceNames) {
         return false;
     }
+    if (scope.names) {
+        return scope.names.includes(task.name);
+    }
     return (0, label_values_1.appliesToLabels)(task.data.labels, scope);
 }
 function matchesServiceWorkScope(service, scope) {
@@ -129,6 +143,9 @@ function matchesServiceWorkScope(service, scope) {
     if (scope.serviceNames) {
         return scope.serviceNames.includes(service.name);
     }
+    if (scope.names) {
+        return scope.names.includes(service.name);
+    }
     return (0, label_values_1.appliesToLabels)(service.labels, scope);
 }
 //# sourceMappingURL=work-scope-parser.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hammerkit",
   "description": "Containerized build tool with incremental caching that runs the same build file locally, in Docker and on Kubernetes.",
-  "version": "1.27.0-next.20",
+  "version": "1.27.0-next.21",
   "keywords": [
     "build",
     "build-tool",