@tolinax/ayoune-cli 2026.8.2 → 2026.9.0

package/lib/commands/aggregate/_stageBuilders.js

@@ -0,0 +1,295 @@
+// Pipeline stage builders for the `ay aggregate wizard` flow.
+//
+// Each `build*Stage` function drives an inquirer wizard that asks the user
+// the questions appropriate for one stage type ($match, $group, $sort, etc.)
+// and returns the assembled MongoDB stage object. They live in their own
+// file because they're large (~200 lines combined), only used by the wizard
+// subcommand, and would otherwise dominate `wizard.ts`.
+//
+// `coerceValue` handles "the user typed `42` but the field is a Number" / "the
+// user typed `2026-04-01` but the field is a Date" — without coercion the
+// pipeline would silently match against strings.
+import inquirer from "inquirer";
+import chalk from "chalk";
+export async function buildStage(stageType, fieldNames, fields) {
+    switch (stageType) {
+        case "$match":
+            return buildMatchStage(fieldNames, fields);
+        case "$group":
+            return buildGroupStage(fieldNames);
+        case "$sort":
+            return buildSortStage(fieldNames);
+        case "$project":
+            return buildProjectStage(fieldNames);
+        case "$unwind":
+            return buildUnwindStage(fieldNames);
+        case "$lookup":
+            return buildLookupStage();
+        case "$limit":
+            return buildNumberStage("$limit", "Maximum documents to return:");
+        case "$skip":
+            return buildNumberStage("$skip", "Documents to skip:");
+        case "$count":
+            return buildCountStage();
+        case "$addFields":
+            return buildRawStage("$addFields");
+        case "$raw":
+            return buildFullRawStage();
+        default:
+            return null;
+    }
+}
+async function buildMatchStage(fieldNames, fields) {
+    const match = {};
+    let addMore = true;
+    while (addMore) {
+        const { field } = await inquirer.prompt([
+            { type: "search-list", name: "field", message: "Field to match:", choices: fieldNames },
+        ]);
+        const fieldMeta = fields.find((f) => f.field === field);
+        const isNumber = (fieldMeta === null || fieldMeta === void 0 ? void 0 : fieldMeta.type) === "Number";
+        const isDate = (fieldMeta === null || fieldMeta === void 0 ? void 0 : fieldMeta.type) === "Date";
+        const isBool = (fieldMeta === null || fieldMeta === void 0 ? void 0 : fieldMeta.type) === "Boolean";
+        const { operator } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "operator",
+                message: "Operator:",
+                choices: [
+                    { name: "equals", value: "eq" },
+                    { name: "not equals", value: "$ne" },
+                    { name: "greater than", value: "$gt" },
+                    { name: "less than", value: "$lt" },
+                    { name: "greater or equal", value: "$gte" },
+                    { name: "less or equal", value: "$lte" },
+                    { name: "in (comma-separated)", value: "$in" },
+                    { name: "not in", value: "$nin" },
+                    { name: "regex", value: "$regex" },
+                    { name: "exists", value: "$exists" },
+                ],
+            },
+        ]);
+        let value;
+        if (operator === "$exists") {
+            const { exists } = await inquirer.prompt([
+                { type: "confirm", name: "exists", message: "Field should exist?", default: true },
+            ]);
+            value = exists;
+            match[field] = { $exists: value };
+        }
+        else if (isBool) {
+            const { boolVal } = await inquirer.prompt([
+                { type: "confirm", name: "boolVal", message: `${field} =`, default: true },
+            ]);
+            match[field] = operator === "eq" ? boolVal : { [operator]: boolVal };
+        }
+        else if (operator === "$in" || operator === "$nin") {
+            const { vals } = await inquirer.prompt([
+                { type: "input", name: "vals", message: "Values (comma-separated):" },
+            ]);
+            const arr = vals.split(",").map((v) => coerceValue(v.trim(), isNumber, isDate));
+            match[field] = { [operator]: arr };
+        }
+        else {
+            const { val } = await inquirer.prompt([
+                { type: "input", name: "val", message: "Value:" },
+            ]);
+            const coerced = coerceValue(val, isNumber, isDate);
+            match[field] = operator === "eq" ? coerced : { [operator]: coerced };
+        }
+        const { more } = await inquirer.prompt([
+            { type: "confirm", name: "more", message: "Add another match condition?", default: false },
+        ]);
+        addMore = more;
+    }
+    return { $match: match };
+}
+async function buildGroupStage(fieldNames) {
+    const { idType } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "idType",
+            message: "Group by:",
+            choices: [
+                { name: "Single field", value: "single" },
+                { name: "Multiple fields", value: "multi" },
+                { name: "null (aggregate all)", value: "null" },
+            ],
+        },
+    ]);
+    let _id = null;
+    if (idType === "single") {
+        const { field } = await inquirer.prompt([
+            { type: "search-list", name: "field", message: "Group by field:", choices: fieldNames },
+        ]);
+        _id = `$${field}`;
+    }
+    else if (idType === "multi") {
+        const { selected } = await inquirer.prompt([
+            { type: "checkbox", name: "selected", message: "Select fields:", choices: fieldNames },
+        ]);
+        _id = {};
+        for (const f of selected)
+            _id[f] = `$${f}`;
+    }
+    const group = { _id };
+    let addAcc = true;
+    while (addAcc) {
+        const { outputName } = await inquirer.prompt([
+            {
+                type: "input",
+                name: "outputName",
+                message: "Output field name:",
+                validate: (v) => v.length > 0,
+            },
+        ]);
+        const { accumulator } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "accumulator",
+                message: "Accumulator:",
+                choices: ["$sum", "$avg", "$min", "$max", "$count", "$push", "$first", "$last"],
+            },
+        ]);
+        if (accumulator === "$count") {
+            group[outputName] = { $count: {} };
+        }
+        else {
+            const { srcField } = await inquirer.prompt([
+                {
+                    type: "search-list",
+                    name: "srcField",
+                    message: "Source field:",
+                    choices: ["1 (constant)", ...fieldNames],
+                },
+            ]);
+            group[outputName] = { [accumulator]: srcField === "1 (constant)" ? 1 : `$${srcField}` };
+        }
+        const { more } = await inquirer.prompt([
+            { type: "confirm", name: "more", message: "Add another accumulator?", default: false },
+        ]);
+        addAcc = more;
+    }
+    return { $group: group };
+}
+async function buildSortStage(fieldNames) {
+    const sort = {};
+    let addMore = true;
+    while (addMore) {
+        const { field } = await inquirer.prompt([
+            { type: "search-list", name: "field", message: "Sort by field:", choices: fieldNames },
+        ]);
+        const { direction } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "direction",
+                message: "Direction:",
+                choices: [
+                    { name: "Ascending (1)", value: 1 },
+                    { name: "Descending (-1)", value: -1 },
+                ],
+            },
+        ]);
+        sort[field] = direction;
+        const { more } = await inquirer.prompt([
+            { type: "confirm", name: "more", message: "Add another sort field?", default: false },
+        ]);
+        addMore = more;
+    }
+    return { $sort: sort };
+}
+async function buildProjectStage(fieldNames) {
+    const { mode } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "mode",
+            message: "Projection mode:",
+            choices: [
+                { name: "Include selected fields (1)", value: "include" },
+                { name: "Exclude selected fields (0)", value: "exclude" },
+            ],
+        },
+    ]);
+    const { selected } = await inquirer.prompt([
+        {
+            type: "checkbox",
+            name: "selected",
+            message: `Fields to ${mode}:`,
+            choices: fieldNames,
+            validate: (v) => v.length > 0 || "Select at least one field",
+        },
+    ]);
+    const project = {};
+    for (const f of selected)
+        project[f] = mode === "include" ? 1 : 0;
+    return { $project: project };
+}
+async function buildUnwindStage(fieldNames) {
+    const { field } = await inquirer.prompt([
+        { type: "search-list", name: "field", message: "Array field to unwind:", choices: fieldNames },
+    ]);
+    return { $unwind: `$${field}` };
+}
+async function buildLookupStage() {
+    const answers = await inquirer.prompt([
+        { type: "input", name: "from", message: "Foreign collection (lowercase):" },
+        { type: "input", name: "localField", message: "Local field:" },
+        { type: "input", name: "foreignField", message: "Foreign field:", default: "_id" },
+        { type: "input", name: "as", message: "Output array field name:" },
+    ]);
+    return { $lookup: answers };
+}
+async function buildNumberStage(op, message) {
+    const { num } = await inquirer.prompt([
+        {
+            type: "input",
+            name: "num",
+            message,
+            validate: (v) => !isNaN(parseInt(v)) || "Must be a number",
+        },
+    ]);
+    return { [op]: parseInt(num) };
+}
+async function buildCountStage() {
+    const { field } = await inquirer.prompt([
+        { type: "input", name: "field", message: "Count output field name:", default: "count" },
+    ]);
+    return { $count: field };
+}
+async function buildRawStage(op) {
+    const { json } = await inquirer.prompt([
+        { type: "input", name: "json", message: `${op} body (JSON):` },
+    ]);
+    try {
+        return { [op]: JSON.parse(json) };
+    }
+    catch (_a) {
+        console.log(chalk.red("  Invalid JSON — stage skipped"));
+        return null;
+    }
+}
+async function buildFullRawStage() {
+    const { json } = await inquirer.prompt([
+        { type: "input", name: "json", message: "Full stage (JSON object):" },
+    ]);
+    try {
+        return JSON.parse(json);
+    }
+    catch (_a) {
+        console.log(chalk.red("  Invalid JSON — stage skipped"));
+        return null;
+    }
+}
+function coerceValue(val, isNumber, isDate) {
+    if (val === "true")
+        return true;
+    if (val === "false")
+        return false;
+    if (val === "null")
+        return null;
+    if (isNumber && !isNaN(Number(val)))
+        return Number(val);
+    if (isDate && !isNaN(Date.parse(val)))
+        return { $date: val };
+    return val;
+}

package/lib/commands/aggregate/exec.js

@@ -0,0 +1,51 @@
+// `ay aggregate exec <slugOrId>` — execute a saved query by slug or ObjectId.
+//
+// Two-step lookup when given a slug: first GET /config/queries?slug=... to
+// resolve the query's _id, then POST /aggregation/queries/execute/{id}. When
+// given an ObjectId directly we skip the lookup. Returned `wrapAggResult`
+// shape so output formatting matches `ay agg run`.
+import { apiCallHandler } from "../../api/apiCallHandler.js";
+import { handleResponseFormatOptions } from "../../helpers/handleResponseFormatOptions.js";
+import { spinner } from "../../../index.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { cliError } from "../../helpers/cliError.js";
+import { wrapAggResult } from "./_shared.js";
+export function addExecSubcommand(agg, rootProgram) {
+    agg
+        .command("exec <slugOrId>")
+        .description("Execute a saved query by slug name or ObjectId")
+        .addHelpText("after", `
+Examples:
+  ay agg exec monthly-revenue -r table
+  ay agg exec 507f1f77bcf86cd799439011 -r json --quiet`)
+        .action(async (slugOrId, options) => {
+        var _a, _b, _c, _d;
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            const isObjectId = /^[a-f0-9]{24}$/i.test(slugOrId);
+            spinner.start({ text: `Executing query "${slugOrId}"...`, color: "magenta" });
+            let queryId = slugOrId;
+            if (!isObjectId) {
+                // Resolve slug to ID via config-api
+                const lookup = await apiCallHandler("config", "queries", "get", null, {
+                    slug: slugOrId,
+                    limit: 1,
+                    responseFormat: "json",
+                });
+                const entries = lookup === null || lookup === void 0 ? void 0 : lookup.payload;
+                if (!entries || (Array.isArray(entries) && entries.length === 0)) {
+                    cliError(`No query found with slug "${slugOrId}"`, EXIT_GENERAL_ERROR);
+                }
+                queryId = Array.isArray(entries) ? entries[0]._id : entries._id;
+            }
+            const res = await apiCallHandler("aggregation", `queries/execute/${queryId}`, "post");
+            const wrapped = wrapAggResult(res);
+            handleResponseFormatOptions(opts, wrapped);
+            const count = (_d = (_b = (_a = wrapped.meta) === null || _a === void 0 ? void 0 : _a.resultCount) !== null && _b !== void 0 ? _b : (_c = wrapped.payload) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : "?";
+            spinner.success({ text: `Query returned ${count} results` });
+        }
+        catch (e) {
+            cliError(e.message || "Query execution failed", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/aggregate/index.js

@@ -0,0 +1,38 @@
+// `ay aggregate` parent command — aggregator for the seven aggregation
+// subcommands. Each subcommand lives in its own file in this directory; this
+// file just instantiates the parent and wires the children.
+//
+// Why split: the original `createAggregateCommand.ts` was 720 lines with all
+// seven subcommands inline + the wizard's stage builders. The split makes
+// each subcommand independently readable, makes the wizard's complex
+// stage-builder logic easy to find, and lets `ay agg run` skip the import
+// cost of inquirer + every stage builder it doesn't need.
+import { addRunSubcommand } from "./run.js";
+import { addExecSubcommand } from "./exec.js";
+import { addListSubcommand } from "./list.js";
+import { addSaveSubcommand } from "./save.js";
+import { addValidateSubcommand } from "./validate.js";
+import { addModelsSubcommand } from "./models.js";
+import { addWizardSubcommand } from "./wizard.js";
+export function createAggregateCommand(program) {
+    const agg = program
+        .command("aggregate")
+        .alias("agg")
+        .description("Run MongoDB aggregation pipelines, manage saved queries, and explore models")
+        .addHelpText("after", `
+Examples:
+  ay agg run consumers --pipeline '[{"$count":"total"}]'
+  ay agg wizard
+  ay agg exec monthly-revenue -r table
+  ay agg list
+  ay agg save --name "Active Users" --model consumers --pipeline '[{"$match":{"status":"active"}}]'
+  ay agg validate --pipeline '[{"$group":{"_id":"$type","count":{"$sum":1}}}]'
+  ay agg models consumers`);
+    addRunSubcommand(agg, program);
+    addExecSubcommand(agg, program);
+    addListSubcommand(agg, program);
+    addSaveSubcommand(agg, program);
+    addValidateSubcommand(agg, program);
+    addModelsSubcommand(agg, program);
+    addWizardSubcommand(agg, program);
+}

package/lib/commands/aggregate/list.js

@@ -0,0 +1,43 @@
+// `ay aggregate list` — list saved aggregation queries via config-api.
+//
+// Saved queries live in the `queries` collection on config-api. We filter by
+// `dataSource.source=aggregation` so only aggregation-flavored queries
+// surface (config-api also stores SQL/REST queries which would otherwise
+// pollute the listing).
+import { apiCallHandler } from "../../api/apiCallHandler.js";
+import { handleResponseFormatOptions } from "../../helpers/handleResponseFormatOptions.js";
+import { spinner } from "../../../index.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { cliError } from "../../helpers/cliError.js";
+export function addListSubcommand(agg, rootProgram) {
+    agg
+        .command("list")
+        .alias("ls")
+        .description("List saved aggregation queries")
+        .option("-l, --limit <number>", "Limit results", parseInt, 50)
+        .option("-p, --page <number>", "Page number", parseInt, 1)
+        .option("--search <term>", "Search by name")
+        .action(async (options) => {
+        var _a, _b, _c, _d, _e;
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            spinner.start({ text: "Fetching queries...", color: "magenta" });
+            const params = {
+                page: opts.page,
+                limit: opts.limit,
+                responseFormat: opts.responseFormat,
+                verbosity: opts.verbosity,
+                "dataSource.source": "aggregation",
+            };
+            if (opts.search)
+                params.q = opts.search;
+            const res = await apiCallHandler("config", "queries", "get", null, params);
+            handleResponseFormatOptions(opts, res);
+            const total = (_e = (_c = (_b = (_a = res.meta) === null || _a === void 0 ? void 0 : _a.pageInfo) === null || _b === void 0 ? void 0 : _b.totalEntries) !== null && _c !== void 0 ? _c : (_d = res.payload) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0;
+            spinner.success({ text: `Found ${total} queries` });
+        }
+        catch (e) {
+            cliError(e.message || "Failed to list queries", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/aggregate/models.js

@@ -0,0 +1,43 @@
+// `ay aggregate models [model]` — discover aggregation models and their fields.
+//
+// Without an argument, lists all models the user has access to. With a model
+// name, returns the field schema (name, type, ref, required) for that model
+// — used by the wizard to populate field-selection prompts, but also useful
+// standalone for ad-hoc exploration.
+import { apiCallHandler } from "../../api/apiCallHandler.js";
+import { handleResponseFormatOptions } from "../../helpers/handleResponseFormatOptions.js";
+import { spinner } from "../../../index.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { cliError } from "../../helpers/cliError.js";
+export function addModelsSubcommand(agg, rootProgram) {
+    agg
+        .command("models [model]")
+        .description("List available models, or show fields for a specific model")
+        .addHelpText("after", `
+Examples:
+  ay agg models                  List all available models
+  ay agg models consumers        Show fields for Consumers`)
+        .action(async (model, options) => {
+        var _a, _b, _c, _d, _e;
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            if (model) {
+                spinner.start({ text: `Loading fields for ${model}...`, color: "magenta" });
+                const res = await apiCallHandler("aggregation", `models/${model}/fields`, "get");
+                handleResponseFormatOptions(opts, res);
+                const fieldCount = (_c = (_b = (_a = res.payload) === null || _a === void 0 ? void 0 : _a.fields) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;
+                spinner.success({ text: `${model}: ${fieldCount} fields` });
+            }
+            else {
+                spinner.start({ text: "Loading models...", color: "magenta" });
+                const res = await apiCallHandler("aggregation", "models", "get");
+                handleResponseFormatOptions(opts, res);
+                const count = (_e = (_d = res.payload) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0;
+                spinner.success({ text: `${count} models available` });
+            }
+        }
+        catch (e) {
+            cliError(e.message || "Failed to load models", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/aggregate/run.js

@@ -0,0 +1,53 @@
+// `ay aggregate run <model>` — execute a pipeline against a specific model.
+//
+// The pipeline can come from --pipeline (JSON string), --file (path), or
+// stdin. `readPipelineInput` handles all three. We POST to `/aggregation/{model}`
+// with the pipeline as the body and surface optional flags (--global,
+// --replace, --resultAsObject, --random) via query params.
+import { apiCallHandler } from "../../api/apiCallHandler.js";
+import { handleResponseFormatOptions } from "../../helpers/handleResponseFormatOptions.js";
+import { spinner } from "../../../index.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { cliError } from "../../helpers/cliError.js";
+import { readPipelineInput } from "../../helpers/readPipelineInput.js";
+import { wrapAggResult } from "./_shared.js";
+export function addRunSubcommand(agg, rootProgram) {
+    agg
+        .command("run <model>")
+        .description("Execute an aggregation pipeline on a model")
+        .option("--pipeline <json>", "Pipeline as JSON array string")
+        .option("--file <path>", "Read pipeline from a JSON file")
+        .option("--global", "Skip tenant filter (superuser only)")
+        .option("--replace", "Enable template variable replacement")
+        .option("--resultAsObject", "Return result as single object")
+        .option("--random", "Return one random result")
+        .addHelpText("after", `
+Examples:
+  ay agg run consumers --pipeline '[{"$match":{"status":"active"}},{"$count":"total"}]'
+  ay agg run orders --file pipeline.json -r table
+  cat pipeline.json | ay agg run products`)
+        .action(async (model, options) => {
+        var _a, _b;
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            const pipeline = await readPipelineInput(opts);
+            spinner.start({ text: `Executing pipeline on ${model}...`, color: "magenta" });
+            const params = {};
+            if (opts.global)
+                params.global = true;
+            if (opts.replace)
+                params.replace = true;
+            if (opts.resultAsObject)
+                params.resultAsObject = true;
+            if (opts.random)
+                params.random = true;
+            const res = await apiCallHandler("aggregation", model, "post", pipeline, params);
+            const wrapped = wrapAggResult(res);
+            handleResponseFormatOptions(opts, wrapped);
+            spinner.success({ text: `Pipeline returned ${(_b = (_a = wrapped.meta) === null || _a === void 0 ? void 0 : _a.resultCount) !== null && _b !== void 0 ? _b : "?"} results` });
+        }
+        catch (e) {
+            cliError(e.message || "Pipeline execution failed", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/aggregate/save.js

@@ -0,0 +1,53 @@
+// `ay aggregate save` — persist a pipeline as a reusable query in config-api.
+//
+// The query body wraps the pipeline JSON inside the `dataSource` shape that
+// the config-api `queries` collection expects (source = "aggregation",
+// aggregationModel = the target model name, aggregationPipeline = the
+// pipeline serialized as a JSON string). Caching is disabled by default
+// because the wizard / one-off `save` flow shouldn't memoize results
+// silently — users can flip caching on later via the web UI or `ay edit`.
+import { apiCallHandler } from "../../api/apiCallHandler.js";
+import { handleResponseFormatOptions } from "../../helpers/handleResponseFormatOptions.js";
+import { spinner } from "../../../index.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { cliError } from "../../helpers/cliError.js";
+import { readPipelineInput } from "../../helpers/readPipelineInput.js";
+export function addSaveSubcommand(agg, rootProgram) {
+    agg
+        .command("save")
+        .description("Save a pipeline as a reusable query")
+        .requiredOption("--name <name>", "Query name")
+        .requiredOption("--model <model>", "Aggregation model name")
+        .option("--pipeline <json>", "Pipeline as JSON array string")
+        .option("--file <path>", "Read pipeline from a JSON file")
+        .addHelpText("after", `
+Examples:
+  ay agg save --name "Monthly Revenue" --model orders --pipeline '[{"$group":{"_id":null,"total":{"$sum":"$amount"}}}]'
+  ay agg save --name "Active Users" --model consumers --file pipeline.json`)
+        .action(async (options) => {
+        var _a, _b;
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            const pipeline = await readPipelineInput(opts);
+            spinner.start({ text: "Saving query...", color: "magenta" });
+            const body = {
+                name: opts.name,
+                dataSource: {
+                    source: "aggregation",
+                    aggregationModel: opts.model,
+                    aggregationPipeline: JSON.stringify(pipeline),
+                },
+                cache: { enabled: false },
+            };
+            const res = await apiCallHandler("config", "queries", "post", body, {
+                responseFormat: opts.responseFormat,
+            });
+            handleResponseFormatOptions(opts, res);
+            const slug = ((_a = res.payload) === null || _a === void 0 ? void 0 : _a.slug) || ((_b = res.payload) === null || _b === void 0 ? void 0 : _b.name) || opts.name;
+            spinner.success({ text: `Query saved — run with: ay agg exec ${slug}` });
+        }
+        catch (e) {
+            cliError(e.message || "Failed to save query", EXIT_GENERAL_ERROR);
+        }
+    });
+}

package/lib/commands/aggregate/validate.js

@@ -0,0 +1,47 @@
+// `ay aggregate validate` — server-side validation without execution.
+//
+// Calls `/aggregation/models/validate` which type-checks the pipeline against
+// the model schema and returns `{ valid, stageCount, errors[], warnings[] }`.
+// Useful in CI to lint pipeline JSON files before merging. Exits non-zero if
+// the pipeline is invalid.
+import chalk from "chalk";
+import { apiCallHandler } from "../../api/apiCallHandler.js";
+import { spinner } from "../../../index.js";
+import { EXIT_GENERAL_ERROR } from "../../exitCodes.js";
+import { cliError } from "../../helpers/cliError.js";
+import { readPipelineInput } from "../../helpers/readPipelineInput.js";
+export function addValidateSubcommand(agg, rootProgram) {
+    agg
+        .command("validate")
+        .alias("check")
+        .description("Validate a pipeline without executing")
+        .option("--pipeline <json>", "Pipeline as JSON array string")
+        .option("--file <path>", "Read pipeline from a JSON file")
+        .action(async (options) => {
+        var _a, _b, _c;
+        try {
+            const opts = { ...rootProgram.opts(), ...options };
+            const pipeline = await readPipelineInput(opts);
+            spinner.start({ text: "Validating pipeline...", color: "magenta" });
+            const res = await apiCallHandler("aggregation", "models/validate", "post", { pipeline });
+            spinner.stop();
+            const v = res.payload || res;
+            const icon = v.valid ? chalk.green("✓") : chalk.red("✗");
+            console.log(`\n  ${icon} Pipeline is ${v.valid ? "valid" : "invalid"} (${(_a = v.stageCount) !== null && _a !== void 0 ? _a : pipeline.length} stages)`);
+            if ((_b = v.errors) === null || _b === void 0 ? void 0 : _b.length) {
+                for (const err of v.errors)
+                    console.log(chalk.red(`    - ${err}`));
+            }
+            if ((_c = v.warnings) === null || _c === void 0 ? void 0 : _c.length) {
+                for (const w of v.warnings)
+                    console.log(chalk.yellow(`    ! ${w}`));
+            }
+            console.log();
+            if (!v.valid)
+                process.exit(EXIT_GENERAL_ERROR);
+        }
+        catch (e) {
+            cliError(e.message || "Validation failed", EXIT_GENERAL_ERROR);
+        }
+    });
+}