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

package/__tests__/generateEventDocs.test.js

@@ -56,6 +56,9 @@ describe('generateEventDocs (non-versioned)', () => {
       'utf-8',
     );
     expect(addToCart).toMatchSnapshot();
+    expect(addToCart).toContain('sourcePath={"add-to-cart-event.json"}');
+    expect(addToCart).toContain(JSON.stringify('components/product.json'));
+    expect(addToCart).toContain('"$ref":"./components/product.json"');
 
     const choiceEvent = fs.readFileSync(
       path.join(outputDir, 'choice-event.mdx'),

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

@@ -34,6 +34,12 @@ describe('example-helper', () => {
       };
       expect(getExamples(schema)).toEqual(['example1']);
     });
+
+    it('preserves falsy "example" values', () => {
+      expect(getExamples({ example: false })).toEqual([false]);
+      expect(getExamples({ example: 0 })).toEqual([0]);
+      expect(getExamples({ example: '' })).toEqual(['']);
+    });
   });
 
   describe('getSingleExampleValue', () => {
@@ -67,5 +73,11 @@ describe('example-helper', () => {
       };
       expect(getSingleExampleValue(schema)).toBe('default-value');
     });
+
+    it('returns falsy "example" values when present', () => {
+      expect(getSingleExampleValue({ example: false })).toBe(false);
+      expect(getSingleExampleValue({ example: 0 })).toBe(0);
+      expect(getSingleExampleValue({ example: '' })).toBe('');
+    });
   });
 });

package/__tests__/helpers/getConstraints.test.js

@@ -59,6 +59,7 @@ describe('getConstraints', () => {
       contains: { type: 'string' },
       enum: ['a', 'b', 'c'],
       const: 'hello',
+      not: { const: 'US' },
     };
     const expected = [
       'pattern: /^[a-z]+$/',
@@ -69,6 +70,7 @@ describe('getConstraints', () => {
       'contains: {"type":"string"}',
       'enum: [a, b, c]',
       'const: "hello"',
+      'not: { const: "US" }',
     ];
     expect(getConstraints(prop, false)).toEqual(
       expect.arrayContaining(expected),
@@ -100,4 +102,18 @@ describe('getConstraints', () => {
       expect.arrayContaining(['required', ...expected]),
     );
   });
+
+  it('should render "not" constraint in JSON schema syntax for const', () => {
+    const prop = {
+      not: { const: 'US' },
+    };
+    expect(getConstraints(prop, false)).toEqual(['not: { const: "US" }']);
+  });
+
+  it('should render "not" constraint in JSON schema syntax for type', () => {
+    const prop = {
+      not: { type: 'string' },
+    };
+    expect(getConstraints(prop, false)).toEqual(['not: { type: "string" }']);
+  });
 });

package/__tests__/helpers/processSchema.test.js

@@ -82,4 +82,22 @@ describe('processSchema', () => {
       }),
     );
   });
+
+  it('keeps simple not const constraints readable after allOf merge', async () => {
+    const filePath = path.join(
+      __dirname,
+      '..',
+      '__fixtures__',
+      'validateSchemas',
+      'main-schema-with-not-allof.json',
+    );
+    const mergedSchema = await processSchema(filePath);
+
+    expect(mergedSchema.properties.country).toEqual(
+      expect.objectContaining({
+        type: 'string',
+        not: { const: 'US' },
+      }),
+    );
+  });
 });

package/__tests__/helpers/schemaToTableData.test.js

@@ -217,6 +217,118 @@ describe('schemaToTableData', () => {
     expect(tableData[0].examples).toEqual(['default-value']);
   });
 
+  it('renders schema-valued additionalProperties as a synthetic row', () => {
+    const schema = {
+      properties: {
+        metadata: {
+          type: 'object',
+          description: 'Free-form metadata.',
+          additionalProperties: {
+            type: 'string',
+            description: 'Metadata value.',
+            pattern: '^[a-z]+$',
+          },
+        },
+      },
+    };
+
+    const tableData = schemaToTableData(schema);
+
+    const metadataRow = tableData.find((row) => row.name === 'metadata');
+    expect(metadataRow).toBeDefined();
+    expect(metadataRow.containerType).toBe('object');
+
+    const additionalPropertiesRow = tableData.find(
+      (row) =>
+        row.type === 'property' &&
+        row.name === 'additionalProperties' &&
+        row.level === 1,
+    );
+
+    expect(additionalPropertiesRow).toBeDefined();
+    expect(additionalPropertiesRow.propertyType).toBe('string');
+    expect(additionalPropertiesRow.description).toBe('Metadata value.');
+    expect(additionalPropertiesRow.constraints).toContain(
+      'pattern: /^[a-z]+$/',
+    );
+    expect(additionalPropertiesRow.isSchemaKeywordRow).toBe(true);
+    expect(additionalPropertiesRow.keepConnectorOpen).toBe(false);
+    expect(additionalPropertiesRow.isLastInGroup).toBe(true);
+  });
+
+  it('treats additionalProperties as the last sibling after declared properties', () => {
+    const schema = {
+      properties: {
+        user_properties: {
+          type: 'object',
+          properties: {
+            allow_ad_personalization_signals: {
+              type: ['string', 'null'],
+            },
+          },
+          additionalProperties: {
+            type: ['string', 'null'],
+          },
+        },
+      },
+    };
+
+    const tableData = schemaToTableData(schema);
+
+    const explicitPropertyRow = tableData.find(
+      (row) =>
+        row.name === 'allow_ad_personalization_signals' && row.level === 1,
+    );
+    const additionalPropertiesRow = tableData.find(
+      (row) => row.name === 'additionalProperties' && row.level === 1,
+    );
+
+    expect(explicitPropertyRow).toBeDefined();
+    expect(additionalPropertiesRow).toBeDefined();
+    expect(explicitPropertyRow.isLastInGroup).toBe(false);
+    expect(additionalPropertiesRow.isLastInGroup).toBe(true);
+  });
+
+  it('renders schema-valued patternProperties as synthetic keyword rows', () => {
+    const schema = {
+      properties: {
+        attributes: {
+          type: 'object',
+          properties: {
+            segment: { type: 'string' },
+          },
+          patternProperties: {
+            '^custom_': {
+              type: 'number',
+              description: 'Numeric custom attribute values.',
+              minimum: 0,
+            },
+          },
+        },
+      },
+    };
+
+    const tableData = schemaToTableData(schema);
+
+    const explicitPropertyRow = tableData.find(
+      (row) => row.name === 'segment' && row.level === 1,
+    );
+    const patternPropertyRow = tableData.find(
+      (row) => row.name === 'patternProperties /^custom_/' && row.level === 1,
+    );
+
+    expect(explicitPropertyRow).toBeDefined();
+    expect(patternPropertyRow).toBeDefined();
+    expect(explicitPropertyRow.isLastInGroup).toBe(false);
+    expect(patternPropertyRow.isLastInGroup).toBe(true);
+    expect(patternPropertyRow.propertyType).toBe('number');
+    expect(patternPropertyRow.description).toBe(
+      'Numeric custom attribute values.',
+    );
+    expect(patternPropertyRow.constraints).toContain('minimum: 0');
+    expect(patternPropertyRow.isSchemaKeywordRow).toBe(true);
+  });
+
   describe('if/then/else conditional support', () => {
     it('creates a conditional row for schema with if/then/else at root level', () => {
       const tableData = schemaToTableData(conditionalEventSchema);

package/__tests__/helpers/schemaTraversal.test.js

@@ -0,0 +1,110 @@
+const {
+  visitSchemaNodes,
+  visitSchemaPropertyEntries,
+} = require('../../helpers/schemaTraversal.cjs');
+
+describe('schemaTraversal', () => {
+  it('visits nested choice and conditional schema nodes', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        payment_method: {
+          oneOf: [
+            {
+              properties: {
+                card_number: { type: 'string' },
+              },
+            },
+          ],
+        },
+      },
+      if: {
+        properties: {
+          platform: { const: 'ios' },
+        },
+      },
+      then: {
+        properties: {
+          att_status: { type: 'string' },
+        },
+      },
+    };
+
+    const visitedPaths = [];
+    visitSchemaNodes(schema, (_node, context) => {
+      visitedPaths.push(context.path.join('.'));
+    });
+
+    expect(visitedPaths).toEqual(
+      expect.arrayContaining([
+        '',
+        'properties.payment_method',
+        'properties.payment_method.oneOf.0',
+        'properties.payment_method.oneOf.0.properties.card_number',
+        'if',
+        'then',
+        'then.properties.att_status',
+      ]),
+    );
+  });
+
+  it('collects property entries through object, array, choice, and conditional branches', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        event: { type: 'string' },
+        items: {
+          type: 'array',
+          items: {
+            properties: {
+              sku: { type: 'string' },
+            },
+          },
+        },
+        contact_method: {
+          type: 'object',
+          oneOf: [
+            {
+              properties: {
+                email: { type: 'string' },
+              },
+            },
+            {
+              properties: {
+                phone_number: { type: 'string' },
+              },
+            },
+          ],
+        },
+      },
+      then: {
+        properties: {
+          att_status: { type: 'string' },
+        },
+      },
+      else: {
+        properties: {
+          ad_personalization_enabled: { type: 'boolean' },
+        },
+      },
+    };
+
+    const variableNames = [];
+    visitSchemaPropertyEntries(schema, (_property, context) => {
+      variableNames.push(context.name);
+    });
+
+    expect(variableNames).toEqual(
+      expect.arrayContaining([
+        'event',
+        'items',
+        'items.0.sku',
+        'contact_method',
+        'contact_method.email',
+        'contact_method.phone_number',
+        'att_status',
+        'ad_personalization_enabled',
+      ]),
+    );
+  });
+});

package/__tests__/syncGtm.test.js

@@ -79,7 +79,7 @@ describe('getVariablesFromSchemas', () => {
 
   const SCHEMA_PATH = '/fake/schemas';
   const mockFiles = {
-    [SCHEMA_PATH]: ['complex-event.json', 'components'],
+    [SCHEMA_PATH]: ['complex-event.json', 'mobile-event.json', 'components'],
     [path.join(SCHEMA_PATH, 'components')]: ['address.json'],
   };
   const addressSchema = {
@@ -92,6 +92,7 @@ describe('getVariablesFromSchemas', () => {
   };
   const complexEventSchema = {
     title: 'Complex Event',
+    'x-tracking-targets': ['web-datalayer-js'],
     type: 'object',
     properties: {
       $schema: { type: 'string', description: 'Should now be included.' },
@@ -107,12 +108,79 @@ describe('getVariablesFromSchemas', () => {
           },
         },
       },
+      contact_method: {
+        type: 'object',
+        oneOf: [
+          {
+            title: 'Email Contact',
+            properties: {
+              email: {
+                type: 'string',
+                description: 'Email address.',
+              },
+            },
+          },
+          {
+            title: 'Phone Contact',
+            properties: {
+              phone_number: {
+                type: 'string',
+                description: 'Phone number.',
+              },
+            },
+          },
+        ],
+      },
+      platform: {
+        type: 'string',
+        description: 'Target platform.',
+      },
       timestamp: { type: 'number', description: 'Event timestamp.' },
     },
+    if: {
+      properties: {
+        platform: { const: 'ios' },
+      },
+    },
+    then: {
+      properties: {
+        att_status: {
+          type: 'string',
+          description: 'App Tracking Transparency status.',
+        },
+      },
+    },
+    else: {
+      properties: {
+        ad_personalization_enabled: {
+          type: 'boolean',
+          description: 'Whether ad personalization is enabled.',
+        },
+      },
+    },
+  };
+  const mobileEventSchema = {
+    title: 'Mobile Event',
+    'x-tracking-targets': ['android-firebase-kotlin-sdk'],
+    type: 'object',
+    properties: {
+      event: { type: 'string', const: 'screen_view' },
+      screen_name: { type: 'string', description: 'Screen name.' },
+    },
+  };
+  const untaggedEventSchema = {
+    title: 'Untagged Event',
+    type: 'object',
+    properties: {
+      event: { type: 'string', const: 'legacy_event' },
+      legacy_field: { type: 'string', description: 'Legacy field.' },
+    },
   };
   const mockFileContents = {
     [path.join(SCHEMA_PATH, 'complex-event.json')]:
       JSON.stringify(complexEventSchema),
+    [path.join(SCHEMA_PATH, 'mobile-event.json')]:
+      JSON.stringify(mobileEventSchema),
     [path.join(SCHEMA_PATH, 'components', 'address.json')]:
       JSON.stringify(addressSchema),
   };
@@ -148,7 +216,7 @@ describe('getVariablesFromSchemas', () => {
       expect.objectContaining({ name: 'timestamp' }),
     ]);
 
-    expect(result.length).toBe(8);
+    expect(result.length).toBe(14);
     expect(result).toEqual(expected);
   });
 
@@ -172,7 +240,163 @@ describe('getVariablesFromSchemas', () => {
     ];
 
     expect(result.map((r) => r.name)).toEqual(expect.arrayContaining(expected));
-    expect(result.length).toBe(expected.length);
+    expect(result.length).toBe(12);
+  });
+
+  it('should include variables from oneOf choices and conditional branches', async () => {
+    const bundledSchema = JSON.parse(JSON.stringify(complexEventSchema));
+    bundledSchema.properties.user_data.properties.addresses.items =
+      addressSchema;
+    RefParser.bundle.mockResolvedValue(bundledSchema);
+
+    const result = await gtmScript.getVariablesFromSchemas(SCHEMA_PATH, {});
+    const variableNames = result.map((variable) => variable.name);
+
+    expect(variableNames).toEqual(
+      expect.arrayContaining([
+        'contact_method.email',
+        'contact_method.phone_number',
+        'att_status',
+        'ad_personalization_enabled',
+      ]),
+    );
+  });
+
+  it('should only include schemas explicitly targeted to web-datalayer-js', async () => {
+    const untaggedEventPath = path.join(SCHEMA_PATH, 'legacy-event.json');
+    mockFiles[SCHEMA_PATH].push('legacy-event.json');
+    mockFileContents[untaggedEventPath] = JSON.stringify(untaggedEventSchema);
+
+    const bundledWebSchema = JSON.parse(JSON.stringify(complexEventSchema));
+    bundledWebSchema.properties.user_data.properties.addresses.items =
+      addressSchema;
+
+    RefParser.bundle.mockImplementation(async (filePath) => {
+      if (filePath.endsWith('complex-event.json')) {
+        return bundledWebSchema;
+      }
+      if (filePath.endsWith('mobile-event.json')) {
+        return mobileEventSchema;
+      }
+      if (filePath.endsWith('legacy-event.json')) {
+        return untaggedEventSchema;
+      }
+      if (filePath.endsWith('address.json')) {
+        return addressSchema;
+      }
+      throw new Error(`Unexpected schema file: ${filePath}`);
+    });
+
+    const result = await gtmScript.getVariablesFromSchemas(SCHEMA_PATH, {});
+
+    expect(result.map((variable) => variable.name)).toEqual(
+      expect.arrayContaining([
+        '$schema',
+        'event',
+        'user_data',
+        'user_data.user_id',
+        'user_data.addresses',
+        'user_data.addresses.0.street',
+        'user_data.addresses.0.city',
+        'timestamp',
+      ]),
+    );
+    expect(result.map((variable) => variable.name)).not.toContain(
+      'screen_name',
+    );
+    expect(result.map((variable) => variable.name)).not.toContain(
+      'legacy_field',
+    );
+  });
+
+  it('should include root tracking schemas based on content instead of path names', async () => {
+    const nestedSchemaDir = path.join(SCHEMA_PATH, 'event-components-demo');
+    const nestedSchemaPath = path.join(nestedSchemaDir, 'checkout-event.json');
+    const nestedSchema = {
+      title: 'Checkout Event',
+      'x-tracking-targets': ['web-datalayer-js'],
+      type: 'object',
+      properties: {
+        event: { type: 'string', const: 'checkout' },
+        order_id: { type: 'string', description: 'Order identifier.' },
+      },
+    };
+
+    mockFiles[SCHEMA_PATH].push('event-components-demo');
+    mockFiles[nestedSchemaDir] = ['checkout-event.json'];
+    mockFileContents[nestedSchemaPath] = JSON.stringify(nestedSchema);
+
+    const bundledWebSchema = JSON.parse(JSON.stringify(complexEventSchema));
+    bundledWebSchema.properties.user_data.properties.addresses.items =
+      addressSchema;
+
+    RefParser.bundle.mockImplementation(async (filePath) => {
+      if (filePath.endsWith('complex-event.json')) {
+        return bundledWebSchema;
+      }
+      if (filePath.endsWith('mobile-event.json')) {
+        return mobileEventSchema;
+      }
+      if (filePath.endsWith('address.json')) {
+        return addressSchema;
+      }
+      if (filePath.endsWith('legacy-event.json')) {
+        return untaggedEventSchema;
+      }
+      if (filePath.endsWith('checkout-event.json')) {
+        return nestedSchema;
+      }
+      throw new Error(`Unexpected schema file: ${filePath}`);
+    });
+
+    const result = await gtmScript.getVariablesFromSchemas(SCHEMA_PATH, {});
+    const variableNames = result.map((variable) => variable.name);
+
+    expect(variableNames).toContain('order_id');
+    expect(RefParser.bundle).toHaveBeenCalledWith(nestedSchemaPath);
+  });
+
+  it('should ignore component schemas even when scanning all json files', async () => {
+    const bundledWebSchema = JSON.parse(JSON.stringify(complexEventSchema));
+    bundledWebSchema.properties.user_data.properties.addresses.items =
+      addressSchema;
+    const nestedSchema = {
+      title: 'Checkout Event',
+      'x-tracking-targets': ['web-datalayer-js'],
+      type: 'object',
+      properties: {
+        event: { type: 'string', const: 'checkout' },
+        order_id: { type: 'string', description: 'Order identifier.' },
+      },
+    };
+
+    RefParser.bundle.mockImplementation(async (filePath) => {
+      if (filePath.endsWith('complex-event.json')) {
+        return bundledWebSchema;
+      }
+      if (filePath.endsWith('mobile-event.json')) {
+        return mobileEventSchema;
+      }
+      if (filePath.endsWith('address.json')) {
+        return addressSchema;
+      }
+      if (filePath.endsWith('legacy-event.json')) {
+        return untaggedEventSchema;
+      }
+      if (filePath.endsWith('checkout-event.json')) {
+        return nestedSchema;
+      }
+      throw new Error(`Unexpected schema file: ${filePath}`);
+    });
+
+    const result = await gtmScript.getVariablesFromSchemas(SCHEMA_PATH, {});
+    const variableNames = result.map((variable) => variable.name);
+
+    expect(RefParser.bundle).toHaveBeenCalledWith(
+      path.join(SCHEMA_PATH, 'components', 'address.json'),
+    );
+    expect(variableNames).not.toContain('street');
+    expect(variableNames).not.toContain('city');
   });
 });
 

package/__tests__/validateSchemas.test.js

@@ -102,4 +102,54 @@ describe('validateSchemas', () => {
     expect(consoleErrorSpy).toHaveBeenCalled();
     expect(consoleErrorSpy.mock.calls[0][0]).toContain('x-tracking-targets');
   });
+
+  it('should treat falsy scalar examples as valid examples', async () => {
+    const schemaDir = path.join(tmpDir, 'schemas');
+    fs.mkdirSync(schemaDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(schemaDir, 'event.json'),
+      JSON.stringify({
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        type: 'object',
+        properties: {
+          event: {
+            type: 'string',
+            const: 'test_event',
+          },
+          is_enabled: {
+            type: 'boolean',
+            example: false,
+          },
+          retry_count: {
+            type: 'integer',
+            example: 0,
+          },
+          note: {
+            type: 'string',
+            example: '',
+          },
+        },
+        required: ['event', 'is_enabled', 'retry_count', 'note'],
+      }),
+    );
+
+    const result = await validateSchemas(schemaDir);
+    expect(result).toBe(true);
+  });
+
+  it('should allow a top-level falsy example value', async () => {
+    const schemaDir = path.join(tmpDir, 'schemas');
+    fs.mkdirSync(schemaDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(schemaDir, 'flag.json'),
+      JSON.stringify({
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        type: 'boolean',
+        example: false,
+      }),
+    );
+
+    const result = await validateSchemas(schemaDir);
+    expect(result).toBe(true);
+  });
 });

package/components/ConditionalRows.js

@@ -17,6 +17,8 @@ import {
  */
 export default function ConditionalRows({
   row,
+  stripeIndex = 0,
+  stripeState,
   bracketEnds: parentBracketEnds,
 }) {
   const {
@@ -91,7 +93,7 @@ export default function ConditionalRows({
   return (
     <>
       {/* Condition (if) section - always visible */}
-      <tr className="conditional-condition-header">
+      <tr className="conditional-condition-header schema-row--control">
         <td colSpan={5} style={headerStyle}>
           <span className="conditional-condition-label">
             <span className="conditional-info-icon-wrapper">
@@ -111,7 +113,7 @@ export default function ConditionalRows({
           )}
         </td>
       </tr>
-      <SchemaRows tableData={condition.rows} />
+      <SchemaRows tableData={condition.rows} stripeState={stripeState} />
 
       {/* Branch toggles (then / else) */}
       {branches.map((branch, index) => {
@@ -121,7 +123,7 @@ export default function ConditionalRows({
           isLastBranch && !isActive ? lastToggleStyle : middleStyle;
         return (
           <React.Fragment key={branch.title}>
-            <tr className="choice-row">
+            <tr className="choice-row schema-row--control">
               <td colSpan={5} style={toggleStyle}>
                 <label className="choice-row-header">
                   <input
@@ -141,6 +143,7 @@ export default function ConditionalRows({
             {isActive && (
               <SchemaRows
                 tableData={branch.rows}
+                stripeState={stripeState}
                 bracketEnds={
                   isLastBranch
                     ? [ownBracket, ...(parentBracketEnds || [])]