fix small issues

components/schemas/environments/EnvironmentFeatures.yml

@@ -19,6 +19,6 @@ properties:
         type: string
         enum:
           - limited
-          - standard
+          - basic
           - premium
           - enterprise

components/schemas/environments/services/DiscoveryEnvironmentService.yml

@@ -5,7 +5,6 @@ required:
   - enable
   - container_id
   - high_availability
-  - config
 properties:
   enable:
     type: boolean

components/schemas/environments/services/LoadBalancerEnvironmentService.yml

@@ -5,7 +5,6 @@ required:
   - enable
   - container_id
   - high_availability
-  - config
 properties:
   enable:
     type: boolean

components/schemas/environments/services/SchedulerEnvironmentService.yml

@@ -7,7 +7,6 @@ required:
   - enable
   - container_id
   - high_availablity
-  # - config
 properties:
   enable:
     type: boolean

components/schemas/environments/services/VpnEnvironmentService.yml

@@ -5,7 +5,6 @@ required:
   - enable
   - container_id
   - high_availability
-  - config
 properties:
   enable:
     type: boolean

components/schemas/environments/services/discovery/DiscoveryConfig.yml

@@ -30,6 +30,8 @@ properties:
             type: string
   custom_resolvers:
     description: "A list of custom DNS resolver strings.  Can specifify domains or ips."
-    type: array
-    items:
-      type: string
+    oneOf:
+      - type: array
+        items:
+          type: string
+      - type: "null"

components/schemas/environments/services/loadbalancer/config/types/v1/V1LbType.yml

@@ -17,7 +17,9 @@ properties:
     enum:
       - "v1"
   details:
-    $ref: V1LbConfig.yml
+    anyOf:
+      - $ref: V1LbConfig.yml
+      - type: "null"
   bind_host:
     description: |
       Binds the load balancer to the host server IP address. 

components/schemas/environments/services/loadbalancer/config/types/v1/WafConfig.yml

@@ -33,6 +33,8 @@ properties:
           enum:
             - any
             - all
+            # legacy value TODO remove
+            - ""
         conditions:
           description: An array of the specific conditions for the rule.
           type: array

components/schemas/environments/services/loadbalancer/config/types/v1/routers/HttpRouterConfig.yml

@@ -75,7 +75,9 @@ properties:
                       description: Replacement value.
                       type: string
           url:
-            type: string
+            type: 
+              - string
+              - "null"
             description: |
               The URL to forward the request to.
 

stackspec/schema/services/loadbalancer/types/StackSpecDefaultLbType.yml

@@ -20,5 +20,4 @@ properties:
     oneOf:
       - $ref: ./haproxy/StackSpecHaProxyConfig.yml
       - $ref: ./v1/StackSpecV1LbConfig.yml
-
       - type: "null"

util/downconvert.ts

@@ -116,7 +116,8 @@ class Schema {
   adjust(schemaMap: Record<string, Schema>) {
     this.removeUnsupportedProperties();
     this.handleConstAsEnum();
-    this.flattenAnyOfOrOneOfWithRefAndNull(schemaMap);
+    this.handleAnyOfWithNull();
+    this.handleOneOfWithNull();
     this.flattenIdenticalReferences(schemaMap);
     this.adjustNestedSchemas(schemaMap);
   }
@@ -141,40 +142,94 @@ class Schema {
     }
   }
 
-  // Handle the specific case where `anyOf` or `oneOf` contains a `$ref` and `null`
-  flattenAnyOfOrOneOfWithRefAndNull(schemaMap: Record<string, Schema>) {
-    const keywords = ["oneOf", "anyOf"] as const;
+  // Handle `anyOf` containing `null` and a reference or another type
+  handleAnyOfWithNull() {
+    if (this.anyOf) {
+      let hasNullType = false;
+      let nonNullEntry: Schema | null = null;
+
+      // Check for `null` type in `anyOf`
+      this.anyOf.forEach((entry) => {
+        if (entry.type === "null") {
+          hasNullType = true;
+        } else {
+          nonNullEntry = entry;
+        }
+      });
 
-    keywords.forEach((keyword) => {
-      if (this[keyword]) {
-        let hasNullType = false;
-        let refEntry: Schema | null = null;
+      // If both `null` and another type are present, make the schema nullable and use `allOf` for reference
+      if (hasNullType && nonNullEntry) {
+        this.nullable = true;
 
-        // Check for `$ref` and `null` type in `oneOf` or `anyOf`
-        this[keyword]!.forEach((entry) => {
-          if (entry.type === "null") {
-            hasNullType = true;
-          } else if (entry.$ref) {
-            refEntry = entry;
+        if (nonNullEntry.$ref) {
+          // Convert `anyOf` to `allOf` with the reference
+          this.allOf = [{ $ref: nonNullEntry.$ref }];
+        } else {
+          // Otherwise, retain all properties of the non-null entry
+          Object.assign(this, nonNullEntry);
+        }
+
+        delete this.anyOf;
+      }
+    }
+  }
+
+  // Handle `oneOf` containing `null` and another type
+  handleOneOfWithNull() {
+    // Do not modify `oneOf` if a discriminator is present
+    if (this.discriminator) {
+      return;
+    }
+
+    if (this.oneOf) {
+      let hasNullType = false;
+      let nonNullEntry: Schema | null = null;
+
+      // Iterate through the `oneOf` entries
+      this.oneOf.forEach((entry) => {
+        if (entry.type === "null") {
+          hasNullType = true;
+        } else {
+          nonNullEntry = entry;
+        }
+      });
+
+      // If both `null` and another type are present
+      if (hasNullType && nonNullEntry) {
+        // Set nullable to true
+        this.nullable = true;
+
+        // Retain all properties of the non-null entry (type, enum, description, etc.)
+        for (const key in nonNullEntry) {
+          if (key !== "type" && key !== "nullable") {
+            (this as any)[key] = nonNullEntry[key];
           }
-        });
+        }
 
-        // If both `$ref` and `null` are present, convert to `allOf` with `nullable: true`
-        if (refEntry && hasNullType) {
-          this.nullable = true;
-          this.allOf = [refEntry];
-          delete this[keyword];
+        // Assign the type of the non-null entry
+        this.type = nonNullEntry.type;
+
+        // If there's an enum, retain it
+        if (nonNullEntry.enum) {
+          this.enum = nonNullEntry.enum;
         }
+
+        delete this.oneOf;
       }
-    });
+    }
   }
 
   // Flatten `oneOf` or `anyOf` if all `$ref` point to the same primitive type
   flattenIdenticalReferences(schemaMap: Record<string, Schema>) {
+    // Do not modify `oneOf` or `anyOf` if a discriminator is present
+    if (this.discriminator) {
+      return;
+    }
+
     const keywords = ["oneOf", "anyOf"] as const;
 
     keywords.forEach((keyword) => {
-      if (this[keyword] && !this.discriminator) {
+      if (this[keyword]) {
         const entries = this[keyword]!;
         let primitiveType: string | null = null;
         let hasNullType = false;
@@ -238,8 +293,11 @@ class Schema {
     keywords.forEach((keyword) => {
       if (this[keyword]) {
         this[keyword] = this[keyword]!.map((entry) => {
-          entry.adjust(schemaMap);
-          return entry;
+          // Ensure entry is converted to a Schema instance before adjustment
+          const schemaEntry =
+            entry instanceof Schema ? entry : new Schema(entry);
+          schemaEntry.adjust(schemaMap);
+          return schemaEntry;
         });
       }
     });