@get-dx/cli 0.2.0 → 0.2.1

package/dist/cli.js

@@ -5,6 +5,7 @@ import { initCommand } from "./commands/init.js";
 import { scorecardsCommand } from "./commands/scorecards.js";
 import { studioCommand } from "./commands/studio.js";
 import { teamsCommand } from "./commands/teams.js";
+import { workflowsCommand } from "./commands/workflows.js";
 import { handleError } from "./commandHelpers.js";
 import cliPackage from "../package.json" with { type: "json" };
 export async function run(argv = process.argv) {
@@ -35,6 +36,7 @@ function createProgram() {
     program.addCommand(scorecardsCommand());
     program.addCommand(studioCommand());
     program.addCommand(teamsCommand());
+    program.addCommand(workflowsCommand());
     applyExitOverride(program);
     return program;
 }

package/dist/commands/catalog/entities.js

@@ -21,6 +21,7 @@ export function entitiesCommand() {
         .option("--owner-team-ids <ids>", "Comma-separated owner team IDs")
         .option("--owner-user-ids <ids>", "Comma-separated owner user IDs")
         .option("--property <kv>", "Set a property value as key=value. Repeat for multiple properties.", (val, prev) => [...prev, val], [])
+        .option("--alias <kv>", "Set an alias value as key=value. Repeat for multiple aliases.", (val, prev) => [...prev, val], [])
         .addHelpText("afterAll", createExampleText([
         {
             label: "Create a new service entity",
@@ -38,6 +39,10 @@ export function entitiesCommand() {
             label: "Create with properties",
             command: 'dx catalog entities create --type service --identifier my-service --property tier=Tier-1 --property "languages=Ruby,TypeScript"',
         },
+        {
+            label: "Create with aliases",
+            command: "dx catalog entities create --type service --identifier my-service --alias github_repo=12345",
+        },
     ]))
         .action(wrapAction(async (options, command) => {
         if (!options.identifier) {
@@ -47,7 +52,7 @@ export function entitiesCommand() {
             throw new CliError("--type is required", EXIT_CODES.ARGUMENT_ERROR);
         }
         const runtime = buildRuntime(getContext(command));
-        const properties = await resolvePropertiesForEntityType(runtime, options.type, options.property);
+        const resolvedValues = await resolveValuesForEntityType(runtime, options.type, options.property, options.alias);
         const response = await createEntity(runtime, options.identifier, {
             type: options.type,
             name: options.name,
@@ -58,7 +63,7 @@ export function entitiesCommand() {
             owner_user_ids: options.ownerUserIds
                 ?.split(",")
                 .map((s) => s.trim()),
-            properties,
+            ...resolvedValues,
         });
         if (runtime.context.json) {
             renderJson(response);
@@ -100,6 +105,7 @@ export function entitiesCommand() {
         .option("--owner-team-ids <ids>", "Comma-separated owner team IDs")
         .option("--owner-user-ids <ids>", "Comma-separated owner user IDs")
         .option("--property <kv>", "Set a property value as key=value. Repeat for multiple properties. Use value null to remove a property.", (val, prev) => [...prev, val], [])
+        .option("--alias <kv>", "Set an alias value as key=value. Repeat for multiple aliases. Use value null to remove an alias.", (val, prev) => [...prev, val], [])
         .addHelpText("afterAll", createExampleText([
         {
             label: "Rename an entity",
@@ -113,13 +119,17 @@ export function entitiesCommand() {
             label: "Update properties",
             command: 'dx catalog entities update my-service --property tier=Tier-1 --property "languages=Ruby,TypeScript"',
         },
+        {
+            label: "Update aliases",
+            command: "dx catalog entities update my-service --alias github_repo=12345",
+        },
     ]))
         .action(wrapAction(async (identifier, options, command) => {
         const runtime = buildRuntime(getContext(command));
-        const properties = await resolvePropertiesForExistingEntity(runtime, identifier, options.property);
+        const resolvedValues = await resolveValuesForExistingEntity(runtime, identifier, options.property, options.alias);
         const response = await updateEntity(runtime, identifier, {
             ...getEntityMutationOptionValues(options),
-            properties,
+            ...resolvedValues,
         });
         if (runtime.context.json) {
             renderJson(response);
@@ -138,6 +148,7 @@ export function entitiesCommand() {
         .option("--owner-team-ids <ids>", "Comma-separated owner team IDs")
         .option("--owner-user-ids <ids>", "Comma-separated owner user IDs")
         .option("--property <kv>", "Set a property value as key=value. Repeat for multiple properties. Use value null to remove a property.", (val, prev) => [...prev, val], [])
+        .option("--alias <kv>", "Set an alias value as key=value. Repeat for multiple aliases. Use value null to remove an alias.", (val, prev) => [...prev, val], [])
         .addHelpText("afterAll", createExampleText([
         {
             label: "Create a new service entity if it does not exist",
@@ -151,6 +162,10 @@ export function entitiesCommand() {
             label: "Set properties while preserving omitted fields",
             command: 'dx catalog entities upsert --type service --identifier my-service --property tier=Tier-1 --property "languages=Ruby,TypeScript"',
         },
+        {
+            label: "Set aliases while preserving omitted fields",
+            command: "dx catalog entities upsert --type service --identifier my-service --alias github_repo=12345",
+        },
     ]))
         .action(wrapAction(async (options, command) => {
         if (!options.type) {
@@ -160,11 +175,11 @@ export function entitiesCommand() {
             throw new CliError("--identifier is required", EXIT_CODES.ARGUMENT_ERROR);
         }
         const runtime = buildRuntime(getContext(command));
-        const properties = await resolvePropertiesForEntityType(runtime, options.type, options.property);
+        const resolvedValues = await resolveValuesForEntityType(runtime, options.type, options.property, options.alias);
         const response = await upsertEntity(runtime, options.identifier, {
             type: options.type,
             ...getEntityMutationOptionValues(options),
-            properties,
+            ...resolvedValues,
         });
         if (runtime.context.json) {
             renderJson(response);
@@ -459,6 +474,33 @@ export function parsePropertyValue(prop, rawValue) {
             return rawValue;
     }
 }
+function parseEntityAliases(entityTypeIdentifier, rawAliases, knownAliases) {
+    const aliasKeys = Object.keys(knownAliases);
+    const aliasSet = new Set(aliasKeys);
+    const result = {};
+    for (const kv of rawAliases) {
+        const eqIndex = kv.indexOf("=");
+        if (eqIndex === -1) {
+            throw new CliError(`Invalid --alias "${kv}": expected format key=value`, EXIT_CODES.ARGUMENT_ERROR);
+        }
+        const key = kv.slice(0, eqIndex);
+        const rawValue = kv.slice(eqIndex + 1);
+        if (!aliasSet.has(key)) {
+            const availableAliases = aliasKeys
+                .sort()
+                .map((k) => `\`${k}\``)
+                .join(", ");
+            const availableAliasesText = availableAliases.length > 0 ? availableAliases : "(none)";
+            throw new CliError(`Unknown alias \`${key}\` for entity type \`${entityTypeIdentifier}\`. Available aliases: ${availableAliasesText}`, EXIT_CODES.ARGUMENT_ERROR);
+        }
+        if (rawValue === "null") {
+            result[key] = [];
+            continue;
+        }
+        result[key] = [...(result[key] ?? []), { identifier: rawValue }];
+    }
+    return result;
+}
 // --- Include helpers ---
 const ENTITY_INCLUDE_SECTIONS = [
     "core",
@@ -487,22 +529,31 @@ function parseIncludeSections(include) {
     }
     return results;
 }
-async function resolvePropertiesForEntityType(runtime, entityTypeIdentifier, rawProperties) {
-    if (rawProperties.length === 0) {
-        return undefined;
+async function resolveValuesForEntityType(runtime, entityTypeIdentifier, rawProperties, rawAliases) {
+    if (rawProperties.length === 0 && rawAliases.length === 0) {
+        return {};
     }
     let entityTypeResponse;
     try {
         entityTypeResponse = await getEntityType(runtime, entityTypeIdentifier);
     }
     catch (err) {
-        throw wrapEntityTypeLookupError(entityTypeIdentifier, err);
+        throw wrapEntityTypeLookupError(entityTypeIdentifier, err, rawAliases.length > 0
+            ? "resolve property and alias values"
+            : "resolve property types");
+    }
+    const values = {};
+    if (rawProperties.length > 0) {
+        values.properties = parseEntityProperties(entityTypeIdentifier, rawProperties, entityTypeResponse.entity_type.properties);
     }
-    return parseEntityProperties(entityTypeIdentifier, rawProperties, entityTypeResponse.entity_type.properties);
+    if (rawAliases.length > 0) {
+        values.aliases = parseEntityAliases(entityTypeIdentifier, rawAliases, entityTypeResponse.entity_type.aliases);
+    }
+    return values;
 }
-async function resolvePropertiesForExistingEntity(runtime, identifier, rawProperties) {
-    if (rawProperties.length === 0) {
-        return undefined;
+async function resolveValuesForExistingEntity(runtime, identifier, rawProperties, rawAliases) {
+    if (rawProperties.length === 0 && rawAliases.length === 0) {
+        return {};
     }
     let entityResponse;
     try {
@@ -512,9 +563,23 @@ async function resolvePropertiesForExistingEntity(runtime, identifier, rawProper
         const exitCode = err instanceof HttpError && err.status !== undefined && err.status < 500
             ? EXIT_CODES.ARGUMENT_ERROR
             : EXIT_CODES.RETRY_RECOMMENDED;
-        throw new CliError(`Failed to fetch entity "${identifier}" to resolve property types: ${err instanceof Error ? err.message : String(err)}`, exitCode);
+        throw new CliError(`Failed to fetch entity "${identifier}" to resolve property and alias values: ${err instanceof Error ? err.message : String(err)}`, exitCode);
+    }
+    let entityTypeResponse;
+    try {
+        entityTypeResponse = await getEntityType(runtime, entityResponse.entity.type);
+    }
+    catch (err) {
+        throw wrapEntityTypeLookupError(entityResponse.entity.type, err, "resolve property and alias values");
+    }
+    const values = {};
+    if (rawProperties.length > 0) {
+        values.properties = parseEntityProperties(entityResponse.entity.type, rawProperties, entityTypeResponse.entity_type.properties);
+    }
+    if (rawAliases.length > 0) {
+        values.aliases = parseEntityAliases(entityResponse.entity.type, rawAliases, entityTypeResponse.entity_type.aliases);
     }
-    return resolvePropertiesForEntityType(runtime, entityResponse.entity.type, rawProperties);
+    return values;
 }
 function getEntityMutationOptionValues(options) {
     return {
@@ -549,13 +614,15 @@ function buildEntityMutationBody(identifier, params) {
         body.owner_user_ids = params.owner_user_ids;
     if (params.properties !== undefined)
         body.properties = params.properties;
+    if (params.aliases !== undefined)
+        body.aliases = params.aliases;
     return body;
 }
-function wrapEntityTypeLookupError(entityTypeIdentifier, err) {
+function wrapEntityTypeLookupError(entityTypeIdentifier, err, purpose = "resolve property types") {
     const exitCode = err instanceof HttpError && err.status !== undefined && err.status < 500
         ? EXIT_CODES.ARGUMENT_ERROR
         : EXIT_CODES.RETRY_RECOMMENDED;
-    return new CliError(`Failed to fetch entity type "${entityTypeIdentifier}" to resolve property types: ${err instanceof Error ? err.message : String(err)}`, exitCode);
+    return new CliError(`Failed to fetch entity type "${entityTypeIdentifier}" to ${purpose}: ${err instanceof Error ? err.message : String(err)}`, exitCode);
 }
 function uniqueSectionsInOrder(sections) {
     const seen = new Set();

package/dist/commands/scorecardsRendering.js

@@ -97,7 +97,7 @@ function entityFilterContent(scorecard) {
     else if (scorecard.entity_filter_type === "sql") {
         blocks.push(ui.p(`Filter: ${ui.code("sql")}`));
         if (scorecard.entity_filter_sql) {
-            blocks.push(truncatedSqlBlock(scorecard.entity_filter_sql));
+            blocks.push(ui.truncatedSqlBlock(scorecard.entity_filter_sql));
         }
         else {
             blocks.push(ui.p(ui.dim("(No SQL provided)")));
@@ -190,7 +190,7 @@ function checkContent(check, scorecardType) {
     }
     // Query
     blocks.push(ui.p(ui.bold("Query:")));
-    blocks.push(truncatedSqlBlock(check.sql));
+    blocks.push(ui.truncatedSqlBlock(check.sql));
     // Output settings
     if (check.output_enabled) {
         const outputParts = [`Output: ${ui.code(check.output_type ?? "unknown")}`];
@@ -202,18 +202,10 @@ function checkContent(check, scorecardType) {
     // Entity filter
     if (check.filter_sql) {
         blocks.push(ui.p(ui.bold("Entity filter:")));
-        blocks.push(truncatedSqlBlock(check.filter_sql));
+        blocks.push(ui.truncatedSqlBlock(check.filter_sql));
         if (check.filter_message) {
             blocks.push(ui.p(`Excluded message: ${ui.dim(check.filter_message)}`, false));
         }
     }
     return blocks;
 }
-function truncatedSqlBlock(sql) {
-    const lines = sql.split("\n");
-    const firstLine = lines[0];
-    const isLong = firstLine.length > 80 || lines.length > 1;
-    const truncated = firstLine.length > 80 ? firstLine.slice(0, 80) : firstLine;
-    const display = isLong ? truncated + ui.dim(" …") : truncated;
-    return ui.p(ui.code(display));
-}

package/dist/commands/workflows.js

@@ -0,0 +1,82 @@
+import { Command } from "commander";
+import { createExampleText, getContext, 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 { renderWorkflowList } from "./workflowsRendering.js";
+const WORKFLOW_SCOPES = ["GLOBAL", "ENTITY"];
+export function workflowsCommand() {
+    const workflows = new Command()
+        .name("workflows")
+        .description("Manage Self-service workflow definitions");
+    workflows
+        .command("list")
+        .description("List Self-service workflows for the account")
+        .option("--scope <scope>", "Filter by workflow scope: GLOBAL or ENTITY (omit for both)")
+        .option("--entity-identifier <id>", "Catalog entity identifier; must be used with --scope ENTITY")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "List workflows the token can trigger",
+            command: "dx workflows list",
+        },
+        {
+            label: "Entity-scoped workflows for a catalog entity",
+            command: "dx workflows list --scope ENTITY --entity-identifier acme-app",
+        },
+        {
+            label: "Same request as JSON",
+            command: "dx --json workflows list --scope ENTITY --entity-identifier acme-app",
+        },
+    ]))
+        .action(wrapAction(async (options, command) => {
+        const scope = parseOptionalScope(options.scope);
+        const entityIdentifier = parseOptionalTrimmed(options.entityIdentifier);
+        if (entityIdentifier && scope !== "ENTITY") {
+            throw new CliError("--entity-identifier requires --scope ENTITY", EXIT_CODES.ARGUMENT_ERROR);
+        }
+        const runtime = buildRuntime(getContext(command));
+        const response = await listWorkflows(runtime, {
+            scope,
+            entity_identifier: entityIdentifier,
+        });
+        if (runtime.context.json) {
+            renderJson(response);
+        }
+        else {
+            renderWorkflowList(response.workflows);
+        }
+    }));
+    return workflows;
+}
+function parseOptionalTrimmed(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const t = value.trim();
+    return t.length > 0 ? t : undefined;
+}
+function parseOptionalScope(value) {
+    const raw = parseOptionalTrimmed(value);
+    if (raw === undefined) {
+        return undefined;
+    }
+    if (!WORKFLOW_SCOPES.includes(raw)) {
+        throw new CliError(`--scope must be one of: ${WORKFLOW_SCOPES.join(", ")}`, EXIT_CODES.ARGUMENT_ERROR);
+    }
+    return raw;
+}
+// --- API ---
+async function listWorkflows(runtime, params) {
+    const query = {};
+    if (params.scope !== undefined)
+        query.scope = params.scope;
+    if (params.entity_identifier !== undefined) {
+        query.entity_identifier = params.entity_identifier;
+    }
+    const response = await request(runtime, "/workflows.list", {
+        method: "GET",
+        query,
+    });
+    return response.body;
+}

package/dist/commands/workflowsRendering.js

@@ -0,0 +1,136 @@
+import { renderRichText } from "../renderers.js";
+import * as ui from "../ui.js";
+const WORKFLOW_SCOPE_LABELS = {
+    GLOBAL: "Global",
+    ENTITY: "Catalog entity",
+};
+const WORKFLOW_EXECUTION_TYPE_LABELS = {
+    SIMPLE: "Simple",
+    EVENT_DRIVEN: "Event-driven",
+};
+const WORKFLOW_TRIGGER_TYPE_LABELS = {
+    ANY: "All users",
+    APPROVAL: "All users with approval",
+    RUNNERS: "Selected teams and users",
+    ENTITY: "Entity owners only",
+};
+const WORKFLOW_TRIGGER_TYPE_DESCRIPTIONS = {
+    ANY: "All users can trigger this workflow run without approval.",
+    APPROVAL: "All users can request a workflow run, but a designated approver must accept before it runs.",
+    RUNNERS: "Only selected teams or users can trigger a workflow run.",
+    ENTITY: "Only users who directly own the entity, or belong to an owning team, can trigger a run.",
+};
+function workflowScopeLabel(scope) {
+    return WORKFLOW_SCOPE_LABELS[scope] ?? scope;
+}
+function workflowExecutionTypeLabel(executionType) {
+    return WORKFLOW_EXECUTION_TYPE_LABELS[executionType] ?? executionType;
+}
+function workflowTriggerTypeLabel(triggerType) {
+    return WORKFLOW_TRIGGER_TYPE_LABELS[triggerType] ?? triggerType;
+}
+function workflowTriggerTypeDescription(triggerType) {
+    return WORKFLOW_TRIGGER_TYPE_DESCRIPTIONS[triggerType] ?? "";
+}
+export function renderWorkflowList(workflows) {
+    const blocks = [
+        ui.h1("Workflows"),
+        ui.p(`Displaying ${ui.bold(workflows.length.toString())} workflows.`),
+    ];
+    for (const workflow of workflows) {
+        blocks.push(ui.h2(`${workflow.name} (${ui.code(workflow.identifier)})`));
+        blocks.push(ui.h3("Core attributes"));
+        blocks.push(...coreContent(workflow));
+        if (workflow.scope === "ENTITY") {
+            blocks.push(ui.h3("Entity filter"));
+            blocks.push(...entityFilterContent(workflow));
+        }
+        blocks.push(ui.h3("Parameters"));
+        blocks.push(...parametersContent(workflow));
+    }
+    renderRichText(blocks);
+}
+function coreContent(workflow) {
+    const blocks = [];
+    const description = workflow.description?.trim()
+        ? workflow.description
+        : ui.dim("(None)");
+    blocks.push(ui.dl([
+        ui.dli("Description", description),
+        ui.dli("Scope", workflowScopeLabel(workflow.scope)),
+        ui.dli("Execution type", workflowExecutionTypeLabel(workflow.execution_type)),
+        ui.dli("Who can run", `${workflowTriggerTypeLabel(workflow.trigger_type)}  ${ui.dim(workflowTriggerTypeDescription(workflow.trigger_type))}`),
+    ], { termWidth: 16 }));
+    return blocks;
+}
+function entityFilterContent(workflow) {
+    const blocks = [];
+    if (workflow.entity_filter_type === "ENTITY_TYPES") {
+        blocks.push(ui.p(`Filter type: ${ui.code("Entity types")}`));
+        if (workflow.entity_filter_type_identifiers &&
+            workflow.entity_filter_type_identifiers.length > 0) {
+            blocks.push(ui.ul(workflow.entity_filter_type_identifiers.map((identifier) => ui.li([ui.p(ui.code(identifier), false)]))));
+        }
+    }
+    else if (workflow.entity_filter_type === "SQL") {
+        blocks.push(ui.p(`Filter type: ${ui.code("SQL")}`));
+        if (workflow.entity_filter_sql) {
+            blocks.push(ui.truncatedSqlBlock(workflow.entity_filter_sql));
+        }
+    }
+    return blocks;
+}
+function parametersContent(workflow) {
+    if (workflow.parameters.length === 0) {
+        return [ui.p(ui.dim("(No parameters)"))];
+    }
+    return [
+        ui.ul(workflow.parameters.map((parameter) => ui.li(singleParameterContent(parameter)))),
+    ];
+}
+function singleParameterContent(parameter) {
+    const requiredPart = parameter.is_required ? `  ${ui.dim("required")}` : "";
+    const headline = `${ui.bold(parameter.name)} (${ui.code(parameter.identifier)})  ${ui.code(parameter.type)}${requiredPart}`;
+    const blocks = [ui.p(headline, false)];
+    const desc = parameter.description?.trim();
+    if (desc) {
+        blocks.push(ui.p(desc, false));
+    }
+    if (parameter.default_value !== null &&
+        parameter.default_value !== undefined &&
+        parameter.default_value !== "") {
+        blocks.push(ui.p(`Default: ${ui.code(formatParameterDefault(parameter.default_value))}`, false));
+    }
+    if (parameter.type === "SELECT") {
+        const options = selectParameterOptions(parameter.definition);
+        if (options.length > 0) {
+            blocks.push(ui.p("Options:", false));
+            blocks.push(ui.ul(options.map((value) => ui.li([ui.p(ui.code(value), false)]))));
+        }
+    }
+    return blocks;
+}
+function selectParameterOptions(definition) {
+    if (!definition || typeof definition !== "object") {
+        return [];
+    }
+    const raw = definition.options;
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    return raw.filter((item) => typeof item === "string");
+}
+function formatParameterDefault(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}

package/dist/ui.js

@@ -58,6 +58,14 @@ export function json(value) {
 export function blankLine() {
     return new ParagraphBlock("", false);
 }
+export function truncatedSqlBlock(sql) {
+    const lines = sql.split("\n");
+    const firstLine = lines[0];
+    const isLong = firstLine.length > 80 || lines.length > 1;
+    const truncated = firstLine.length > 80 ? firstLine.slice(0, 80) : firstLine;
+    const display = isLong ? truncated + dim(" …") : truncated;
+    return p(code(display));
+}
 // Inline elements
 export function bold(text) {
     return pc.bold(text);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@get-dx/cli",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "DX CLI",
   "author": "DX <developers@getdx.com>",
   "bugs": {