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

package/__tests__/generateEventDocs.partials.test.js

@@ -0,0 +1,134 @@
+/**
+ * @jest-environment node
+ *
+ * Tests that top and bottom partials are correctly injected into generated MDX
+ * when matching partial files exist in the partials directory, and that the
+ * generated import paths use the event name (not the component prefix).
+ */
+
+import generateEventDocs from '../generateEventDocs';
+import fs from 'fs';
+import path from 'path';
+
+jest.mock('fs', () => {
+  const memfs = require('memfs');
+  return memfs;
+});
+
+describe('generateEventDocs (partials)', () => {
+  const fixturesDir = path.resolve(__dirname, '__fixtures__');
+  const options = {
+    organizationName: 'test-org',
+    projectName: 'test-project',
+    siteDir: fixturesDir,
+    url: 'https://tracking-docs-demo.buchert.digital',
+  };
+  const outputDir = path.join(fixturesDir, 'docs');
+  const partialsDir = path.join(outputDir, 'partials');
+
+  beforeEach(() => {
+    fs.vol.reset();
+    const realFs = jest.requireActual('fs');
+
+    function readDirRecursive(dir) {
+      const files = realFs.readdirSync(dir, { withFileTypes: true });
+      for (const file of files) {
+        const filePath = path.join(dir, file.name);
+        if (file.isDirectory()) {
+          fs.vol.mkdirSync(filePath, { recursive: true });
+          readDirRecursive(filePath);
+        } else {
+          fs.vol.writeFileSync(filePath, realFs.readFileSync(filePath));
+        }
+      }
+    }
+    readDirRecursive(fixturesDir);
+  });
+
+  it('injects top partial when _<eventName>.mdx exists in partials dir', async () => {
+    console.log = jest.fn();
+    fs.vol.mkdirSync(partialsDir, { recursive: true });
+    fs.vol.writeFileSync(
+      path.join(partialsDir, '_add-to-cart-event.mdx'),
+      '## Top content',
+    );
+
+    await generateEventDocs(options);
+
+    const output = fs.readFileSync(
+      path.join(outputDir, 'add-to-cart-event.mdx'),
+      'utf-8',
+    );
+
+    expect(output).toContain(
+      "import TopPartial from '@site/docs/partials/_add-to-cart-event.mdx'",
+    );
+    expect(output).toContain('<TopPartial />');
+    expect(output).not.toContain('_Top.mdx');
+  });
+
+  it('injects bottom partial when _<eventName>_bottom.mdx exists in partials dir', async () => {
+    console.log = jest.fn();
+    fs.vol.mkdirSync(partialsDir, { recursive: true });
+    fs.vol.writeFileSync(
+      path.join(partialsDir, '_add-to-cart-event_bottom.mdx'),
+      '## Bottom content',
+    );
+
+    await generateEventDocs(options);
+
+    const output = fs.readFileSync(
+      path.join(outputDir, 'add-to-cart-event.mdx'),
+      'utf-8',
+    );
+
+    expect(output).toContain(
+      "import BottomPartial from '@site/docs/partials/_add-to-cart-event_bottom.mdx'",
+    );
+    expect(output).toContain('<BottomPartial />');
+    expect(output).not.toContain('_Bottom.mdx');
+  });
+
+  it('injects both top and bottom partials when both exist', async () => {
+    console.log = jest.fn();
+    fs.vol.mkdirSync(partialsDir, { recursive: true });
+    fs.vol.writeFileSync(
+      path.join(partialsDir, '_add-to-cart-event.mdx'),
+      '## Top content',
+    );
+    fs.vol.writeFileSync(
+      path.join(partialsDir, '_add-to-cart-event_bottom.mdx'),
+      '## Bottom content',
+    );
+
+    await generateEventDocs(options);
+
+    const output = fs.readFileSync(
+      path.join(outputDir, 'add-to-cart-event.mdx'),
+      'utf-8',
+    );
+
+    expect(output).toContain(
+      "import TopPartial from '@site/docs/partials/_add-to-cart-event.mdx'",
+    );
+    expect(output).toContain('<TopPartial />');
+    expect(output).toContain(
+      "import BottomPartial from '@site/docs/partials/_add-to-cart-event_bottom.mdx'",
+    );
+    expect(output).toContain('<BottomPartial />');
+  });
+
+  it('omits partial imports when no partial files exist', async () => {
+    console.log = jest.fn();
+
+    await generateEventDocs(options);
+
+    const output = fs.readFileSync(
+      path.join(outputDir, 'add-to-cart-event.mdx'),
+      'utf-8',
+    );
+
+    expect(output).not.toContain('TopPartial');
+    expect(output).not.toContain('BottomPartial');
+  });
+});

package/__tests__/generateEventDocs.test.js

@@ -80,11 +80,18 @@ describe('generateEventDocs (non-versioned)', () => {
       'utf-8',
     );
     expect(rootChoiceA).toMatchSnapshot();
+    // Inline oneOf options must link to the parent schema file, not a temp output file
+    expect(rootChoiceA).toContain(
+      'custom_edit_url: https://github.com/test-org/test-project/edit/main/__fixtures__/static/schemas/root-choice-event.json',
+    );
 
     const rootChoiceB = fs.readFileSync(
       path.join(choiceEventDir, '02-option-b.mdx'),
       'utf-8',
     );
     expect(rootChoiceB).toMatchSnapshot();
+    expect(rootChoiceB).toContain(
+      'custom_edit_url: https://github.com/test-org/test-project/edit/main/__fixtures__/static/schemas/root-choice-event.json',
+    );
   });
 });

package/__tests__/helpers/buildExampleFromSchema.test.js

@@ -185,4 +185,53 @@ describe('buildExampleFromSchema', () => {
       },
     });
   });
+
+  it('should handle if/then/else by defaulting to then branch', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        event: { type: 'string', examples: ['form_submit'] },
+      },
+      if: { properties: { event: { const: 'form_submit' } } },
+      then: {
+        properties: {
+          form_name: { type: 'string', examples: ['contact'] },
+        },
+      },
+      else: {
+        properties: {
+          error_code: { type: 'integer', examples: [404] },
+        },
+      },
+    };
+
+    const example = buildExampleFromSchema(schema);
+    expect(example).toHaveProperty('event', 'form_submit');
+    expect(example).toHaveProperty('form_name', 'contact');
+    expect(example).not.toHaveProperty('error_code');
+  });
+
+  it('should handle nested if/then/else inside a property', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        shipping: {
+          type: 'object',
+          properties: {
+            method: { type: 'string', examples: ['express'] },
+          },
+          if: { properties: { method: { const: 'express' } } },
+          then: {
+            properties: {
+              priority: { type: 'string', examples: ['high'] },
+            },
+          },
+        },
+      },
+    };
+
+    const example = buildExampleFromSchema(schema);
+    expect(example.shipping).toHaveProperty('method', 'express');
+    expect(example.shipping).toHaveProperty('priority', 'high');
+  });
 });

package/__tests__/helpers/schemaToExamples.test.js

@@ -1,5 +1,7 @@
 import { schemaToExamples } from '../../helpers/schemaToExamples';
 import choiceEventSchema from '../__fixtures__/static/schemas/choice-event.json';
+import conditionalEventSchema from '../__fixtures__/static/schemas/conditional-event.json';
+import nestedConditionalEventSchema from '../__fixtures__/static/schemas/nested-conditional-event.json';
 
 describe('schemaToExamples', () => {
   it('should generate examples for all options in a complex schema', () => {
@@ -53,4 +55,77 @@ describe('schemaToExamples', () => {
     expect(userIdIntegerOption).toBeDefined();
     expect(userIdIntegerOption.example).toHaveProperty('payment_method');
   });
+
+  describe('if/then/else conditional examples', () => {
+    it('generates two examples for schema with if/then/else', () => {
+      const groups = schemaToExamples(conditionalEventSchema);
+      const conditionalGroup = groups.find((g) => g.property === 'conditional');
+      expect(conditionalGroup).toBeDefined();
+      expect(conditionalGroup.options).toHaveLength(2);
+    });
+
+    it('then example includes then properties merged with base', () => {
+      const groups = schemaToExamples(conditionalEventSchema);
+      const conditionalGroup = groups.find((g) => g.property === 'conditional');
+      const thenOption = conditionalGroup.options.find(
+        (o) => o.title === 'When condition is met',
+      );
+      expect(thenOption).toBeDefined();
+      expect(thenOption.example).toHaveProperty('event');
+      expect(thenOption.example).toHaveProperty('postal_code', '90210');
+      expect(thenOption.example).toHaveProperty('state', 'CA');
+    });
+
+    it('else example includes else properties merged with base', () => {
+      const groups = schemaToExamples(conditionalEventSchema);
+      const conditionalGroup = groups.find((g) => g.property === 'conditional');
+      const elseOption = conditionalGroup.options.find(
+        (o) => o.title === 'When condition is not met',
+      );
+      expect(elseOption).toBeDefined();
+      expect(elseOption.example).toHaveProperty('event');
+      expect(elseOption.example).toHaveProperty('postal_code', 'K1A 0B1');
+      expect(elseOption.example).not.toHaveProperty('state');
+    });
+
+    it('generates only one example when else is absent', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          status: { type: 'string', examples: ['active'] },
+        },
+        if: { properties: { status: { const: 'active' } } },
+        then: {
+          properties: {
+            active_since: { type: 'string', examples: ['2024-01-01'] },
+          },
+        },
+      };
+      const groups = schemaToExamples(schema);
+      const conditionalGroup = groups.find((g) => g.property === 'conditional');
+      expect(conditionalGroup).toBeDefined();
+      expect(conditionalGroup.options).toHaveLength(1);
+      expect(conditionalGroup.options[0].title).toBe('When condition is met');
+    });
+
+    it('detects nested conditional points inside properties', () => {
+      const groups = schemaToExamples(nestedConditionalEventSchema);
+      const conditionalGroup = groups.find((g) => g.property === 'conditional');
+      expect(conditionalGroup).toBeDefined();
+      expect(conditionalGroup.options).toHaveLength(2);
+
+      const thenOption = conditionalGroup.options.find(
+        (o) => o.title === 'When condition is met',
+      );
+      expect(thenOption.example.shipping).toHaveProperty(
+        'priority_level',
+        'high',
+      );
+
+      const elseOption = conditionalGroup.options.find(
+        (o) => o.title === 'When condition is not met',
+      );
+      expect(elseOption.example.shipping).toHaveProperty('estimated_days', 5);
+    });
+  });
 });