hammerkit 1.22.0 → 1.24.0

package/dist/server/definitions.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefinitionStore = exports.inspectBundle = exports.DefinitionError = void 0;
+const promises_1 = require("fs/promises");
+const os_1 = require("os");
+const path_1 = require("path");
+const crypto_1 = require("crypto");
+const yaml_1 = require("yaml");
+const get_file_context_1 = require("../file/get-file-context");
+const resolve_git_source_1 = require("../includes/resolve-git-source");
+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");
+const work_task_1 = require("../planner/work-task");
+const bundle_1 = require("../remote/bundle");
+const log_1 = require("../log");
+class DefinitionError extends Error {
+}
+exports.DefinitionError = DefinitionError;
+// 40 (sha-1) or 64 (sha-256) hex digits
+const COMMIT_PATTERN = /^[0-9a-f]{40}([0-9a-f]{24})?$/i;
+// A hash alone can only name what is inside the bundle, so everything a build
+// file pulls in from elsewhere has to be pinned: a git include needs a commit
+// and a remote that is not a path on the server.
+function findLooseIncludes(bundle) {
+    const problems = [];
+    for (const [path, content] of Object.entries(bundle.files)) {
+        if (!/\.ya?ml$/i.test(path)) {
+            continue;
+        }
+        let document;
+        try {
+            document = (0, yaml_1.parse)(content);
+        }
+        catch {
+            continue; // a file that isn't valid yaml is reported when the bundle is parsed
+        }
+        for (const block of ['includes', 'references']) {
+            for (const [name, include] of Object.entries(document?.[block] ?? {})) {
+                const source = include;
+                if (!source || typeof source !== 'object' || source.git === undefined) {
+                    continue;
+                }
+                if (typeof source.git !== 'string' || !/^(https:\/\/|ssh:\/\/|git@[\w.-]+:)/.test(source.git)) {
+                    problems.push(`${path}: ${block}.${name}: git has to be an https:// or ssh:// address`);
+                }
+                if (typeof source.ref !== 'string' || !COMMIT_PATTERN.test(source.ref)) {
+                    problems.push(`${path}: ${block}.${name}: pin ref to a commit, a branch or tag can move`);
+                }
+            }
+        }
+    }
+    return problems;
+}
+// What a build file may read while it is inspected: its own files. The rest of
+// the server is not its business (a missing file is "not there", not an error).
+function confined(files, root) {
+    const check = (path) => {
+        if (!(0, resolve_git_source_1.isWithin)(root, (0, path_1.resolve)(root, path))) {
+            throw new DefinitionError(`${path} is outside of the bundle`);
+        }
+    };
+    const guarded = (fn) => (path) => {
+        check(path);
+        return fn.call(files, path);
+    };
+    return {
+        ...files,
+        read: guarded(files.read),
+        readStream: guarded(files.readStream),
+        listFiles: guarded(files.listFiles),
+        stats: guarded(files.stats),
+        exists: async (path) => (0, resolve_git_source_1.isWithin)(root, (0, path_1.resolve)(root, path)) && files.exists(path),
+        watch: files.watch,
+    };
+}
+// A path of a task, written relative to the root of the bundle with forward
+// slashes. A leading `!` (an exclusion) is kept. Nothing is returned for a path
+// outside of the bundle.
+function insideBundle(root, cwd, path) {
+    const negated = path.startsWith('!');
+    const absolute = (0, path_1.resolve)(cwd, negated ? path.slice(1) : path);
+    const inside = (0, path_1.relative)(root, absolute);
+    if (inside === '..' || inside.startsWith(`..${path_1.sep}`) || (0, path_1.isAbsolute)(inside)) {
+        return [];
+    }
+    const portable = inside.split(path_1.sep).join(path_1.posix.sep);
+    // a pattern keeps its glob characters, `resolve` only normalizes separators
+    return [`${negated ? '!' : ''}${portable === '' ? '.' : portable}`];
+}
+// Writes the bundle into a directory of its own and reads it the way a run
+// would, so a build file that doesn't parse is refused when it is published, not
+// when somebody wants to run it.
+async function inspectBundle(bundle, environment) {
+    const problems = findLooseIncludes(bundle);
+    if (problems.length > 0) {
+        throw new DefinitionError(problems.join('\n'));
+    }
+    const directory = await (0, promises_1.mkdtemp)((0, path_1.join)((0, os_1.tmpdir)(), 'hammerkit-definition-'));
+    try {
+        for (const [path, content] of Object.entries(bundle.files)) {
+            await (0, promises_1.mkdir)((0, path_1.dirname)((0, path_1.join)(directory, path)), { recursive: true });
+            await (0, promises_1.writeFile)((0, path_1.join)(directory, path), content);
+        }
+        const inspected = {
+            ...environment,
+            cwd: directory,
+            file: confined((0, get_file_context_1.getFileContext)(directory), directory),
+        };
+        try {
+            const { ctx, scope } = await (0, schema_parser_1.createParseContext)((0, path_1.join)(directory, bundle.entry), inspected);
+            const context = await (0, reference_parser_1.parseReferences)(ctx, scope, inspected);
+            const workTree = (0, work_scope_parser_1.getWorkContext)(context, { environmentName: null }, inspected);
+            const inputs = {};
+            for (const item of Object.values(workTree.tasks)) {
+                inputs[item.name] = {
+                    // the sources a task inherits from its dependencies belong to those
+                    src: item.data.src
+                        .filter((source) => source.inherited === null)
+                        .flatMap((source) => insideBundle(directory, item.data.cwd, source.source)),
+                    mounts: (0, work_task_1.isContainerWorkTask)(item.data)
+                        ? item.data.mounts.flatMap((mount) => insideBundle(directory, item.data.cwd, mount.localPath))
+                        : [],
+                    deps: item.deps.map((dep) => dep.name).sort(),
+                    needs: item.needs.map((need) => need.name).sort(),
+                };
+            }
+            return {
+                tasks: Object.keys(context.tasks).sort(),
+                services: Object.keys(context.services).sort(),
+                inputs: Object.fromEntries(Object.entries(inputs).sort(([a], [b]) => (a < b ? -1 : 1))),
+            };
+        }
+        catch (e) {
+            throw new DefinitionError((0, log_1.getErrorMessage)(e).split(directory).join('.'));
+        }
+    }
+    finally {
+        await (0, promises_1.rm)(directory, { recursive: true, force: true });
+    }
+}
+exports.inspectBundle = inspectBundle;
+// The published build files: immutable versions, each named by its hash. They
+// are kept in files, so a restart doesn't forget what runs were started from.
+class DefinitionStore {
+    constructor(directory, environment, now = Date.now) {
+        this.directory = directory;
+        this.environment = environment;
+        this.now = now;
+        this.versions = new Map();
+    }
+    async load() {
+        let names = [];
+        try {
+            names = await (0, promises_1.readdir)(this.directory);
+        }
+        catch {
+            return; // nothing was published yet
+        }
+        for (const name of names) {
+            for (const file of await (0, promises_1.readdir)((0, path_1.join)(this.directory, name))) {
+                if (!file.endsWith('.json')) {
+                    continue;
+                }
+                const stored = JSON.parse(await (0, promises_1.readFile)((0, path_1.join)(this.directory, name, file), 'utf8'));
+                this.add(stored.version);
+            }
+        }
+    }
+    names() {
+        return [...this.versions.keys()].sort();
+    }
+    // newest first
+    list(name) {
+        return this.has(name) ? [...this.versions.get(name)] : [];
+    }
+    // a hash, or `latest` for the version published last
+    find(name, hash) {
+        const versions = this.list(name);
+        return hash === 'latest' ? versions[0] : versions.find((v) => v.hash === hash);
+    }
+    async files(version) {
+        try {
+            return JSON.parse(await (0, promises_1.readFile)(this.file(version.name, version.hash), 'utf8')).bundle;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    // Reads a bundle the way a run would and says what it would be as a version;
+    // `existing` is the published version with the same hash, if there is one.
+    async prepare(name, bundle, publisher) {
+        const hash = (0, bundle_1.hashBundle)(bundle);
+        const existing = this.find(name, hash);
+        if (existing) {
+            return { version: existing, existing };
+        }
+        const { tasks, services, inputs } = await inspectBundle(bundle, this.environment);
+        return {
+            version: {
+                name,
+                hash,
+                entry: bundle.entry,
+                publishedAt: new Date(this.now()).toISOString(),
+                publishedBy: { iss: publisher.iss, sub: publisher.sub },
+                tasks,
+                services,
+                inputs,
+            },
+        };
+    }
+    // Publishing what already is there changes nothing and says so.
+    async publish(name, bundle, publisher, approvedBy) {
+        const prepared = await this.prepare(name, bundle, publisher);
+        if (prepared.existing) {
+            return { version: prepared.existing, created: false };
+        }
+        const version = {
+            ...prepared.version,
+            publishedAt: new Date(this.now()).toISOString(),
+            ...(approvedBy ? { approvedBy: { iss: approvedBy.iss, sub: approvedBy.sub } } : {}),
+        };
+        const file = this.file(name, version.hash);
+        await (0, promises_1.mkdir)((0, path_1.dirname)(file), { recursive: true });
+        const temporary = `${file}.${(0, crypto_1.randomBytes)(8).toString('hex')}.tmp`;
+        await (0, promises_1.writeFile)(temporary, JSON.stringify({ version, bundle }), { flag: 'wx' });
+        await (0, promises_1.rename)(temporary, file);
+        this.add(version);
+        return { version, created: true };
+    }
+    has(name) {
+        return this.versions.has(name);
+    }
+    add(version) {
+        const versions = this.versions.get(version.name) ?? [];
+        versions.unshift(version);
+        versions.sort((a, b) => b.publishedAt.localeCompare(a.publishedAt));
+        this.versions.set(version.name, versions);
+    }
+    file(name, hash) {
+        if (!bundle_1.HASH_PATTERN.test(hash)) {
+            throw new DefinitionError('invalid hash');
+        }
+        return (0, path_1.join)(this.directory, name, `${hash.slice('sha256:'.length)}.json`);
+    }
+}
+exports.DefinitionStore = DefinitionStore;
+//# sourceMappingURL=definitions.js.map

package/dist/server/discovery.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DISCOVERY_PATH = exports.SERVER_PROTOCOL = void 0;
+// What a client needs to know about a server before it signs in. Kept apart from
+// the server so the client does not load the http server and token code.
+// Bumped when a client could no longer talk to an older or newer server.
+exports.SERVER_PROTOCOL = 1;
+exports.DISCOVERY_PATH = '/.well-known/hammerkit';
+//# sourceMappingURL=discovery.js.map

package/dist/server/executor.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostExecutor = exports.passedEnvironment = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const cli_1 = require("../cli");
+const get_file_context_1 = require("../file/get-file-context");
+const log_1 = require("../log");
+const resolve_git_source_1 = require("../includes/resolve-git-source");
+const parse_label_arguments_1 = require("../parser/parse-label-arguments");
+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");
+const work_item_status_1 = require("../planner/work-item-status");
+const plan_work_tasks_1 = require("../planner/utils/plan-work-tasks");
+const redact_1 = require("../utils/redact");
+const empty_writable_1 = require("../utils/empty-writable");
+const units_1 = require("../utils/units");
+const git_checkout_1 = require("./git-checkout");
+// What a task on the server sees of the server's own environment: the tools it
+// needs to find and reach docker, nothing the operator keeps there for the server.
+const PASSED_ENVS = [
+    'PATH',
+    'HOME',
+    'LANG',
+    'LC_ALL',
+    'TMPDIR',
+    'DOCKER_HOST',
+    'DOCKER_CONFIG',
+    'SSL_CERT_FILE',
+    'HTTP_PROXY',
+    'HTTPS_PROXY',
+    'NO_PROXY',
+    'http_proxy',
+    'https_proxy',
+    'no_proxy',
+    'SSH_AUTH_SOCK',
+    // Windows: without these powershell and git can not find their profile
+    'SystemRoot',
+    'SystemDrive',
+    'windir',
+    'ComSpec',
+    'PATHEXT',
+    'USERPROFILE',
+    'APPDATA',
+    'LOCALAPPDATA',
+    'TEMP',
+    'TMP',
+    'ProgramData',
+    'ProgramFiles',
+    'ProgramFiles(x86)',
+    // powershell is very slow to start without it
+    'PSModulePath',
+];
+// one log line of a task is cut here, the registry caps how many events a run keeps
+const MAX_LOG_TEXT = 8 * 1024;
+function passedEnvironment(envs) {
+    const passed = {};
+    for (const name of PASSED_ENVS) {
+        if (envs[name] !== undefined) {
+            passed[name] = envs[name];
+        }
+    }
+    return passed;
+}
+exports.passedEnvironment = passedEnvironment;
+/**
+ * Runs the tasks of a run on this machine with the engine of `hammerkit run`.
+ *
+ * The working directory is made for the run and removed afterwards. Its build
+ * file is the published version the run is pinned to, written over the code of the
+ * source, so the commands are the published ones whatever the source says. The
+ * local cache is shared by all runs, a task is keyed by its definition and
+ * sources and not by where they are.
+ */
+class HostExecutor {
+    constructor(options) {
+        this.options = options;
+    }
+    async execute(run, context) {
+        const { definitions, config, environment } = this.options;
+        const version = definitions.find(run.definition.name, run.definition.hash);
+        const bundle = version ? await definitions.files(version) : undefined;
+        if (!version || !bundle) {
+            throw new Error(`the build file ${run.definition.name} at ${run.definition.hash} is no longer on this server`);
+        }
+        if (run.source.type !== 'ref') {
+            throw new Error('runs from an upload are not supported by this server yet, use a git ref');
+        }
+        const repository = config.sources[run.definition.name]?.git;
+        if (!repository) {
+            throw new Error(`this server has no repository for ${run.definition.name} to run ${run.source.ref} from, ` +
+                `the operator sets sources.${run.definition.name}.git`);
+        }
+        const abortCtrl = new AbortController();
+        const abort = () => abortCtrl.abort();
+        if (context.signal.aborted) {
+            abort();
+        }
+        context.signal.addEventListener('abort', abort, { once: true });
+        const root = (0, path_1.join)(this.options.directory, run.id);
+        const checkout = (0, path_1.join)(root, 'source');
+        try {
+            const passed = passedEnvironment(environment.processEnvs);
+            const commit = await (0, git_checkout_1.checkoutRef)(repository, run.source.ref, checkout, passed, abortCtrl.signal);
+            context.emit({ type: 'log', task: 'hammerkit', stream: 'stdout', text: `checked out ${commit}` });
+            await this.writeBundle(checkout, bundle.files);
+            await this.runTasks(run, context, (0, path_1.join)(checkout, version.entry), checkout, passed, abortCtrl);
+        }
+        finally {
+            context.signal.removeEventListener('abort', abort);
+            await (0, promises_1.rm)(root, { recursive: true, force: true });
+        }
+    }
+    // The published files go over the checkout; nothing may land outside of it or in
+    // its git directory.
+    async writeBundle(directory, files) {
+        for (const [path, content] of Object.entries(files)) {
+            const target = (0, path_1.resolve)(directory, path);
+            if (!(0, resolve_git_source_1.isWithin)(directory, target) || /^\.git(\/|$)/.test(path)) {
+                throw new Error(`the published file ${JSON.stringify(path)} can not be written into the source`);
+            }
+            await (0, promises_1.mkdir)((0, path_1.dirname)(target), { recursive: true });
+            await (0, promises_1.writeFile)(target, content);
+        }
+    }
+    async runTasks(run, context, entry, cwd, passed, abortCtrl) {
+        const secrets = (0, redact_1.createSecretRegistry)();
+        const status = (0, work_item_status_1.statusConsole)((0, empty_writable_1.emptyWritable)(), secrets);
+        // what the engine would print to a terminal is not wanted, its status console
+        // is what is streamed: it is redacted with the secrets of this run
+        const environment = {
+            processEnvs: passed,
+            abortCtrl,
+            cwd,
+            file: (0, get_file_context_1.getFileContext)(cwd),
+            console: (0, log_1.consoleContext)((0, empty_writable_1.emptyWritable)()),
+            status,
+            secrets,
+            stdout: (0, empty_writable_1.emptyWritable)(),
+            stderr: (0, empty_writable_1.emptyWritable)(),
+            stdoutColumns: 120,
+        };
+        const listener = status.on((message) => {
+            if (message.type === 'console') {
+                context.emit({
+                    type: 'log',
+                    task: message.context.name,
+                    stream: message.console,
+                    text: message.message.slice(0, MAX_LOG_TEXT),
+                });
+            }
+            else if (message.level === 'error' || message.level === 'warn') {
+                context.emit({
+                    type: 'log',
+                    task: message.context.name,
+                    stream: 'stderr',
+                    text: message.message.slice(0, MAX_LOG_TEXT),
+                });
+            }
+        });
+        try {
+            const options = run.options;
+            const execOptions = {
+                logMode: 'live',
+                cacheDefault: options.cache ?? 'checksum',
+                cacheReadOnly: options.cacheReadOnly ?? false,
+                timeout: options.timeout ? (0, units_1.parseDuration)(options.timeout) : null,
+                skipDeps: options.skipDeps !== false,
+            };
+            // the tasks in the order they were named; by labels when none is
+            const scopes = run.tasks.length > 0
+                ? run.tasks.map((task) => ({
+                    name: task,
+                    scope: { taskName: task, environmentName: options.env ?? null },
+                }))
+                : [
+                    {
+                        name: 'labels',
+                        scope: {
+                            filterLabels: labels(options.filter),
+                            excludeLabels: labels(options.exclude),
+                            environmentName: options.env ?? null,
+                        },
+                    },
+                ];
+            for (const { name, scope } of scopes) {
+                const { ctx, scope: parsed } = await (0, schema_parser_1.createParseContext)(entry, environment);
+                const workTree = (0, work_scope_parser_1.getWorkContext)(await (0, reference_parser_1.parseReferences)(ctx, parsed, environment), scope, environment);
+                const cli = (0, cli_1.getCli)(workTree, environment);
+                if (cli.tasks().length === 0) {
+                    throw new Error(`no tasks found for ${name}`);
+                }
+                const execution = cli.exec({ ...execOptions, workers: cli.defaultWorkers() });
+                const seen = new Map();
+                const watch = execution.state.on('run-events', () => reportTasks(context, execution.state.current, seen));
+                try {
+                    const result = await execution.start();
+                    reportTasks(context, execution.state.current, seen);
+                    if (!result.success) {
+                        throw new Error(context.signal.aborted ? 'the run was cancelled' : `${name} failed`);
+                    }
+                }
+                finally {
+                    watch.close();
+                }
+            }
+        }
+        finally {
+            listener.close();
+        }
+    }
+}
+exports.HostExecutor = HostExecutor;
+function labels(values) {
+    return values && values.length > 0 ? (0, parse_label_arguments_1.parseLabelArguments)(values) : undefined;
+}
+// A task event when a task has moved on since the last look.
+function reportTasks(context, workTree, seen) {
+    for (const task of (0, plan_work_tasks_1.iterateWorkTasks)(workTree)) {
+        const state = task.state.current;
+        let event = null;
+        if (state.type === 'running') {
+            event = 'running';
+        }
+        else if (state.type === 'completed') {
+            event = state.skipped ? null : state.cached ? 'cached' : 'succeeded';
+        }
+        else if (state.type === 'error' || state.type === 'crash') {
+            event = 'failed';
+        }
+        if (event && seen.get(task.name) !== event) {
+            seen.set(task.name, event);
+            context.emit({ type: 'task', task: task.name, state: event });
+        }
+    }
+}
+//# sourceMappingURL=executor.js.map

package/dist/server/git-checkout.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkoutRef = exports.isValidRef = void 0;
+const child_process_1 = require("child_process");
+const promises_1 = require("fs/promises");
+const util_1 = require("util");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+// Anything but plain network and local transports is refused: `ext::` runs a command.
+const ALLOWED_PROTOCOLS = 'file:git:http:https:ssh';
+// A branch, a tag or a commit. It is passed after `--` as well, but a ref that
+// looks like an option, has a `..` or odd characters is not one of the three.
+const REF_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._/-]{0,199}$/;
+function isValidRef(ref) {
+    return (REF_PATTERN.test(ref) && !ref.includes('..') && !ref.includes('//') && !ref.endsWith('/') && !ref.endsWith('.lock'));
+}
+exports.isValidRef = isValidRef;
+/**
+ * Fetches one commit of a repository into `directory` and checks it out, and
+ * answers which commit that is. The repository is the operator's, the ref is the
+ * caller's. Credentials come from the git configuration of the server, there is no
+ * prompt a run could hang on.
+ */
+async function checkoutRef(repository, ref, directory, env, signal) {
+    if (!isValidRef(ref)) {
+        throw new Error(`${JSON.stringify(ref.slice(0, 80))} is not a branch, tag or commit`);
+    }
+    await (0, promises_1.mkdir)(directory, { recursive: true });
+    const run = (args) => git(args, env, signal, `${repository} at ${ref}`);
+    await run(['init', '--quiet', directory]);
+    await run(['-C', directory, 'fetch', '--quiet', '--depth', '1', '--', repository, ref]);
+    await run(['-C', directory, '-c', 'advice.detachedHead=false', 'checkout', '--quiet', 'FETCH_HEAD']);
+    return (await run(['-C', directory, 'rev-parse', 'HEAD'])).trim();
+}
+exports.checkoutRef = checkoutRef;
+async function git(args, baseEnv, signal, what) {
+    const env = {};
+    for (const [key, value] of Object.entries(baseEnv)) {
+        if (value !== undefined) {
+            env[key] = value;
+        }
+    }
+    env.GIT_TERMINAL_PROMPT = '0';
+    env.GIT_ALLOW_PROTOCOL = ALLOWED_PROTOCOLS;
+    try {
+        return (await execFileAsync('git', args, { env, signal })).stdout;
+    }
+    catch (e) {
+        const error = e;
+        if (error.code === 'ABORT_ERR') {
+            throw new Error(`fetching ${what} was cancelled`);
+        }
+        if (error.code === 'ENOENT') {
+            throw new Error(`unable to fetch ${what}: git is not installed`);
+        }
+        const reason = (error.stderr ?? '')
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0)
+            .pop() ?? error.message;
+        throw new Error(`unable to fetch ${what}: ${reason}`);
+    }
+}
+//# sourceMappingURL=git-checkout.js.map

package/dist/server/http.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readJson = exports.MAX_BODY_BYTES = exports.HttpError = exports.send = void 0;
+function send(res, status, body, headers = {}) {
+    res.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store', ...headers });
+    res.end(JSON.stringify(body));
+}
+exports.send = send;
+// An answer to the caller, thrown from wherever the request turns out to be wrong.
+class HttpError extends Error {
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+exports.HttpError = HttpError;
+exports.MAX_BODY_BYTES = 64 * 1024;
+async function readJson(req, limit = exports.MAX_BODY_BYTES) {
+    if (!/^application\/json(;|$)/i.test(req.headers['content-type'] ?? '')) {
+        throw new HttpError(415, 'send application/json');
+    }
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        size += chunk.length;
+        if (size > limit) {
+            throw new HttpError(413, `the request is larger than ${limit} bytes`);
+        }
+        chunks.push(chunk);
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        throw new HttpError(400, 'the body is not valid JSON');
+    }
+}
+exports.readJson = readJson;
+//# sourceMappingURL=http.js.map