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

package/__tests__/helpers/buildExampleFromSchema.test.js

@@ -1,188 +1,188 @@
 import buildExampleFromSchema from '../../helpers/buildExampleFromSchema.js';
 
 describe('buildExampleFromSchema', () => {
-    it('should build a basic example from a schema', () => {
-        const schema = {
-            type: 'object',
-            properties: {
-                name: { type: 'string' },
-                age: { type: 'integer' },
-                isStudent: { type: 'boolean' },
-            },
-        };
+  it('should build a basic example from a schema', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        name: { type: 'string' },
+        age: { type: 'integer' },
+        isStudent: { type: 'boolean' },
+      },
+    };
 
-        const example = buildExampleFromSchema(schema);
+    const example = buildExampleFromSchema(schema);
 
-        expect(example).toEqual({
-            name: '',
-            age: 0,
-            isStudent: false,
-        });
+    expect(example).toEqual({
+      name: '',
+      age: 0,
+      isStudent: false,
     });
+  });
 
-    it('should handle nested objects and arrays', () => {
-        const schema = {
+  it('should handle nested objects and arrays', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        user: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+          },
+        },
+        posts: {
+          type: 'array',
+          items: {
             type: 'object',
             properties: {
-                user: {
-                    type: 'object',
-                    properties: {
-                        name: { type: 'string' },
-                    },
-                },
-                posts: {
-                    type: 'array',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            title: { type: 'string' },
-                            tags: {
-                                type: 'array',
-                                items: { type: 'string' },
-                            },
-                        },
-                    },
-                },
+              title: { type: 'string' },
+              tags: {
+                type: 'array',
+                items: { type: 'string' },
+              },
             },
-        };
+          },
+        },
+      },
+    };
 
-        const example = buildExampleFromSchema(schema);
+    const example = buildExampleFromSchema(schema);
 
-        expect(example).toEqual({
-            user: {
-                name: '',
-            },
-            posts: [
-                {
-                    title: '',
-                    tags: [''],
-                },
-            ],
-        });
+    expect(example).toEqual({
+      user: {
+        name: '',
+      },
+      posts: [
+        {
+          title: '',
+          tags: [''],
+        },
+      ],
     });
+  });
 
-    it('should use examples, const, and default values', () => {
-        const schema = {
-            type: 'object',
-            properties: {
-                name: {
-                    type: 'string',
-                    examples: ['John Doe'],
-                },
-                role: {
-                    type: 'string',
-                    const: 'admin',
-                },
-                level: {
-                    type: 'integer',
-                    default: 1,
-                },
-            },
-        };
+  it('should use examples, const, and default values', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+          examples: ['John Doe'],
+        },
+        role: {
+          type: 'string',
+          const: 'admin',
+        },
+        level: {
+          type: 'integer',
+          default: 1,
+        },
+      },
+    };
 
-        const example = buildExampleFromSchema(schema);
+    const example = buildExampleFromSchema(schema);
 
-        expect(example).toEqual({
-            name: 'John Doe',
-            role: 'admin',
-            level: 1,
-        });
+    expect(example).toEqual({
+      name: 'John Doe',
+      role: 'admin',
+      level: 1,
     });
+  });
 
-    it('should build a complex example', () => {
-        const schema = {
-            type: 'object',
-            properties: {
-                event: {
-                    type: 'string',
-                    examples: ['purchase'],
-                },
-                ecommerce: {
-                    type: 'object',
-                    properties: {
-                        transaction_id: {
-                            type: 'string',
-                            examples: ['T_12345'],
-                        },
-                        value: {
-                            type: 'number',
-                            default: 10.0,
-                        },
-                        items: {
-                            type: 'array',
-                            items: {
-                                type: 'object',
-                                properties: {
-                                    item_id: { type: 'string', examples: ['SKU_123'] },
-                                    item_name: { type: 'string', examples: ['Stan Smith Shoes'] },
-                                    price: { type: 'number' },
-                                    quantity: { type: 'integer', default: 1 },
-                                },
-                            },
-                        },
-                    },
+  it('should build a complex example', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        event: {
+          type: 'string',
+          examples: ['purchase'],
+        },
+        ecommerce: {
+          type: 'object',
+          properties: {
+            transaction_id: {
+              type: 'string',
+              examples: ['T_12345'],
+            },
+            value: {
+              type: 'number',
+              default: 10.0,
+            },
+            items: {
+              type: 'array',
+              items: {
+                type: 'object',
+                properties: {
+                  item_id: { type: 'string', examples: ['SKU_123'] },
+                  item_name: { type: 'string', examples: ['Stan Smith Shoes'] },
+                  price: { type: 'number' },
+                  quantity: { type: 'integer', default: 1 },
                 },
+              },
             },
-        };
+          },
+        },
+      },
+    };
 
-        const example = buildExampleFromSchema(schema);
+    const example = buildExampleFromSchema(schema);
 
-        expect(example).toEqual({
-            event: 'purchase',
-            ecommerce: {
-                transaction_id: 'T_12345',
-                value: 10.0,
-                items: [
-                    {
-                        item_id: 'SKU_123',
-                        item_name: 'Stan Smith Shoes',
-                        price: 0,
-                        quantity: 1,
-                    },
-                ],
-            },
-        });
+    expect(example).toEqual({
+      event: 'purchase',
+      ecommerce: {
+        transaction_id: 'T_12345',
+        value: 10.0,
+        items: [
+          {
+            item_id: 'SKU_123',
+            item_name: 'Stan Smith Shoes',
+            price: 0,
+            quantity: 1,
+          },
+        ],
+      },
     });
-    it('should not include empty objects for properties with no defined value', () => {
-        const schema = {
-            type: 'object',
-            properties: {
-                event: { type: 'string', examples: ['test_event'] },
-                user_data: {
-                    type: 'object'
+  });
+  it('should not include empty objects for properties with no defined value', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        event: { type: 'string', examples: ['test_event'] },
+        user_data: {
+          type: 'object',
+        },
+        ecommerce: {
+          type: 'object',
+          properties: {
+            items: {
+              type: 'array',
+              items: {
+                type: 'object',
+                properties: {
+                  item_id: { type: 'string', examples: ['SKU_123'] },
                 },
-                ecommerce: {
-                    type: 'object',
-                    properties: {
-                        items: {
-                            type: 'array',
-                            items: {
-                                type: 'object',
-                                properties: {
-                                    item_id: { type: 'string', examples: ['SKU_123'] }
-                                }
-                            }
-                        }
-                    }
-                },
-                empty_object: {
-                    type: 'object',
-                    properties: {}
-                }
-            }
-        };
+              },
+            },
+          },
+        },
+        empty_object: {
+          type: 'object',
+          properties: {},
+        },
+      },
+    };
 
-        const example = buildExampleFromSchema(schema);
+    const example = buildExampleFromSchema(schema);
 
-        expect(example).toEqual({
-            event: 'test_event',
-            ecommerce: {
-                items: [
-                    {
-                        item_id: 'SKU_123',
-                    },
-                ],
-            },
-        });
+    expect(example).toEqual({
+      event: 'test_event',
+      ecommerce: {
+        items: [
+          {
+            item_id: 'SKU_123',
+          },
+        ],
+      },
     });
+  });
 });

package/__tests__/helpers/file-system.test.js

@@ -0,0 +1,44 @@
+import fs from 'fs';
+import path from 'path';
+import { readSchemas, writeDoc, createDir } from '../../helpers/file-system';
+
+jest.mock('fs', () => {
+  const memfs = require('memfs');
+  return memfs;
+});
+
+describe('file-system helpers', () => {
+  beforeEach(() => {
+    fs.vol.reset();
+    fs.vol.fromJSON({
+      '/schemas/schema1.json': '{}',
+      '/schemas/schema2.json': '{}',
+      '/schemas/not-a-schema.txt': 'hello',
+    });
+  });
+
+  describe('readSchemas', () => {
+    it('should read all json files from a directory', () => {
+      const schemas = readSchemas('/schemas');
+      expect(schemas).toHaveLength(2);
+      expect(schemas[0].fileName).toBe('schema1.json');
+      expect(schemas[1].fileName).toBe('schema2.json');
+    });
+  });
+
+  describe('writeDoc', () => {
+    it('should write a file to the specified directory', () => {
+      fs.mkdirSync('/output', { recursive: true });
+      writeDoc('/output', 'doc1.mdx', 'content');
+      const content = fs.readFileSync('/output/doc1.mdx', 'utf-8');
+      expect(content).toBe('content');
+    });
+  });
+
+  describe('createDir', () => {
+    it('should create a directory if it does not exist', () => {
+      createDir('/new-dir');
+      expect(fs.existsSync('/new-dir')).toBe(true);
+    });
+  });
+});

package/__tests__/helpers/getConstraints.test.js

@@ -1,58 +1,58 @@
 import { getConstraints } from '../../helpers/getConstraints';
 
 describe('getConstraints', () => {
-    it('should return "required" if isReq is true', () => {
-        const constraints = getConstraints({}, true);
-        expect(constraints).toContain('required');
-    });
+  it('should return "required" if isReq is true', () => {
+    const constraints = getConstraints({}, true);
+    expect(constraints).toContain('required');
+  });
 
-    it('should handle simple key-value constraints', () => {
-        const prop = {
-            minLength: 1,
-            maxLength: 10,
-            minimum: 0,
-            maximum: 100,
-            minItems: 1,
-            maxItems: 5,
-        };
-        const constraints = getConstraints(prop, false);
-        expect(constraints).toEqual([
-            'minLength: 1',
-            'maxLength: 10',
-            'minimum: 0',
-            'maximum: 100',
-            'minItems: 1',
-            'maxItems: 5',
-        ]);
-    });
+  it('should handle simple key-value constraints', () => {
+    const prop = {
+      minLength: 1,
+      maxLength: 10,
+      minimum: 0,
+      maximum: 100,
+      minItems: 1,
+      maxItems: 5,
+    };
+    const constraints = getConstraints(prop, false);
+    expect(constraints).toEqual([
+      'minLength: 1',
+      'maxLength: 10',
+      'minimum: 0',
+      'maximum: 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]+$/');
-    });
+  it('should handle pattern constraint', () => {
+    const prop = { pattern: '^[a-z]+$' };
+    const constraints = getConstraints(prop, false);
+    expect(constraints).toContain('pattern: /^[a-z]+$/');
+  });
 
-    it('should handle uniqueItems constraint', () => {
-        const prop = { uniqueItems: true };
-        const constraints = getConstraints(prop, false);
-        expect(constraints).toContain('uniqueItems: true');
-    });
+  it('should handle uniqueItems constraint', () => {
+    const prop = { uniqueItems: true };
+    const constraints = getConstraints(prop, false);
+    expect(constraints).toContain('uniqueItems: true');
+  });
 
-    it('should handle additionalProperties constraint', () => {
-        const prop = { additionalProperties: false };
-        const constraints = getConstraints(prop, false);
-        expect(constraints).toContain('additionalProperties: false');
-    });
+  it('should handle additionalProperties constraint', () => {
+    const prop = { additionalProperties: false };
+    const constraints = getConstraints(prop, false);
+    expect(constraints).toContain('additionalProperties: false');
+  });
 
-    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 handle enum constraint', () => {
+    const prop = { enum: ['a', 'b', 'c'] };
+    const constraints = getConstraints(prop, false);
+    expect(constraints).toContain('enum: [a, b, c]');
+  });
 
-    it('should handle const constraint', () => {
-        const prop = { const: 'a' };
-        const constraints = getConstraints(prop, false);
-        expect(constraints).toContain('const: "a"');
-    });
+  it('should handle const constraint', () => {
+    const prop = { const: 'a' };
+    const constraints = getConstraints(prop, false);
+    expect(constraints).toContain('const: "a"');
+  });
 });

package/__tests__/helpers/loadSchema.test.js

@@ -6,9 +6,15 @@ import path from 'path';
 import loadSchema from '../../helpers/loadSchema';
 
 describe('loadSchema', () => {
-    it('should load and parse a JSON file', () => {
-        const filePath = path.join(__dirname, '..', '__fixtures__', 'validateSchemas', 'circular-schema.json');
-        const schema = loadSchema(filePath);
-        expect(schema.title).toBe('Circular Schema');
-    });
+  it('should load and parse a JSON file', () => {
+    const filePath = path.join(
+      __dirname,
+      '..',
+      '__fixtures__',
+      'validateSchemas',
+      'circular-schema.json',
+    );
+    const schema = loadSchema(filePath);
+    expect(schema.title).toBe('Circular Schema');
+  });
 });

package/__tests__/helpers/path-helpers.test.js

@@ -0,0 +1,34 @@
+import { getPathsForVersion } from '../../helpers/path-helpers';
+import path from 'path';
+
+describe('getPathsForVersion', () => {
+  const siteDir = '/test/site';
+
+  it('should return paths for a specific version', () => {
+    const version = '1.0.0';
+    const { schemaDir, outputDir } = getPathsForVersion(version, siteDir);
+    expect(schemaDir).toBe(path.join(siteDir, 'static/schemas', version));
+    expect(outputDir).toBe(
+      path.join(siteDir, 'versioned_docs', `version-${version}`),
+    );
+  });
+
+  it('should return paths for the "current" version', () => {
+    const version = 'current';
+    const { schemaDir, outputDir } = getPathsForVersion(version, siteDir);
+    expect(schemaDir).toBe(path.join(siteDir, 'static/schemas', 'next'));
+    expect(outputDir).toBe(path.join(siteDir, 'docs'));
+  });
+
+  it('should return paths for a non-versioned site', () => {
+    const { schemaDir, outputDir } = getPathsForVersion(null, siteDir);
+    expect(schemaDir).toBe(path.join(siteDir, 'static/schemas'));
+    expect(outputDir).toBe(path.join(siteDir, 'docs'));
+  });
+
+  it('should handle undefined version', () => {
+    const { schemaDir, outputDir } = getPathsForVersion(undefined, siteDir);
+    expect(schemaDir).toBe(path.join(siteDir, 'static/schemas'));
+    expect(outputDir).toBe(path.join(siteDir, 'docs'));
+  });
+});

package/__tests__/helpers/processSchema.test.js

@@ -6,31 +6,51 @@ import path from 'path';
 import processSchema from '../../helpers/processSchema';
 
 describe('processSchema', () => {
-    it('should bundle refs and return a merged schema', async () => {
-        const filePath = path.join(__dirname, '..', '__fixtures__', 'validateSchemas', 'main-schema-with-ref.json');
-        const mergedSchema = await processSchema(filePath);
+  it('should bundle refs and return a merged schema', async () => {
+    const filePath = path.join(
+      __dirname,
+      '..',
+      '__fixtures__',
+      'validateSchemas',
+      'main-schema-with-ref.json',
+    );
+    const mergedSchema = await processSchema(filePath);
 
-        expect(mergedSchema.title).toBe('Main Schema with Ref');
-        expect(mergedSchema.properties.component.$ref).toBeUndefined();
-        expect(mergedSchema.properties.component.type).toBe('object');
-        expect(mergedSchema.properties.component.properties.prop.type).toBe('string');
-    });
+    expect(mergedSchema.title).toBe('Main Schema with Ref');
+    expect(mergedSchema.properties.component.$ref).toBeUndefined();
+    expect(mergedSchema.properties.component.type).toBe('object');
+    expect(mergedSchema.properties.component.properties.prop.type).toBe(
+      'string',
+    );
+  });
 
-    it('should handle circular references correctly', async () => {
-        const filePath = path.join(__dirname, '..', '__fixtures__', 'validateSchemas', 'circular-schema.json');
-        const mergedSchema = await processSchema(filePath);
+  it('should handle circular references correctly', async () => {
+    const filePath = path.join(
+      __dirname,
+      '..',
+      '__fixtures__',
+      'validateSchemas',
+      'circular-schema.json',
+    );
+    const mergedSchema = await processSchema(filePath);
 
-        expect(mergedSchema.title).toBe('Circular Schema');
-        expect(mergedSchema.properties.parent.$ref).toBe('#');
-    });
+    expect(mergedSchema.title).toBe('Circular Schema');
+    expect(mergedSchema.properties.parent.$ref).toBe('#');
+  });
 
-    it('should handle multi-file circular references and produce a self-contained schema', async () => {
-        const filePath = path.join(__dirname, '..', '__fixtures__', 'validateSchemas', 'schema-A.json');
-        const mergedSchema = await processSchema(filePath);
+  it('should handle multi-file circular references and produce a self-contained schema', async () => {
+    const filePath = path.join(
+      __dirname,
+      '..',
+      '__fixtures__',
+      'validateSchemas',
+      'schema-A.json',
+    );
+    const mergedSchema = await processSchema(filePath);
 
-        expect(mergedSchema.title).toBe('Schema A');
-        expect(mergedSchema.properties.b.$ref).toBeUndefined();
-        expect(mergedSchema.properties.b.title).toBe('Schema B');
-        expect(mergedSchema.properties.b.properties.a.$ref).toBe('#');
-    });
+    expect(mergedSchema.title).toBe('Schema A');
+    expect(mergedSchema.properties.b.$ref).toBeUndefined();
+    expect(mergedSchema.properties.b.title).toBe('Schema B');
+    expect(mergedSchema.properties.b.properties.a.$ref).toBe('#');
+  });
 });