docusaurus-plugin-generate-schema-docs 1.8.4 → 1.8.5

package/__tests__/update-schema-ids.test.js

@@ -1,5 +1,5 @@
 /**
- * @jest-environment node
+ * @jest-environment @stryker-mutator/jest-runner/jest-env/node
  */
 
 import fs from 'fs';
@@ -21,6 +21,75 @@ describe('updateSchemaIds', () => {
     fs.rmSync(tempSiteDir, { recursive: true });
   });
 
+  it('skips versions whose schema directory does not exist (L33)', () => {
+    // Add a version that has no corresponding directory
+    const versionsPath = path.join(tempSiteDir, 'versions.json');
+    fs.writeFileSync(versionsPath, JSON.stringify(['1.1.1', '9.9.9']));
+
+    // Should not throw; 9.9.9 directory doesn't exist and is skipped
+    expect(() => updateSchemaIds(tempSiteDir, url)).not.toThrow();
+
+    // The existing 1.1.1 schemas should still be updated
+    const schemaPath = path.join(
+      tempSiteDir,
+      'static/schemas',
+      '1.1.1',
+      'add-to-cart-event.json',
+    );
+    const schema = JSON.parse(fs.readFileSync(schemaPath, 'utf8'));
+    expect(schema.$id).toBe(
+      'https://tracking-docs-demo.buchert.digital/schemas/1.1.1/add-to-cart-event.json',
+    );
+  });
+
+  it('skips non-.json files in schema directories (L19)', () => {
+    // Create a non-json file in the schema directory
+    const nonJsonPath = path.join(
+      tempSiteDir,
+      'static/schemas',
+      '1.1.1',
+      'readme.txt',
+    );
+    fs.writeFileSync(nonJsonPath, 'This is not a JSON file');
+
+    expect(() => updateSchemaIds(tempSiteDir, url)).not.toThrow();
+
+    // The non-json file should remain unchanged
+    const content = fs.readFileSync(nonJsonPath, 'utf8');
+    expect(content).toBe('This is not a JSON file');
+  });
+
+  it('accepts a specific version parameter (L27-28)', () => {
+    updateSchemaIds(tempSiteDir, url, '1.1.1');
+
+    const schemaPath = path.join(
+      tempSiteDir,
+      'static/schemas',
+      '1.1.1',
+      'add-to-cart-event.json',
+    );
+    const schema = JSON.parse(fs.readFileSync(schemaPath, 'utf8'));
+    expect(schema.$id).toBe(
+      'https://tracking-docs-demo.buchert.digital/schemas/1.1.1/add-to-cart-event.json',
+    );
+  });
+
+  it('returns early when versions.json does not exist (L6-8)', () => {
+    const noVersionsDir = path.resolve(__dirname, '__temp_no_versions__');
+    fs.mkdirSync(noVersionsDir, { recursive: true });
+
+    try {
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+      updateSchemaIds(noVersionsDir, url);
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'No versions.json file found, skipping schema ID update.',
+      );
+      consoleSpy.mockRestore();
+    } finally {
+      fs.rmSync(noVersionsDir, { recursive: true });
+    }
+  });
+
   it('should update the $id of the schemas in the versioned directories', () => {
     updateSchemaIds(tempSiteDir, url);
 

package/__tests__/validateSchemas-integration.test.js

@@ -1,5 +1,5 @@
 /**
- * @jest-environment node
+ * @jest-environment @stryker-mutator/jest-runner/jest-env/node
  */
 
 import path from 'path';
@@ -25,5 +25,5 @@ describe('validateSchemas - Integration', () => {
     const { schemaDir } = getPathsForVersion('next', siteDir);
     const result = await validateSchemas(schemaDir);
     expect(result).toBe(true);
-  });
+  }, 60000);
 });

package/__tests__/validateSchemas.test.js

@@ -1,5 +1,5 @@
 /**
- * @jest-environment node
+ * @jest-environment @stryker-mutator/jest-runner/jest-env/node
  */
 
 import path from 'path';
@@ -152,4 +152,145 @@ describe('validateSchemas', () => {
     const result = await validateSchemas(schemaDir);
     expect(result).toBe(true);
   });
+
+  it('should return false and log errors when a schema produces no examples', async () => {
+    const fixturePath = path.resolve(
+      __dirname,
+      '__fixtures__',
+      'validateSchemas',
+      'no-example-schema.json',
+    );
+    const schemaDir = path.join(tmpDir, 'schemas');
+    fs.mkdirSync(schemaDir, { recursive: true });
+    fs.copyFileSync(
+      fixturePath,
+      path.join(schemaDir, 'no-example-schema.json'),
+    );
+
+    const result = await validateSchemas(schemaDir);
+    expect(result).toBe(false);
+    expect(consoleErrorSpy).toHaveBeenCalled();
+    const errorMessages = consoleErrorSpy.mock.calls
+      .map((c) => c[0])
+      .join('\n');
+    expect(errorMessages).toContain('does not produce any examples');
+  });
+
+  it('should return false and log error when processing a schema throws', async () => {
+    const fixturePath = path.resolve(
+      __dirname,
+      '__fixtures__',
+      'validateSchemas',
+      'main-schema-with-missing-ref.json',
+    );
+    const schemaDir = path.join(tmpDir, 'schemas');
+    fs.mkdirSync(schemaDir, { recursive: true });
+    fs.copyFileSync(
+      fixturePath,
+      path.join(schemaDir, 'main-schema-with-missing-ref.json'),
+    );
+
+    const result = await validateSchemas(schemaDir);
+    expect(result).toBe(false);
+    expect(consoleErrorSpy).toHaveBeenCalled();
+    const errorMessages = consoleErrorSpy.mock.calls
+      .map((c) => c[0])
+      .join('\n');
+    expect(errorMessages).toContain('Error processing');
+  });
+
+  it('should report errors for all failing schemas when multiple schemas exist', async () => {
+    const schemaDir = path.join(tmpDir, 'schemas');
+    fs.mkdirSync(schemaDir, { recursive: true });
+
+    // First schema: valid
+    fs.writeFileSync(
+      path.join(schemaDir, 'valid.json'),
+      JSON.stringify({
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        type: 'object',
+        properties: { event: { type: 'string', const: 'ok' } },
+        required: ['event'],
+      }),
+    );
+
+    // Second schema: no examples produced
+    fs.writeFileSync(
+      path.join(schemaDir, 'no-examples.json'),
+      JSON.stringify({
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        type: 'object',
+        properties: { untyped: { description: 'no type or example' } },
+        required: ['untyped'],
+      }),
+    );
+
+    const result = await validateSchemas(schemaDir);
+    expect(result).toBe(false);
+    expect(consoleErrorSpy).toHaveBeenCalled();
+  });
+
+  it('should return false when a oneOf option produces an undefined example', async () => {
+    const schemaDir = path.join(tmpDir, 'schemas');
+    fs.mkdirSync(schemaDir, { recursive: true });
+
+    // Schema with a oneOf where one option has no resolvable example
+    fs.writeFileSync(
+      path.join(schemaDir, 'undef-option.json'),
+      JSON.stringify({
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        type: 'object',
+        oneOf: [
+          {
+            title: 'ValidOption',
+            properties: { event: { type: 'string', const: 'test' } },
+            required: ['event'],
+          },
+          {
+            title: 'UndefinedOption',
+            properties: { mystery: { description: 'no type, no example' } },
+            required: ['mystery'],
+          },
+        ],
+      }),
+    );
+
+    const result = await validateSchemas(schemaDir);
+    expect(result).toBe(false);
+    expect(consoleErrorSpy).toHaveBeenCalled();
+    const errorMessages = consoleErrorSpy.mock.calls
+      .map((c) => c[0])
+      .join('\n');
+    expect(errorMessages).toContain('does not produce a valid example');
+  });
+
+  it('should report all examples invalid when every example fails validation', async () => {
+    const schemaDir = path.join(tmpDir, 'schemas');
+    fs.mkdirSync(schemaDir, { recursive: true });
+
+    // Schema where every oneOf option produces an example that fails schema validation
+    fs.writeFileSync(
+      path.join(schemaDir, 'all-invalid.json'),
+      JSON.stringify({
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        type: 'object',
+        properties: {
+          count: {
+            type: 'integer',
+            minimum: 100,
+            example: 1,
+          },
+        },
+        required: ['count'],
+      }),
+    );
+
+    const result = await validateSchemas(schemaDir);
+    expect(result).toBe(false);
+    expect(consoleErrorSpy).toHaveBeenCalled();
+    const errorMessages = consoleErrorSpy.mock.calls
+      .map((c) => c[0])
+      .join('\n');
+    expect(errorMessages).toContain('example data failed validation');
+  });
 });

package/generateEventDocs.js

@@ -7,7 +7,7 @@ import {
   writeDoc,
   createDir,
 } from './helpers/file-system.js';
-import { processOneOfSchema, slugify } from './helpers/schema-processing.js';
+import { processOneOfSchema } from './helpers/schema-processing.js';
 import SchemaDocTemplate from './helpers/schema-doc-template.js';
 import ChoiceIndexTemplate from './helpers/choice-index-template.js';
 import processSchema from './helpers/processSchema.js';
@@ -233,6 +233,26 @@ async function generateOneOfDocs(
 
   const processed = await processOneOfSchema(schema, filePath);
 
+  // Remove stale files/dirs from previous runs that are no longer in the schema
+  const expectedNames = new Set(['index.mdx']);
+  for (const [
+    index,
+    { slug, schema: processedSchema },
+  ] of processed.entries()) {
+    const prefixedSlug = `${(index + 1).toString().padStart(2, '0')}-${slug}`;
+    expectedNames.add(
+      processedSchema.oneOf ? prefixedSlug : `${prefixedSlug}.mdx`,
+    );
+  }
+  for (const entry of fs.readdirSync(eventOutputDir, { withFileTypes: true })) {
+    if (!expectedNames.has(entry.name)) {
+      const fullPath = path.join(eventOutputDir, entry.name);
+      entry.isDirectory()
+        ? fs.rmSync(fullPath, { recursive: true })
+        : fs.unlinkSync(fullPath);
+    }
+  }
+
   const indexPageContent = ChoiceIndexTemplate({
     schema,
     processedOptions: processed,

package/helpers/constraintSchemaPaths.js

@@ -1,22 +1,18 @@
 import path from 'path';
 import fs from 'fs';
 
+function buildCandidatePaths(baseSegments, packageName) {
+  return [
+    path.resolve(process.cwd(), ...baseSegments, packageName),
+    path.resolve(process.cwd(), '..', ...baseSegments, packageName),
+    path.resolve(process.cwd(), '..', '..', ...baseSegments, packageName),
+  ];
+}
+
 function getConstraintsPackageRoot() {
   const candidates = [
-    path.resolve(process.cwd(), 'packages', 'tracking-target-constraints'),
-    path.resolve(
-      process.cwd(),
-      '..',
-      'packages',
-      'tracking-target-constraints',
-    ),
-    path.resolve(
-      process.cwd(),
-      '..',
-      '..',
-      'packages',
-      'tracking-target-constraints',
-    ),
+    ...buildCandidatePaths(['packages'], 'tracking-target-constraints'),
+    ...buildCandidatePaths(['node_modules'], 'tracking-target-constraints'),
   ];
 
   return candidates.find((candidate) => fs.existsSync(candidate));