@devkong/cli 0.0.67-alpha.22 → 0.0.67-alpha.24

package/index.js

@@ -63543,6 +63543,63 @@ function validateName(value) {
     );
   }
 }
+var MAX_USES = 5;
+function parseVersionWeight(text) {
+  const [versionPart, weightPart, ...rest] = text.split(":");
+  if (rest.length > 0) {
+    throw new AppError(
+      `Invalid version config "${text}". Expected "<version>" or "<version>:<weight|shadow>".`
+    );
+  }
+  if (!/^\d+$/.test(versionPart)) {
+    throw new AppError(
+      `Invalid version "${versionPart}" in "${text}". Expected a positive integer.`
+    );
+  }
+  const version = Number(versionPart);
+  if (weightPart === void 0) {
+    return { version, balance: 100 };
+  }
+  if (weightPart.toLowerCase() === "shadow") {
+    return { version, balance: null };
+  }
+  if (!/^\d+$/.test(weightPart)) {
+    throw new AppError(
+      `Invalid weight "${weightPart}" in "${text}". Expected a number 1-100 or "shadow".`
+    );
+  }
+  return { version, balance: Number(weightPart) };
+}
+function parseVersionWeightList(list) {
+  if (list.length === 0) {
+    throw new AppError("At least one extension version must be provided.");
+  }
+  if (list.length > MAX_USES) {
+    throw new AppError(`A maximum of ${MAX_USES} version(s) can share an alias.`);
+  }
+  const uses = list.map(parseVersionWeight);
+  const seen = /* @__PURE__ */ new Set();
+  for (const use of uses) {
+    if (seen.has(use.version)) {
+      throw new AppError(`Version ${use.version} is listed more than once.`);
+    }
+    seen.add(use.version);
+  }
+  const live = uses.filter((use) => use.balance !== null);
+  if (live.length === 0) {
+    throw new AppError("At least one non-shadow version with live traffic is required.");
+  }
+  if (live.some((use) => use.balance <= 0)) {
+    throw new AppError("All traffic weights must be greater than 0%.");
+  }
+  const total = live.reduce((sum, use) => sum + use.balance, 0);
+  if (total !== 100) {
+    throw new AppError(
+      `Traffic weights must sum to 100% (got ${total}%). ${total < 100 ? "Add" : "Remove"} ${Math.abs(100 - total)}%.`
+    );
+  }
+  return uses;
+}
 var DEPLOY_STEPS = [
   "create deployment",
   "save deployment details",
@@ -63568,7 +63625,7 @@ var SetAliasCommand = class {
     this.publicClient = new PublicClient(profile.kongBaseUrl, clientHeaderProvider);
     this.managementClient = new ManagementClient(profile.kongBaseUrl, clientHeaderProvider);
   }
-  async execute(aliasName, extensionVersion, timeoutSeconds) {
+  async execute(aliasName, weights, timeoutSeconds) {
     validateName(aliasName);
     const startedAt = utcNow(DEFAULT_TIMEZONE);
     const steps = createDeploySteps();
@@ -63578,25 +63635,29 @@ var SetAliasCommand = class {
           title: "get snapshot details",
           task: async (ctx, task) => {
             ctx.kongJson = getKongJson();
-            ctx.snapshot = await this.managementClient.getExtensionSnapshot(
-              ctx.kongJson.id,
-              extensionVersion
+            ctx.aliasUseList = await Promise.all(
+              weights.map(async (use) => {
+                const snapshot = await this.managementClient.getExtensionSnapshot(
+                  ctx.kongJson.id,
+                  use.version
+                );
+                if (!snapshot || !snapshot.id) {
+                  throw new AppError(`Snapshot for version ${use.version} not found`);
+                }
+                return {
+                  snapshot,
+                  balance: use.balance,
+                  inputFilter: void 0,
+                  outputFilter: void 0
+                };
+              })
             );
-            if (!ctx.snapshot || !ctx.snapshot.id) {
-              throw new AppError(`Snapshot for version ${extensionVersion} not found`);
-            }
           }
         },
         {
           title: "assign extension alias",
           task: async (ctx, task) => {
             const now = utcNow(DEFAULT_TIMEZONE);
-            const aliasUse = {
-              snapshot: ctx.snapshot,
-              balance: 100,
-              inputFilter: void 0,
-              outputFilter: void 0
-            };
             const alias = {
               name: aliasName,
               basedOnName: ctx.kongJson.name,
@@ -63608,7 +63669,7 @@ var SetAliasCommand = class {
               triggerSettings: {
                 targetKey: `/extensions/${ctx.kongJson.id}/aliases/${aliasName}`
               },
-              use: [aliasUse],
+              use: ctx.aliasUseList,
               inputSchema: createEmptyJsonSchema(),
               outputSchema: createEmptyJsonSchema(),
               invoke: void 0,
@@ -63743,17 +63804,20 @@ async function main() {
       printError("list-versions command failed", ex);
     }
   });
-  const setAliasCommand = new Command("set-alias").description("Assign alias to an extension").argument("alias-name", "Alias name to assign").argument("extension-version", "Extension version to use. Should be one of existing versions").addOption(new Option("--profile <name>", "Configured Kong profile to use").default("default")).addOption(
-    new Option(
-      "--timeout <seconds>",
-      "How long to wait for the deployment to finish"
-    ).default("120")
-  ).action(async (aliasName, extensionVersion, options) => {
+  const setAliasCommand = new Command("set-alias").description("Assign alias to one or more extension versions").argument("<alias-name>", "Alias name to assign").argument(
+    "<version-spec...>",
+    "Version assignments. Each is '<version>', '<version>:<weight>', or '<version>:shadow'. Simple form 'set-alias stable 1' sends 100% of traffic to version 1. Advanced form 'set-alias stable 1:80 2:20 3:shadow' load-balances live traffic 80/20 across versions 1 and 2 (weights must sum to 100%) while mirroring it to shadow version 3."
+  ).addOption(new Option("--profile <name>", "Configured Kong profile to use").default("default")).addOption(
+    new Option("--timeout <seconds>", "How long to wait for the deployment to finish").default(
+      "120"
+    )
+  ).action(async (aliasName, versionSpecs, options) => {
     try {
+      const weights = parseVersionWeightList(versionSpecs);
       printProfile(options.profile);
       await new SetAliasCommand(getProfile(options.profile)).execute(
         aliasName,
-        extensionVersion,
+        weights,
         Number(options.timeout)
       );
     } catch (ex) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devkong/cli",
-  "version": "0.0.67-alpha.22",
+  "version": "0.0.67-alpha.24",
   "type": "commonjs",
   "main": "./index.js",
   "typings": "./index.d.ts",

package/packages/kong-cli/src/commands/setAliasCommand.d.ts

@@ -1,10 +1,22 @@
 import { Profile } from "../common/profile";
+/** A single version→weight assignment parsed from the command line. */
+export interface AppAliasVersionWeight {
+    version: number;
+    /** Traffic percentage, or `null` for a "shadow" version (mirrored, no live traffic). */
+    balance: number | null;
+}
+/**
+ * Parse and validate all version configs. Live (non-shadow) weights must be > 0 and
+ * sum to exactly 100%; shadow versions are excluded from that total. Versions may
+ * not repeat and no more than {@link MAX_USES} versions can share an alias.
+ */
+export declare function parseVersionWeightList(list: string[]): AppAliasVersionWeight[];
 export declare class SetAliasCommand {
     private profile;
     private publicClient;
     private managementClient;
     constructor(profile: Profile);
-    execute(aliasName: string, extensionVersion: number, timeoutSeconds: number): Promise<void>;
+    execute(aliasName: string, weights: AppAliasVersionWeight[], timeoutSeconds: number): Promise<void>;
     /**
      * Poll the deployment audit log and settle one step per matching event. Runs
      * detached from the task list; it settles a step as its event arrives and