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

package/helpers/schemaToTableData.js

@@ -41,6 +41,36 @@ function materializeConditionalBranchSchema(branchSchema, parentSchema) {
   };
 }
 
+function hasRenderableAdditionalProperties(schemaNode) {
+  return !!(
+    schemaNode &&
+    schemaNode.additionalProperties &&
+    typeof schemaNode.additionalProperties === 'object' &&
+    !Array.isArray(schemaNode.additionalProperties)
+  );
+}
+
+function getRenderablePatternProperties(schemaNode) {
+  if (!schemaNode?.patternProperties) {
+    return [];
+  }
+
+  return Object.entries(schemaNode.patternProperties)
+    .filter(
+      ([, patternSchema]) =>
+        patternSchema &&
+        typeof patternSchema === 'object' &&
+        !Array.isArray(patternSchema),
+    )
+    .map(([pattern, patternSchema]) => [
+      `patternProperties /${pattern}/`,
+      {
+        ...patternSchema,
+        'x-schema-keyword-row': true,
+      },
+    ]);
+}
+
 function processOptions(
   choices,
   level,
@@ -247,8 +277,26 @@ export function schemaToTableData(
   ) {
     if (!subSchema) return;
 
-    if (subSchema.properties) {
-      const propKeys = Object.keys(subSchema.properties);
+    const patternPropertyEntries = getRenderablePatternProperties(subSchema);
+
+    if (
+      subSchema.properties ||
+      hasRenderableAdditionalProperties(subSchema) ||
+      patternPropertyEntries.length > 0
+    ) {
+      const propEntries = subSchema.properties
+        ? Object.entries(subSchema.properties)
+        : [];
+      if (hasRenderableAdditionalProperties(subSchema)) {
+        propEntries.push([
+          'additionalProperties',
+          {
+            ...subSchema.additionalProperties,
+            'x-schema-keyword-row': true,
+          },
+        ]);
+      }
+      propEntries.push(...patternPropertyEntries);
       const hasSiblingChoices = !!(
         subSchema.oneOf ||
         subSchema.anyOf ||
@@ -256,19 +304,17 @@ export function schemaToTableData(
       );
 
       // Filter out properties that should be skipped to get accurate count
-      const visiblePropKeys = propKeys.filter((name) => {
-        const propSchema = subSchema.properties[name];
+      const visiblePropEntries = propEntries.filter(([name, propSchema]) => {
         return !(
           propSchema['x-gtm-clear'] === true && isEffectivelyEmpty(propSchema)
         );
       });
 
-      visiblePropKeys.forEach((name, index) => {
-        const propSchema = subSchema.properties[name];
+      visiblePropEntries.forEach(([name, propSchema], index) => {
         const newPath = [...currentPath, name];
 
         const isLastProp =
-          index === visiblePropKeys.length - 1 && !hasSiblingChoices;
+          index === visiblePropEntries.length - 1 && !hasSiblingChoices;
 
         // Updated Logic:
         // A property is visually "last" only if it is the last property
@@ -283,6 +329,8 @@ export function schemaToTableData(
 
         // Determine if this property has children and what type
         const hasNestedProperties = !!propSchema.properties;
+        const hasAdditionalProperties =
+          hasRenderableAdditionalProperties(propSchema);
         const hasArrayItems =
           propSchema.type === 'array' &&
           !!(propSchema.items?.properties || propSchema.items?.if);
@@ -290,6 +338,7 @@ export function schemaToTableData(
         const hasNestedConditional = isConditionalWrapper;
         const hasChildren =
           hasNestedProperties ||
+          hasAdditionalProperties ||
           hasArrayItems ||
           hasNestedChoice ||
           hasNestedConditional;
@@ -302,6 +351,7 @@ export function schemaToTableData(
           choiceOptions.some((opt) => opt.type === 'object' || opt.properties);
         if (
           hasNestedProperties ||
+          hasAdditionalProperties ||
           (isChoiceWrapper && propSchema.type === 'object') ||
           (isConditionalWrapper && propSchema.type === 'object') ||
           choiceOptionsAreObjects
@@ -388,6 +438,8 @@ export function schemaToTableData(
             containerType,
             continuingLevels: [...continuingLevels],
             groupBrackets: [...currentGroupBrackets],
+            isSchemaKeywordRow: propSchema['x-schema-keyword-row'] === true,
+            keepConnectorOpen: propSchema['x-keep-connector-open'] === true,
           });
 
           if (propSchema.properties) {
@@ -399,6 +451,15 @@ export function schemaToTableData(
               childContinuingLevels,
               currentGroupBrackets,
             );
+          } else if (propSchema.type === 'object' && hasAdditionalProperties) {
+            buildRows(
+              propSchema,
+              currentLevel + 1,
+              newPath,
+              [],
+              childContinuingLevels,
+              currentGroupBrackets,
+            );
           } else if (
             propSchema.type === 'array' &&
             (propSchema.items?.properties || propSchema.items?.if)

package/helpers/schemaTraversal.cjs

@@ -0,0 +1,148 @@
+function visitSchemaNodes(schema, visitor, path = []) {
+  if (!schema || typeof schema !== 'object') {
+    return;
+  }
+
+  visitor(schema, { path });
+
+  if (schema.properties && typeof schema.properties === 'object') {
+    Object.entries(schema.properties).forEach(([key, propertySchema]) => {
+      visitSchemaNodes(propertySchema, visitor, [...path, 'properties', key]);
+    });
+  }
+
+  if (schema.items && typeof schema.items === 'object') {
+    visitSchemaNodes(schema.items, visitor, [...path, 'items']);
+  }
+
+  if (Array.isArray(schema.oneOf)) {
+    schema.oneOf.forEach((optionSchema, index) => {
+      visitSchemaNodes(optionSchema, visitor, [...path, 'oneOf', index]);
+    });
+  }
+
+  if (Array.isArray(schema.anyOf)) {
+    schema.anyOf.forEach((optionSchema, index) => {
+      visitSchemaNodes(optionSchema, visitor, [...path, 'anyOf', index]);
+    });
+  }
+
+  if (schema.if && typeof schema.if === 'object') {
+    visitSchemaNodes(schema.if, visitor, [...path, 'if']);
+  }
+
+  if (schema.then && typeof schema.then === 'object') {
+    visitSchemaNodes(schema.then, visitor, [...path, 'then']);
+  }
+
+  if (schema.else && typeof schema.else === 'object') {
+    visitSchemaNodes(schema.else, visitor, [...path, 'else']);
+  }
+}
+
+function visitPropertyEntryBranches(
+  schema,
+  visitor,
+  { prefix = '', path = [], skipArraySubProperties = false } = {},
+) {
+  if (!schema || typeof schema !== 'object') {
+    return;
+  }
+
+  if (Array.isArray(schema.oneOf)) {
+    schema.oneOf.forEach((optionSchema, index) => {
+      visitSchemaPropertyEntries(optionSchema, visitor, {
+        prefix,
+        path: [...path, 'oneOf', index],
+        skipArraySubProperties,
+      });
+    });
+  }
+
+  if (Array.isArray(schema.anyOf)) {
+    schema.anyOf.forEach((optionSchema, index) => {
+      visitSchemaPropertyEntries(optionSchema, visitor, {
+        prefix,
+        path: [...path, 'anyOf', index],
+        skipArraySubProperties,
+      });
+    });
+  }
+
+  if (schema.then && typeof schema.then === 'object') {
+    visitSchemaPropertyEntries(schema.then, visitor, {
+      prefix,
+      path: [...path, 'then'],
+      skipArraySubProperties,
+    });
+  }
+
+  if (schema.else && typeof schema.else === 'object') {
+    visitSchemaPropertyEntries(schema.else, visitor, {
+      prefix,
+      path: [...path, 'else'],
+      skipArraySubProperties,
+    });
+  }
+}
+
+function visitSchemaPropertyEntries(
+  schema,
+  visitor,
+  { prefix = '', path = [], skipArraySubProperties = false } = {},
+) {
+  if (!schema || typeof schema !== 'object') {
+    return;
+  }
+
+  if (schema.properties && typeof schema.properties === 'object') {
+    Object.entries(schema.properties).forEach(([key, propertySchema]) => {
+      const currentName = prefix ? `${prefix}.${key}` : key;
+      const currentPath = [...path, 'properties', key];
+
+      visitor(propertySchema, {
+        key,
+        name: currentName,
+        path: currentPath,
+        parentSchema: schema,
+      });
+
+      if (propertySchema?.type === 'object' && propertySchema.properties) {
+        visitSchemaPropertyEntries(propertySchema, visitor, {
+          prefix: currentName,
+          path: currentPath,
+          skipArraySubProperties,
+        });
+      }
+
+      if (
+        propertySchema?.type === 'array' &&
+        propertySchema.items?.properties &&
+        !skipArraySubProperties
+      ) {
+        visitSchemaPropertyEntries(propertySchema.items, visitor, {
+          prefix: `${currentName}.0`,
+          path: [...currentPath, 'items'],
+          skipArraySubProperties,
+        });
+      }
+
+      visitPropertyEntryBranches(propertySchema, visitor, {
+        prefix: currentName,
+        path: currentPath,
+        skipArraySubProperties,
+      });
+    });
+  }
+
+  visitPropertyEntryBranches(schema, visitor, {
+    prefix,
+    path,
+    skipArraySubProperties,
+  });
+}
+
+module.exports = {
+  visitSchemaNodes,
+  visitSchemaPropertyEntries,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docusaurus-plugin-generate-schema-docs",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "Docusaurus plugin to generate documentation from JSON schemas.",
   "main": "index.js",
   "license": "MIT",

package/scripts/sync-gtm.js

@@ -3,6 +3,9 @@ const path = require('path');
 const { execSync } = require('child_process');
 const RefParser = require('@apidevtools/json-schema-ref-parser');
 const mergeAllOf = require('json-schema-merge-allof');
+const {
+  visitSchemaPropertyEntries,
+} = require('../helpers/schemaTraversal.cjs');
 
 const logger = {
   _isQuiet: false,
@@ -86,49 +89,58 @@ function findJsonFiles(dir) {
   return results;
 }
 
+function isRootTrackingSchema(schema) {
+  return Boolean(schema?.properties?.event || schema?.['x-tracking-targets']);
+}
+
 function parseSchema(schema, options, prefix = '') {
-  if (!schema || !schema.properties) {
-    return [];
-  }
+  const variables = [];
+
+  visitSchemaPropertyEntries(
+    schema,
+    (property, context) => {
+      variables.push({
+        name: context.name,
+        description: property.description,
+        type: property.type,
+      });
+    },
+    {
+      prefix,
+      skipArraySubProperties: options.skipArraySubProperties,
+    },
+  );
 
-  let variables = [];
-  for (const key in schema.properties) {
-    const property = schema.properties[key];
-    const currentPath = prefix ? `${prefix}.${key}` : key;
-    variables.push({
-      name: currentPath,
-      description: property.description,
-      type: property.type,
-    });
-    if (
-      property.type === 'array' &&
-      property.items &&
-      !options.skipArraySubProperties
-    ) {
-      if (property.items.properties) {
-        variables.push(
-          ...parseSchema(property.items, options, `${currentPath}.0`),
-        );
-      }
-    } else if (property.type === 'object' && property.properties) {
-      variables.push(...parseSchema(property, options, currentPath));
-    }
-  }
   return variables;
 }
 
+function shouldIncludeSchemaForGtm(schema) {
+  if (!isRootTrackingSchema(schema)) {
+    return false;
+  }
+
+  const trackingTargets = schema?.['x-tracking-targets'];
+
+  return (
+    Array.isArray(trackingTargets) &&
+    trackingTargets.includes('web-datalayer-js')
+  );
+}
+
 async function getVariablesFromSchemas(
   schemaPath,
   { skipArraySubProperties = false },
 ) {
   const allVariables = new Map();
   const jsonFiles = findJsonFiles(schemaPath);
-  const eventFiles = jsonFiles.filter((f) => !f.includes('components'));
 
-  for (const file of eventFiles) {
+  for (const file of jsonFiles) {
     try {
       let schema = await RefParser.bundle(file);
       schema = mergeAllOf(schema);
+      if (!shouldIncludeSchemaForGtm(schema)) {
+        continue;
+      }
       const fileVariables = parseSchema(schema, { skipArraySubProperties });
       for (const variable of fileVariables) {
         if (!allVariables.has(variable.name)) {
@@ -388,6 +400,7 @@ module.exports = {
   createGtmVariables,
   deleteGtmVariables,
   parseSchema,
+  shouldIncludeSchemaForGtm,
   findJsonFiles,
   safeJsonParse,
   logger,

package/test-data/payloadContracts.js

@@ -118,6 +118,41 @@ const PAYLOAD_CONTRACTS = [
       },
     },
   },
+  {
+    id: 'login-with-user-properties',
+    class: 'user_properties',
+    example: {
+      event: 'login',
+      method: 'email',
+      user_properties: {
+        sign_up_method: 'email',
+        allow_ad_personalization_signals: 'false',
+      },
+    },
+    expected: {
+      web: {
+        eventName: 'login',
+        payload: {
+          event: 'login',
+          method: 'email',
+          user_properties: {
+            sign_up_method: 'email',
+            allow_ad_personalization_signals: 'false',
+          },
+        },
+      },
+      firebase: {
+        eventName: 'login',
+        parameters: {
+          method: 'email',
+        },
+        userProperties: {
+          sign_up_method: 'email',
+          allow_personalized_ads: 'false',
+        },
+      },
+    },
+  },
   {
     id: 'web-fallback-json-serialization',
     class: 'fallback_json_serialization',

package/validateSchemas.js

@@ -43,7 +43,7 @@ const validateSingleSchema = async (filePath, schemaPath) => {
         fileHasAnyExample = true;
         const { example, title } = option;
 
-        if (!example) {
+        if (typeof example === 'undefined') {
           errors.push(
             `x Schema ${file} (option: ${title}) does not produce a valid example.`,
           );