docusaurus-plugin-generate-schema-docs 1.3.0 → 1.5.0

package/__tests__/helpers/example-helper.test.js

@@ -0,0 +1,71 @@
+import {
+  getExamples,
+  getSingleExampleValue,
+} from '../../helpers/example-helper';
+
+describe('example-helper', () => {
+  describe('getExamples', () => {
+    it('returns "const" as the only example when present', () => {
+      const schema = {
+        examples: ['example1'],
+        const: 'const-value',
+      };
+      expect(getExamples(schema)).toEqual(['const-value']);
+    });
+
+    it('aggregates "examples", "example", and "default"', () => {
+      const schema = {
+        examples: ['example1'],
+        example: 'example2',
+        default: 'default-value',
+      };
+      expect(getExamples(schema)).toEqual([
+        'example1',
+        'example2',
+        'default-value',
+      ]);
+    });
+
+    it('handles duplicates', () => {
+      const schema = {
+        examples: ['example1'],
+        example: 'example1',
+        default: 'example1',
+      };
+      expect(getExamples(schema)).toEqual(['example1']);
+    });
+  });
+
+  describe('getSingleExampleValue', () => {
+    it('returns "const" when present', () => {
+      const schema = {
+        const: 'const-value',
+        examples: ['example1'],
+      };
+      expect(getSingleExampleValue(schema)).toBe('const-value');
+    });
+
+    it('returns the first "examples" when "const" is not present', () => {
+      const schema = {
+        examples: ['example1', 'example2'],
+        default: 'default-value',
+      };
+      expect(getSingleExampleValue(schema)).toBe('example1');
+    });
+
+    it('returns "example" when "const" and "examples" are not present', () => {
+      const schema = {
+        example: 'example',
+        default: 'default-value',
+      };
+      expect(getSingleExampleValue(schema)).toBe('example');
+    });
+
+    it('returns "default" as a fallback', () => {
+      const schema = {
+        default: 'default-value',
+      };
+      expect(getSingleExampleValue(schema)).toBe('default-value');
+    });
+  });
+});

package/__tests__/helpers/getConstraints.test.js

@@ -2,8 +2,11 @@ import { getConstraints } from '../../helpers/getConstraints';
 
 describe('getConstraints', () => {
   it('should return "required" if isReq is true', () => {
-    const constraints = getConstraints({}, true);
-    expect(constraints).toContain('required');
+    expect(getConstraints({}, true)).toEqual(['required']);
+  });
+
+  it('should return an empty array if isReq is false and there are no other constraints', () => {
+    expect(getConstraints({}, false)).toEqual([]);
   });
 
   it('should handle simple key-value constraints', () => {
@@ -12,47 +15,89 @@ describe('getConstraints', () => {
       maxLength: 10,
       minimum: 0,
       maximum: 100,
+      exclusiveMinimum: 0,
+      exclusiveMaximum: 100,
       minItems: 1,
       maxItems: 5,
+      minProperties: 2,
+      maxProperties: 3,
+      multipleOf: 2,
+      format: 'email',
+      minContains: 1,
+      maxContains: 3,
     };
-    const constraints = getConstraints(prop, false);
-    expect(constraints).toEqual([
+    const expected = [
       'minLength: 1',
       'maxLength: 10',
       'minimum: 0',
       'maximum: 100',
+      'exclusiveMinimum: 0',
+      'exclusiveMaximum: 100',
       'minItems: 1',
       'maxItems: 5',
-    ]);
-  });
-
-  it('should handle pattern constraint', () => {
-    const prop = { pattern: '^[a-z]+$' };
-    const constraints = getConstraints(prop, false);
-    expect(constraints).toContain('pattern: /^[a-z]+$/');
+      'minProperties: 2',
+      'maxProperties: 3',
+      'multipleOf: 2',
+      'format: email',
+      'minContains: 1',
+      'maxContains: 3',
+    ];
+    expect(getConstraints(prop, false)).toEqual(
+      expect.arrayContaining(expected),
+    );
   });
 
-  it('should handle uniqueItems constraint', () => {
-    const prop = { uniqueItems: true };
-    const constraints = getConstraints(prop, false);
-    expect(constraints).toContain('uniqueItems: true');
+  it('should handle special-cased constraints', () => {
+    const prop = {
+      pattern: '^[a-z]+$',
+      uniqueItems: true,
+      additionalProperties: false,
+      propertyNames: { pattern: '^[A-Z][a-zA-Z0-9]*$' },
+      dependentRequired: {
+        prop1: ['prop2', 'prop3'],
+      },
+      contains: { type: 'string' },
+      enum: ['a', 'b', 'c'],
+      const: 'hello',
+    };
+    const expected = [
+      'pattern: /^[a-z]+$/',
+      'uniqueItems: true',
+      'additionalProperties: false',
+      'propertyNames: {"pattern":"^[A-Z][a-zA-Z0-9]*$"}',
+      'dependentRequired: prop1 -> [prop2, prop3]',
+      'contains: {"type":"string"}',
+      'enum: [a, b, c]',
+      'const: "hello"',
+    ];
+    expect(getConstraints(prop, false)).toEqual(
+      expect.arrayContaining(expected),
+    );
   });
 
-  it('should handle additionalProperties constraint', () => {
-    const prop = { additionalProperties: false };
-    const constraints = getConstraints(prop, false);
-    expect(constraints).toContain('additionalProperties: false');
+  it('should handle default constraint', () => {
+    const prop = {
+      default: 'default value',
+    };
+    const expected = ['default: "default value"'];
+    expect(getConstraints(prop, false)).toEqual(expected);
   });
 
-  it('should handle enum constraint', () => {
-    const prop = { enum: ['a', 'b', 'c'] };
-    const constraints = getConstraints(prop, false);
-    expect(constraints).toContain('enum: [a, b, c]');
+  it('should not include a constraint for a value of undefined', () => {
+    const prop = {
+      minLength: undefined,
+    };
+    expect(getConstraints(prop, false)).toEqual([]);
   });
 
-  it('should handle const constraint', () => {
-    const prop = { const: 'a' };
-    const constraints = getConstraints(prop, false);
-    expect(constraints).toContain('const: "a"');
+  it('should handle a mix of constraints', () => {
+    const prop = {
+      minLength: 5,
+      pattern: '^[a-zA-Z0-9]*$',
+    };
+    const expected = ['minLength: 5', 'pattern: /^[a-zA-Z0-9]*$/'];
+    expect(getConstraints(prop, true)).toEqual(
+      expect.arrayContaining(['required', ...expected]),
+    );
   });
 });

package/__tests__/helpers/schemaToTableData.test.js

@@ -118,39 +118,6 @@ describe('schemaToTableData', () => {
     expect(choiceRow.choiceType).toBe('oneOf');
   });
 
-  it('correctly processes the "examples" array', () => {
-    const schema = {
-      properties: {
-        prop_with_examples: {
-          type: 'string',
-          examples: ['first-example', 'second-example'],
-        },
-      },
-    };
-
-    const tableData = schemaToTableData(schema);
-
-    expect(tableData).toHaveLength(1);
-    const propRow = tableData[0];
-
-    expect(propRow.name).toBe('prop_with_examples');
-    expect(propRow.example).toEqual(['first-example', 'second-example']);
-  });
-
-  it('handles singular "example" if "examples" is not present', () => {
-    const schema = {
-      properties: {
-        prop_with_example: {
-          type: 'string',
-          example: 'singular-example',
-        },
-      },
-    };
-
-    const tableData = schemaToTableData(schema);
-    expect(tableData[0].example).toBe('singular-example');
-  });
-
   it('handles "oneOf" nested inside a property', () => {
     const schema = {
       properties: {
@@ -219,4 +186,32 @@ describe('schemaToTableData', () => {
     expect(paramD.name).toBe('param_d');
     expect(paramD.level).toBe(0); // This is the core of the test
   });
+
+  it('uses "const" as example if "examples" and "example" are not present', () => {
+    const schema = {
+      properties: {
+        prop_with_const: {
+          type: 'string',
+          const: 'const-value',
+        },
+      },
+    };
+
+    const tableData = schemaToTableData(schema);
+    expect(tableData[0].examples).toEqual(['const-value']);
+  });
+
+  it('uses "default" as example if "examples", "example", and "const" are not present', () => {
+    const schema = {
+      properties: {
+        prop_with_default: {
+          type: 'string',
+          default: 'default-value',
+        },
+      },
+    };
+
+    const tableData = schemaToTableData(schema);
+    expect(tableData[0].examples).toEqual(['default-value']);
+  });
 });

package/__tests__/helpers/validator.test.js

@@ -0,0 +1,115 @@
+import { createValidator } from '../../helpers/validator';
+
+describe('createValidator', () => {
+  it('creates a validator that returns true for valid data with no schema version (draft-07)', async () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+        },
+      },
+      required: ['name'],
+    };
+
+    const validator = await createValidator(schema);
+    const result = validator({ name: 'test' });
+
+    expect(result.valid).toBe(true);
+    expect(result.errors).toEqual([]);
+  });
+
+  it('creates a validator that returns false for invalid data with no schema version (draft-07)', async () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+        },
+      },
+      required: ['name'],
+    };
+
+    const validator = await createValidator(schema);
+    const result = validator({ name: 123 });
+
+    expect(result.valid).toBe(false);
+    expect(result.errors).not.toEqual([]);
+  });
+
+  it('creates a validator that can validate against a draft-04 schema', async () => {
+    const schema = {
+      $schema: 'http://json-schema.org/draft-04/schema#',
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+        },
+      },
+      required: ['name'],
+    };
+
+    const validator = await createValidator(schema);
+    const result = validator({ name: 'test' });
+
+    expect(result.valid).toBe(true);
+    expect(result.errors).toEqual([]);
+  });
+
+  it('creates a validator that can validate against a draft-07 schema', async () => {
+    const schema = {
+      $schema: 'http://json-schema.org/draft-07/schema#',
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+        },
+      },
+      required: ['name'],
+    };
+
+    const validator = await createValidator(schema);
+    const result = validator({ name: 'test' });
+
+    expect(result.valid).toBe(true);
+    expect(result.errors).toEqual([]);
+  });
+
+  it('creates a validator that can validate against a 2019-09 schema', async () => {
+    const schema = {
+      $schema: 'https://json-schema.org/draft/2019-09/schema',
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+        },
+      },
+      required: ['name'],
+    };
+
+    const validator = await createValidator(schema);
+    const result = validator({ name: 'test' });
+
+    expect(result.valid).toBe(true);
+    expect(result.errors).toEqual([]);
+  });
+
+  it('creates a validator that can validate against a 2020-12 schema', async () => {
+    const schema = {
+      $schema: 'https://json-schema.org/draft/2020-12/schema',
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+        },
+      },
+      required: ['name'],
+    };
+
+    const validator = await createValidator(schema);
+    const result = validator({ name: 'test' });
+
+    expect(result.valid).toBe(true);
+    expect(result.errors).toEqual([]);
+  });
+});

package/__tests__/validateSchemas-integration.test.js

@@ -0,0 +1,29 @@
+/**
+ * @jest-environment node
+ */
+
+import path from 'path';
+import validateSchemas from '../validateSchemas';
+import { getPathsForVersion } from '../helpers/path-helpers';
+
+describe('validateSchemas - Integration', () => {
+  let consoleErrorSpy;
+  let consoleLogSpy;
+
+  beforeEach(() => {
+    // Spy on console.error and console.log to keep test output clean
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should return true for the "next" version schemas', async () => {
+    const siteDir = path.resolve(__dirname, '../../../demo');
+    const { schemaDir } = getPathsForVersion('next', siteDir);
+    const result = await validateSchemas(schemaDir);
+    expect(result).toBe(true);
+  });
+});

package/__tests__/validateSchemas.test.js

@@ -14,124 +14,40 @@ describe('validateSchemas', () => {
 
   beforeEach(() => {
     tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'schema-test-'));
-    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
-    consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
   });
 
   afterEach(() => {
     fs.rmSync(tmpDir, { recursive: true, force: true });
-    jest.restoreAllMocks();
   });
 
-  const writeSchema = (dir, fileName, content) => {
-    const filePath = path.join(dir, fileName);
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, JSON.stringify(content, null, 2));
-  };
-
-  const loadFixture = (fixtureName) => {
-    const fixturePath = path.resolve(
+  it('should return true for a complex set of valid schemas', async () => {
+    const fixtureDir = path.resolve(
       __dirname,
       '__fixtures__',
       'validateSchemas',
-      fixtureName,
+      'complex-validation',
     );
-    const schemaContent = fs.readFileSync(fixturePath, 'utf8');
-    return JSON.parse(schemaContent);
-  };
-
-  it('should return true when all schemas are valid', async () => {
-    const validSchema = loadFixture('valid-schema.json');
-    writeSchema(tmpDir, 'valid-schema.json', validSchema);
-
-    const result = await validateSchemas(tmpDir);
+    const schemaDir = path.join(tmpDir, 'schemas');
+    fs.mkdirSync(schemaDir, { recursive: true });
+    fs.cpSync(fixtureDir, schemaDir, { recursive: true });
+    const result = await validateSchemas(schemaDir);
     expect(result).toBe(true);
-    expect(consoleLogSpy).toHaveBeenCalledWith(
-      'OK Schema valid-schema.json produced a valid example.',
-    );
   });
 
   it('should return false if an example fails validation', async () => {
-    const invalidExampleSchema = loadFixture('invalid-example-schema.json');
-    writeSchema(tmpDir, 'invalid-example-schema.json', invalidExampleSchema);
-
-    const result = await validateSchemas(tmpDir);
-    expect(result).toBe(false);
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      'x Schema invalid-example-schema.json example data failed validation:',
+    const fixturePath = path.resolve(
+      __dirname,
+      '__fixtures__',
+      'validateSchemas',
+      'invalid-example-schema.json',
     );
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      expect.arrayContaining([
-        expect.objectContaining({
-          instancePath: '/age',
-          keyword: 'type',
-          message: 'must be number',
-        }),
-      ]),
+    const schemaDir = path.join(tmpDir, 'schemas');
+    fs.mkdirSync(schemaDir, { recursive: true });
+    fs.copyFileSync(
+      fixturePath,
+      path.join(schemaDir, 'invalid-example-schema.json'),
     );
-  });
-
-  it('should fail validation for missing required property', async () => {
-    const noValidExampleSchema = loadFixture('no-example-schema.json');
-    writeSchema(tmpDir, 'no-valid-example-schema.json', noValidExampleSchema);
-
-    const result = await validateSchemas(tmpDir);
+    const result = await validateSchemas(schemaDir);
     expect(result).toBe(false);
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      'x Schema no-valid-example-schema.json does not produce a valid example.',
-    );
-  });
-
-  it('should handle schemas with $refs correctly', async () => {
-    const componentSchema = loadFixture(
-      path.join('components', 'referenced.json'),
-    );
-    const mainSchema = loadFixture('main-schema-with-ref.json');
-
-    writeSchema(
-      path.join(tmpDir, 'components'),
-      'referenced.json',
-      componentSchema,
-    );
-    writeSchema(tmpDir, 'main-schema-with-ref.json', mainSchema);
-
-    const result = await validateSchemas(tmpDir);
-    expect(result).toBe(true);
-    expect(consoleLogSpy).toHaveBeenCalledWith(
-      'OK Schema main-schema-with-ref.json produced a valid example.',
-    );
-  });
-
-  it('should reject if a referenced schema is missing', async () => {
-    const mainSchema = loadFixture('main-schema-with-missing-ref.json');
-    writeSchema(tmpDir, 'main-schema-with-missing-ref.json', mainSchema);
-
-    const expectedErrorPath = path.join(tmpDir, 'non-existent-component.json');
-    await expect(validateSchemas(tmpDir)).rejects.toThrow(
-      expect.objectContaining({
-        message: expect.stringContaining(
-          `Error opening file ${expectedErrorPath}`,
-        ),
-      }),
-    );
-  });
-
-  it('should throw an error if duplicate schema IDs are found', async () => {
-    const schemaA = {
-      $id: 'duplicate-id',
-      type: 'object',
-      properties: { a: { type: 'string' } },
-    };
-    const schemaB = {
-      $id: 'duplicate-id',
-      type: 'object',
-      properties: { b: { type: 'string' } },
-    };
-    writeSchema(path.join(tmpDir, 'A'), 'schema-A.json', schemaA);
-    writeSchema(path.join(tmpDir, 'B'), 'schema-B.json', schemaB);
-
-    await expect(validateSchemas(tmpDir)).rejects.toThrow(
-      'schema with key or id "duplicate-id" already exists',
-    );
   });
 });

package/components/ExampleDataLayer.js

@@ -5,7 +5,7 @@ import TabItem from '@theme/TabItem';
 import Heading from '@theme/Heading';
 import { schemaToExamples } from '../helpers/schemaToExamples';
 
-const generateCodeSnippet = (example, schema) => {
+const generateCodeSnippet = (example, schema, dataLayerName = 'dataLayer') => {
   const clearableProperties = findClearableProperties(schema || {});
   let codeSnippet = '';
   const propertiesToClear = clearableProperties.filter(
@@ -17,14 +17,22 @@ const generateCodeSnippet = (example, schema) => {
     propertiesToClear.forEach((prop) => {
       resetObject[prop] = null;
     });
-    codeSnippet += `window.dataLayer.push(${JSON.stringify(resetObject, null, 2)});\n`;
+    codeSnippet += `window.${dataLayerName}.push(${JSON.stringify(
+      resetObject,
+      null,
+      2,
+    )});\n`;
   }
 
-  codeSnippet += `window.dataLayer.push(${JSON.stringify(example, null, 2)});`;
+  codeSnippet += `window.${dataLayerName}.push(${JSON.stringify(
+    example,
+    null,
+    2,
+  )});`;
   return codeSnippet;
 };
 
-export default function ExampleDataLayer({ schema }) {
+export default function ExampleDataLayer({ schema, dataLayerName }) {
   const exampleGroups = schemaToExamples(schema);
 
   if (!exampleGroups || exampleGroups.length === 0) {
@@ -36,6 +44,7 @@ export default function ExampleDataLayer({ schema }) {
     const codeSnippet = generateCodeSnippet(
       exampleGroups[0].options[0].example,
       schema,
+      dataLayerName,
     );
     return <CodeBlock language="javascript">{codeSnippet}</CodeBlock>;
   }
@@ -51,7 +60,7 @@ export default function ExampleDataLayer({ schema }) {
             {group.options.map(({ title, example }, index) => (
               <TabItem value={index} label={title} key={index}>
                 <CodeBlock language="javascript">
-                  {generateCodeSnippet(example, schema)}
+                  {generateCodeSnippet(example, schema, dataLayerName)}
                 </CodeBlock>
               </TabItem>
             ))}

package/components/PropertiesTable.js

@@ -1,17 +1,32 @@
-import React from 'react';
+import React, { useState } from 'react';
 import SchemaRows from './SchemaRows';
 import TableHeader from './TableHeader';
+import WordWrapButton from './WordWrapButton';
 import { schemaToTableData } from '../helpers/schemaToTableData';
+import styles from './PropertiesTable.module.css';
 
 export default function PropertiesTable({ schema }) {
+  const [isWordWrapOn, setIsWordWrapOn] = useState(true);
   const tableData = schemaToTableData(schema);
 
   return (
-    <table>
-      <TableHeader />
-      <tbody>
-        <SchemaRows tableData={tableData} />
-      </tbody>
-    </table>
+    <div
+      className={`${styles.tableWrapper} ${
+        !isWordWrapOn ? styles.noWordWrap : ''
+      }`}
+    >
+      <div className={styles.buttonGroup}>
+        <WordWrapButton
+          onClick={() => setIsWordWrapOn((w) => !w)}
+          isEnabled={isWordWrapOn}
+        />
+      </div>
+      <table>
+        <TableHeader />
+        <tbody>
+          <SchemaRows tableData={tableData} />
+        </tbody>
+      </table>
+    </div>
   );
 }

package/components/PropertiesTable.module.css

@@ -0,0 +1,27 @@
+.tableWrapper {
+  position: relative;
+  margin-top: 1rem;
+}
+
+.tableWrapper code {
+  white-space: pre-wrap;
+  word-break: break-word;
+  min-width: auto;
+}
+
+.tableWrapper td {
+  min-width: 5.3rem;
+}
+
+.noWordWrap code {
+  white-space: pre;
+  word-break: normal;
+}
+
+.buttonGroup {
+  position: absolute;
+  right: 0;
+  top: -2.7rem;
+  display: flex;
+  gap: 0.5rem;
+}