vercel 59.11.2 → 59.12.0

package/dist/chunks/chunk-2NIDTSQJ.js

@@ -0,0 +1,305 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  humanizeReference,
+  renderAlertTable
+} from "./chunk-GDOUDU6O.js";
+import {
+  formatDate
+} from "./chunk-GZLPFESR.js";
+import {
+  truncateEnd,
+  truncateMiddle
+} from "./chunk-ND5CF2H3.js";
+import {
+  printAlignedLabel
+} from "./chunk-MADFAH3O.js";
+import {
+  buildCommandWithGlobalFlags,
+  quoteArg
+} from "./chunk-26CU4Q3C.js";
+import {
+  output_manager_default
+} from "./chunk-2JIX6UMI.js";
+import {
+  require_source
+} from "./chunk-S7KYDPEM.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/commands/alerts/rules/format.ts
+var import_chalk = __toESM(require_source(), 1);
+function formatBoolean(value) {
+  return value ? "yes" : "no";
+}
+function formatOperator(operator) {
+  return {
+    gt: ">",
+    gte: ">=",
+    lt: "<",
+    lte: "<="
+  }[operator] ?? operator;
+}
+function formatPublicRuleScope(rule) {
+  const scope = rule.ruleScope;
+  if (scope.type === "all")
+    return "all projects";
+  if (scope.type === "project")
+    return `project: ${scope.projectId}`;
+  return `${scope.type}: ${scope.projectIds.join(", ")}`;
+}
+function formatMetricSelection(metric) {
+  const modifiers = [
+    metric.per ? `per ${metric.per}` : void 0,
+    metric.normalize ? `normalize ${metric.normalize}` : void 0,
+    metric.dimensions?.length ? `dimensions ${metric.dimensions.join(", ")}` : void 0
+  ].filter(Boolean);
+  return `${metric.aggregation} ${metric.metric}${modifiers.length ? ` (${modifiers.join("; ")})` : ""}`;
+}
+function formatCustomTrigger(trigger) {
+  const minimum = trigger.minimum ? `; minimum ${trigger.minimum.output} >= ${trigger.minimum.threshold}` : "";
+  if (trigger.type === "anomaly") {
+    return `${trigger.output} anomaly at ${trigger.standardDeviations} standard deviations${minimum}`;
+  }
+  return `${trigger.output} ${formatOperator(trigger.operator)} ${trigger.threshold}${minimum}`;
+}
+function formatCustomCondition(rule) {
+  if (!rule.querySupported)
+    return "Query unavailable via API";
+  const query = rule.evaluation.query;
+  const output = query.outputs[0];
+  const selection = query.formulas?.[output] ? `${output} = ${query.formulas[output]}` : query.metrics[output] ? formatMetricSelection(query.metrics[output]) : output;
+  return `${selection}; ${formatCustomTrigger(rule.trigger)}; ${rule.evaluation.window}`;
+}
+function formatBuiltInCondition(rule) {
+  const triggers = rule.triggers.mode === "all" ? "all triggers" : rule.triggers.items.map((trigger) => humanizeReference(trigger.type)).join(", ");
+  return `${triggers}; minimum ${rule.matchMinimumSeverityLevel}`;
+}
+function formatRuleCondition(rule) {
+  return rule.type === "built-in" ? formatBuiltInCondition(rule) : formatCustomCondition(rule);
+}
+function printRules(rules) {
+  const rows = [
+    ["Name", "Rule ID", "Type", "Scope", "Condition"].map(
+      (header) => import_chalk.default.cyan(header)
+    ),
+    ...rules.map((rule) => [
+      import_chalk.default.bold(truncateEnd(rule.name, 36)),
+      import_chalk.default.dim(rule.id),
+      rule.isDefault ? `${rule.type} (default)` : rule.type,
+      truncateMiddle(formatPublicRuleScope(rule), 38),
+      truncateEnd(formatRuleCondition(rule), 72)
+    ])
+  ];
+  output_manager_default.print(`
+${renderAlertTable(rows, 2)}
+`);
+}
+function commonRows(rule) {
+  return [
+    ["Name", rule.name],
+    ["Rule ID", rule.id],
+    ["Type", rule.type],
+    ["Scope", formatPublicRuleScope(rule)],
+    ["Default", formatBoolean(rule.isDefault)],
+    ...rule.createdAt ? [["Created", formatDate(rule.createdAt)]] : [],
+    ...rule.updatedAt ? [["Updated", formatDate(rule.updatedAt)]] : []
+  ];
+}
+function notificationRows(rule) {
+  return [
+    [
+      "Team owner notifications",
+      formatBoolean(rule.notificationSettings.enableTeamOwnerNotifications)
+    ],
+    ...rule.notificationSettings.incidentIoRoutingKey ? [
+      [
+        "Incident.io routing key",
+        rule.notificationSettings.incidentIoRoutingKey
+      ]
+    ] : []
+  ];
+}
+function printBuiltInRule(rule) {
+  output_manager_default.print(`${import_chalk.default.cyan("Built-in conditions")}
+
+`);
+  if (rule.triggers.mode === "all") {
+    output_manager_default.print(
+      `${renderAlertTable(
+        [
+          ["Minimum severity", rule.matchMinimumSeverityLevel],
+          ["Triggers", "all built-in triggers"]
+        ],
+        3
+      )}
+`
+    );
+  } else {
+    output_manager_default.print(
+      `${renderAlertTable(
+        [["Minimum severity", rule.matchMinimumSeverityLevel]],
+        3
+      )}
+
+${renderAlertTable(
+        [
+          ["Trigger", "Filter"].map((header) => import_chalk.default.cyan(header)),
+          ...rule.triggers.items.map((trigger) => [
+            trigger.type,
+            trigger.filter || "-"
+          ])
+        ],
+        3
+      )}
+`
+    );
+  }
+}
+function metricRows(rule) {
+  return Object.entries(rule.evaluation.query.metrics).map(
+    ([alias, metric]) => [
+      alias,
+      metric.metric,
+      metric.aggregation,
+      [
+        metric.per ? `per ${metric.per}` : void 0,
+        metric.normalize ? `normalize ${metric.normalize}` : void 0,
+        metric.dimensions?.join(", ")
+      ].filter(Boolean).join("; ") || "-",
+      metric.filter || "-"
+    ]
+  );
+}
+function printCustomRule(rule) {
+  output_manager_default.print(`${import_chalk.default.cyan("Custom alert")}
+
+`);
+  if (!rule.querySupported) {
+    output_manager_default.print(
+      "  Query unavailable via API. You can update metadata, delete the rule, or recreate it with a supported query.\n"
+    );
+    output_manager_default.print(`
+${renderAlertTable([["Severity", rule.severity]], 3)}
+`);
+    return;
+  }
+  const query = rule.evaluation.query;
+  output_manager_default.print(
+    `${renderAlertTable(
+      [
+        ["Severity", rule.severity],
+        ["Window", rule.evaluation.window],
+        ["Output", query.outputs[0]],
+        ...query.formulas ? Object.entries(query.formulas).map(([alias, formula]) => [
+          `Formula ${alias}`,
+          formula
+        ]) : [],
+        ...query.groupBy?.length ? [["Group By", query.groupBy.join(", ")]] : [],
+        ...query.filter ? [["Query Filter", query.filter]] : []
+      ],
+      3
+    )}
+`
+  );
+  output_manager_default.print(`
+${import_chalk.default.cyan("Metrics")}
+
+`);
+  output_manager_default.print(
+    `${renderAlertTable(
+      [
+        ["Alias", "Metric", "Aggregation", "Modifiers", "Filter"].map(
+          (header) => import_chalk.default.cyan(header)
+        ),
+        ...metricRows(rule)
+      ],
+      3
+    )}
+`
+  );
+  output_manager_default.print(`
+${import_chalk.default.cyan("Trigger")}
+
+`);
+  output_manager_default.print(
+    `${renderAlertTable(
+      [
+        ["Type", rule.trigger.type],
+        ["Output", rule.trigger.output],
+        ...rule.trigger.type === "threshold" ? [
+          ["Operator", rule.trigger.operator],
+          ["Threshold", String(rule.trigger.threshold)]
+        ] : [["Standard Deviations", String(rule.trigger.standardDeviations)]],
+        ...rule.trigger.minimum ? [
+          ["Minimum Output", rule.trigger.minimum.output],
+          ["Minimum Threshold", String(rule.trigger.minimum.threshold)]
+        ] : []
+      ],
+      3
+    )}
+`
+  );
+}
+function printRule(rule) {
+  output_manager_default.print(
+    `
+${import_chalk.default.bold("Alert rule")} ${import_chalk.default.cyan(rule.id)}
+${renderAlertTable(
+      commonRows(rule),
+      3
+    )}
+
+${import_chalk.default.cyan("Notifications")}
+
+${renderAlertTable(
+      notificationRows(rule),
+      3
+    )}
+
+`
+  );
+  if (rule.type === "built-in")
+    printBuiltInRule(rule);
+  else
+    printCustomRule(rule);
+}
+function printRulePreview(rule) {
+  printAlignedLabel("Name", rule.name);
+  printAlignedLabel("Rule ID", rule.id);
+  printAlignedLabel("Type", rule.type);
+  printAlignedLabel("Scope", formatPublicRuleScope(rule));
+}
+function printRuleDeletionReceipt(ruleId) {
+  output_manager_default.print("\n");
+  printAlignedLabel("Deleted", ruleId, { gutter: "\u2713" });
+}
+function printRuleMutationReceipt(action, rule, argv) {
+  output_manager_default.print("\n");
+  printAlignedLabel(action, rule.name, { gutter: "\u2713" });
+  printAlignedLabel("Rule ID", rule.id);
+  printAlignedLabel("Type", rule.type);
+  printAlignedLabel("Scope", formatPublicRuleScope(rule));
+  if (action !== "Deleted") {
+    printAlignedLabel(
+      "Inspect",
+      buildCommandWithGlobalFlags(
+        argv,
+        `alerts rules inspect ${quoteArg(rule.id)}`
+      )
+    );
+  }
+}
+
+export {
+  printRules,
+  printRule,
+  printRulePreview,
+  printRuleDeletionReceipt,
+  printRuleMutationReceipt
+};

package/dist/chunks/chunk-32XSMM3W.js

@@ -0,0 +1,49 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  require_json_parse_better_errors
+} from "./chunk-6E6KPBXY.js";
+import {
+  require_lib
+} from "./chunk-MADFAH3O.js";
+import {
+  CantParseJSONFile
+} from "./chunk-CV5YC2EN.js";
+import {
+  require_dist
+} from "./chunk-ZW6HETRE.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/util/read-json-file.ts
+var import_fs_extra = __toESM(require_lib(), 1);
+var import_json_parse_better_errors = __toESM(require_json_parse_better_errors(), 1);
+var import_error_utils = __toESM(require_dist(), 1);
+async function readJSONFile(file) {
+  const content = await readFileSafe(file);
+  if (content === null) {
+    return content;
+  }
+  try {
+    const json = (0, import_json_parse_better_errors.default)(content);
+    return json;
+  } catch (error) {
+    return new CantParseJSONFile(file, (0, import_error_utils.errorToString)(error));
+  }
+}
+async function readFileSafe(file) {
+  try {
+    return await import_fs_extra.default.readFile(file, "utf8");
+  } catch (_) {
+    return null;
+  }
+}
+
+export {
+  readJSONFile
+};