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

package/__tests__/syncGtm.test.js

@@ -1,6 +1,6 @@
 /* eslint-env jest */
 /**
- * @jest-environment node
+ * @jest-environment @stryker-mutator/jest-runner/jest-env/node
  */
 const fs = require('fs');
 const path = require('path');
@@ -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,104 @@ 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 mobileConditionalSchema = {
+    title: 'Mobile Conditional Event',
+    'x-tracking-targets': ['android-firebase-kotlin-sdk'],
+    type: 'object',
+    allOf: [
+      {
+        if: {
+          properties: {
+            mobile_platform_hint: { const: 'ios' },
+          },
+          required: ['mobile_platform_hint'],
+        },
+        then: {
+          required: ['att_status'],
+        },
+        else: {
+          required: ['ad_personalization_enabled'],
+        },
+      },
+    ],
+    properties: {
+      event: { type: 'string', const: 'screen_view' },
+      mobile_platform_hint: { type: 'string' },
+    },
+  };
+  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 +241,7 @@ describe('getVariablesFromSchemas', () => {
       expect.objectContaining({ name: 'timestamp' }),
     ]);
 
-    expect(result.length).toBe(8);
+    expect(result.length).toBe(14);
     expect(result).toEqual(expected);
   });
 
@@ -172,7 +265,209 @@ 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 skip non-web schemas before mergeAllOf can fail on unsupported keywords', async () => {
+    const mobileConditionalPath = path.join(
+      SCHEMA_PATH,
+      'mobile-conditional-event.json',
+    );
+    mockFiles[SCHEMA_PATH].push('mobile-conditional-event.json');
+    mockFileContents[mobileConditionalPath] = JSON.stringify(
+      mobileConditionalSchema,
+    );
+
+    const bundledWebSchema = JSON.parse(JSON.stringify(complexEventSchema));
+    bundledWebSchema.properties.user_data.properties.addresses.items =
+      addressSchema;
+    const loggerErrorSpy = jest
+      .spyOn(console, 'error')
+      .mockImplementation(() => {});
+
+    RefParser.bundle.mockImplementation(async (filePath) => {
+      if (filePath.endsWith('complex-event.json')) {
+        return bundledWebSchema;
+      }
+      if (filePath.endsWith('mobile-event.json')) {
+        return mobileEventSchema;
+      }
+      if (filePath.endsWith('mobile-conditional-event.json')) {
+        return mobileConditionalSchema;
+      }
+      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)).not.toContain(
+      'mobile_platform_hint',
+    );
+    expect(loggerErrorSpy).not.toHaveBeenCalledWith(
+      expect.stringContaining(
+        `Error processing schema ${mobileConditionalPath}`,
+      ),
+      expect.any(Error),
+    );
+  });
+
+  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');
   });
 });
 
@@ -270,18 +565,61 @@ describe('GTM Synchronization Logic', () => {
   });
 
   describe('deleteGtmVariables', () => {
-    it('should call execSync to delete variables and return their names', () => {
+    it('should delete variables and return their names', () => {
       const toDelete = gtmScript.getVariablesToDelete(
         schemaVariables,
         gtmVariables,
       );
-      const deleted = gtmScript.deleteGtmVariables(toDelete);
+      const { deleted, failedDeletes } = gtmScript.deleteGtmVariables(toDelete);
       expect(execSync).toHaveBeenCalledTimes(1);
       expect(execSync).toHaveBeenCalledWith(
         'gtm variables delete --variable-id 123 --force --quiet',
         { stdio: 'inherit' },
       );
       expect(deleted).toEqual(['old_variable']);
+      expect(failedDeletes).toEqual([]);
+    });
+
+    it('should capture failed deletes when GTM rejects the deletion', () => {
+      execSync.mockImplementation(() => {
+        throw new Error('Returned an error response for your request.');
+      });
+
+      const toDelete = gtmScript.getVariablesToDelete(
+        schemaVariables,
+        gtmVariables,
+      );
+      const { deleted, failedDeletes } = gtmScript.deleteGtmVariables(toDelete);
+
+      expect(deleted).toEqual([]);
+      expect(failedDeletes).toEqual([
+        { name: 'old_variable', variableId: '123' },
+      ]);
+    });
+  });
+
+  describe('syncGtmVariables', () => {
+    it('should report failed deletes when GTM rejects a deletion', async () => {
+      const syncedSchemaVariables = [
+        { name: 'event', description: 'The event name.' },
+      ];
+
+      execSync.mockImplementation((command) => {
+        if (command === 'gtm variables list -o json --quiet') {
+          return Buffer.from(JSON.stringify(gtmVariables));
+        }
+        if (command.startsWith('gtm variables delete')) {
+          throw new Error('Returned an error response for your request.');
+        }
+        throw new Error(`Unexpected command: ${command}`);
+      });
+
+      const summary = await gtmScript.syncGtmVariables(syncedSchemaVariables);
+
+      expect(summary.deleted).toEqual([]);
+      expect(summary.failedDeletes).toEqual([
+        { name: 'old_variable', variableId: '123' },
+      ]);
     });
   });
 });
@@ -301,6 +639,12 @@ describe('main function', () => {
       syncGtmVariables: jest.fn().mockResolvedValue({
         created: ['var1'],
         deleted: ['var2'],
+        failedDeletes: [
+          {
+            name: 'legacy_field',
+            variableId: '88',
+          },
+        ],
         inSync: ['var3'],
       }),
       getVariablesFromSchemas: jest
@@ -334,6 +678,12 @@ describe('main function', () => {
       workspace: { workspaceName: 'test-workspace', workspaceId: '123' },
       created: ['var1'],
       deleted: ['var2'],
+      failedDeletes: [
+        {
+          name: 'legacy_field',
+          variableId: '88',
+        },
+      ],
       inSync: ['var3'],
     });
   });
@@ -343,4 +693,14 @@ describe('main function', () => {
     await gtmScript.main(argv, mockDeps);
     expect(mockDeps.getLatestSchemaPath).toHaveBeenCalledWith('./my-demo');
   });
+
+  it('should report failed deletions in human-readable output', async () => {
+    const argv = ['node', 'script.js'];
+    await gtmScript.main(argv, mockDeps);
+
+    expect(logSpy).toHaveBeenCalledWith(
+      'Skipped deleting 1 GTM variables (GTM rejected the delete, they may still be referenced):',
+    );
+    expect(logSpy).toHaveBeenCalledWith('- legacy_field (ID: 88)');
+  });
 });

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);
 });