@depup/vercel 50.32.5-depup.0

package/dist/chunks/reorder-GU65YMIN.js

@@ -0,0 +1,259 @@
+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 {
+  getRouteVersions
+} from "./chunk-AHU7WNL2.js";
+import {
+  ensureProjectLink,
+  getRoutes,
+  offerAutoPromote,
+  parsePosition,
+  parseSubcommandArgs,
+  resolveRoute
+} from "./chunk-TNBMKNET.js";
+import {
+  reorderSubcommand
+} from "./chunk-U6XOC6E4.js";
+import "./chunk-AQLVWVEN.js";
+import "./chunk-P4I4DMEU.js";
+import {
+  stamp_default
+} from "./chunk-SOTR4CXR.js";
+import "./chunk-7EHTK7LP.js";
+import "./chunk-GGP5R3FU.js";
+import {
+  getCommandName
+} from "./chunk-ZLCMHY2G.js";
+import "./chunk-3XFFP2BA.js";
+import {
+  output_manager_default
+} from "./chunk-FDJURQMQ.js";
+import {
+  require_source
+} from "./chunk-S7KYDPEM.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/commands/routes/reorder.ts
+var import_chalk = __toESM(require_source(), 1);
+
+// src/util/routes/stage-routes.ts
+async function stageRoutes(client, projectId, routes, overwrite, options = {}) {
+  const { teamId } = options;
+  const query = new URLSearchParams();
+  if (teamId)
+    query.set("teamId", teamId);
+  const queryString = query.toString();
+  const url = `/v1/projects/${projectId}/routes${queryString ? `?${queryString}` : ""}`;
+  return await client.fetch(url, {
+    method: "PUT",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ routes, overwrite })
+  });
+}
+
+// src/commands/routes/reorder.ts
+async function reorder(client, argv) {
+  const parsed = await parseSubcommandArgs(argv, reorderSubcommand);
+  if (typeof parsed === "number")
+    return parsed;
+  const link = await ensureProjectLink(client);
+  if (typeof link === "number")
+    return link;
+  const { project, org } = link;
+  const teamId = org.type === "team" ? org.id : void 0;
+  const { args, flags } = parsed;
+  const skipConfirmation = flags["--yes"];
+  const identifier = args[0];
+  if (!identifier) {
+    output_manager_default.error(
+      `Route name or ID is required. Usage: ${getCommandName("routes reorder <name-or-id> --position <pos>")}`
+    );
+    return 1;
+  }
+  const { versions } = await getRouteVersions(client, project.id, { teamId });
+  const existingStagingVersion = versions.find((v) => v.isStaging);
+  output_manager_default.spinner("Fetching routes");
+  const { routes } = await getRoutes(client, project.id, { teamId });
+  output_manager_default.stopSpinner();
+  if (routes.length === 0) {
+    output_manager_default.error("No routes found in this project.");
+    return 1;
+  }
+  if (routes.length === 1) {
+    output_manager_default.error("Cannot reorder when there is only one route.");
+    return 1;
+  }
+  const route = await resolveRoute(client, routes, identifier);
+  if (!route) {
+    output_manager_default.error(
+      `No route found matching "${identifier}". Run ${import_chalk.default.cyan(
+        getCommandName("routes list")
+      )} to see all routes.`
+    );
+    return 1;
+  }
+  const currentIndex = routes.findIndex((r) => r.id === route.id);
+  const currentPosition = currentIndex + 1;
+  let targetIndex;
+  const positionFlag = flags["--position"];
+  const firstFlag = flags["--first"];
+  const lastFlag = flags["--last"];
+  if (firstFlag) {
+    targetIndex = 0;
+  } else if (lastFlag) {
+    targetIndex = routes.length;
+  } else if (positionFlag) {
+    if (positionFlag === "first") {
+      targetIndex = 0;
+    } else if (positionFlag === "last") {
+      targetIndex = routes.length;
+    } else {
+      const num = parseInt(positionFlag, 10);
+      if (!isNaN(num) && String(num) === positionFlag) {
+        if (num < 1) {
+          output_manager_default.error("Position must be 1 or greater.");
+          return 1;
+        }
+        targetIndex = Math.min(num - 1, routes.length);
+      } else {
+        try {
+          const pos = parsePosition(positionFlag);
+          if (pos.placement === "start") {
+            targetIndex = 0;
+          } else if (pos.placement === "end") {
+            targetIndex = routes.length;
+          } else if (pos.placement === "after" && pos.referenceId) {
+            const refIndex = routes.findIndex((r) => r.id === pos.referenceId);
+            if (refIndex === -1) {
+              output_manager_default.error(
+                `Reference route "${pos.referenceId}" not found. Run ${import_chalk.default.cyan(
+                  getCommandName("routes list")
+                )} to see route IDs.`
+              );
+              return 1;
+            }
+            targetIndex = refIndex + 1;
+          } else if (pos.placement === "before" && pos.referenceId) {
+            const refIndex = routes.findIndex((r) => r.id === pos.referenceId);
+            if (refIndex === -1) {
+              output_manager_default.error(
+                `Reference route "${pos.referenceId}" not found. Run ${import_chalk.default.cyan(
+                  getCommandName("routes list")
+                )} to see route IDs.`
+              );
+              return 1;
+            }
+            targetIndex = refIndex;
+          } else {
+            output_manager_default.error("Invalid position specification.");
+            return 1;
+          }
+        } catch (e) {
+          output_manager_default.error(
+            `${e instanceof Error ? e.message : "Invalid position"}. Usage: ${getCommandName("routes reorder <name-or-id> --position <pos>")}`
+          );
+          return 1;
+        }
+      }
+    }
+  } else {
+    output_manager_default.print("\n");
+    output_manager_default.log("Current route order:");
+    for (let i = 0; i < routes.length; i++) {
+      const r = routes[i];
+      const isCurrent = r.id === route.id;
+      const prefix = isCurrent ? import_chalk.default.cyan("\u2192") : " ";
+      const num = import_chalk.default.gray(`${i + 1}.`);
+      const name = isCurrent ? import_chalk.default.bold(r.name) : r.name;
+      const src = import_chalk.default.gray(`(${r.route.src})`);
+      const marker = isCurrent ? import_chalk.default.cyan("  \u2190 current") : "";
+      output_manager_default.print(`  ${prefix} ${num} ${name} ${src}${marker}
+`);
+    }
+    output_manager_default.print("\n");
+    const input = await client.input.text({
+      message: `Move "${route.name}" to position (1-${routes.length}, "first", or "last"):`,
+      validate: (val) => {
+        if (!val)
+          return "Position is required";
+        if (val === "first" || val === "last")
+          return true;
+        const num = parseInt(val, 10);
+        if (isNaN(num) || num < 1 || num > routes.length) {
+          return `Enter a number between 1 and ${routes.length}, "first", or "last"`;
+        }
+        return true;
+      }
+    });
+    if (input === "first") {
+      targetIndex = 0;
+    } else if (input === "last") {
+      targetIndex = routes.length;
+    } else {
+      targetIndex = parseInt(input, 10) - 1;
+    }
+  }
+  const adjustedTarget = currentIndex < targetIndex ? targetIndex - 1 : targetIndex;
+  const clampedTarget = Math.max(
+    0,
+    Math.min(adjustedTarget, routes.length - 1)
+  );
+  if (currentIndex === clampedTarget) {
+    output_manager_default.log(
+      `Route "${route.name}" is already at position ${currentPosition}.`
+    );
+    return 0;
+  }
+  const finalPosition = clampedTarget + 1;
+  if (!skipConfirmation) {
+    const confirmed = await client.input.confirm(
+      `Move "${route.name}" from position ${currentPosition} to position ${finalPosition}?`,
+      true
+    );
+    if (!confirmed) {
+      output_manager_default.log("Aborted.");
+      return 0;
+    }
+  }
+  const reordered = [...routes];
+  reordered.splice(currentIndex, 1);
+  reordered.splice(clampedTarget, 0, route);
+  const reorderStamp = stamp_default();
+  output_manager_default.spinner(`Moving route "${route.name}"`);
+  try {
+    const { version } = await stageRoutes(
+      client,
+      project.id,
+      reordered,
+      true,
+      // overwrite
+      { teamId }
+    );
+    output_manager_default.log(
+      `${import_chalk.default.cyan("Moved")} "${route.name}" from position ${currentPosition} to ${finalPosition} ${import_chalk.default.gray(reorderStamp())}`
+    );
+    await offerAutoPromote(
+      client,
+      project.id,
+      version,
+      !!existingStagingVersion,
+      { teamId, skipPrompts: skipConfirmation }
+    );
+    return 0;
+  } catch (e) {
+    const error = e;
+    output_manager_default.error(error.message || "Failed to reorder route");
+    return 1;
+  }
+}
+export {
+  reorder as default
+};

package/dist/chunks/restore-Q7ENGWVJ.js

@@ -0,0 +1,158 @@
+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 {
+  updateRouteVersion
+} from "./chunk-PMSMUMUO.js";
+import {
+  getRouteVersions
+} from "./chunk-AHU7WNL2.js";
+import {
+  confirmAction,
+  ensureProjectLink,
+  findVersionById,
+  getRoutes,
+  parseSubcommandArgs,
+  printDiffSummary,
+  validateRequiredArgs
+} from "./chunk-TNBMKNET.js";
+import {
+  restoreSubcommand
+} from "./chunk-U6XOC6E4.js";
+import "./chunk-AQLVWVEN.js";
+import "./chunk-P4I4DMEU.js";
+import {
+  stamp_default
+} from "./chunk-SOTR4CXR.js";
+import "./chunk-7EHTK7LP.js";
+import "./chunk-GGP5R3FU.js";
+import {
+  getCommandName
+} from "./chunk-ZLCMHY2G.js";
+import "./chunk-3XFFP2BA.js";
+import {
+  output_manager_default
+} from "./chunk-FDJURQMQ.js";
+import {
+  require_source
+} from "./chunk-S7KYDPEM.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/commands/routes/restore.ts
+var import_chalk = __toESM(require_source(), 1);
+async function restore(client, argv) {
+  const parsed = await parseSubcommandArgs(argv, restoreSubcommand);
+  if (typeof parsed === "number")
+    return parsed;
+  const error = validateRequiredArgs(parsed.args, ["version-id"]);
+  if (error) {
+    output_manager_default.error(error);
+    return 1;
+  }
+  const link = await ensureProjectLink(client);
+  if (typeof link === "number")
+    return link;
+  const { project, org } = link;
+  const teamId = org.type === "team" ? org.id : void 0;
+  const [versionIdentifier] = parsed.args;
+  output_manager_default.spinner(`Fetching route versions for ${import_chalk.default.bold(project.name)}`);
+  const { versions } = await getRouteVersions(client, project.id, { teamId });
+  const result = findVersionById(versions, versionIdentifier);
+  if (result.error) {
+    output_manager_default.error(result.error);
+    return 1;
+  }
+  const version = result.version;
+  if (!version) {
+    output_manager_default.error("Version not found.");
+    return 1;
+  }
+  if (version.isLive) {
+    output_manager_default.error(
+      `Version ${import_chalk.default.bold(
+        version.id.slice(0, 12)
+      )} is currently live. You cannot restore the live version.
+Run ${import_chalk.default.cyan(
+        getCommandName("routes list-versions")
+      )} to see previous versions you can restore.`
+    );
+    return 1;
+  }
+  if (version.isStaging) {
+    output_manager_default.error(
+      `Version ${import_chalk.default.bold(
+        version.id.slice(0, 12)
+      )} is staged. Use ${import_chalk.default.cyan(
+        getCommandName("routes publish")
+      )} to publish it instead.`
+    );
+    return 1;
+  }
+  output_manager_default.spinner("Fetching changes");
+  const { routes: diffRoutes } = await getRoutes(client, project.id, {
+    teamId,
+    versionId: version.id,
+    diff: true
+  });
+  const changedRoutes = diffRoutes.filter((r) => r.action !== void 0);
+  if (changedRoutes.length > 0) {
+    output_manager_default.print(`
+${import_chalk.default.bold("Changes to be restored:")}
+
+`);
+    printDiffSummary(changedRoutes);
+    output_manager_default.print("\n");
+  } else {
+    output_manager_default.print(
+      `
+${import_chalk.default.gray("No changes detected from current production version.")}
+
+`
+    );
+  }
+  const confirmed = await confirmAction(
+    client,
+    parsed.flags["--yes"],
+    `Restore version ${import_chalk.default.bold(version.id.slice(0, 12))} to production?`,
+    `This will replace the current live routes for ${import_chalk.default.bold(project.name)}.`
+  );
+  if (!confirmed) {
+    output_manager_default.log("Canceled");
+    return 0;
+  }
+  const updateStamp = stamp_default();
+  output_manager_default.spinner(`Restoring version ${import_chalk.default.bold(version.id.slice(0, 12))}`);
+  try {
+    const { version: newVersion } = await updateRouteVersion(
+      client,
+      project.id,
+      version.id,
+      "restore",
+      { teamId }
+    );
+    output_manager_default.log(
+      `${import_chalk.default.cyan("Success!")} Version ${import_chalk.default.bold(
+        newVersion.id.slice(0, 12)
+      )} restored to production ${import_chalk.default.gray(updateStamp())}`
+    );
+    if (newVersion.ruleCount !== void 0) {
+      output_manager_default.print(
+        `  ${import_chalk.default.bold("Active routes:")} ${newVersion.ruleCount}
+`
+      );
+    }
+    return 0;
+  } catch (e) {
+    const error2 = e;
+    output_manager_default.error(error2.message || "Failed to restore version");
+    return 1;
+  }
+}
+export {
+  restore as default
+};

package/dist/chunks/routes-Q5CWG44T.js

@@ -0,0 +1,20 @@
+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 {
+  RoutesAddTelemetryClient,
+  RoutesEditTelemetryClient,
+  RoutesTelemetryClient
+} from "./chunk-3FRG2XGZ.js";
+import "./chunk-P4I4DMEU.js";
+import "./chunk-FDJURQMQ.js";
+import "./chunk-S7KYDPEM.js";
+import "./chunk-TZ2YI2VH.js";
+export {
+  RoutesAddTelemetryClient,
+  RoutesEditTelemetryClient,
+  RoutesTelemetryClient
+};

package/dist/chunks/schema-PJKLO2K2.js

@@ -0,0 +1,176 @@
+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 {
+  formatErrorJson,
+  formatSchemaDetailJson,
+  formatSchemaListJson,
+  getAggregations,
+  getEvent,
+  getEventNames,
+  validateEvent
+} from "./chunk-BQ3DXZNT.js";
+import "./chunk-IE7MNZ56.js";
+import {
+  indent_default
+} from "./chunk-A3NYPUKZ.js";
+import {
+  formatTable
+} from "./chunk-SGGLJFUZ.js";
+import {
+  validateJsonOutput
+} from "./chunk-XPKWKPWA.js";
+import {
+  schemaSubcommand
+} from "./chunk-2DLBVZWU.js";
+import "./chunk-LWBSOTJP.js";
+import {
+  require_pluralize
+} from "./chunk-7EHTK7LP.js";
+import "./chunk-GGP5R3FU.js";
+import {
+  getFlagsSpecification,
+  parseArguments,
+  printError
+} from "./chunk-ZLCMHY2G.js";
+import "./chunk-3XFFP2BA.js";
+import {
+  output_manager_default
+} from "./chunk-FDJURQMQ.js";
+import {
+  require_source
+} from "./chunk-S7KYDPEM.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/commands/metrics/schema.ts
+var import_chalk = __toESM(require_source(), 1);
+var import_pluralize = __toESM(require_pluralize(), 1);
+async function schema(client, telemetry) {
+  let parsedArgs;
+  const flagsSpecification = getFlagsSpecification(schemaSubcommand.options);
+  try {
+    parsedArgs = parseArguments(client.argv.slice(2), flagsSpecification);
+  } catch (err) {
+    printError(err);
+    return 1;
+  }
+  const flags = parsedArgs.flags;
+  const formatResult = validateJsonOutput(flags);
+  if (!formatResult.valid) {
+    output_manager_default.error(formatResult.error);
+    return 1;
+  }
+  const jsonOutput = formatResult.jsonOutput;
+  const event = flags["--event"];
+  telemetry.trackCliOptionEvent(event);
+  telemetry.trackCliOptionFormat(flags["--format"]);
+  if (event) {
+    const eventResult = validateEvent(event);
+    if (!eventResult.valid) {
+      if (jsonOutput) {
+        client.stdout.write(
+          formatErrorJson(
+            eventResult.code,
+            eventResult.message,
+            eventResult.allowedValues
+          )
+        );
+      } else {
+        output_manager_default.error(eventResult.message);
+        if (eventResult.allowedValues) {
+          output_manager_default.print(
+            `
+Available events: ${eventResult.allowedValues.join(", ")}
+`
+          );
+        }
+      }
+      return 1;
+    }
+    const eventData = getEvent(event);
+    const eventWithName = { ...eventData, name: event };
+    if (jsonOutput) {
+      const hasNonCount = eventData.measures.some((m) => m.name !== "count");
+      const sampleMeasure = hasNonCount ? eventData.measures.find((m) => m.name !== "count").name : eventData.measures.length > 0 ? "count" : "";
+      const aggregations = sampleMeasure ? getAggregations(event, sampleMeasure) : [];
+      client.stdout.write(formatSchemaDetailJson(eventWithName, aggregations));
+    } else {
+      output_manager_default.log(`Event: ${event} - ${eventData.description}`);
+      const dimTable = formatDimensionsTable(eventWithName.dimensions);
+      if (dimTable) {
+        output_manager_default.print(dimTable);
+        output_manager_default.print("\n");
+      }
+      const measTable = formatMeasuresTable(eventWithName.measures);
+      if (measTable) {
+        output_manager_default.print(measTable);
+        output_manager_default.print("\n");
+      }
+    }
+  } else {
+    const events = getEventNames().map((name) => ({
+      name,
+      description: getEvent(name).description
+    }));
+    if (jsonOutput) {
+      client.stdout.write(formatSchemaListJson(events));
+    } else {
+      output_manager_default.log(`${(0, import_pluralize.default)("Event", events.length, true)} found`);
+      output_manager_default.print(formatEventsTable(events));
+      output_manager_default.print("\n");
+    }
+  }
+  return 0;
+}
+function formatEventsTable(events) {
+  return indent_default(
+    formatTable(
+      ["Event", "Description"],
+      ["l", "l"],
+      [{ rows: events.map((e) => [e.name, e.description]) }]
+    ),
+    1
+  );
+}
+function formatDimensionsTable(dimensions) {
+  if (dimensions.length === 0) {
+    return null;
+  }
+  return indent_default(
+    formatTable(
+      ["Dimension", "Label", "Groupable"],
+      ["l", "l", "l"],
+      [
+        {
+          rows: dimensions.map((d) => [
+            d.name,
+            d.label,
+            d.filterOnly ? import_chalk.default.dim("no") : "yes"
+          ])
+        }
+      ]
+    ),
+    1
+  );
+}
+function formatMeasuresTable(measures) {
+  if (measures.length === 0) {
+    return null;
+  }
+  return indent_default(
+    formatTable(
+      ["Measure", "Label", "Unit"],
+      ["l", "l", "l"],
+      [{ rows: measures.map((m) => [m.name, m.label, m.unit]) }]
+    ),
+    1
+  );
+}
+export {
+  schema as default
+};

package/dist/chunks/stamp-RTPE2EBB.js

@@ -0,0 +1,15 @@
+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 {
+  stamp_default
+} from "./chunk-SOTR4CXR.js";
+import "./chunk-GGP5R3FU.js";
+import "./chunk-S7KYDPEM.js";
+import "./chunk-TZ2YI2VH.js";
+export {
+  stamp_default as default
+};