@devkong/cli 0.0.14 → 0.0.15

package/index.js

@@ -43402,6 +43402,228 @@ var require_create_nx_workspace = __commonJS({
   }
 });
 
+// node_modules/json-schema/lib/validate.js
+var require_validate = __commonJS({
+  "node_modules/json-schema/lib/validate.js"(exports2, module2) {
+    (function(root, factory) {
+      if (typeof define === "function" && define.amd) {
+        define([], function() {
+          return factory();
+        });
+      } else if (typeof module2 === "object" && module2.exports) {
+        module2.exports = factory();
+      } else {
+        root.jsonSchema = factory();
+      }
+    })(exports2, function() {
+      var exports3 = validate4;
+      exports3.Integer = { type: "integer" };
+      var primitiveConstructors = {
+        String,
+        Boolean,
+        Number,
+        Object,
+        Array,
+        Date
+      };
+      exports3.validate = validate4;
+      function validate4(instance, schema) {
+        return validate4(instance, schema, { changing: false });
+      }
+      ;
+      exports3.checkPropertyChange = function(value, schema, property) {
+        return validate4(value, schema, { changing: property || "property" });
+      };
+      var validate4 = exports3._validate = function(instance, schema, options) {
+        if (!options)
+          options = {};
+        var _changing = options.changing;
+        function getType(schema2) {
+          return schema2.type || primitiveConstructors[schema2.name] == schema2 && schema2.name.toLowerCase();
+        }
+        var errors = [];
+        function checkProp(value, schema2, path6, i) {
+          var l;
+          path6 += path6 ? typeof i == "number" ? "[" + i + "]" : typeof i == "undefined" ? "" : "." + i : i;
+          function addError(message2) {
+            errors.push({ property: path6, message: message2 });
+          }
+          if ((typeof schema2 != "object" || schema2 instanceof Array) && (path6 || typeof schema2 != "function") && !(schema2 && getType(schema2))) {
+            if (typeof schema2 == "function") {
+              if (!(value instanceof schema2)) {
+                addError("is not an instance of the class/constructor " + schema2.name);
+              }
+            } else if (schema2) {
+              addError("Invalid schema/property definition " + schema2);
+            }
+            return null;
+          }
+          if (_changing && schema2.readonly) {
+            addError("is a readonly field, it can not be changed");
+          }
+          if (schema2["extends"]) {
+            checkProp(value, schema2["extends"], path6, i);
+          }
+          function checkType(type, value2) {
+            if (type) {
+              if (typeof type == "string" && type != "any" && (type == "null" ? value2 !== null : typeof value2 != type) && !(value2 instanceof Array && type == "array") && !(value2 instanceof Date && type == "date") && !(type == "integer" && value2 % 1 === 0)) {
+                return [{ property: path6, message: value2 + " - " + typeof value2 + " value found, but a " + type + " is required" }];
+              }
+              if (type instanceof Array) {
+                var unionErrors = [];
+                for (var j2 = 0; j2 < type.length; j2++) {
+                  if (!(unionErrors = checkType(type[j2], value2)).length) {
+                    break;
+                  }
+                }
+                if (unionErrors.length) {
+                  return unionErrors;
+                }
+              } else if (typeof type == "object") {
+                var priorErrors = errors;
+                errors = [];
+                checkProp(value2, type, path6);
+                var theseErrors = errors;
+                errors = priorErrors;
+                return theseErrors;
+              }
+            }
+            return [];
+          }
+          if (value === void 0) {
+            if (schema2.required) {
+              addError("is missing and it is required");
+            }
+          } else {
+            errors = errors.concat(checkType(getType(schema2), value));
+            if (schema2.disallow && !checkType(schema2.disallow, value).length) {
+              addError(" disallowed value was matched");
+            }
+            if (value !== null) {
+              if (value instanceof Array) {
+                if (schema2.items) {
+                  var itemsIsArray = schema2.items instanceof Array;
+                  var propDef = schema2.items;
+                  for (i = 0, l = value.length; i < l; i += 1) {
+                    if (itemsIsArray)
+                      propDef = schema2.items[i];
+                    if (options.coerce)
+                      value[i] = options.coerce(value[i], propDef);
+                    errors.concat(checkProp(value[i], propDef, path6, i));
+                  }
+                }
+                if (schema2.minItems && value.length < schema2.minItems) {
+                  addError("There must be a minimum of " + schema2.minItems + " in the array");
+                }
+                if (schema2.maxItems && value.length > schema2.maxItems) {
+                  addError("There must be a maximum of " + schema2.maxItems + " in the array");
+                }
+              } else if (schema2.properties || schema2.additionalProperties) {
+                errors.concat(checkObj(value, schema2.properties, path6, schema2.additionalProperties));
+              }
+              if (schema2.pattern && typeof value == "string" && !value.match(schema2.pattern)) {
+                addError("does not match the regex pattern " + schema2.pattern);
+              }
+              if (schema2.maxLength && typeof value == "string" && value.length > schema2.maxLength) {
+                addError("may only be " + schema2.maxLength + " characters long");
+              }
+              if (schema2.minLength && typeof value == "string" && value.length < schema2.minLength) {
+                addError("must be at least " + schema2.minLength + " characters long");
+              }
+              if (typeof schema2.minimum !== "undefined" && typeof value == typeof schema2.minimum && schema2.minimum > value) {
+                addError("must have a minimum value of " + schema2.minimum);
+              }
+              if (typeof schema2.maximum !== "undefined" && typeof value == typeof schema2.maximum && schema2.maximum < value) {
+                addError("must have a maximum value of " + schema2.maximum);
+              }
+              if (schema2["enum"]) {
+                var enumer = schema2["enum"];
+                l = enumer.length;
+                var found;
+                for (var j = 0; j < l; j++) {
+                  if (enumer[j] === value) {
+                    found = 1;
+                    break;
+                  }
+                }
+                if (!found) {
+                  addError("does not have a value in the enumeration " + enumer.join(", "));
+                }
+              }
+              if (typeof schema2.maxDecimal == "number" && value.toString().match(new RegExp("\\.[0-9]{" + (schema2.maxDecimal + 1) + ",}"))) {
+                addError("may only have " + schema2.maxDecimal + " digits of decimal places");
+              }
+            }
+          }
+          return null;
+        }
+        function checkObj(instance2, objTypeDef, path6, additionalProp) {
+          if (typeof objTypeDef == "object") {
+            if (typeof instance2 != "object" || instance2 instanceof Array) {
+              errors.push({ property: path6, message: "an object is required" });
+            }
+            for (var i in objTypeDef) {
+              if (objTypeDef.hasOwnProperty(i) && i != "__proto__" && i != "constructor") {
+                var value = instance2.hasOwnProperty(i) ? instance2[i] : void 0;
+                if (value === void 0 && options.existingOnly)
+                  continue;
+                var propDef = objTypeDef[i];
+                if (value === void 0 && propDef["default"]) {
+                  value = instance2[i] = propDef["default"];
+                }
+                if (options.coerce && i in instance2) {
+                  value = instance2[i] = options.coerce(value, propDef);
+                }
+                checkProp(value, propDef, path6, i);
+              }
+            }
+          }
+          for (i in instance2) {
+            if (instance2.hasOwnProperty(i) && !(i.charAt(0) == "_" && i.charAt(1) == "_") && objTypeDef && !objTypeDef[i] && additionalProp === false) {
+              if (options.filter) {
+                delete instance2[i];
+                continue;
+              } else {
+                errors.push({ property: path6, message: "The property " + i + " is not defined in the schema and the schema does not allow additional properties" });
+              }
+            }
+            var requires = objTypeDef && objTypeDef[i] && objTypeDef[i].requires;
+            if (requires && !(requires in instance2)) {
+              errors.push({ property: path6, message: "the presence of the property " + i + " requires that " + requires + " also be present" });
+            }
+            value = instance2[i];
+            if (additionalProp && (!(objTypeDef && typeof objTypeDef == "object") || !(i in objTypeDef))) {
+              if (options.coerce) {
+                value = instance2[i] = options.coerce(value, additionalProp);
+              }
+              checkProp(value, additionalProp, path6, i);
+            }
+            if (!_changing && value && value.$schema) {
+              errors = errors.concat(checkProp(value, value.$schema, path6, i));
+            }
+          }
+          return errors;
+        }
+        if (schema) {
+          checkProp(instance, schema, "", _changing || "");
+        }
+        if (!_changing && instance && instance.$schema) {
+          checkProp(instance, instance.$schema, "", "");
+        }
+        return { valid: !errors.length, errors };
+      };
+      exports3.mustBeValid = function(result) {
+        if (!result.valid) {
+          throw new TypeError(result.errors.map(function(error) {
+            return "for property " + error.property + ": " + error.message;
+          }).join(", \n"));
+        }
+      };
+      return exports3;
+    });
+  }
+});
+
 // node_modules/listr2/node_modules/eventemitter3/index.js
 var require_eventemitter3 = __commonJS({
   "node_modules/listr2/node_modules/eventemitter3/index.js"(exports2, module2) {
@@ -44430,13 +44652,13 @@ var init_lookup = __esm({
 });
 
 // node_modules/get-east-asian-width/index.js
-function validate2(codePoint) {
+function validate3(codePoint) {
   if (!Number.isSafeInteger(codePoint)) {
     throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
   }
 }
 function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
-  validate2(codePoint);
+  validate3(codePoint);
   if (isFullWidth(codePoint) || isWide(codePoint) || ambiguousAsWide && isAmbiguous(codePoint)) {
     return 2;
   }
@@ -45992,252 +46214,30 @@ var init_wrap_ansi2 = __esm({
           if (groups.code !== void 0) {
             const code2 = Number.parseFloat(groups.code);
             escapeCode = code2 === END_CODE2 ? void 0 : code2;
-          } else if (groups.uri !== void 0) {
-            escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
-          }
-        }
-        const code = ansi_styles_default3.codes.get(Number(escapeCode));
-        if (pre[index + 1] === "\n") {
-          if (escapeUrl) {
-            returnValue += wrapAnsiHyperlink2("");
-          }
-          if (escapeCode && code) {
-            returnValue += wrapAnsiCode2(code);
-          }
-        } else if (character === "\n") {
-          if (escapeCode && code) {
-            returnValue += wrapAnsiCode2(escapeCode);
-          }
-          if (escapeUrl) {
-            returnValue += wrapAnsiHyperlink2(escapeUrl);
-          }
-        }
-        preStringIndex += character.length;
-      }
-      return returnValue;
-    };
-  }
-});
-
-// node_modules/json-schema/lib/validate.js
-var require_validate = __commonJS({
-  "node_modules/json-schema/lib/validate.js"(exports2, module2) {
-    (function(root, factory) {
-      if (typeof define === "function" && define.amd) {
-        define([], function() {
-          return factory();
-        });
-      } else if (typeof module2 === "object" && module2.exports) {
-        module2.exports = factory();
-      } else {
-        root.jsonSchema = factory();
-      }
-    })(exports2, function() {
-      var exports3 = validate4;
-      exports3.Integer = { type: "integer" };
-      var primitiveConstructors = {
-        String,
-        Boolean,
-        Number,
-        Object,
-        Array,
-        Date
-      };
-      exports3.validate = validate4;
-      function validate4(instance, schema) {
-        return validate4(instance, schema, { changing: false });
-      }
-      ;
-      exports3.checkPropertyChange = function(value, schema, property) {
-        return validate4(value, schema, { changing: property || "property" });
-      };
-      var validate4 = exports3._validate = function(instance, schema, options) {
-        if (!options)
-          options = {};
-        var _changing = options.changing;
-        function getType(schema2) {
-          return schema2.type || primitiveConstructors[schema2.name] == schema2 && schema2.name.toLowerCase();
-        }
-        var errors = [];
-        function checkProp(value, schema2, path6, i) {
-          var l;
-          path6 += path6 ? typeof i == "number" ? "[" + i + "]" : typeof i == "undefined" ? "" : "." + i : i;
-          function addError(message2) {
-            errors.push({ property: path6, message: message2 });
-          }
-          if ((typeof schema2 != "object" || schema2 instanceof Array) && (path6 || typeof schema2 != "function") && !(schema2 && getType(schema2))) {
-            if (typeof schema2 == "function") {
-              if (!(value instanceof schema2)) {
-                addError("is not an instance of the class/constructor " + schema2.name);
-              }
-            } else if (schema2) {
-              addError("Invalid schema/property definition " + schema2);
-            }
-            return null;
-          }
-          if (_changing && schema2.readonly) {
-            addError("is a readonly field, it can not be changed");
-          }
-          if (schema2["extends"]) {
-            checkProp(value, schema2["extends"], path6, i);
-          }
-          function checkType(type, value2) {
-            if (type) {
-              if (typeof type == "string" && type != "any" && (type == "null" ? value2 !== null : typeof value2 != type) && !(value2 instanceof Array && type == "array") && !(value2 instanceof Date && type == "date") && !(type == "integer" && value2 % 1 === 0)) {
-                return [{ property: path6, message: value2 + " - " + typeof value2 + " value found, but a " + type + " is required" }];
-              }
-              if (type instanceof Array) {
-                var unionErrors = [];
-                for (var j2 = 0; j2 < type.length; j2++) {
-                  if (!(unionErrors = checkType(type[j2], value2)).length) {
-                    break;
-                  }
-                }
-                if (unionErrors.length) {
-                  return unionErrors;
-                }
-              } else if (typeof type == "object") {
-                var priorErrors = errors;
-                errors = [];
-                checkProp(value2, type, path6);
-                var theseErrors = errors;
-                errors = priorErrors;
-                return theseErrors;
-              }
-            }
-            return [];
-          }
-          if (value === void 0) {
-            if (schema2.required) {
-              addError("is missing and it is required");
-            }
-          } else {
-            errors = errors.concat(checkType(getType(schema2), value));
-            if (schema2.disallow && !checkType(schema2.disallow, value).length) {
-              addError(" disallowed value was matched");
-            }
-            if (value !== null) {
-              if (value instanceof Array) {
-                if (schema2.items) {
-                  var itemsIsArray = schema2.items instanceof Array;
-                  var propDef = schema2.items;
-                  for (i = 0, l = value.length; i < l; i += 1) {
-                    if (itemsIsArray)
-                      propDef = schema2.items[i];
-                    if (options.coerce)
-                      value[i] = options.coerce(value[i], propDef);
-                    errors.concat(checkProp(value[i], propDef, path6, i));
-                  }
-                }
-                if (schema2.minItems && value.length < schema2.minItems) {
-                  addError("There must be a minimum of " + schema2.minItems + " in the array");
-                }
-                if (schema2.maxItems && value.length > schema2.maxItems) {
-                  addError("There must be a maximum of " + schema2.maxItems + " in the array");
-                }
-              } else if (schema2.properties || schema2.additionalProperties) {
-                errors.concat(checkObj(value, schema2.properties, path6, schema2.additionalProperties));
-              }
-              if (schema2.pattern && typeof value == "string" && !value.match(schema2.pattern)) {
-                addError("does not match the regex pattern " + schema2.pattern);
-              }
-              if (schema2.maxLength && typeof value == "string" && value.length > schema2.maxLength) {
-                addError("may only be " + schema2.maxLength + " characters long");
-              }
-              if (schema2.minLength && typeof value == "string" && value.length < schema2.minLength) {
-                addError("must be at least " + schema2.minLength + " characters long");
-              }
-              if (typeof schema2.minimum !== "undefined" && typeof value == typeof schema2.minimum && schema2.minimum > value) {
-                addError("must have a minimum value of " + schema2.minimum);
-              }
-              if (typeof schema2.maximum !== "undefined" && typeof value == typeof schema2.maximum && schema2.maximum < value) {
-                addError("must have a maximum value of " + schema2.maximum);
-              }
-              if (schema2["enum"]) {
-                var enumer = schema2["enum"];
-                l = enumer.length;
-                var found;
-                for (var j = 0; j < l; j++) {
-                  if (enumer[j] === value) {
-                    found = 1;
-                    break;
-                  }
-                }
-                if (!found) {
-                  addError("does not have a value in the enumeration " + enumer.join(", "));
-                }
-              }
-              if (typeof schema2.maxDecimal == "number" && value.toString().match(new RegExp("\\.[0-9]{" + (schema2.maxDecimal + 1) + ",}"))) {
-                addError("may only have " + schema2.maxDecimal + " digits of decimal places");
-              }
-            }
-          }
-          return null;
-        }
-        function checkObj(instance2, objTypeDef, path6, additionalProp) {
-          if (typeof objTypeDef == "object") {
-            if (typeof instance2 != "object" || instance2 instanceof Array) {
-              errors.push({ property: path6, message: "an object is required" });
-            }
-            for (var i in objTypeDef) {
-              if (objTypeDef.hasOwnProperty(i) && i != "__proto__" && i != "constructor") {
-                var value = instance2.hasOwnProperty(i) ? instance2[i] : void 0;
-                if (value === void 0 && options.existingOnly)
-                  continue;
-                var propDef = objTypeDef[i];
-                if (value === void 0 && propDef["default"]) {
-                  value = instance2[i] = propDef["default"];
-                }
-                if (options.coerce && i in instance2) {
-                  value = instance2[i] = options.coerce(value, propDef);
-                }
-                checkProp(value, propDef, path6, i);
-              }
-            }
-          }
-          for (i in instance2) {
-            if (instance2.hasOwnProperty(i) && !(i.charAt(0) == "_" && i.charAt(1) == "_") && objTypeDef && !objTypeDef[i] && additionalProp === false) {
-              if (options.filter) {
-                delete instance2[i];
-                continue;
-              } else {
-                errors.push({ property: path6, message: "The property " + i + " is not defined in the schema and the schema does not allow additional properties" });
-              }
-            }
-            var requires = objTypeDef && objTypeDef[i] && objTypeDef[i].requires;
-            if (requires && !(requires in instance2)) {
-              errors.push({ property: path6, message: "the presence of the property " + i + " requires that " + requires + " also be present" });
-            }
-            value = instance2[i];
-            if (additionalProp && (!(objTypeDef && typeof objTypeDef == "object") || !(i in objTypeDef))) {
-              if (options.coerce) {
-                value = instance2[i] = options.coerce(value, additionalProp);
-              }
-              checkProp(value, additionalProp, path6, i);
-            }
-            if (!_changing && value && value.$schema) {
-              errors = errors.concat(checkProp(value, value.$schema, path6, i));
-            }
+          } else if (groups.uri !== void 0) {
+            escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
           }
-          return errors;
-        }
-        if (schema) {
-          checkProp(instance, schema, "", _changing || "");
-        }
-        if (!_changing && instance && instance.$schema) {
-          checkProp(instance, instance.$schema, "", "");
         }
-        return { valid: !errors.length, errors };
-      };
-      exports3.mustBeValid = function(result) {
-        if (!result.valid) {
-          throw new TypeError(result.errors.map(function(error) {
-            return "for property " + error.property + ": " + error.message;
-          }).join(", \n"));
+        const code = ansi_styles_default3.codes.get(Number(escapeCode));
+        if (pre[index + 1] === "\n") {
+          if (escapeUrl) {
+            returnValue += wrapAnsiHyperlink2("");
+          }
+          if (escapeCode && code) {
+            returnValue += wrapAnsiCode2(code);
+          }
+        } else if (character === "\n") {
+          if (escapeCode && code) {
+            returnValue += wrapAnsiCode2(escapeCode);
+          }
+          if (escapeUrl) {
+            returnValue += wrapAnsiHyperlink2(escapeUrl);
+          }
         }
-      };
-      return exports3;
-    });
+        preStringIndex += character.length;
+      }
+      return returnValue;
+    };
   }
 });
 
@@ -66915,53 +66915,258 @@ var ConfigureCommand = class {
       currentProfileName,
       availableProfiles[currentProfileName]
     );
-    availableProfiles[currentProfileName] = updatedProfile;
-    saveProfiles(availableProfiles);
+    availableProfiles[currentProfileName] = updatedProfile;
+    saveProfiles(availableProfiles);
+  }
+  async selectProfile(profiles) {
+    const profileNames = Object.keys(profiles);
+    const { profileName } = await esm_default12.prompt({
+      type: "list",
+      name: "profileName",
+      message: "Select a profile to configure:",
+      choices: [...profileNames, "Create a new profile"]
+    });
+    if (profileName === "Create a new profile") {
+      const { newProfileName } = await esm_default12.prompt({
+        type: "input",
+        name: "newProfileName",
+        message: "Enter the name for the new profile:",
+        validate: (input) => profileNames.includes(input) ? "Profile already exists!" : true
+      });
+      profiles[newProfileName] = {
+        kongBaseUrl: urlText("")
+      };
+      return newProfileName;
+    }
+    return profileName;
+  }
+  async configureProfile(profileName, profile) {
+    const currentConfig = profile || {
+      kongBaseUrl: urlText("")
+    };
+    const answers = await esm_default12.prompt({
+      type: "input",
+      name: "kongUrl",
+      message: `Enter Kong URL for profile "${profileName}":`,
+      default: currentConfig.kongBaseUrl
+    });
+    const updatedProfile = { ...currentConfig };
+    updatedProfile.kongBaseUrl = urlText(answers.kongUrl);
+    console.log(`Configuration for profile "${profileName}" has been updated.`);
+    return updatedProfile;
+  }
+};
+
+// packages/kong-cli/src/commands/generateCommand.ts
+var import_create_nx_workspace = __toESM(require_create_nx_workspace());
+
+// packages/kong-cli/src/common/kongJson.ts
+var import_fs3 = __toESM(require("fs"));
+var import_json_schema = __toESM(require_validate());
+
+// packages/kong-cli/src/common/kongJsonSchema.ts
+var KONG_JSON_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  properties: {
+    id: {
+      type: "string"
+    },
+    name: {
+      type: "string"
+    },
+    ownership: {
+      type: "array",
+      items: {
+        type: "string"
+      }
+    },
+    sdk: {
+      type: "string",
+      enum: ["python", "kotlin"]
+    },
+    alias: {
+      type: "object",
+      properties: {
+        env: {
+          type: "object",
+          additionalProperties: true
+        },
+        input: {
+          type: "object",
+          properties: {
+            filter: {
+              type: "string"
+            },
+            schema: {
+              $ref: "https://json-schema.org/draft-07/schema#"
+            }
+          },
+          required: ["schema", "filter"]
+        },
+        output: {
+          type: "object",
+          properties: {
+            filter: {
+              type: "string"
+            },
+            schema: {
+              $ref: "https://json-schema.org/draft-07/schema#"
+            }
+          },
+          required: ["schema", "filter"]
+        },
+        invoke: {
+          type: "object",
+          properties: {
+            prefix: {
+              type: "string"
+            },
+            cache: {
+              type: "object",
+              properties: {
+                enabled: {
+                  type: "boolean"
+                },
+                key: {
+                  type: ["string"]
+                },
+                ttl: {
+                  type: "string"
+                },
+                onFailure: {
+                  type: "string",
+                  enum: ["skip", "retry"]
+                }
+              },
+              required: ["enabled", "key", "ttl", "onFailure"]
+            },
+            retry: {
+              type: "object",
+              properties: {
+                maxAttempts: {
+                  type: "number"
+                },
+                attemptDelay: {
+                  type: "string"
+                },
+                attemptTimeout: {
+                  type: "string"
+                }
+              },
+              required: ["maxAttempts", "attemptDelay", "attemptTimeout"]
+            },
+            circuitBreaker: {
+              type: "object",
+              properties: {
+                enabled: {
+                  type: "boolean"
+                },
+                requestVolumeThreshold: {
+                  type: "number"
+                },
+                failureRatio: {
+                  type: "number"
+                },
+                successThreshold: {
+                  type: "number"
+                }
+              },
+              required: ["enabled", "requestVolumeThreshold", "failureRatio", "successThreshold"]
+            },
+            rateLimiter: {
+              type: "object",
+              properties: {
+                enabled: {
+                  type: "boolean"
+                },
+                value: {
+                  type: "number"
+                },
+                window: {
+                  type: "string"
+                },
+                minSpacing: {
+                  type: "string"
+                }
+              },
+              required: ["enabled", "value", "window", "minSpacing"]
+            }
+          }
+        }
+      },
+      additionalProperties: false
+    }
+  },
+  additionalProperties: false,
+  required: ["id", "name", "ownership", "sdk"]
+};
+
+// packages/kong-cli/src/common/kongJson.ts
+var SUPPORTED_SDK = ["kotlin", "python"];
+function validateKongJson(kongJson) {
+  if (isEmpty(kongJson.id)) {
+    throw new AppError(
+      "The `id` field should not be empty. Please provide a valid identifier in kong.json."
+    );
+  }
+  if (!/^[a-zA-Z0-9]{12}$/.test(kongJson.id)) {
+    throw new AppError(
+      "The `id` should contain exactly 12 alphanumeric characters (letters and digits). Ensure the ID is not longer than 12 characters and does not include any special characters.Please provide a valid identifier in kong.json."
+    );
+  }
+  if (!SUPPORTED_SDK.includes(kongJson.sdk)) {
+    throw new AppError(
+      `Unexpected SDK value: ${kongJson.sdk}. Supported SDK: ${SUPPORTED_SDK}.Please provide a valid identifier in kong.json.`
+    );
+  }
+  if (isEmpty(kongJson.name)) {
+    throw new AppError(
+      "The `name` field should not be empty. Please provide a valid name  in kong.json."
+    );
+  }
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(kongJson.name)) {
+    throw new AppError(
+      "The `name` should only contain lowercase letters, digits, and dashes. Dashes can only appear between alphanumeric characters, and the name cannot start or end with a dash.Please provide a valid name in kong.json."
+    );
+  }
+  if (kongJson.ownership.length === 0) {
+    throw new AppError(
+      "The `ownership` field should contain at least one user name. Please provide valid ownership information in kong.json."
+    );
+  }
+  const result = (0, import_json_schema.validate)(kongJson.alias, KONG_JSON_SCHEMA);
+  if (result.errors.length) {
+    throw new AppError(
+      "The provided `kong.json` does not follow the expected JSON schema. Errors: \n" + prettyJson(result.errors)
+    );
   }
-  async selectProfile(profiles) {
-    const profileNames = Object.keys(profiles);
-    const { profileName } = await esm_default12.prompt({
-      type: "list",
-      name: "profileName",
-      message: "Select a profile to configure:",
-      choices: [...profileNames, "Create a new profile"]
-    });
-    if (profileName === "Create a new profile") {
-      const { newProfileName } = await esm_default12.prompt({
-        type: "input",
-        name: "newProfileName",
-        message: "Enter the name for the new profile:",
-        validate: (input) => profileNames.includes(input) ? "Profile already exists!" : true
-      });
-      profiles[newProfileName] = {
-        kongBaseUrl: urlText("")
-      };
-      return newProfileName;
+  return kongJson;
+}
+function getKongJson() {
+  const kongJsonPath = resolveProjectPath("kong.json");
+  try {
+    const fileContent = import_fs3.default.readFileSync(kongJsonPath, "utf-8");
+    const kongJson = JSON.parse(fileContent);
+    return validateKongJson(kongJson);
+  } catch (ex) {
+    if (ex instanceof SyntaxError) {
+      throw new AppError(`Error parsing kong.json: ${ex.message}`);
     }
-    return profileName;
-  }
-  async configureProfile(profileName, profile) {
-    const currentConfig = profile || {
-      kongBaseUrl: urlText("")
-    };
-    const answers = await esm_default12.prompt({
-      type: "input",
-      name: "kongUrl",
-      message: `Enter Kong URL for profile "${profileName}":`,
-      default: currentConfig.kongBaseUrl
-    });
-    const updatedProfile = { ...currentConfig };
-    updatedProfile.kongBaseUrl = urlText(answers.kongUrl);
-    console.log(`Configuration for profile "${profileName}" has been updated.`);
-    return updatedProfile;
+    throw ex;
   }
-};
+}
 
 // packages/kong-cli/src/commands/generateCommand.ts
-var import_create_nx_workspace = __toESM(require_create_nx_workspace());
 var GenerateCommand = class {
   async execute(extensionName, sdk, presetVersion) {
     const id = generateShortId();
+    validateKongJson({
+      id,
+      sdk,
+      name: extensionName,
+      ownership: ["devkong"]
+    });
     await (0, import_create_nx_workspace.createWorkspace)(`@devkong/cli-nx@${presetVersion}`, {
       name: extensionName,
       id,
@@ -69513,201 +69718,6 @@ var InstallCommand = class {
   }
 };
 
-// packages/kong-cli/src/common/kongJson.ts
-var import_fs3 = __toESM(require("fs"));
-var import_json_schema = __toESM(require_validate());
-
-// packages/kong-cli/src/common/kongJsonSchema.ts
-var KONG_JSON_SCHEMA = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  type: "object",
-  properties: {
-    id: {
-      type: "string"
-    },
-    name: {
-      type: "string"
-    },
-    ownership: {
-      type: "array",
-      items: {
-        type: "string"
-      }
-    },
-    sdk: {
-      type: "string",
-      enum: ["python", "kotlin"]
-    },
-    alias: {
-      type: "object",
-      properties: {
-        env: {
-          type: "object",
-          additionalProperties: true
-        },
-        input: {
-          type: "object",
-          properties: {
-            filter: {
-              type: "string"
-            },
-            schema: {
-              $ref: "https://json-schema.org/draft-07/schema#"
-            }
-          },
-          required: ["schema", "filter"]
-        },
-        output: {
-          type: "object",
-          properties: {
-            filter: {
-              type: "string"
-            },
-            schema: {
-              $ref: "https://json-schema.org/draft-07/schema#"
-            }
-          },
-          required: ["schema", "filter"]
-        },
-        invoke: {
-          type: "object",
-          properties: {
-            prefix: {
-              type: "string"
-            },
-            cache: {
-              type: "object",
-              properties: {
-                enabled: {
-                  type: "boolean"
-                },
-                key: {
-                  type: ["string"]
-                },
-                ttl: {
-                  type: "string"
-                },
-                onFailure: {
-                  type: "string",
-                  enum: ["skip", "retry"]
-                }
-              },
-              required: ["enabled", "key", "ttl", "onFailure"]
-            },
-            retry: {
-              type: "object",
-              properties: {
-                maxAttempts: {
-                  type: "number"
-                },
-                attemptDelay: {
-                  type: "string"
-                },
-                attemptTimeout: {
-                  type: "string"
-                }
-              },
-              required: ["maxAttempts", "attemptDelay", "attemptTimeout"]
-            },
-            circuitBreaker: {
-              type: "object",
-              properties: {
-                enabled: {
-                  type: "boolean"
-                },
-                requestVolumeThreshold: {
-                  type: "number"
-                },
-                failureRatio: {
-                  type: "number"
-                },
-                successThreshold: {
-                  type: "number"
-                }
-              },
-              required: ["enabled", "requestVolumeThreshold", "failureRatio", "successThreshold"]
-            },
-            rateLimiter: {
-              type: "object",
-              properties: {
-                enabled: {
-                  type: "boolean"
-                },
-                value: {
-                  type: "number"
-                },
-                window: {
-                  type: "string"
-                },
-                minSpacing: {
-                  type: "string"
-                }
-              },
-              required: ["enabled", "value", "window", "minSpacing"]
-            }
-          }
-        }
-      },
-      additionalProperties: false
-    }
-  },
-  additionalProperties: false,
-  required: ["id", "name", "ownership", "sdk"]
-};
-
-// packages/kong-cli/src/common/kongJson.ts
-var SUPPORTED_SDK = ["kotlin", "python"];
-function validateKongJson(kongJson) {
-  if (isEmpty(kongJson.id)) {
-    throw new AppError(
-      "The `id` field should not be empty. Please provide a valid identifier in kong.json."
-    );
-  }
-  if (!SUPPORTED_SDK.includes(kongJson.sdk)) {
-    throw new AppError(`Unexpected SDK value: ${kongJson.sdk}. Supported SDK: ${SUPPORTED_SDK}.`);
-  }
-  if (!/^[a-zA-Z0-9]{12}$/.test(kongJson.id)) {
-    throw new AppError(
-      "The `id` should contain exactly 12 alphanumeric characters (letters and digits). Ensure the ID is not longer than 12 characters and does not include any special characters."
-    );
-  }
-  if (isEmpty(kongJson.name)) {
-    throw new AppError(
-      "The `name` field should not be empty. Please provide a valid name  in kong.json."
-    );
-  }
-  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(kongJson.name)) {
-    throw new AppError(
-      "The `name` should only contain lowercase letters, digits, and dashes. Dashes can only appear between alphanumeric characters, and the name cannot start or end with a dash."
-    );
-  }
-  if (kongJson.ownership.length === 0) {
-    throw new AppError(
-      "The `ownership` field should contain at least one user name. Please provide valid ownership information in kong.json."
-    );
-  }
-  const result = (0, import_json_schema.validate)(kongJson.alias, KONG_JSON_SCHEMA);
-  if (result.errors.length) {
-    throw new AppError(
-      "The provided `kong.json` does not follow the expected JSON schema. Errors: \n" + prettyJson(result.errors)
-    );
-  }
-  return kongJson;
-}
-function getKongJson() {
-  const kongJsonPath = resolveProjectPath("kong.json");
-  try {
-    const fileContent = import_fs3.default.readFileSync(kongJsonPath, "utf-8");
-    const kongJson = JSON.parse(fileContent);
-    return validateKongJson(kongJson);
-  } catch (ex) {
-    if (ex instanceof SyntaxError) {
-      throw new AppError(`Error parsing kong.json: ${ex.message}`);
-    }
-    throw ex;
-  }
-}
-
 // packages/kong-cli/src/services/api.ts
 var API_HEADERS = {
   headers: {
@@ -69942,12 +69952,23 @@ var PublicClient = class {
 };
 
 // packages/kong-cli/src/commands/setExtensionAliasCommand.ts
+function validateName(value) {
+  if (isEmpty(value)) {
+    throw new AppError("The alias name should not be empty.");
+  }
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value)) {
+    throw new AppError(
+      "The alias name should only contain lowercase letters, digits, and dashes. Dashes can only appear between alphanumeric characters, and the name cannot start or end with a dash."
+    );
+  }
+}
 var SetExtensionAliasCommand = class {
   constructor(profile) {
     this.publicClient = new PublicClient(profile.kongBaseUrl);
     this.managementClient = new ManagementClient(profile.kongBaseUrl);
   }
   async execute(aliasName, extensionVersion) {
+    validateName(aliasName);
     await new Listr(
       [
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devkong/cli",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "type": "commonjs",
   "main": "./index.js",
   "typings": "./index.d.ts",

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

@@ -7,4 +7,5 @@ export interface KongJson {
     ownership: [User["name"], ...Array<User["name"]>];
     alias?: SdkExtensionAlias;
 }
+export declare function validateKongJson(kongJson: KongJson): KongJson;
 export declare function getKongJson(): KongJson;

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

@@ -1,3 +1,4 @@
+import { ShortUUID } from "@kong/ts";
 export interface ILogger {
     info(message: string): any;
     debug(message: string): any;
@@ -7,6 +8,6 @@ export interface ILogger {
 export declare function env(key: string): string;
 export declare function optionalEnv(key: string): string;
 export declare function resolveProjectPath(fileName: string): string;
-export declare function generateShortId(): string;
+export declare function generateShortId(): ShortUUID;
 export declare function spawnCommand(commandText: string, logger?: ILogger, shell?: boolean): Promise<string>;
 export declare function printError(message: string, error: unknown): void;