@devkong/cli 0.0.67-alpha.21 → 0.0.67-alpha.23

package/index.js

@@ -60771,25 +60771,25 @@ async function spawnCommandWithArgs(command, commandArgs, logger = null, shell =
     });
   });
 }
-function printError(message2, error) {
+function printError(label, error) {
   if (axios_default.isAxiosError(error)) {
-    console.error(message2 + ":", error.message);
-    console.error("URL:", error.config?.url);
-    console.error("Method:", error.config?.method);
-    console.error("Headers:", error.config?.headers);
-    console.error("Request Data:", error.config?.data);
+    console.error("url:", error.config?.url);
+    console.error("method:", error.config?.method);
+    console.error("headers:", error.config?.headers);
+    console.error("request data:", error.config?.data);
     if (error.response) {
-      console.error("Response Status:", error.response.status);
-      console.error("Response Headers:", error.response.headers);
-      console.error("Response Data:", error.response.data);
+      console.error("response status:", error.response.status);
+      console.error("response headers:", error.response.headers);
+      console.error("response data:", error.response.data);
     } else if (error.request) {
-      console.error("Request was made but no response received");
-      console.error("Request Data:", error.request);
+      console.error("request was made but no response received");
+      console.error("request data:", error.request);
     }
+    console.error(label + ":", error.message);
   } else if (error instanceof AppError) {
-    console.error(message2, error.message);
+    console.error(label + ":", error.message);
   } else {
-    console.error(message2, error);
+    console.error(label + ":", error);
   }
 }
 function escapePathSpaces(sourcePath) {
@@ -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.21",
+  "version": "0.0.67-alpha.23",
   "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

package/packages/kong-cli/src/common/utils.d.ts

@@ -12,5 +12,5 @@ export declare function resolveProjectPath(fileName: string): string;
 export declare function generateShortId(): ShortUUID;
 export declare function spawnCommand(commandText: string, logger?: ILogger | null, shell?: boolean): Promise<string>;
 export declare function spawnCommandWithArgs(command: string, commandArgs: string[], logger?: ILogger | null, shell?: boolean): Promise<string>;
-export declare function printError(message: string, error: unknown): void;
+export declare function printError(label: string, error: unknown): void;
 export declare function escapePathSpaces(sourcePath: string): string;

package/packages/kong-ts/src/index.d.ts

@@ -20,7 +20,7 @@ export { applyJqFilterReplacements, applyJqObjectReplacements, applyJqTextReplac
 export type { JqArray, JqFilter, JqObject, JqSerializer, JqText, RefactorReplacement, } from "./lib/jq";
 export { generateFakeJsonObject, jsonToHumanReadable, prettyJsonObject, prettyJsonText, safeJsonParse, } from "./lib/json";
 export type { JsonArray, JsonObject, JsonSchemaUrl, JsonText } from "./lib/json";
-export { buildExampleObject, buildJSONSchemaType, createEmptyJsonSchema, getNestedValue, getPropertyType, hasJSONSchemaType, isRequired, updateNestedValue, } from "./lib/jsonSchema";
+export { buildExampleObject, buildJSONSchemaType, createEmptyJsonSchema, getNestedValue, getPropertyType, hasJSONSchemaType, isRequired, normalizeNullableUnions, updateNestedValue, } from "./lib/jsonSchema";
 export { KeyGenerator } from "./lib/keyGenerator";
 export { findLastIndex, insertItem, moveItem, unique } from "./lib/list";
 export { deepMerge, deepMergeAll } from "./lib/merge";

package/packages/kong-ts/src/lib/jsonSchema.d.ts

@@ -1,5 +1,17 @@
 import { JSONSchema7, JSONSchema7TypeName } from "json-schema";
 import { JsonObject, Optional } from "./types";
+/**
+ * Collapses Pydantic's optional idiom `anyOf: [X, { "type": "null" }]` (and the `oneOf` form) down
+ * to `X`, recursively, and drops the now-dead `$defs`/`definitions`.
+ *
+ * Pydantic encodes every optional/nullable field as such a union instead of a nullable type, and
+ * `$ref` dereferencing inlines the branch but leaves the union in place. A form that reads
+ * `properties`/`type` straight off the node then sees an `anyOf` wrapper with no `properties` and
+ * renders nothing. When a single non-null branch remains it is merged with the union's sibling
+ * keywords (`default`, `description`, `title`, ...); genuine multi-branch unions keep their non-null
+ * branches. Run this right after dereferencing, before the schema reaches the form.
+ */
+export declare function normalizeNullableUnions<T = JSONSchema7>(schema: T): T;
 export declare function hasJSONSchemaType(type: JSONSchema7["type"], name: JSONSchema7TypeName): boolean;
 export declare function getPropertyType(schema: Optional<JSONSchema7> | null): string;
 export declare function isRequired(schema: Optional<JSONSchema7> | null, propertyKey: string): boolean;