docusaurus-plugin-generate-schema-docs 1.5.4 → 1.7.0

package/__tests__/helpers/schemaToTableData.hierarchicalLines.test.js

@@ -181,7 +181,7 @@ describe('schemaToTableData - hierarchical lines', () => {
       expect(nameRow.continuingLevels).not.toContain(0);
     });
 
-    it('removes immediate parent level from continuingLevels when item is last', () => {
+    it('preserves ancestor continuingLevels through last children', () => {
       const schema = {
         properties: {
           user_data: {
@@ -211,8 +211,9 @@ describe('schemaToTableData - hierarchical lines', () => {
 
       const tableData = schemaToTableData(schema);
 
-      // addresses is last at level 1, so its children should NOT have level 0 in continuingLevels
-      // because the level 0 line stops at addresses
+      // addresses is last at level 1, but user_data has a sibling (other_field),
+      // so the level 0 line must continue through all of user_data's descendants
+      // to visually connect to other_field in the flat table.
       const streetRow = tableData.find(
         (row) => row.name === 'street' && row.level === 2,
       );
@@ -220,8 +221,8 @@ describe('schemaToTableData - hierarchical lines', () => {
         (row) => row.name === 'city' && row.level === 2,
       );
 
-      expect(streetRow.continuingLevels).not.toContain(0);
-      expect(cityRow.continuingLevels).not.toContain(0);
+      expect(streetRow.continuingLevels).toContain(0);
+      expect(cityRow.continuingLevels).toContain(0);
     });
 
     it('maintains continuingLevels through multiple nesting levels', () => {
@@ -521,11 +522,12 @@ describe('schemaToTableData - hierarchical lines', () => {
       expect(addressesRow.isLastInGroup).toBe(true);
 
       // street: level 2, inside addresses (which is last at level 1)
-      // should NOT have level 0 in continuingLevels because addresses is last
+      // should STILL have level 0 in continuingLevels because user_data has a
+      // sibling (string_field), so the level 0 line continues through descendants
       const streetRow = tableData.find(
         (row) => row.name === 'street' && row.level === 2,
       );
-      expect(streetRow.continuingLevels).not.toContain(0);
+      expect(streetRow.continuingLevels).toContain(0);
 
       // string_field: level 0, no children, IS last
       const stringFieldRow = tableData.find(
@@ -536,4 +538,185 @@ describe('schemaToTableData - hierarchical lines', () => {
       expect(stringFieldRow.isLastInGroup).toBe(true);
     });
   });
+
+  describe('conditional rows (if/then/else)', () => {
+    const conditionalSchema = {
+      properties: {
+        method: {
+          type: 'string',
+          enum: ['express', 'standard'],
+        },
+      },
+      required: ['method'],
+      if: {
+        properties: { method: { const: 'express' } },
+        required: ['method'],
+      },
+      then: {
+        description: 'Express shipping',
+        properties: {
+          priority: { type: 'string' },
+          guaranteed_by: { type: 'string', format: 'date' },
+        },
+      },
+      else: {
+        description: 'Standard shipping',
+        properties: {
+          estimated_days: { type: 'integer' },
+        },
+      },
+    };
+
+    it('condition rows are never isLastInGroup (branches always follow)', () => {
+      const tableData = schemaToTableData(conditionalSchema);
+      const conditional = tableData.find((r) => r.type === 'conditional');
+      conditional.condition.rows.forEach((row) => {
+        expect(row.isLastInGroup).toBe(false);
+      });
+    });
+
+    it('then branch last property is not isLastInGroup when else exists', () => {
+      const tableData = schemaToTableData(conditionalSchema);
+      const conditional = tableData.find((r) => r.type === 'conditional');
+      const thenBranch = conditional.branches.find((b) => b.title === 'Then');
+      const guaranteedBy = thenBranch.rows.find(
+        (r) => r.name === 'guaranteed_by',
+      );
+      expect(guaranteedBy.isLastInGroup).toBe(false);
+    });
+
+    it('else branch last property IS isLastInGroup (nothing follows)', () => {
+      const tableData = schemaToTableData(conditionalSchema);
+      const conditional = tableData.find((r) => r.type === 'conditional');
+      const elseBranch = conditional.branches.find((b) => b.title === 'Else');
+      const estimatedDays = elseBranch.rows.find(
+        (r) => r.name === 'estimated_days',
+      );
+      expect(estimatedDays.isLastInGroup).toBe(true);
+    });
+
+    it('then-only conditional marks last then property as isLastInGroup', () => {
+      const thenOnlySchema = {
+        properties: {
+          status: { type: 'string' },
+        },
+        if: {
+          properties: { status: { const: 'active' } },
+        },
+        then: {
+          properties: {
+            expires: { type: 'string' },
+          },
+        },
+      };
+      const tableData = schemaToTableData(thenOnlySchema);
+      const conditional = tableData.find((r) => r.type === 'conditional');
+      const thenBranch = conditional.branches[0];
+      const expires = thenBranch.rows.find((r) => r.name === 'expires');
+      expect(expires.isLastInGroup).toBe(true);
+    });
+
+    it('properties before a conditional are not isLastInGroup', () => {
+      const tableData = schemaToTableData(conditionalSchema);
+      const methodRow = tableData.find(
+        (r) => r.type === 'property' && r.name === 'method',
+      );
+      expect(methodRow.isLastInGroup).toBe(false);
+    });
+
+    it('does not add spurious ancestor lines when parent is last in group', () => {
+      // Wrap conditionalSchema inside a parent that is the last property
+      const wrappedSchema = {
+        properties: {
+          shipping: {
+            type: 'object',
+            ...conditionalSchema,
+          },
+        },
+      };
+      const tableData = schemaToTableData(wrappedSchema);
+      const conditional = tableData.find((r) => r.type === 'conditional');
+
+      // shipping is the only/last root property — level 0 should NOT be in
+      // continuingLevels (no root-level siblings to connect to)
+      expect(conditional.continuingLevels).not.toContain(0);
+    });
+
+    it('includes ancestor lines when parent has siblings', () => {
+      const wrappedSchema = {
+        properties: {
+          shipping: {
+            type: 'object',
+            ...conditionalSchema,
+          },
+          total: { type: 'number' },
+        },
+      };
+      const tableData = schemaToTableData(wrappedSchema);
+      const conditional = tableData.find((r) => r.type === 'conditional');
+
+      // shipping is NOT last (total follows) — level 0 should be in
+      // continuingLevels for the root-level tree line
+      expect(conditional.continuingLevels).toContain(0);
+    });
+  });
+
+  describe('complex choice property (oneOf with object options)', () => {
+    it('marks last property in last option as isLastInGroup', () => {
+      const schema = {
+        properties: {
+          contact_method: {
+            description: 'How to reach the user',
+            oneOf: [
+              {
+                title: 'Email Contact',
+                type: 'object',
+                properties: {
+                  channel: { type: 'string', const: 'email' },
+                  email_address: { type: 'string' },
+                },
+                required: ['channel', 'email_address'],
+              },
+              {
+                title: 'SMS Contact',
+                type: 'object',
+                properties: {
+                  channel: { type: 'string', const: 'sms' },
+                  phone_number: { type: 'string' },
+                },
+                required: ['channel', 'phone_number'],
+              },
+            ],
+          },
+          preferences: {
+            type: 'object',
+            properties: {
+              marketing_consent: { type: 'boolean' },
+            },
+          },
+        },
+      };
+
+      const data = schemaToTableData(schema);
+      const choiceRow = data.find((r) => r.type === 'choice');
+      expect(choiceRow).toBeDefined();
+
+      // SMS Contact is the last option
+      const smsOption = choiceRow.options[1];
+      expect(smsOption.title).toBe('SMS Contact');
+
+      const phoneRow = smsOption.rows.find((r) => r.name === 'phone_number');
+      expect(phoneRow).toBeDefined();
+      expect(phoneRow.isLastInGroup).toBe(true);
+
+      // Email Contact is NOT the last option
+      const emailOption = choiceRow.options[0];
+      const emailAddressRow = emailOption.rows.find(
+        (r) => r.name === 'email_address',
+      );
+      expect(emailAddressRow).toBeDefined();
+      // email_address is the last prop in a non-last option — should NOT be isLastInGroup
+      expect(emailAddressRow.isLastInGroup).toBe(false);
+    });
+  });
 });

package/__tests__/helpers/schemaToTableData.test.js

@@ -1,6 +1,8 @@
 import { schemaToTableData } from '../../helpers/schemaToTableData';
 import choiceEventSchema from '../__fixtures__/static/schemas/choice-event.json';
 import rootAnyOfEventSchema from '../__fixtures__/static/schemas/root-any-of-event.json';
+import conditionalEventSchema from '../__fixtures__/static/schemas/conditional-event.json';
+import nestedConditionalEventSchema from '../__fixtures__/static/schemas/nested-conditional-event.json';
 
 describe('schemaToTableData', () => {
   it('handles "oneOf" and "anyOf" correctly for a complex schema', () => {
@@ -19,7 +21,7 @@ describe('schemaToTableData', () => {
     expect(eventProp.propertyType).toBe('string');
     expect(eventProp.required).toBe(true);
 
-    // 2. Test 'user_id' property (oneOf)
+    // 2. Test 'user_id' property (oneOf with scalar options — simple choice, no property row)
     const userIdChoice = tableData.find(
       (row) =>
         row.type === 'choice' &&
@@ -133,7 +135,7 @@ describe('schemaToTableData', () => {
 
     const tableData = schemaToTableData(schema);
 
-    // Expect a single 'choice' row that correctly represents the property.
+    // Scalar oneOf options — renders as a single simple choice row (no property row).
     expect(tableData).toHaveLength(1);
 
     const choiceRow = tableData[0];
@@ -214,4 +216,263 @@ describe('schemaToTableData', () => {
     const tableData = schemaToTableData(schema);
     expect(tableData[0].examples).toEqual(['default-value']);
   });
+
+  describe('if/then/else conditional support', () => {
+    it('creates a conditional row for schema with if/then/else at root level', () => {
+      const tableData = schemaToTableData(conditionalEventSchema);
+      const conditionalRow = tableData.find((r) => r.type === 'conditional');
+      expect(conditionalRow).toBeDefined();
+      expect(conditionalRow.level).toBe(0);
+      expect(conditionalRow.condition).toBeDefined();
+      expect(conditionalRow.branches).toBeDefined();
+      expect(conditionalRow.branches).toHaveLength(2); // then + else
+    });
+
+    it('flags condition rows with isCondition: true', () => {
+      const tableData = schemaToTableData(conditionalEventSchema);
+      const conditionalRow = tableData.find((r) => r.type === 'conditional');
+      expect(conditionalRow.condition.rows.length).toBeGreaterThan(0);
+      conditionalRow.condition.rows.forEach((row) => {
+        expect(row.isCondition).toBe(true);
+      });
+    });
+
+    it('processes then branch rows correctly', () => {
+      const tableData = schemaToTableData(conditionalEventSchema);
+      const conditionalRow = tableData.find((r) => r.type === 'conditional');
+      const thenBranch = conditionalRow.branches.find(
+        (b) => b.title === 'Then',
+      );
+      expect(thenBranch).toBeDefined();
+      // then has postal_code + state
+      expect(thenBranch.rows.length).toBe(2);
+      const postalCode = thenBranch.rows.find((r) => r.name === 'postal_code');
+      expect(postalCode).toBeDefined();
+      expect(postalCode.propertyType).toBe('string');
+    });
+
+    it('processes else branch rows correctly', () => {
+      const tableData = schemaToTableData(conditionalEventSchema);
+      const conditionalRow = tableData.find((r) => r.type === 'conditional');
+      const elseBranch = conditionalRow.branches.find(
+        (b) => b.title === 'Else',
+      );
+      expect(elseBranch).toBeDefined();
+      // else has postal_code only
+      expect(elseBranch.rows.length).toBe(1);
+    });
+
+    it('handles if/then without else', () => {
+      const schema = {
+        type: 'object',
+        properties: { status: { type: 'string' } },
+        if: { properties: { status: { const: 'active' } } },
+        then: {
+          properties: { active_since: { type: 'string' } },
+        },
+      };
+      const tableData = schemaToTableData(schema);
+      const conditionalRow = tableData.find((r) => r.type === 'conditional');
+      expect(conditionalRow).toBeDefined();
+      expect(conditionalRow.branches).toHaveLength(1);
+      expect(conditionalRow.branches[0].title).toBe('Then');
+    });
+
+    it('renders regular properties alongside conditional rows', () => {
+      const tableData = schemaToTableData(conditionalEventSchema);
+      const propRows = tableData.filter((r) => r.type === 'property');
+      // event + country
+      expect(propRows.length).toBe(2);
+      const conditionalRow = tableData.find((r) => r.type === 'conditional');
+      expect(conditionalRow).toBeDefined();
+    });
+
+    it('creates nested conditional row inside a property sub-schema', () => {
+      const tableData = schemaToTableData(nestedConditionalEventSchema);
+
+      // Should have event property + shipping property + shipping's children + conditional
+      const shippingProp = tableData.find(
+        (r) => r.type === 'property' && r.name === 'shipping',
+      );
+      expect(shippingProp).toBeDefined();
+      expect(shippingProp.hasChildren).toBe(true);
+
+      // method property at level 1
+      const methodProp = tableData.find(
+        (r) => r.type === 'property' && r.name === 'method',
+      );
+      expect(methodProp).toBeDefined();
+      expect(methodProp.level).toBe(1);
+
+      // Conditional row should be nested at level 1 (inside shipping)
+      const conditionalRow = tableData.find((r) => r.type === 'conditional');
+      expect(conditionalRow).toBeDefined();
+      expect(conditionalRow.level).toBe(1);
+      expect(conditionalRow.branches).toHaveLength(2);
+
+      // Then branch has priority_level
+      const thenBranch = conditionalRow.branches.find(
+        (b) => b.title === 'Then',
+      );
+      expect(thenBranch.rows.length).toBe(1);
+      expect(thenBranch.rows[0].name).toBe('priority_level');
+
+      // Else branch has estimated_days
+      const elseBranch = conditionalRow.branches.find(
+        (b) => b.title === 'Else',
+      );
+      expect(elseBranch.rows.length).toBe(1);
+      expect(elseBranch.rows[0].name).toBe('estimated_days');
+    });
+
+    it('handles if/then/else inside array items', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          items: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                kind: { type: 'string' },
+              },
+              if: { properties: { kind: { const: 'digital' } } },
+              then: {
+                properties: {
+                  download_url: { type: 'string' },
+                },
+              },
+              else: {
+                properties: {
+                  weight: { type: 'number' },
+                },
+              },
+            },
+          },
+        },
+      };
+      const tableData = schemaToTableData(schema);
+      const conditionalRow = tableData.find((r) => r.type === 'conditional');
+      expect(conditionalRow).toBeDefined();
+      // items is at level 0, array items content is at level 1
+      expect(conditionalRow.level).toBe(1);
+      expect(conditionalRow.branches).toHaveLength(2);
+    });
+
+    it('preserves parent continuingLevels in nested conditional branch rows', () => {
+      // Schema where the conditional is NOT the last child - the parent
+      // property has siblings after it, so continuing lines must flow through
+      const schema = {
+        type: 'object',
+        properties: {
+          shipping: {
+            type: 'object',
+            description: 'Shipping details.',
+            properties: {
+              method: {
+                type: 'string',
+                examples: ['express'],
+              },
+            },
+            required: ['method'],
+            if: {
+              properties: { method: { const: 'express' } },
+              required: ['method'],
+            },
+            then: {
+              properties: {
+                priority_level: {
+                  type: 'string',
+                  examples: ['high'],
+                },
+              },
+            },
+            else: {
+              properties: {
+                estimated_days: { type: 'integer', examples: [5] },
+              },
+            },
+          },
+          total: {
+            type: 'number',
+            description: 'Order total.',
+          },
+        },
+      };
+
+      const tableData = schemaToTableData(schema);
+      const conditionalRow = tableData.find((r) => r.type === 'conditional');
+
+      // shipping is at level 0 and is NOT the last root property (total follows)
+      // So the conditional row and its branch rows should have level 0
+      // in continuingLevels to draw the parent's continuing line.
+      expect(conditionalRow.continuingLevels).toContain(0);
+
+      const thenBranch = conditionalRow.branches.find(
+        (b) => b.title === 'Then',
+      );
+      const priorityLevel = thenBranch.rows.find(
+        (r) => r.name === 'priority_level',
+      );
+      expect(priorityLevel.continuingLevels).toContain(0);
+
+      const conditionMethod = conditionalRow.condition.rows.find(
+        (r) => r.name === 'method',
+      );
+      expect(conditionMethod.continuingLevels).toContain(0);
+    });
+
+    it('does not add spurious parent level to continuingLevels when parent is last in group', () => {
+      // In the nested-conditional-event, shipping is the last root property.
+      // Level 0 should NOT appear in continuingLevels for any conditional
+      // or branch rows — the immediate parent connector is handled at the
+      // component level (ConditionalRows pushes level-1 to ancestorLevels).
+      const tableData = schemaToTableData(nestedConditionalEventSchema);
+      const conditionalRow = tableData.find((r) => r.type === 'conditional');
+
+      // The conditional row should have level 1 (for property sibling lines)
+      // but NOT level 0 (shipping is the last root property)
+      expect(conditionalRow.continuingLevels).toContain(1);
+      expect(conditionalRow.continuingLevels).not.toContain(0);
+
+      // Then branch rows inherit continuingLevels without the parent level
+      const thenBranch = conditionalRow.branches.find(
+        (b) => b.title === 'Then',
+      );
+      thenBranch.rows.forEach((row) => {
+        expect(row.continuingLevels).not.toContain(0);
+      });
+
+      // Else branch rows also should NOT have the parent line
+      const elseBranch = conditionalRow.branches.find(
+        (b) => b.title === 'Else',
+      );
+      elseBranch.rows.forEach((row) => {
+        expect(row.continuingLevels).not.toContain(0);
+      });
+    });
+
+    it('marks condition (if) rows with their natural isLastInGroup values', () => {
+      const tableData = schemaToTableData(nestedConditionalEventSchema);
+      const conditionalRow = tableData.find((r) => r.type === 'conditional');
+      // Condition rows keep their natural isLastInGroup so the tree within the
+      // If block is self-contained and doesn't create orphan lines into Then/Else.
+      conditionalRow.condition.rows.forEach((row) => {
+        expect(row.isCondition).toBe(true);
+      });
+    });
+
+    it('correctly calculates isLastInGroup with conditional as last element', () => {
+      const tableData = schemaToTableData(conditionalEventSchema);
+      // The conditional row should be the last element at root level
+      const conditionalRow = tableData.find((r) => r.type === 'conditional');
+      expect(conditionalRow.isLastInGroup).toBe(true);
+
+      // The last property before conditional should NOT be last in group
+      const countryProp = tableData.find(
+        (r) => r.type === 'property' && r.name === 'country',
+      );
+      expect(countryProp.isLastInGroup).toBe(false);
+    });
+  });
 });

package/__tests__/helpers/validator.test.js

@@ -12,7 +12,7 @@ describe('createValidator', () => {
       required: ['name'],
     };
 
-    const validator = await createValidator(schema);
+    const validator = await createValidator([], schema);
     const result = validator({ name: 'test' });
 
     expect(result.valid).toBe(true);
@@ -30,7 +30,7 @@ describe('createValidator', () => {
       required: ['name'],
     };
 
-    const validator = await createValidator(schema);
+    const validator = await createValidator([], schema);
     const result = validator({ name: 123 });
 
     expect(result.valid).toBe(false);
@@ -49,7 +49,7 @@ describe('createValidator', () => {
       required: ['name'],
     };
 
-    const validator = await createValidator(schema);
+    const validator = await createValidator([], schema);
     const result = validator({ name: 'test' });
 
     expect(result.valid).toBe(true);
@@ -68,7 +68,7 @@ describe('createValidator', () => {
       required: ['name'],
     };
 
-    const validator = await createValidator(schema);
+    const validator = await createValidator([], schema);
     const result = validator({ name: 'test' });
 
     expect(result.valid).toBe(true);
@@ -87,7 +87,7 @@ describe('createValidator', () => {
       required: ['name'],
     };
 
-    const validator = await createValidator(schema);
+    const validator = await createValidator([], schema);
     const result = validator({ name: 'test' });
 
     expect(result.valid).toBe(true);
@@ -106,7 +106,7 @@ describe('createValidator', () => {
       required: ['name'],
     };
 
-    const validator = await createValidator(schema);
+    const validator = await createValidator([], schema);
     const result = validator({ name: 'test' });
 
     expect(result.valid).toBe(true);