@get-dx/cli 0.8.0 → 0.10.0

package/dist/commands/catalog/relations.js

@@ -0,0 +1,231 @@
+import { Command } from "commander";
+import { createExampleText, getContext, parsePositiveIntOption, wrapAction, } from "../../commandHelpers.js";
+import { CliError, EXIT_CODES } from "../../errors.js";
+import { request } from "../../http.js";
+import { renderJson } from "../../renderers.js";
+import { buildRuntime } from "../../runtime.js";
+import * as ui from "../../ui.js";
+import { renderRelation, renderRelationDeleted, renderRelationList, } from "./relationsRendering.js";
+const RELATION_TYPES = [
+    "consumes",
+    "depends on",
+    "parent of",
+    "part of",
+    "provides",
+    "manages",
+];
+const RELATION_CARDINALITIES = [
+    "one_to_one",
+    "one_to_many",
+    "many_to_one",
+    "many_to_many",
+];
+const RELATION_TYPE_HELP = `Relation type. One of: ${RELATION_TYPES.map((t) => `"${t}"`).join(", ")}`;
+export function relationsCommand() {
+    const relations = new Command()
+        .name("relations")
+        .description("Manage relation definitions between entity types");
+    relations
+        .command("create")
+        .description("Create a new relation definition between two entity types in your software catalog")
+        .requiredOption("--identifier <identifier>", "Unique identifier for the new relation (required)")
+        .requiredOption("--source-type <type>", "Entity type identifier for the source side of the relation (required)")
+        .requiredOption("--target-type <type>", "Entity type identifier for the target side of the relation (required)")
+        .requiredOption("--type <type>", `${RELATION_TYPE_HELP} (required)`)
+        .requiredOption("--cardinality <cardinality>", `Relation cardinality. One of: ${RELATION_CARDINALITIES.join(", ")} (required)`)
+        .option("--description <desc>", "Description of the relation")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Create a relation between services",
+            command: 'dx catalog relations create --identifier service-depends-on-service --source-type service --target-type service --type "depends on" --cardinality many_to_many',
+        },
+        {
+            label: "Create with a description and return JSON",
+            command: 'dx catalog relations create --identifier service-provides-package --source-type service --target-type package --type provides --cardinality one_to_many --description "Service provides a client SDK" --json',
+        },
+    ]))
+        .action(wrapAction(async (options, command) => {
+        const runtime = await buildRuntime(getContext(command));
+        const response = await createRelation(runtime, {
+            identifier: options.identifier,
+            source_entity_type_identifier: options.sourceType,
+            target_entity_type_identifier: options.targetType,
+            type: options.type,
+            cardinality: options.cardinality,
+            description: options.description,
+        });
+        if (runtime.context.json) {
+            renderJson(response);
+        }
+        else {
+            renderRelation(response.relation, `${ui.success(ui.GLYPHS.CHECK)} Relation created`);
+        }
+    }));
+    relations
+        .command("delete")
+        .description("Delete a relation definition from your software catalog")
+        .argument("<identifier>", "Relation identifier")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Delete the `service-depends-on-service` relation",
+            command: "dx catalog relations delete service-depends-on-service",
+        },
+        {
+            label: "Delete a relation and return JSON",
+            command: "dx catalog relations delete service-depends-on-service --json",
+        },
+    ]))
+        .action(wrapAction(async (identifier, _options, command) => {
+        const runtime = await buildRuntime(getContext(command));
+        const response = await deleteRelation(runtime, identifier);
+        if (runtime.context.json) {
+            renderJson(response);
+        }
+        else {
+            renderRelationDeleted(response.relation);
+        }
+    }));
+    relations
+        .command("info")
+        .description("Get information about a relation definition")
+        .argument("<identifier>", "Relation identifier")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Fetch info for the `service-depends-on-service` relation",
+            command: "dx catalog relations info service-depends-on-service",
+        },
+        {
+            label: "Fetch info and return as JSON",
+            command: "dx catalog relations info service-depends-on-service --json",
+        },
+    ]))
+        .action(wrapAction(async (identifier, _options, command) => {
+        const runtime = await buildRuntime(getContext(command));
+        const response = await getRelation(runtime, identifier);
+        if (runtime.context.json) {
+            renderJson(response);
+        }
+        else {
+            renderRelation(response.relation);
+        }
+    }));
+    relations
+        .command("list")
+        .description("List relation definitions in your software catalog")
+        .option("--cursor <cursor>", "Cursor for the next page of results")
+        .option("--limit <n>", "Max relations per page (default is 25)", (value) => parsePositiveIntOption(value, "--limit"))
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "List the first page of relations",
+            command: "dx catalog relations list",
+        },
+        {
+            label: "List with a limit and return JSON",
+            command: "dx catalog relations list --limit 10 --json",
+        },
+        {
+            label: "Fetch the next page using a cursor from the prior response",
+            command: "dx catalog relations list --cursor avsgf30ccan3",
+        },
+    ]))
+        .action(wrapAction(async (options, command) => {
+        const runtime = await buildRuntime(getContext(command));
+        const response = await listRelations(runtime, {
+            cursor: options.cursor,
+            limit: options.limit,
+        });
+        if (runtime.context.json) {
+            renderJson(response);
+        }
+        else {
+            renderRelationList(response.relations, response.response_metadata?.next_cursor ?? null);
+        }
+    }));
+    relations
+        .command("update")
+        .description("Update a relation definition. The identifier, source and target entity types, and cardinality cannot be changed.")
+        .argument("<identifier>", "Relation identifier")
+        .option("--type <type>", RELATION_TYPE_HELP)
+        .option("--description <desc>", "Description of the relation")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Update a relation's description",
+            command: 'dx catalog relations update service-depends-on-service --description "Runtime dependencies between services"',
+        },
+        {
+            label: "Change the relation type and return JSON",
+            command: "dx catalog relations update service-provides-package --type provides --json",
+        },
+    ]))
+        .action(wrapAction(async (identifier, options, command) => {
+        if (options.type === undefined && options.description === undefined) {
+            throw new CliError("Provide at least one of --type or --description to update", EXIT_CODES.ARGUMENT_ERROR);
+        }
+        const runtime = await buildRuntime(getContext(command));
+        const response = await updateRelation(runtime, identifier, {
+            type: options.type,
+            description: options.description,
+        });
+        if (runtime.context.json) {
+            renderJson(response);
+        }
+        else {
+            renderRelation(response.relation, `${ui.success(ui.GLYPHS.CHECK)} Relation updated`);
+        }
+    }));
+    return relations;
+}
+async function createRelation(runtime, params) {
+    const body = {
+        identifier: params.identifier,
+        source_entity_type_identifier: params.source_entity_type_identifier,
+        target_entity_type_identifier: params.target_entity_type_identifier,
+        type: params.type,
+        cardinality: params.cardinality,
+    };
+    if (params.description !== undefined)
+        body.description = params.description;
+    const response = await request(runtime, "/catalog.relations.create", {
+        method: "POST",
+        body,
+    });
+    return response.body;
+}
+async function deleteRelation(runtime, identifier) {
+    const response = await request(runtime, "/catalog.relations.delete", {
+        method: "POST",
+        query: { identifier },
+    });
+    return response.body;
+}
+async function getRelation(runtime, identifier) {
+    const response = await request(runtime, "/catalog.relations.info", {
+        method: "GET",
+        query: { identifier },
+    });
+    return response.body;
+}
+async function listRelations(runtime, params) {
+    const query = {};
+    if (params.cursor !== undefined)
+        query.cursor = params.cursor;
+    if (params.limit !== undefined)
+        query.limit = params.limit;
+    const response = await request(runtime, "/catalog.relations.list", {
+        method: "GET",
+        query,
+    });
+    return response.body;
+}
+async function updateRelation(runtime, identifier, params) {
+    const body = { identifier };
+    if (params.type !== undefined)
+        body.type = params.type;
+    if (params.description !== undefined)
+        body.description = params.description;
+    const response = await request(runtime, "/catalog.relations.update", {
+        method: "POST",
+        body,
+    });
+    return response.body;
+}

package/dist/commands/catalog/relationsRendering.js

@@ -0,0 +1,37 @@
+import { renderRichText } from "../../renderers.js";
+import * as ui from "../../ui.js";
+export function renderRelationList(relations, nextCursor) {
+    const blocks = [ui.h1("Relations")];
+    blocks.push(ui.p(`Displaying ${ui.bold(relations.length.toString())} relations.`));
+    if (nextCursor) {
+        blocks.push(ui.p(`Next cursor: ${ui.code(nextCursor)}`));
+    }
+    for (const relation of relations) {
+        blocks.push(ui.h2(ui.code(relation.identifier)));
+        blocks.push(...relationContent(relation));
+    }
+    renderRichText(blocks);
+}
+export function renderRelation(relation, title = "Relation Information") {
+    renderRichText([ui.h1(title), ...relationContent(relation)]);
+}
+export function renderRelationDeleted(relation) {
+    renderRichText([
+        ui.h1(`${ui.success(ui.GLYPHS.CHECK)} Relation deleted`),
+        ui.p(`The relation ${ui.code(relation.identifier)} has been deleted.`),
+    ]);
+}
+function relationContent(relation) {
+    return [
+        ui.dl([
+            ui.dli("Identifier", ui.code(relation.identifier)),
+            ui.dli("Relation", `${ui.code(relation.source_entity_type_identifier)} ${relation.type} ${ui.code(relation.target_entity_type_identifier)}`),
+            ui.dli("Type", relation.type),
+            ui.dli("Inverse type", relation.inverse_type),
+            ui.dli("Cardinality", ui.code(relation.cardinality)),
+            ui.dli("Description", relation.description || ui.dim("(None)")),
+            ui.dli("Created", ui.timestampSummary(relation.created_at)),
+            ui.dli("Last updated", ui.timestampSummary(relation.updated_at)),
+        ], { termWidth: 15 }),
+    ];
+}

package/dist/commands/catalog.js

@@ -1,11 +1,15 @@
 import { Command } from "commander";
 import { entitiesCommand } from "./catalog/entities.js";
 import { entityTypesCommand } from "./catalog/entityTypes.js";
+import { relationEdgesCommand } from "./catalog/relationEdges.js";
+import { relationsCommand } from "./catalog/relations.js";
 export function catalogCommand() {
     const catalog = new Command()
         .name("catalog")
         .description("Manage the Software Catalog");
     catalog.addCommand(entitiesCommand());
     catalog.addCommand(entityTypesCommand());
+    catalog.addCommand(relationEdgesCommand());
+    catalog.addCommand(relationsCommand());
     return catalog;
 }

package/dist/commands/doctor.js

@@ -0,0 +1,85 @@
+import { Command } from "commander";
+import { createExampleText, getContext, wrapAction, } from "../commandHelpers.js";
+import { runDoctor } from "../doctor/index.js";
+import { AsyncProgressReporter, renderJson, renderRichText, } from "../renderers.js";
+import * as ui from "../ui.js";
+const MIN_LABEL_WIDTH = 26;
+const PHASE_MESSAGES = {
+    config: "Checking configuration…",
+    network: "Checking network…",
+    auth: "Checking authentication…",
+    version: "Checking for updates…",
+};
+export function doctorCommand() {
+    return new Command("doctor")
+        .description("Diagnose problems with your CLI instance's installation, configuration, networking, and authentication")
+        .addHelpText("afterAll", createExampleText([
+        { label: "Check your setup", command: "dx doctor" },
+        { label: "Print the report as JSON", command: "dx doctor --json" },
+    ]))
+        .action(wrapAction(async (_options, command) => {
+        const context = getContext(command);
+        const progress = new AsyncProgressReporter();
+        progress.start(PHASE_MESSAGES.config);
+        let report;
+        try {
+            report = await runDoctor(context, {
+                onPhase: (phase) => progress.update(PHASE_MESSAGES[phase]),
+            });
+        }
+        finally {
+            progress.stop();
+        }
+        if (context.json) {
+            renderJson(report);
+        }
+        else {
+            renderDoctorReport(report);
+        }
+        if (!report.ok) {
+            process.exitCode = 1;
+        }
+    }));
+}
+export function renderDoctorReport(report) {
+    const labelWidth = Math.max(MIN_LABEL_WIDTH, ...report.sections.flatMap((section) => section.checks.map((check) => check.label.length + 2)));
+    renderRichText([
+        ...report.sections.map((section) => ui.statusList(section.title, section.checks.map((check) => ({
+            status: check.status,
+            label: check.label,
+            detail: formatDetail(check),
+            hint: check.hint,
+        })), { labelWidth })),
+        ui.p(summaryLine(report)),
+    ]);
+}
+function formatDetail(check) {
+    if (!check.source) {
+        return check.message;
+    }
+    return `${check.message} ${ui.dim(`[from ${sourceName(check.source)}]`)}`;
+}
+function sourceName(source) {
+    switch (source) {
+        case "env":
+            return "env";
+        case "config":
+            return "config file";
+        case "default":
+            return "default";
+        case "keychain":
+            return "keychain";
+    }
+}
+function summaryLine(report) {
+    const { fail, warn } = report.summary;
+    const plural = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+    if (fail > 0) {
+        const failed = ui.error(`${plural(fail, "check")} failed`);
+        return warn > 0 ? `${failed}, ${plural(warn, "warning")}.` : `${failed}.`;
+    }
+    if (warn > 0) {
+        return ui.warning(`All required checks passed, ${plural(warn, "warning")}.`);
+    }
+    return ui.success("All checks passed.");
+}