vercel 58.4.4 → 58.5.1

package/dist/chunks/schema-R54OXIXC.js

@@ -0,0 +1,426 @@
+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 {
+  CUSTOM_ALERT_EVENT_HELP
+} from "./chunk-MXLA3VQS.js";
+import {
+  indent_default
+} from "./chunk-A3NYPUKZ.js";
+import {
+  outputError
+} from "./chunk-BUZRVER7.js";
+import {
+  formatTable
+} from "./chunk-JLWQWYKO.js";
+import {
+  validateJsonOutput
+} from "./chunk-XPKWKPWA.js";
+import {
+  rulesSchemaSubcommand
+} from "./chunk-UMA66MKW.js";
+import "./chunk-KT4XXKJK.js";
+import {
+  printError
+} from "./chunk-KBEX5MYS.js";
+import {
+  parseArguments
+} from "./chunk-XLKFJPMT.js";
+import {
+  getFlagsSpecification
+} from "./chunk-SOFC4MLS.js";
+import "./chunk-P4QNYOFB.js";
+import {
+  output_manager_default
+} from "./chunk-OX7KI3LF.js";
+import "./chunk-GGP5R3FU.js";
+import "./chunk-S7KYDPEM.js";
+import "./chunk-TZ2YI2VH.js";
+
+// src/commands/alerts/rules/schema.ts
+var RULE_TYPES = [
+  {
+    type: "usage_anomaly",
+    description: "Built-in usage anomaly alerts"
+  },
+  {
+    type: "error_anomaly",
+    description: "Built-in error anomaly alerts"
+  },
+  {
+    type: "custom_alert",
+    description: "Custom Observability metric alerts"
+  }
+];
+var BUILT_IN_COMMON_FIELDS = [
+  field("name", "yes", "string", "Rule name"),
+  field("alertTypes", "yes", "array", "One or more alert type configs"),
+  field(
+    "projectId",
+    "no",
+    "string",
+    "OData project filter; omit for team-wide"
+  ),
+  field(
+    "autosubscribeOwnersInKnock",
+    "no",
+    "boolean",
+    "Subscribe project owners"
+  )
+];
+var CUSTOM_ALERT_COMMON_FIELDS = [
+  field("name", "yes", "string", "Rule name"),
+  field(
+    "projectId",
+    "no",
+    "string",
+    "Defaults to --project or the linked project"
+  ),
+  field("alertTypes", "yes", "array", "One or more alert type configs"),
+  field("customAlert", "yes", "object", "Custom alert definition"),
+  field(
+    "autosubscribeOwnersInKnock",
+    "no",
+    "boolean",
+    "Subscribe project owners"
+  )
+];
+var USAGE_METRICS = [
+  "fluid_cpu_duration",
+  "fluid_duration",
+  "fast_data_transfer",
+  "edge_requests",
+  "function_invocations"
+];
+var customQueryJson = {
+  event: "incomingRequest",
+  rollups: {
+    requests: {
+      measure: "count",
+      aggregation: "sum"
+    }
+  },
+  groupBy: ["route"],
+  granularity: { minutes: 5 }
+};
+var ratioQueryJson = {
+  event: "incomingRequest",
+  rollups: {
+    numerator: {
+      measure: "count",
+      aggregation: "sum",
+      filter: "httpStatus ge 500"
+    },
+    denominator: {
+      measure: "count",
+      aggregation: "sum"
+    }
+  },
+  granularity: { hours: 1 }
+};
+var SCHEMAS = {
+  usage_anomaly: {
+    type: "usage_anomaly",
+    description: "Built-in usage anomaly alerts",
+    fields: [
+      ...BUILT_IN_COMMON_FIELDS,
+      field("alertTypes[].type", "yes", "string", "usage_anomaly"),
+      field(
+        "alertTypes[].filter",
+        "no",
+        "string",
+        "OData filter for this type"
+      )
+    ],
+    alertTypeFilterValues: [["metric", USAGE_METRICS.join(", ")]],
+    examples: [
+      {
+        name: "Minimal",
+        body: {
+          name: "Usage anomalies",
+          alertTypes: [{ type: "usage_anomaly" }]
+        }
+      },
+      {
+        name: "Filtered to one metric",
+        body: {
+          name: "Edge request anomalies",
+          projectId: "projectId eq 'prj_123'",
+          alertTypes: [
+            { type: "usage_anomaly", filter: "metric eq 'edge_requests'" }
+          ]
+        }
+      }
+    ]
+  },
+  error_anomaly: {
+    type: "error_anomaly",
+    description: "Built-in error anomaly alerts",
+    fields: [
+      ...BUILT_IN_COMMON_FIELDS,
+      field("alertTypes[].type", "yes", "string", "error_anomaly"),
+      field(
+        "alertTypes[].filter",
+        "no",
+        "string",
+        "OData filter for this type"
+      )
+    ],
+    alertTypeFilterValues: [
+      ["statusGroup", "4xx, 5xx"],
+      ["route", `route eq '/api/checkout', contains(route, '/api')`]
+    ],
+    examples: [
+      {
+        name: "Minimal",
+        body: {
+          name: "Error anomalies",
+          alertTypes: [{ type: "error_anomaly" }]
+        }
+      },
+      {
+        name: "Filtered to 5xx on one route",
+        body: {
+          name: "Checkout 5xx errors",
+          projectId: "projectId eq 'prj_123'",
+          alertTypes: [
+            {
+              type: "error_anomaly",
+              filter: "statusGroup eq '5xx' and route eq '/api/checkout'"
+            }
+          ]
+        }
+      }
+    ]
+  },
+  custom_alert: {
+    type: "custom_alert",
+    description: "Custom Observability metric alerts",
+    fields: [
+      ...CUSTOM_ALERT_COMMON_FIELDS,
+      field("alertTypes[].type", "yes", "string", "custom_alert")
+    ],
+    customAlertFields: [
+      field(
+        "customAlert.queryJsonString",
+        "yes",
+        "string",
+        "Escaped query JSON"
+      ),
+      field("customAlert.triggerType", "yes", "string", "threshold, anomaly"),
+      field("customAlert.triggerOperator", "yes", "string", "gt, gte, lt, lte"),
+      field(
+        "customAlert.triggerThreshold",
+        "yes",
+        "number",
+        "Threshold value or z-score"
+      ),
+      field(
+        "customAlert.minThreshold",
+        "no",
+        "number",
+        "Minimum observed value"
+      ),
+      field(
+        "customAlert.formula",
+        "no",
+        "object",
+        "Ratio formula; left and right reference rollup keys"
+      )
+    ],
+    queryJsonFields: [
+      field("scope", "no", "object", "Project scope"),
+      field(
+        "event",
+        "yes",
+        "string",
+        "Alert query event name, for example incomingRequest"
+      ),
+      field("rollups", "yes", "object", "Named measure aggregations"),
+      field("rollups.*.measure", "yes", "string", "Metric measure"),
+      field("rollups.*.aggregation", "yes", "string", "Metric aggregation"),
+      field("rollups.*.filter", "no", "string", "Rollup-level OData filter"),
+      field("groupBy", "no", "array", "At most one dimension"),
+      field("filter", "no", "string", "Top-level OData filter"),
+      field("granularity", "no", "object", "5m, 1h, or 1d; defaults to 5m")
+    ],
+    queryJsonBeforeEscaping: customQueryJson,
+    help: CUSTOM_ALERT_EVENT_HELP,
+    examples: [
+      {
+        name: "Anomaly",
+        body: {
+          name: "Request volume anomaly",
+          alertTypes: [{ type: "custom_alert" }],
+          customAlert: {
+            queryJsonString: JSON.stringify(customQueryJson),
+            triggerType: "anomaly",
+            triggerOperator: "gt",
+            triggerThreshold: 3
+          }
+        }
+      },
+      {
+        name: "Threshold ratio",
+        body: {
+          name: "Checkout error rate",
+          alertTypes: [{ type: "custom_alert" }],
+          customAlert: {
+            queryJsonString: JSON.stringify(ratioQueryJson),
+            triggerType: "threshold",
+            triggerOperator: "gt",
+            triggerThreshold: 0.05,
+            formula: {
+              operator: "divide",
+              left: "numerator",
+              right: "denominator"
+            },
+            minThreshold: 20
+          }
+        }
+      }
+    ]
+  }
+};
+async function schema(client, argv) {
+  let parsedArgs;
+  try {
+    parsedArgs = parseArguments(
+      argv,
+      getFlagsSpecification(rulesSchemaSubcommand.options)
+    );
+  } catch (err) {
+    printError(err);
+    return 1;
+  }
+  const formatResult = validateJsonOutput(parsedArgs.flags);
+  if (!formatResult.valid) {
+    output_manager_default.error(formatResult.error);
+    return 1;
+  }
+  const jsonOutput = formatResult.jsonOutput;
+  const ruleType = normalizeRuleType(parsedArgs.flags["--type"]);
+  if (!ruleType) {
+    if (parsedArgs.flags["--type"]) {
+      return outputError(
+        client,
+        jsonOutput,
+        "INVALID_ARGUMENTS",
+        `Invalid alert rule type "${String(parsedArgs.flags["--type"])}". Use usage_anomaly, error_anomaly, or custom_alert.`
+      );
+    }
+    if (jsonOutput) {
+      client.stdout.write(
+        `${JSON.stringify({ types: RULE_TYPES }, null, 2)}
+`
+      );
+    } else {
+      output_manager_default.log("Alert rule schema");
+      output_manager_default.print(
+        `
+${formatRows(
+          ["Type", "Description"],
+          RULE_TYPES.map((type) => [type.type, type.description])
+        )}
+
+Run \`vercel alerts rules schema --type <type>\` to see a rule body schema.
+`
+      );
+    }
+    return 0;
+  }
+  printRuleSchema(client, SCHEMAS[ruleType], jsonOutput);
+  return 0;
+}
+function field(field2, required, type, notes) {
+  return { field: field2, required, type, notes };
+}
+function normalizeRuleType(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase().replace(/[-\s]+/g, "_");
+  return RULE_TYPES.some((type) => type.type === normalized) ? normalized : void 0;
+}
+function printRuleSchema(client, schema2, jsonOutput) {
+  if (jsonOutput) {
+    client.stdout.write(`${JSON.stringify({ schema: schema2 }, null, 2)}
+`);
+    return;
+  }
+  output_manager_default.log(`Alert rule schema: ${schema2.type}`);
+  output_manager_default.print("\n");
+  printFieldSection("Fields", schema2.fields);
+  if (schema2.alertTypeFilterValues) {
+    output_manager_default.print("alertTypes[].filter values\n\n");
+    output_manager_default.print(
+      `${formatRows(
+        ["Field", "Allowed values / examples"],
+        schema2.alertTypeFilterValues
+      )}
+
+`
+    );
+  }
+  if (schema2.customAlertFields) {
+    printFieldSection("Custom alert fields", schema2.customAlertFields);
+  }
+  if (schema2.queryJsonFields) {
+    printFieldSection(
+      "customAlert.queryJsonString fields",
+      schema2.queryJsonFields
+    );
+  }
+  if (schema2.queryJsonBeforeEscaping) {
+    output_manager_default.print("customAlert.queryJsonString before escaping\n\n");
+    output_manager_default.print(
+      `${indent_default(JSON.stringify(schema2.queryJsonBeforeEscaping, null, 2), 2)}
+
+`
+    );
+  }
+  if (schema2.help) {
+    output_manager_default.print("Custom alert metric discovery\n\n");
+    output_manager_default.print(`${indent_default(schema2.help.join("\n"), 2)}
+
+`);
+  }
+  output_manager_default.print("Body examples\n\n");
+  for (const example of schema2.examples) {
+    output_manager_default.print(`  ${example.name}
+
+`);
+    output_manager_default.print(`${indent_default(JSON.stringify(example.body, null, 2), 4)}
+
+`);
+  }
+}
+function printFieldSection(title, fields) {
+  output_manager_default.print(`${title}
+
+`);
+  output_manager_default.print(
+    `${formatRows(
+      ["Field", "Required", "Type", "Values / notes"],
+      fields.map((field2) => [
+        field2.field,
+        field2.required,
+        field2.type,
+        field2.notes
+      ])
+    )}
+
+`
+  );
+}
+function formatRows(headers, rows) {
+  const alignment = headers.map(() => "l");
+  const tableRows = rows.map((row) => [...row]);
+  return formatTable(headers, alignment, [{ rows: tableRows }]).trim();
+}
+export {
+  schema as default
+};

package/dist/chunks/{tags-HNPC63QA.js → tags-NDPHPWME.js}

@@ -52,9 +52,9 @@ async function tags(client, argv, telemetry) {
   }
   switch (subcommand) {
     case "ls":
-      return (await import("./ls-DL2LA35C.js")).default(client, args, telemetry);
+      return (await import("./ls-DD7RQ7KH.js")).default(client, args, telemetry);
     case "inspect":
-      return (await import("./inspect-5J5GSTOB.js")).default(client, args, telemetry);
+      return (await import("./inspect-WUT7EW6R.js")).default(client, args, telemetry);
     default:
       output_manager_default.error(`Unhandled tags subcommand: ${subcommand}`);
       return 1;

package/dist/chunks/{update-LUYWNZP3.js → update-YAN3MGMW.js}

@@ -4,21 +4,29 @@ import { dirname as __dirname_ } from 'node:path';
 const require = __createRequire(import.meta.url);
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
+import {
+  parseCustomAlertQueryBody,
+  resolveCustomAlertProjectName,
+  setMissingCustomAlertProjectScope
+} from "./chunk-ZHDQMUK4.js";
 import {
   emitRulesArgParseError,
   handleRulesApiError,
   parseRulesFlagsAndScope,
   rulesItemPath
-} from "./chunk-Y5GTPWXB.js";
-import "./chunk-YDUINEII.js";
+} from "./chunk-IRX26ZL5.js";
+import "./chunk-QS5I33VI.js";
 import "./chunk-BUZRVER7.js";
+import "./chunk-GKLT2ZGC.js";
+import "./chunk-V5P25P7F.js";
 import {
   validateJsonOutput
 } from "./chunk-XPKWKPWA.js";
 import {
   rulesUpdateSubcommand
-} from "./chunk-4UYKSYKQ.js";
-import "./chunk-4CCY5OPH.js";
+} from "./chunk-UMA66MKW.js";
+import "./chunk-GE5R7SYE.js";
+import "./chunk-LXRK7KPA.js";
 import "./chunk-ECCWJHC6.js";
 import {
   AGENT_REASON,
@@ -168,11 +176,35 @@ async function update(client, argv) {
     output_manager_default.error("Invalid JSON in --body file.");
     return 1;
   }
+  const parsedCustomAlertQuery = parseCustomAlertQueryBody(client, body);
+  if (typeof parsedCustomAlertQuery === "number") {
+    return parsedCustomAlertQuery;
+  }
   delete body.id;
   delete body.teamId;
   const path = rulesItemPath(scope, ruleId);
   output_manager_default.spinner("Updating alert rule...");
   try {
+    if (parsedCustomAlertQuery && !Object.hasOwn(parsedCustomAlertQuery.query, "scope")) {
+      let projectId = typeof body.projectId === "string" ? body.projectId : void 0;
+      if (!projectId) {
+        const rule = await client.fetch(path);
+        projectId = rule.projectId;
+      }
+      if (projectId) {
+        const projectName = await resolveCustomAlertProjectName(
+          client,
+          scope,
+          projectId
+        );
+        setMissingCustomAlertProjectScope(
+          parsedCustomAlertQuery,
+          scope.teamId,
+          projectId,
+          projectName
+        );
+      }
+    }
     const updated = await client.fetch(path, {
       method: "PATCH",
       body

package/dist/commands/build/index.js

@@ -12,31 +12,31 @@ import {
   isLambda,
   staticFiles,
   writeBuildResult
-} from "../../chunks/chunk-ZGBBPJ6B.js";
+} from "../../chunks/chunk-PGH6RJJF.js";
 import {
   pullCommandLogic
-} from "../../chunks/chunk-2MAPZXVV.js";
+} from "../../chunks/chunk-TQE7DRGH.js";
 import {
   require_semver
 } from "../../chunks/chunk-IB5L4LKZ.js";
 import {
   pickOverrides,
   readProjectSettings
-} from "../../chunks/chunk-M5NOLAJ4.js";
+} from "../../chunks/chunk-4PZ2IIZI.js";
 import "../../chunks/chunk-R6IGDGX3.js";
-import "../../chunks/chunk-NJUPUGOE.js";
+import "../../chunks/chunk-HT2XWSAJ.js";
 import {
   stamp_default
 } from "../../chunks/chunk-64IF634X.js";
 import "../../chunks/chunk-VXYGCOKL.js";
 import {
   ensureLink
-} from "../../chunks/chunk-2FMPLU44.js";
-import "../../chunks/chunk-UE3JUVUZ.js";
-import "../../chunks/chunk-CPFNFVCL.js";
+} from "../../chunks/chunk-MEOBIY2L.js";
+import "../../chunks/chunk-LTEFJ3VD.js";
+import "../../chunks/chunk-GE5R7SYE.js";
 import {
   buildCommand
-} from "../../chunks/chunk-YCPUAG77.js";
+} from "../../chunks/chunk-FQ4R66UG.js";
 import {
   help
 } from "../../chunks/chunk-ZX2FSPWV.js";
@@ -64,7 +64,7 @@ import {
   resolveProjectCwd,
   ua_default,
   validateConfig
-} from "../../chunks/chunk-4CCY5OPH.js";
+} from "../../chunks/chunk-LXRK7KPA.js";
 import {
   TelemetryClient
 } from "../../chunks/chunk-ECCWJHC6.js";
@@ -319,11 +319,11 @@ async function detectFirstDeploymentFramework(options) {
     ...detected.detectedVersion && { version: detected.detectedVersion }
   };
 }
-async function detectAllFrameworks(workPath) {
+async function detectAllFrameworks(workPath, customFrameworkList) {
   logDebug(`Framework cross-check: detecting frameworks at "${workPath}"`);
   const frameworks = await (0, import_fs_detectors2.detectFrameworks)({
     fs: new import_fs_detectors2.LocalFileSystemDetector(workPath),
-    frameworkList: import_frameworks.frameworkList
+    frameworkList: customFrameworkList ?? import_frameworks.frameworkList
   });
   const slugs = frameworks.map((f) => f.slug).filter((slug) => Boolean(slug));
   logDebug(`Framework cross-check: detected [${slugs.join(", ") || "<none>"}]`);
@@ -3556,11 +3556,12 @@ async function writeManifests(packageManifests, diagnostics, ops, outputDir) {
     builderUse
   } of packageManifests) {
     const key = `${builderUse}:${workspace}`;
+    const framework = service?.framework ?? buildConfig.framework ?? manifest.framework;
     projectManifest[key] = {
       ...manifest,
       workspace,
       builder: builderUse,
-      framework: service?.framework ?? buildConfig.framework,
+      framework,
       serviceName: service?.name,
       serviceType: service && isExperimentalService(service) ? service.type : void 0,
       routePrefix: service && isExperimentalService(service) ? service.routePrefix : void 0
@@ -3568,6 +3569,7 @@ async function writeManifests(packageManifests, diagnostics, ops, outputDir) {
     const { version: _version, ...manifestWithoutVersion } = manifest;
     deployManifestBuilds[key] = {
       ...manifestWithoutVersion,
+      framework,
       root: workspace,
       builder: builderUse
     };
@@ -4318,6 +4320,7 @@ async function doBuild(client, project, buildsJson, cwd, outputDir, span, standa
   }
   const diagnostics = {};
   const packageManifests = [];
+  const apiDirFrameworkDetector = createApiDirFrameworkDetector();
   const getHasDetectedServices = () => detectedResolvedServices !== void 0 && detectedResolvedServices.length > 0;
   const synthesizedServiceCrons = [];
   const serviceByBuilder = /* @__PURE__ */ new Map();
@@ -4383,6 +4386,10 @@ async function doBuild(client, project, buildsJson, cwd, outputDir, span, standa
         }
         const isFrontendBuilder = build.config && "framework" in build.config;
         const builderFramework = build.config?.framework ?? projectSettings.framework;
+        const apiDirFramework = isZeroConfig && !service && !isFrontendBuilder ? await apiDirFrameworkDetector.detect(
+          build.use ?? "",
+          buildWorkPath
+        ) : void 0;
         let buildConfig;
         if (isZeroConfig) {
           if (service) {
@@ -4416,7 +4423,7 @@ async function doBuild(client, project, buildsJson, cwd, outputDir, span, standa
               installCommand: projectSettings.installCommand ?? void 0,
               devCommand: projectSettings.devCommand ?? void 0,
               buildCommand: projectSettings.buildCommand ?? void 0,
-              framework: projectSettings.framework,
+              framework: isFrontendBuilder ? projectSettings.framework : void 0,
               nodeVersion: projectSettings.nodeVersion,
               bunVersion: localConfig.bunVersion ?? void 0
             };
@@ -4545,14 +4552,22 @@ async function doBuild(client, project, buildsJson, cwd, outputDir, span, standa
                       );
                     } else {
                       const workspace = service && serviceWorkspace && serviceWorkspace !== "." ? serviceWorkspace : ".";
-                      packageManifests.push({
-                        workspace,
-                        key: fullKey,
-                        buildConfig,
-                        manifest: packageManifest,
-                        service,
-                        builderUse: builderPkg.name
-                      });
+                      const alreadyPushed = packageManifests.some(
+                        (m) => m.builderUse === builderPkg.name && m.workspace === workspace
+                      );
+                      if (!alreadyPushed) {
+                        packageManifests.push({
+                          workspace,
+                          key: fullKey,
+                          buildConfig,
+                          manifest: {
+                            ...packageManifest,
+                            framework: packageManifest.framework ?? apiDirFramework
+                          },
+                          service,
+                          builderUse: builderPkg.name
+                        });
+                      }
                     }
                   } catch (e) {
                     output_manager_default.debug(
@@ -5578,6 +5593,30 @@ async function writeFlagsJSON(buildResults, outputDir) {
     await import_fs_extra3.default.writeJSON(flagsFilePath, flags, { spaces: 2 });
   }
 }
+function createApiDirFrameworkDetector() {
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    detect(builderUse, workPath) {
+      const cacheKey = `${builderUse}:${workPath}`;
+      let cached = cache.get(cacheKey);
+      if (!cached) {
+        cached = detectApiDirFramework(builderUse, workPath);
+        cache.set(cacheKey, cached);
+      }
+      return cached;
+    }
+  };
+}
+async function detectApiDirFramework(builderUse, workPath) {
+  const runtimeFrameworks = import_fs_detectors3.builderToFrameworks.get(builderUse) ?? [];
+  if (runtimeFrameworks.length === 0)
+    return void 0;
+  const detectedSlugs = await detectAllFrameworks(
+    workPath,
+    runtimeFrameworks
+  ).catch(() => []);
+  return detectedSlugs.length === 1 ? detectedSlugs[0] : void 0;
+}
 async function writeBuildJson(buildsJson, outputDir) {
   await import_fs_extra3.default.writeJSON(join5(outputDir, "builds.json"), buildsJson, { spaces: 2 });
 }