vercel 59.11.7 → 59.12.0

package/dist/chunks/schema-UYYFV3JB.js

@@ -0,0 +1,381 @@
+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 {
+  handleRulesApiError,
+  outputRulesError,
+  resolveRulesTeam,
+  rulesSchemaPath
+} from "./chunk-HR2MP4XF.js";
+import "./chunk-3BB2HOO2.js";
+import {
+  indent_default
+} from "./chunk-A3NYPUKZ.js";
+import "./chunk-KFWQ3EFH.js";
+import "./chunk-WT2Y7FRD.js";
+import "./chunk-AINIBIP4.js";
+import "./chunk-QB2UHSUB.js";
+import {
+  formatTable
+} from "./chunk-GVNCVKCI.js";
+import {
+  validateJsonOutput
+} from "./chunk-KXDWXXJH.js";
+import "./chunk-V4RMJKQP.js";
+import {
+  rulesSchemaSubcommand
+} from "./chunk-EDMW7SBH.js";
+import "./chunk-WT6C2ALC.js";
+import "./chunk-P7VSBDR4.js";
+import "./chunk-YPMFZRTN.js";
+import "./chunk-ZDU2NODC.js";
+import "./chunk-PEC3CQSK.js";
+import "./chunk-GGP5R3FU.js";
+import "./chunk-VUS2JQB2.js";
+import "./chunk-KAF4WFF3.js";
+import "./chunk-HRXRELD3.js";
+import "./chunk-B5XLQKHI.js";
+import "./chunk-ABSZNJQO.js";
+import "./chunk-XNIZGCN5.js";
+import "./chunk-NW34PW6V.js";
+import {
+  printError
+} from "./chunk-3VM7HWF6.js";
+import {
+  parseArguments
+} from "./chunk-57RHXXXG.js";
+import "./chunk-MADFAH3O.js";
+import "./chunk-G5FBSUL4.js";
+import "./chunk-26CU4Q3C.js";
+import "./chunk-XPJLPUKO.js";
+import {
+  isAPIError
+} from "./chunk-CV5YC2EN.js";
+import {
+  getFlagsSpecification,
+  packageName
+} from "./chunk-Q2DGFCO7.js";
+import {
+  output_manager_default
+} from "./chunk-2JIX6UMI.js";
+import "./chunk-P4QNYOFB.js";
+import "./chunk-ZW6HETRE.js";
+import "./chunk-S7KYDPEM.js";
+import "./chunk-TZ2YI2VH.js";
+
+// src/commands/alerts/rules/schema.ts
+async function schema(client, argv) {
+  let parsedArgs;
+  try {
+    parsedArgs = parseArguments(
+      argv,
+      getFlagsSpecification(rulesSchemaSubcommand.options)
+    );
+  } catch (error) {
+    printError(error);
+    return 1;
+  }
+  const format = validateJsonOutput(parsedArgs.flags);
+  if (!format.valid) {
+    return outputRulesError(client, false, "INVALID_ARGUMENTS", format.error);
+  }
+  const value = parsedArgs.flags["--type"];
+  if (value !== void 0 && value !== "built-in" && value !== "custom") {
+    const suggestion = value === "custom_alert" ? " Use custom; alert rule types are built-in and custom." : "";
+    return outputRulesError(
+      client,
+      format.jsonOutput,
+      "INVALID_RULE_TYPE",
+      `Invalid rule type "${String(value)}".${suggestion} Expected built-in or custom.`
+    );
+  }
+  const type = value;
+  const scope = await resolveRulesTeam(client, format.jsonOutput);
+  if (typeof scope === "number")
+    return scope;
+  output_manager_default.spinner("Fetching alert rule schema\u2026");
+  try {
+    const document = await client.fetch(
+      rulesSchemaPath(scope.teamId, type)
+    );
+    if (format.jsonOutput) {
+      client.stdout.write(`${JSON.stringify(document, null, 2)}
+`);
+      return 0;
+    }
+    if (!type) {
+      printSchemaIndex(document.ruleTypes);
+      return 0;
+    }
+    const ruleSchema = document.ruleTypes.find((item) => item.type === type);
+    if (!ruleSchema) {
+      return outputRulesError(
+        client,
+        false,
+        "INVALID_SCHEMA_RESPONSE",
+        `The API did not return the ${type} alert rule schema.`
+      );
+    }
+    printSchema(ruleSchema);
+    return 0;
+  } catch (error) {
+    if (isAPIError(error)) {
+      return handleRulesApiError(client, error, format.jsonOutput);
+    }
+    throw error;
+  } finally {
+    output_manager_default.stopSpinner();
+  }
+}
+function printSchemaIndex(ruleTypes) {
+  output_manager_default.log("Alert rule schemas");
+  output_manager_default.print(
+    `${formatRows(
+      ["Type", "Description"],
+      ruleTypes.map((item) => [item.type, item.description])
+    )}
+Run \`${packageName} alerts rules schema --type <type>\` for fields and examples.
+`
+  );
+}
+function printSchema(schema2) {
+  output_manager_default.log(`Alert rule schema: ${schema2.type}`);
+  output_manager_default.print(`${schema2.description}
+
+`);
+  printCliScope(schema2.type);
+  printFields(schema2);
+  if (schema2.metricDiscovery) {
+    output_manager_default.print("Metric discovery\n\n");
+    output_manager_default.print(`${indent_default(schema2.metricDiscovery.command, 2)}
+`);
+    output_manager_default.print(`${indent_default(schema2.metricDiscovery.description, 4)}
+
+`);
+  }
+  printConstraints(schema2.constraints);
+  printExamples("Create examples", "create", schema2.create.examples);
+  printExamples("Update examples", "update", schema2.update.examples);
+}
+function printCliScope(type) {
+  output_manager_default.print("CLI scope flags\n\n");
+  output_manager_default.print(`${indent_default("--project <name-or-id>", 2)}
+`);
+  output_manager_default.print(
+    `${indent_default(
+      type === "built-in" ? "Apply the rule only to the resolved project" : "Set the project evaluated by the rule",
+      4
+    )}
+`
+  );
+  if (type === "built-in") {
+    output_manager_default.print(`${indent_default("--all", 2)}
+`);
+    output_manager_default.print(`${indent_default("Apply the rule to every team project", 4)}
+`);
+  }
+  output_manager_default.print(
+    `${indent_default("Use a scope flag or ruleScope in the body, not both.", 2)}
+
+`
+  );
+}
+function printFields(schema2) {
+  const createFields = collectFields(schema2.create.jsonSchema);
+  const updateFields = collectFields(schema2.update.jsonSchema);
+  const paths = [
+    ...createFields.keys(),
+    ...[...updateFields.keys()].filter((path) => !createFields.has(path))
+  ];
+  output_manager_default.print("Fields\n\n");
+  for (const path of paths) {
+    const create = createFields.get(path);
+    const update = updateFields.get(path);
+    const types = unique([...create?.types ?? [], ...update?.types ?? []]);
+    const descriptions = unique([
+      ...create?.descriptions ?? [],
+      ...update?.descriptions ?? []
+    ]);
+    output_manager_default.print(`${indent_default(path, 2)}
+`);
+    output_manager_default.print(
+      `${indent_default(
+        `${types.join(" | ") || "value"} \xB7 create ${create?.requirement ?? "not accepted"} \xB7 update ${update?.requirement ?? "not accepted"}`,
+        4
+      )}
+`
+    );
+    if (descriptions[0]) {
+      output_manager_default.print(`${indent_default(descriptions[0], 4)}
+`);
+    }
+    output_manager_default.print("\n");
+  }
+}
+function collectFields(schema2) {
+  const fields = /* @__PURE__ */ new Map();
+  visitObjectSchema(schema2, "", false, fields);
+  return fields;
+}
+function visitObjectSchema(schema2, prefix, conditional, fields) {
+  const properties = asSchemaRecord(schema2.properties);
+  const required = new Set(
+    Array.isArray(schema2.required) ? schema2.required.filter(
+      (item) => typeof item === "string"
+    ) : []
+  );
+  for (const [name, propertySchema] of Object.entries(properties)) {
+    const path = prefix ? `${prefix}.${name}` : name;
+    const requirement = conditional ? "conditional" : required.has(name) ? "required" : "optional";
+    addField(fields, path, propertySchema, requirement);
+    visitNestedSchema(propertySchema, path, requirement !== "required", fields);
+  }
+  for (const variant of schemaVariants(schema2)) {
+    visitObjectSchema(variant, prefix, true, fields);
+  }
+}
+function visitNestedSchema(schema2, path, conditional, fields) {
+  if (schema2.properties || schema2.oneOf || schema2.anyOf || schema2.allOf) {
+    visitObjectSchema(schema2, path, conditional, fields);
+  }
+  const additionalProperties = asSchema(schema2.additionalProperties);
+  if (additionalProperties) {
+    const entryPath = `${path}.<key>`;
+    addField(fields, entryPath, additionalProperties, "conditional");
+    visitNestedSchema(additionalProperties, entryPath, true, fields);
+  }
+  const items = asSchema(schema2.items);
+  if (items) {
+    visitNestedSchema(items, `${path}[]`, true, fields);
+  }
+  if (Array.isArray(schema2.prefixItems)) {
+    for (const item of schema2.prefixItems) {
+      const itemSchema = asSchema(item);
+      if (itemSchema)
+        visitNestedSchema(itemSchema, `${path}[]`, true, fields);
+    }
+  }
+}
+function addField(fields, path, schema2, requirement) {
+  const current = fields.get(path);
+  const type = describeSchemaType(schema2);
+  const description = typeof schema2.description === "string" ? schema2.description : void 0;
+  if (!current) {
+    fields.set(path, {
+      requirement,
+      types: type ? [type] : [],
+      descriptions: description ? [description] : []
+    });
+    return;
+  }
+  current.types = unique([...current.types, ...type ? [type] : []]);
+  current.descriptions = unique([
+    ...current.descriptions,
+    ...description ? [description] : []
+  ]);
+  if (current.requirement !== requirement)
+    current.requirement = "conditional";
+}
+function describeSchemaType(schema2) {
+  if ("const" in schema2)
+    return formatLiteral(schema2.const);
+  if (Array.isArray(schema2.enum)) {
+    return schema2.enum.map(formatLiteral).join(" | ");
+  }
+  const variants = schemaVariants(schema2).map(describeSchemaType).filter(Boolean);
+  if (variants.length > 0)
+    return unique(variants).join(" | ");
+  if (schema2.type === "array" || schema2.prefixItems || schema2.items) {
+    if (Array.isArray(schema2.prefixItems)) {
+      const tuple = schema2.prefixItems.map(asSchema).filter((item2) => item2 !== void 0).map(describeSchemaType).join(", ");
+      return `[${tuple || "value"}]`;
+    }
+    const item = asSchema(schema2.items);
+    return `${item ? describeSchemaType(item) : "value"}[]`;
+  }
+  if (schema2.type === "object" || schema2.properties) {
+    const value = asSchema(schema2.additionalProperties);
+    return value ? `record<string, ${describeSchemaType(value)}>` : "object";
+  }
+  return typeof schema2.type === "string" ? schema2.type : "value";
+}
+function schemaVariants(schema2) {
+  return ["oneOf", "anyOf", "allOf"].flatMap((key) => {
+    const value = schema2[key];
+    if (!Array.isArray(value))
+      return [];
+    return value.map(asSchema).filter((item) => item !== void 0);
+  });
+}
+function asSchema(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function asSchemaRecord(value) {
+  const schema2 = asSchema(value);
+  if (!schema2)
+    return {};
+  return Object.fromEntries(
+    Object.entries(schema2).filter(
+      (entry) => asSchema(entry[1]) !== void 0
+    )
+  );
+}
+function formatLiteral(value) {
+  return typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+function printConstraints(constraints) {
+  if (constraints.length === 0)
+    return;
+  output_manager_default.print("Constraints\n\n");
+  for (const constraint of constraints) {
+    const operations = constraint.appliesTo.join("/");
+    const kind = constraint.kind === "request" ? "" : ` \xB7 ${humanize(constraint.kind)}`;
+    output_manager_default.print(
+      `${indent_default(`${humanize(constraint.code)} \xB7 ${operations}${kind}`, 2)}
+`
+    );
+    output_manager_default.print(`${indent_default(`Paths: ${constraint.paths.join(", ")}`, 4)}
+`);
+    output_manager_default.print(`${indent_default(constraint.description, 4)}
+
+`);
+  }
+}
+function humanize(value) {
+  const words = value.replace(/[-_]/g, " ");
+  return `${words.charAt(0).toUpperCase()}${words.slice(1)}`;
+}
+function printExamples(title, operation, examples) {
+  output_manager_default.print(`${title}
+
+`);
+  for (const example of examples) {
+    const fileName = operation === "create" ? "rule.json" : "patch.json";
+    const command = operation === "create" ? `${packageName} alerts rules add --body ./${fileName}` : `${packageName} alerts rules update <rule-id> --body ./${fileName}`;
+    output_manager_default.print(`${indent_default(example.name, 2)}
+`);
+    output_manager_default.print(`${indent_default(`Body (${fileName}):`, 4)}
+`);
+    output_manager_default.print(`${indent_default(JSON.stringify(example.body, null, 2), 6)}
+`);
+    output_manager_default.print(`${indent_default(command, 4)}
+
+`);
+  }
+}
+function formatRows(headers, rows) {
+  return formatTable(
+    headers,
+    headers.map(() => "l"),
+    [{ rows }]
+  ).trim();
+}
+export {
+  schema as default
+};

package/dist/chunks/{set-FYJVKMPV.js → set-TOJPGW4J.js}

@@ -23,8 +23,8 @@ import {
   toRule,
   writeConfigJson,
   writeSamplingRules
-} from "./chunk-DSTNNQVV.js";
-import "./chunk-5GGUB4EO.js";
+} from "./chunk-3F25W3GA.js";
+import "./chunk-QIUK4Z7Q.js";
 import {
   validateJsonOutput
 } from "./chunk-KXDWXXJH.js";
@@ -34,8 +34,8 @@ import {
 import {
   setSubcommand
 } from "./chunk-GY5I4AYD.js";
-import "./chunk-7KROIXQM.js";
-import "./chunk-PJXMXMCO.js";
+import "./chunk-X6TGUHFD.js";
+import "./chunk-ELZ6WQQA.js";
 import "./chunk-VUS2JQB2.js";
 import {
   help
@@ -44,9 +44,9 @@ import {
   TelemetryClient
 } from "./chunk-HB4UKFDO.js";
 import "./chunk-B5XLQKHI.js";
-import "./chunk-NW34PW6V.js";
-import "./chunk-4IVSM24H.js";
+import "./chunk-ABSZNJQO.js";
 import "./chunk-XNIZGCN5.js";
+import "./chunk-NW34PW6V.js";
 import {
   printError
 } from "./chunk-3VM7HWF6.js";
@@ -54,7 +54,7 @@ import {
   parseArguments
 } from "./chunk-57RHXXXG.js";
 import "./chunk-4IALDGB7.js";
-import "./chunk-2TSBB22D.js";
+import "./chunk-MADFAH3O.js";
 import "./chunk-G5FBSUL4.js";
 import "./chunk-26CU4Q3C.js";
 import "./chunk-XPJLPUKO.js";

package/dist/chunks/{setup-and-link-KXPZE32P.js → setup-and-link-DRYXQOH4.js}

@@ -10,42 +10,42 @@ import {
   resolveGitConnectIntent,
   setupAndLink,
   shouldPromptForRootDirectory
-} from "./chunk-FVT74RZ5.js";
+} from "./chunk-YRESLJCW.js";
+import "./chunk-UJPVHLL5.js";
 import "./chunk-RVBZ64EQ.js";
-import "./chunk-VT3Z7HF6.js";
-import "./chunk-A5JZS6ZN.js";
-import "./chunk-Z7JWYFOY.js";
+import "./chunk-WSZ5E4WH.js";
+import "./chunk-QB2UHSUB.js";
 import "./chunk-V4RMJKQP.js";
-import "./chunk-UARGTFCT.js";
+import "./chunk-VJSREJVM.js";
 import "./chunk-332LMJLZ.js";
-import "./chunk-SHFNEZVI.js";
-import "./chunk-G3PXSXIB.js";
+import "./chunk-32XSMM3W.js";
+import "./chunk-WT6C2ALC.js";
 import "./chunk-P7VSBDR4.js";
-import "./chunk-QOPTXV4G.js";
+import "./chunk-YPMFZRTN.js";
 import "./chunk-ZDU2NODC.js";
 import "./chunk-PEC3CQSK.js";
 import "./chunk-GGP5R3FU.js";
-import "./chunk-GHKJAK5V.js";
-import "./chunk-7KROIXQM.js";
+import "./chunk-RNK3LXLR.js";
+import "./chunk-X6TGUHFD.js";
 import "./chunk-FRVG4OW3.js";
 import "./chunk-6E6KPBXY.js";
-import "./chunk-C762AAVU.js";
-import "./chunk-PJXMXMCO.js";
+import "./chunk-PP5GKSIX.js";
+import "./chunk-ELZ6WQQA.js";
 import "./chunk-VUS2JQB2.js";
 import "./chunk-XUAWTW4W.js";
-import "./chunk-DBYHS3CK.js";
+import "./chunk-KAF4WFF3.js";
 import "./chunk-HRXRELD3.js";
 import "./chunk-PNGVSHR3.js";
 import "./chunk-RN6V5ODW.js";
 import "./chunk-HB4UKFDO.js";
 import "./chunk-B5XLQKHI.js";
-import "./chunk-NW34PW6V.js";
-import "./chunk-4IVSM24H.js";
+import "./chunk-ABSZNJQO.js";
 import "./chunk-XNIZGCN5.js";
+import "./chunk-NW34PW6V.js";
 import "./chunk-3VM7HWF6.js";
 import "./chunk-57RHXXXG.js";
 import "./chunk-4IALDGB7.js";
-import "./chunk-2TSBB22D.js";
+import "./chunk-MADFAH3O.js";
 import "./chunk-G5FBSUL4.js";
 import "./chunk-26CU4Q3C.js";
 import "./chunk-XPJLPUKO.js";

package/dist/chunks/{tags-ANIRP5E3.js → tags-TNLVFNVI.js}

@@ -56,9 +56,9 @@ async function tags(client, argv, telemetry) {
   }
   switch (subcommand) {
     case "ls":
-      return (await import("./ls-SVOHC3XW.js")).default(client, args, telemetry);
+      return (await import("./ls-DZYN3SNS.js")).default(client, args, telemetry);
     case "inspect":
-      return (await import("./inspect-RNTSYM6O.js")).default(client, args, telemetry);
+      return (await import("./inspect-XJ7BYLZ5.js")).default(client, args, telemetry);
     default:
       output_manager_default.error(`Unhandled tags subcommand: ${subcommand}`);
       return 1;