wso2 · JaninduRSD · Dec 22, 2025 · Jan 6, 2026 · Jan 20, 2026 · Jan 21, 2026
diff --git a/....wso2.carbon.apimgt.api/src/main/java/org/wso2/carbon/apimgt/api/FederatedAPIBuilder.java b/....wso2.carbon.apimgt.api/src/main/java/org/wso2/carbon/apimgt/api/FederatedAPIBuilder.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2025, WSO2 LLC. (http://www.wso2.com).
+ *
+ * WSO2 LLC. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.wso2.carbon.apimgt.api;
+
+import org.wso2.carbon.apimgt.api.model.API;
+import org.wso2.carbon.apimgt.api.model.APIIdentifier;
+import org.wso2.carbon.apimgt.api.model.Environment;
+
+/**
+ * Abstract builder for creating WSO2 API objects from external API contracts (federated discovery).
+ *
+ * @param <T> The type of the raw data/contract from the external gateway (e.g. Azure API object, Kong API object).
+ */
+public abstract class FederatedAPIBuilder<T> {
+
+    /**
+     * Builds a WSO2 API object from the raw external data.
+     *
+     * @param sourceApi The raw data object from the external gateway.
+     * @param env     The environment where the API is discovered.
+     * @param org     The organization context.
+     * @return The constructed API object.
+     * @throws APIManagementException If an error occurs during building.
+     */
+    public API build(T sourceApi, Environment env, String org) throws APIManagementException {
+        // 1. Basic Identification
+        String provider = org; // Usually defaults to the organization name
+        APIIdentifier apiId = new APIIdentifier(provider, getName(sourceApi), getVersion(sourceApi));
+
+        API api = new API(apiId);
+
+        // 2. Map Common Properties
+        api.setContext(getContext(sourceApi));
+        api.setContextTemplate(getContextTemplate(sourceApi));
+        api.setUuid(getGatewayId(sourceApi)); // Important for mapping updates later
+        api.setDescription(getDescription(sourceApi));
+
+        // 3. Set Standard WSO2 Flags
+        api.setOrganization(org);
+        if (env != null) {
+            api.setGatewayType(env.getGatewayType());
+        }
+        api.setInitiatedFromGateway(true);
+        api.setRevision(false);
+        api.setGatewayVendor("external");
+
+        // 4. Specific Mapping (Delegated to subclasses)
+        mapSpecificDetails(api, sourceApi, env);
+
+        return api;
+    }
+
+    /**
+     * Extracts the name of the API from the raw data.
+     *
+     * @param sourceApi The raw data object.
+     * @return The API name.
+     */
+    protected abstract String getName(T sourceApi);
+
+    /**
+     * Extracts the version of the API from the raw data.
+     *
+     * @param sourceApi The raw data object.
+     * @return The API version.
+     */
+    protected abstract String getVersion(T sourceApi);
+
+    /**
+     * Extracts the context/path of the API from the raw data.
+     *
+     * @param sourceApi The raw data object.
+     * @return The API context.
+     */
+    protected abstract String getContext(T sourceApi);
+
+    /**
+     * Extracts the context/path of the API from the raw data.
+     *
+     * @param sourceApi The raw data object.
+     * @return The API context template.
+     */
+    protected abstract String getContextTemplate(T sourceApi);
+
+    /**
+     * Extracts the unique ID (UUID) from the external gateway.
+     * This is used to link the WSO2 API to the External API for updates.
+     *
+     * @param sourceApi The raw data object.
+     * @return The unique gateway ID.
+     */
+    protected abstract String getGatewayId(T sourceApi);
+
+    /**
+     * Extracts the description of the API from the raw data.
+     *
+     * @param sourceApi The raw data object.
+     * @return The API description.
+     */
+    protected abstract String getDescription(T sourceApi);
+
+    /**
+     * Maps type-specific details (protocol, endpoints, definitions, etc.) to the API object.
+     *
+     * @param api     The WSO2 API object to populate.
+     * @param sourceApi The raw data object.
+     * @throws APIManagementException If an error occurs during mapping.
+     */
+    protected abstract void mapSpecificDetails(API api, T sourceApi, Environment env) throws APIManagementException;
+
+    /**
+     * Checks if this builder can handle the given raw data object.
+     *
+     * @param sourceApi The raw data object.
+     * @return True if this builder can handle the object, false otherwise.
+     */
+    public abstract boolean canHandle(T sourceApi);
+}
diff --git a/...2.carbon.apimgt.api/src/main/java/org/wso2/carbon/apimgt/api/FederatedBuilderFactory.java b/...2.carbon.apimgt.api/src/main/java/org/wso2/carbon/apimgt/api/FederatedBuilderFactory.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2025 WSO2 LLC. (http://www.wso2.org) All Rights Reserved.
+ *
+ * WSO2 LLC. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.wso2.carbon.apimgt.api;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Abstract factory for creating and managing FederatedAPIBuilder instances.
+ * This provides a gateway-agnostic way to select the appropriate builder
+ * for different API types (REST, WebSocket, GraphQL, etc.).
+ * 
+ * Gateway-specific implementations (AzureBuilderFactory, AWSBuilderFactory, etc.)
+ * should extend this class and register their specific builders.
+ * 
+ * @param <T> The type of raw API data from the gateway (e.g., ApiContract for Azure, RestApi for AWS)
+ */
+public abstract class FederatedBuilderFactory<T> {
+
+    private final List<FederatedAPIBuilder<T>> builders;
+
+    /**
+     * Constructor initializes the builders list.
+     * Subclasses should call this and then register their builders.
+     */
+    public FederatedBuilderFactory() {
+        this.builders = new ArrayList<>();
+    }
+
+    /**
+     * Gets the appropriate builder for the given raw API data.
+     * Uses the Strategy pattern - iterates through registered builders
+     * and returns the first one that can handle the API type.
+     * 
+     * @param sourceApi The raw API data from the gateway
+     * @return The builder that can handle this API type, or null if unsupported
+     */
+    public FederatedAPIBuilder<T> getBuilder(T sourceApi) {
+        for (FederatedAPIBuilder<T> builder : builders) {
+            if (builder.canHandle(sourceApi)) {
+                return builder;
+            }
+        }
+        throw new IllegalStateException(
+        "No registered builder can handle the given API data");
+    }
+
+    /**
+     * Checks if the given API type is supported by any registered builder.
+     * 
+     * @param sourceApi The raw API data from the gateway
+     * @return true if a builder can handle this API type, false otherwise
+     */
+    public boolean isSupported(T sourceApi) {
+        try {
+            return getBuilder(sourceApi) != null;
+        } catch (IllegalStateException e) {
+            return false;
+        }
+    }
-    /**
-     * Gets the appropriate builder for the given raw API data.
-     * Uses the Strategy pattern - iterates through registered builders
-     * and returns the first one that can handle the API type.
-     * 
-     * @param sourceApi The raw API data from the gateway
-     * @return The builder that can handle this API type, or null if unsupported
-     */
-    public FederatedAPIBuilder<T> getBuilder(T sourceApi) {
-        for (FederatedAPIBuilder<T> builder : builders) {
-            if (builder.canHandle(sourceApi)) {
-                return builder;
-            }
-        }
-        throw new IllegalStateException(
-        "No registered builder can handle the given API data");
-    }
-    
-    /**
-     * Checks if the given API type is supported by any registered builder.
-     * 
-     * @param sourceApi The raw API data from the gateway
-     * @return true if a builder can handle this API type, false otherwise
-     */
-    public boolean isSupported(T sourceApi) {
-        try {
-            return getBuilder(sourceApi) != null;
-        } catch (IllegalStateException e) {
-            return false;
-        }
-    }
+    /**
+     * Gets the appropriate builder for the given raw API data.
+     * Uses the Strategy pattern - iterates through registered builders
+     * and returns the first one that can handle the API type.
+     * 
+     * `@param` sourceApi The raw API data from the gateway
+     * `@return` The builder that can handle this API type, or null if unsupported
+     */
+    private FederatedAPIBuilder<T> findBuilder(T sourceApi) {
+        for (FederatedAPIBuilder<T> builder : builders) {
+            if (builder.canHandle(sourceApi)) {
+                return builder;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Gets the appropriate builder for the given raw API data.
+     * Uses the Strategy pattern - iterates through registered builders
+     * and returns the first one that can handle the API type.
+     * 
+     * `@param` sourceApi The raw API data from the gateway
+     * `@return` The builder that can handle this API type, or null if unsupported
+     */
+    public FederatedAPIBuilder<T> getBuilder(T sourceApi) {
+        FederatedAPIBuilder<T> builder = findBuilder(sourceApi);
+        if (builder != null) {
+            return builder;
+        }
+        throw new IllegalStateException(
+                "No registered builder can handle the given API data");
+    }
+    
+    /**
+     * {`@inheritDoc`}
+     */
+    public boolean isSupported(T sourceApi) {
+        return findBuilder(sourceApi) != null;
+    }
-    /**
-     * Gets the appropriate builder for the given raw API data.
-     * Uses the Strategy pattern - iterates through registered builders
-     * and returns the first one that can handle the API type.
-     * 
-     * @param sourceApi The raw API data from the gateway
-     * @return The builder that can handle this API type, or null if unsupported
-     */
-    public FederatedAPIBuilder<T> getBuilder(T sourceApi) {
-        for (FederatedAPIBuilder<T> builder : builders) {
-            if (builder.canHandle(sourceApi)) {
-                return builder;
-            }
-        }
-        throw new IllegalStateException(
-        "No registered builder can handle the given API data");
-    }
-    
-    /**
-     * Checks if the given API type is supported by any registered builder.
-     * 
-     * @param sourceApi The raw API data from the gateway
-     * @return true if a builder can handle this API type, false otherwise
-     */
-    public boolean isSupported(T sourceApi) {
-        try {
-            return getBuilder(sourceApi) != null;
-        } catch (IllegalStateException e) {
-            return false;
-        }
-    }
+    /**
+     * Gets the appropriate builder for the given raw API data.
+     * Uses the Strategy pattern - iterates through registered builders
+     * and returns the first one that can handle the API type.
+     * 
+     * `@param` sourceApi The raw API data from the gateway
+     * `@return` The builder that can handle this API type, or null if unsupported
+     */
+    private FederatedAPIBuilder<T> findBuilder(T sourceApi) {
+        for (FederatedAPIBuilder<T> builder : builders) {
+            if (builder.canHandle(sourceApi)) {
+                return builder;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Gets the appropriate builder for the given raw API data.
+     * Uses the Strategy pattern - iterates through registered builders
+     * and returns the first one that can handle the API type.
+     * 
+     * `@param` sourceApi The raw API data from the gateway
+     * `@return` The builder that can handle this API type, or null if unsupported
+     */
+    public FederatedAPIBuilder<T> getBuilder(T sourceApi) {
+        FederatedAPIBuilder<T> builder = findBuilder(sourceApi);
+        if (builder != null) {
+            return builder;
+        }
+        throw new IllegalStateException(
+                "No registered builder can handle the given API data");
+    }
+    
+    /**
+     * {`@inheritDoc`}
+     */
+    public boolean isSupported(T sourceApi) {
+        return findBuilder(sourceApi) != null;
+    }
+
+    /**
+     * Registers a builder in the factory.
+     * Subclasses can use this to add builders in their constructor.
+     * 
+     * @param builder The builder to register
+     */
+    protected void registerBuilder(FederatedAPIBuilder<T> builder) {
+        if (builder != null) {
+            // 1. Check if ANY builder in the list has the same CLASS as the new one
+            boolean alreadyExists = false;
+            for (FederatedAPIBuilder<T> existing : builders) {
+                if (existing.getClass().equals(builder.getClass())) {
+                    alreadyExists = true;
+                    break;
+                }
+            }
+
+            if (!alreadyExists) {
+                builders.add(builder);
+            }
+        }
+    }
+
+    /**
+     * Gets all registered builders.
+     * Useful for testing and debugging.
+     * 
+     * @return List of all registered builders
+     */
+    public List<FederatedAPIBuilder<T>> getRegisteredBuilders() {
+        return new ArrayList<>(builders); // Return a copy for safety
+    }
+
+    /**
+     * Gets the count of registered builders.
+     * 
+     * @return Number of registered builders
+     */
+    public int getBuilderCount() {
+        return builders.size();
+    }
+}
@@ -292,10 +292,26 @@ private void processDiscoveredAPIs(List<DiscoveredAPI> apisToDeployInGatewayEnv,
                     JsonObject apiJson = (JsonObject) new Gson().toJsonTree(apidto);
                     apiJson = CommonUtil.addTypeAndVersionToFile(ImportExportConstants.TYPE_API,
                             ImportExportConstants.APIM_VERSION, apiJson);
+                    String definition;
+                    if (api.isAsync()) {
+                        definition = api.getAsyncApiDefinition();
+                    } else {
+                        definition = api.getSwaggerDefinition();
+                    }
+
+                    if (definition == null || StringUtils.isBlank(definition)) {
+                        log.warn("API definition is empty for: " + apidto.getName() + " version: "
+                            + apidto.getVersion());
+                        if (log.isDebugEnabled()) {
+                            log.debug("API type: " + apidto.getType() + ", API object: " + api.toString());
+                        }
+                        continue;
+                    }
+
                     InputStream apiZip = FederatedGatewayUtil.createZipAsInputStream(
-                    InputStream apiZip = FederatedGatewayUtil.createZipAsInputStream(
+                    InputStream apiZip = FederatedGatewayUtil.createZipAsInputStream(
+                    log.info("Creating import package for API: " + apidto.getName() + " version: " + apidto.getVersion());
-                    InputStream apiZip = FederatedGatewayUtil.createZipAsInputStream(
+                    InputStream apiZip = FederatedGatewayUtil.createZipAsInputStream(
+                    log.info("Creating import package for API: " + apidto.getName() + " version: " + apidto.getVersion());
-                            apiJson.toString(), api.getSwaggerDefinition(),
+                            apiJson.toString(), definition,
                             FederatedGatewayUtil.createDeploymentYaml(environment),
-                            apidto.getName());
+                            apidto.getName(), api.isAsync());
 
                     ImportExportAPI importExportAPI = APIImportExportUtil.getImportExportAPI();
 

@@ -106,9 +106,9 @@ public static API createNewAPIVersion(String apiUUID, String newVersion, String
         return provider.createNewAPIVersion(apiUUID, newVersion, true, organization);
     }
 
-    public static InputStream createZipAsInputStream(String apiYaml, String swaggerYaml, String deploymentYaml,
-                                                     String zipName) throws IOException {
-        if (apiYaml == null || swaggerYaml == null || deploymentYaml == null) {
+    public static InputStream createZipAsInputStream(String apiYaml, String apiDefinition, String deploymentYaml,
+                                                     String zipName, boolean isAsync) throws IOException {
+        if (apiYaml == null || apiDefinition == null || deploymentYaml == null) {
             throw new IllegalArgumentException("Input parameters cannot be null for API: " + zipName);
         }
         ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
@@ -117,8 +117,9 @@ public static InputStream createZipAsInputStream(String apiYaml, String swaggerY
             // Add api.yaml
             addToZip(zos, zipName + "/" + API_YAML_FILE_NAME, apiYaml);
 
-            // Add Definitions/swagger.yaml
-            addToZip(zos, zipName + "/" + SWAGGER_YAML_FILE_NAME, swaggerYaml);
+            // Add Definitions/swagger.yaml or Definitions/asyncapi.yaml
+            String definitionFileName = isAsync ? "Definitions/asyncapi.yaml" : SWAGGER_YAML_FILE_NAME;
+            addToZip(zos, zipName + "/" + definitionFileName, apiDefinition);
 
             // Add deployment_environments.yaml
             addToZip(zos, zipName + "/" + DEPLOYMENT_ENVIRONMENTS_FILE_NAME, deploymentYaml);

@@ -1338,7 +1338,7 @@ private void validateKeyManagers(API api, List<String> existingKeyManagers) thro
                         .forEach(validKeyManagers::add);
             }
         }
-        if (validKeyManagers.isEmpty()) {
+        if (validKeyManagers.isEmpty() && !api.isInitiatedFromGateway()) {
             throw new APIManagementException(
-        }
-        if (validKeyManagers.isEmpty()) {
-        if (validKeyManagers.isEmpty() && !api.isInitiatedFromGateway()) {
-            throw new APIManagementException(
+        }
+        if (validKeyManagers.isEmpty() && !api.isInitiatedFromGateway()) {
+            log.error("API validation failed: No valid key managers found for API: " + api.getId());
+            throw new APIManagementException(
-        }
-        if (validKeyManagers.isEmpty()) {
-        if (validKeyManagers.isEmpty() && !api.isInitiatedFromGateway()) {
-            throw new APIManagementException(
+        }
+        if (validKeyManagers.isEmpty() && !api.isInitiatedFromGateway()) {
+            log.error("API validation failed: No valid key managers found for API: " + api.getId());
+            throw new APIManagementException(
                     "API must have at least one valid and enabled key manager configured",
                     ExceptionCodes.KEY_MANAGER_NOT_FOUND);
@@ -2623,7 +2623,8 @@ public API createNewAPIVersion(String existingApiId, String newVersion, Boolean
 
         existingAPI.setOrganization(organization);
         APIIdentifier existingAPIId = existingAPI.getId();
-        String existingAPISwaggerDefinition = existingAPI.getSwaggerDefinition();
+        String existingApiDefinition = existingAPI.isAsync() ? existingAPI.getAsyncApiDefinition() 
+                : existingAPI.getSwaggerDefinition();
         String existingAPICreatedTime = existingAPI.getCreatedTime();
         String existingAPIStatus = existingAPI.getStatus();
         boolean isExsitingAPIdefaultVersion = existingAPI.isDefaultVersion();
@@ -2646,7 +2647,7 @@ public API createNewAPIVersion(String existingApiId, String newVersion, Boolean
         List<OperationPolicy> apiLevelPolicies = extractAndDropAPILevelPoliciesFromAPI(existingAPI);
         updateMCPServerBackends(existingAPI, existingApiId, organization);
         //update swagger definition with version
-        APIUtil.updateAPISwaggerWithVersion(existingAPI);
+        APIUtil.updateAPIDefinitionWithVersion(existingAPI);
         API newAPI = addAPI(existingAPI);
         String newAPIId = newAPI.getUuid();
         cloneAPIPoliciesForNewAPIVersion(existingApiId, newAPI, operationPoliciesMap, apiLevelPolicies);
@@ -2703,7 +2704,11 @@ public API createNewAPIVersion(String existingApiId, String newVersion, Boolean
         existingAPI.setId(existingAPIId);
         existingAPI.setContext(existingContext);
         existingAPI.setCreatedTime(existingAPICreatedTime);
-        existingAPI.setSwaggerDefinition(existingAPISwaggerDefinition);
+        if (existingAPI.isAsync()) {
+            existingAPI.setAsyncApiDefinition(existingApiDefinition);
+        } else {
+            existingAPI.setSwaggerDefinition(existingApiDefinition);
+        }
         // update existing api with the original timestamp
         existingAPI.setVersionTimestamp(existingVersionTimestamp);
         if (isDefaultVersion) {

@@ -12108,8 +12108,9 @@ public static SolaceConfig getSolaceConfig() {
      *
      * @param api The API object whose Swagger definition needs to be updated.
      */
-    public static void updateAPISwaggerWithVersion(API api) {
+    public static void updateAPIDefinitionWithVersion(API api) {
         String swaggerDefinition = api.getSwaggerDefinition();
+        String asyncApiDefinition = api.getAsyncApiDefinition();
 
         if (swaggerDefinition != null) {
             JsonObject apiSpec = JsonParser.parseString(swaggerDefinition).getAsJsonObject();
@@ -12125,8 +12126,22 @@ public static void updateAPISwaggerWithVersion(API api) {
                 apiSpec.add(SWAGGER_INFO, newInfoObject);
             }
             api.setSwaggerDefinition(apiSpec.toString());
+        } else if (asyncApiDefinition != null) {
+            JsonObject apiSpec = JsonParser.parseString(asyncApiDefinition).getAsJsonObject();
+            JsonObject infoObject = apiSpec.has(SWAGGER_INFO) && apiSpec.get(SWAGGER_INFO).isJsonObject() ?
+                    apiSpec.getAsJsonObject(SWAGGER_INFO) : null;
+            if (infoObject != null) {
+                infoObject.addProperty(SWAGGER_VER, api.getId().getVersion());
+            } else {
+                JsonObject newInfoObject = new JsonObject();
+                newInfoObject.addProperty(SWAGGER_TITLE, api.getId().getApiName());
+                newInfoObject.addProperty(SWAGGER_VER, api.getId().getVersion());
+                newInfoObject.addProperty(SWAGGER_DESCRIPTION, api.getDescription());
+                apiSpec.add(SWAGGER_INFO, newInfoObject);
+            }
+            api.setAsyncApiDefinition(apiSpec.toString());
         } else {
-            log.error("Swagger definition is null for API: " + api.getId().getApiName());
+            log.error("Async API definition is null for API: " + api.getId().getApiName());
         }
     }
 }
diff --git a/...ain/java/org/wso2/carbon/apimgt/rest/api/publisher/v1/common/mappings/APIMappingUtil.java b/...ain/java/org/wso2/carbon/apimgt/rest/api/publisher/v1/common/mappings/APIMappingUtil.java
@@ -1671,6 +1671,9 @@ public static APIDTO fromAPItoDTO(API model, boolean preserveCredentials,
         dto.setRevisionId(model.getRevisionId());
         dto.setEnableSchemaValidation(model.isEnabledSchemaValidation());
         dto.setEnableSubscriberVerification(model.isEnableSubscriberVerification());
+        if (StringUtils.isNotEmpty(model.getTransports())) {
+            dto.setTransport(Arrays.asList(model.getTransports().split(",")));
+        }
         AdvertiseInfoDTO advertiseInfoDTO = new AdvertiseInfoDTO();
         advertiseInfoDTO.setAdvertised(model.isAdvertiseOnly());
         advertiseInfoDTO.setApiExternalProductionEndpoint(model.getApiExternalProductionEndpoint());