private getFeatureFlagValueFromDotnetSchema()

in libraries/azure-app-configuration-importer/src/internal/parsers/defaultConfigurationSettingsConverter.ts [274:355]
69 lines of code
13 McCabe index (conditional complexity)

  private getFeatureFlagValueFromDotnetSchema(
    featureFlagName: string,
    featureData: any,
    enabledForKeyWord: string,
    requirementTypeKeyWord: string
  ): MsFeatureFlagValue {
    const defaultFeatureConditions = { clientFilters: [] };

    const featureFlagValue: MsFeatureFlagValue = {
      id: featureFlagName,
      description: "",
      enabled: false,
      conditions: {
        clientFilters: []
      }
    };

    if (typeof featureData == "object") {
      const filters = featureData[enabledForKeyWord];

      if (!filters) {
        throw new ArgumentError(
          `Data contains feature flags in invalid format. Feature flag '${featureFlagName}' must contain '${enabledForKeyWord}' definition or have a true/false value.`
        );
      }

      if (filters.length != 0) {
        featureFlagValue.enabled = true;
        featureFlagValue.conditions.clientFilters = filters;

        if (featureFlagValue.conditions && featureFlagValue.conditions.clientFilters) {
          for (let i = 0; i < featureFlagValue.conditions.clientFilters.length; i++) {
            const parameters: Partial<ClientFilter> = {};
            //
            // Converting client_filter keys to lower case
            const lowerCaseFilters = this.getLowerCaseFilters(
              featureFlagValue.conditions.clientFilters[i]
            );

            const filtersName = lowerCaseFilters["name"];
            const filtersParameters = lowerCaseFilters["parameters"];

            if (filtersName) {
              if (filtersName.toLowerCase() == "alwayson") {
                featureFlagValue.conditions = defaultFeatureConditions;
                break;
              }
              parameters.name = filtersName;
              if (filtersParameters) {
                parameters.parameters = filtersParameters;
              }

              featureFlagValue.conditions.clientFilters[i] = parameters as ClientFilter;
            }
            else {
              throw new ArgumentError(
                `This feature flag '${featureFlagName}' has a filter without the required 'name' property.`
              );
            }
          }
        }
      }

      const requirementType = featureData[requirementTypeKeyWord];

      if (requirementType) {
        if (this.validateRequirementType(featureFlagName, requirementType)) {
          featureFlagValue.conditions.requirementType = requirementType;
        }
      }
    }
    else if (typeof featureData == "boolean") {
      featureFlagValue.enabled = featureData;
    }
    else {
      throw new ArgumentError(
        `Data contains feature flags in invalid format. The type of ${featureFlagName} should be either boolean or dictionary.`
      );
    }

    return featureFlagValue;
  }