docusaurus-plugin-generate-schema-docs 1.7.0 → 1.7.1

package/README.md

@@ -73,6 +73,23 @@ npm run update-schema-ids
 
 This command will update the `$id` of all schemas in the versioned directories.
 
+### Sync GTM Variables (Optional)
+
+If you use Google Tag Manager, you can sync Data Layer Variables from your schemas:
+
+```bash
+npm install --save-optional @owntag/gtm-cli
+npm run sync:gtm
+```
+
+The Docusaurus CLI command is:
+
+```bash
+docusaurus sync-gtm
+```
+
+By default, it resolves schemas from the project root. Use `--path=<siteDir>` to target a different site directory.
+
 ## How it Works
 
 The plugin reads your JSON schemas, dereferences any `$ref` properties, and merges `allOf` properties. It then generates an MDX file for each schema, which uses custom React components to render the schema details.

package/__tests__/syncGtm.test.js

@@ -0,0 +1,346 @@
+/* eslint-env jest */
+/**
+ * @jest-environment node
+ */
+const fs = require('fs');
+const path = require('path');
+const gtmScript = require('../scripts/sync-gtm');
+const { execSync } = require('child_process');
+const RefParser = require('@apidevtools/json-schema-ref-parser');
+
+jest.mock('fs');
+jest.mock('child_process');
+jest.mock('@apidevtools/json-schema-ref-parser');
+
+describe('parseArgs', () => {
+  it('should parse --quiet, --json, and --skip-array-sub-properties flags', () => {
+    const argv = [
+      'node',
+      'script.js',
+      '--quiet',
+      '--json',
+      '--skip-array-sub-properties',
+    ];
+    const { isQuiet, isJson, skipArraySubProperties } =
+      gtmScript.parseArgs(argv);
+    expect(isQuiet).toBe(true);
+    expect(isJson).toBe(true);
+    expect(skipArraySubProperties).toBe(true);
+  });
+
+  it('should parse --path argument', () => {
+    const argv = ['node', 'script.js', '--path=./my-demo'];
+    const { siteDir } = gtmScript.parseArgs(argv);
+    expect(siteDir).toBe('./my-demo');
+  });
+
+  it('should default siteDir to .', () => {
+    const argv = ['node', 'script.js'];
+    const { siteDir } = gtmScript.parseArgs(argv);
+    expect(siteDir).toBe('.');
+  });
+});
+
+describe('getLatestSchemaPath', () => {
+  const SITE_DIR = '/fake/site';
+  const SCHEMAS_BASE_PATH = path.join(SITE_DIR, 'static', 'schemas');
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should return path to latest version when versions.json exists', () => {
+    fs.existsSync.mockImplementation(
+      (p) => p === path.join(SITE_DIR, 'versions.json'),
+    );
+    fs.readFileSync.mockReturnValue('["1.2.0", "1.1.1"]');
+    const result = gtmScript.getLatestSchemaPath(SITE_DIR);
+    expect(result).toBe(path.join(SCHEMAS_BASE_PATH, '1.2.0'));
+  });
+
+  it('should return path to "next" when versions.json does not exist', () => {
+    const nextPath = path.join(SCHEMAS_BASE_PATH, 'next');
+    fs.existsSync.mockImplementation((p) => p === nextPath);
+    const result = gtmScript.getLatestSchemaPath(SITE_DIR);
+    expect(result).toBe(nextPath);
+  });
+
+  it('should return base schemas path as fallback', () => {
+    fs.existsSync.mockReturnValue(false);
+    const result = gtmScript.getLatestSchemaPath(SITE_DIR);
+    expect(result).toBe(SCHEMAS_BASE_PATH);
+  });
+});
+
+describe('getVariablesFromSchemas', () => {
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  const SCHEMA_PATH = '/fake/schemas';
+  const mockFiles = {
+    [SCHEMA_PATH]: ['complex-event.json', 'components'],
+    [path.join(SCHEMA_PATH, 'components')]: ['address.json'],
+  };
+  const addressSchema = {
+    title: 'Address',
+    type: 'object',
+    properties: {
+      street: { type: 'string', description: 'Street name.' },
+      city: { type: 'string', description: 'City name.' },
+    },
+  };
+  const complexEventSchema = {
+    title: 'Complex Event',
+    type: 'object',
+    properties: {
+      $schema: { type: 'string', description: 'Should now be included.' },
+      event: { type: 'string', const: 'user_update' },
+      user_data: {
+        type: 'object',
+        properties: {
+          user_id: { type: 'string', description: 'The user ID.' },
+          addresses: {
+            type: 'array',
+            description: 'List of addresses.',
+            items: { $ref: './components/address.json' },
+          },
+        },
+      },
+      timestamp: { type: 'number', description: 'Event timestamp.' },
+    },
+  };
+  const mockFileContents = {
+    [path.join(SCHEMA_PATH, 'complex-event.json')]:
+      JSON.stringify(complexEventSchema),
+    [path.join(SCHEMA_PATH, 'components', 'address.json')]:
+      JSON.stringify(addressSchema),
+  };
+
+  beforeEach(() => {
+    fs.readdirSync.mockImplementation((p) => mockFiles[p] || []);
+    fs.statSync.mockImplementation((p) => ({
+      isDirectory: () => !!mockFiles[p],
+    }));
+    fs.readFileSync.mockImplementation((p) => mockFileContents[p] || '');
+    fs.existsSync.mockImplementation(
+      (p) => !!mockFiles[p] || !!mockFileContents[p],
+    );
+    RefParser.bundle.mockClear();
+  });
+
+  it('should find all top-level variables, including $schema', 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 expected = expect.arrayContaining([
+      expect.objectContaining({ name: '$schema' }),
+      expect.objectContaining({ name: 'event' }),
+      expect.objectContaining({ name: 'user_data' }),
+      expect.objectContaining({ name: 'user_data.user_id' }),
+      expect.objectContaining({ name: 'user_data.addresses' }),
+      expect.objectContaining({ name: 'user_data.addresses.0.street' }),
+      expect.objectContaining({ name: 'user_data.addresses.0.city' }),
+      expect.objectContaining({ name: 'timestamp' }),
+    ]);
+
+    expect(result.length).toBe(8);
+    expect(result).toEqual(expected);
+  });
+
+  it('should skip array sub-properties when skipArraySubProperties is true', 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, {
+      skipArraySubProperties: true,
+    });
+
+    const expected = [
+      '$schema',
+      'event',
+      'user_data',
+      'user_data.user_id',
+      'user_data.addresses',
+      'timestamp',
+    ];
+
+    expect(result.map((r) => r.name)).toEqual(expect.arrayContaining(expected));
+    expect(result.length).toBe(expected.length);
+  });
+});
+
+describe('GTM Synchronization Logic', () => {
+  const schemaVariables = [
+    { name: '$schema', description: 'The schema version.' },
+    { name: 'event', description: 'The event name.' },
+    { name: 'user_id', description: 'The user ID.' },
+  ];
+  const gtmVariables = [
+    {
+      name: 'DLV - event',
+      variableId: '1',
+      type: 'v',
+      parameter: [{ key: 'name', value: 'event' }],
+    },
+    {
+      name: 'DLV - old_variable',
+      variableId: '123',
+      type: 'v',
+      parameter: [{ key: 'name', value: 'old_variable' }],
+    },
+  ];
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('getVariablesToCreate', () => {
+    it('should return variables that are in schema but not in GTM', () => {
+      const toCreate = gtmScript.getVariablesToCreate(
+        schemaVariables,
+        gtmVariables,
+      );
+      expect(toCreate).toEqual([
+        { name: '$schema', description: 'The schema version.' },
+        { name: 'user_id', description: 'The user ID.' },
+      ]);
+    });
+  });
+
+  describe('getVariablesToDelete', () => {
+    it('should return variables that are in GTM but not in schema', () => {
+      const toDelete = gtmScript.getVariablesToDelete(
+        schemaVariables,
+        gtmVariables,
+      );
+      expect(toDelete).toEqual([
+        {
+          name: 'DLV - old_variable',
+          variableId: '123',
+          type: 'v',
+          parameter: [{ key: 'name', value: 'old_variable' }],
+        },
+      ]);
+    });
+  });
+
+  describe('createGtmVariables', () => {
+    it('should call execSync to create variables and return their names', () => {
+      const toCreate = gtmScript.getVariablesToCreate(
+        schemaVariables,
+        gtmVariables,
+      );
+      const created = gtmScript.createGtmVariables(toCreate);
+      expect(execSync).toHaveBeenCalledTimes(2);
+
+      const schemaVarConfig = JSON.stringify({
+        notes: "References the '$schema' property. The schema version.",
+        parameter: [
+          { type: 'INTEGER', key: 'dataLayerVersion', value: '2' },
+          { type: 'BOOLEAN', key: 'setDefaultValue', value: 'false' },
+          { type: 'TEMPLATE', key: 'name', value: '$schema' },
+        ],
+      });
+      expect(execSync).toHaveBeenCalledWith(
+        `gtm variables create --name "DLV - \\$schema" --type v --config '${schemaVarConfig}' --quiet`,
+        { stdio: 'inherit' },
+      );
+
+      const userIdVarConfig = JSON.stringify({
+        notes: 'The user ID.',
+        parameter: [
+          { type: 'INTEGER', key: 'dataLayerVersion', value: '2' },
+          { type: 'BOOLEAN', key: 'setDefaultValue', value: 'false' },
+          { type: 'TEMPLATE', key: 'name', value: 'user_id' },
+        ],
+      });
+      expect(execSync).toHaveBeenCalledWith(
+        `gtm variables create --name "DLV - user_id" --type v --config '${userIdVarConfig}' --quiet`,
+        { stdio: 'inherit' },
+      );
+      expect(created).toEqual(['$schema', 'user_id']);
+    });
+  });
+
+  describe('deleteGtmVariables', () => {
+    it('should call execSync to delete variables and return their names', () => {
+      const toDelete = gtmScript.getVariablesToDelete(
+        schemaVariables,
+        gtmVariables,
+      );
+      const deleted = 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']);
+    });
+  });
+});
+
+describe('main function', () => {
+  let mockDeps;
+  let logSpy;
+
+  beforeEach(() => {
+    logSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+    fs.existsSync.mockReturnValue(true);
+    mockDeps = {
+      setupGtmWorkspace: jest.fn().mockResolvedValue({
+        workspaceName: 'test-workspace',
+        workspaceId: '123',
+      }),
+      syncGtmVariables: jest.fn().mockResolvedValue({
+        created: ['var1'],
+        deleted: ['var2'],
+        inSync: ['var3'],
+      }),
+      getVariablesFromSchemas: jest
+        .fn()
+        .mockResolvedValue([{ name: 'event', description: 'Event name' }]),
+      getLatestSchemaPath: jest.fn().mockReturnValue('/fake/schemas'),
+      assertGtmCliAvailable: jest.fn(),
+      logger: gtmScript.logger,
+      parseArgs: gtmScript.parseArgs,
+      process: {
+        exit: jest.fn(),
+      },
+    };
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should run quietly when --quiet is passed', async () => {
+    const argv = ['node', 'script.js', '--quiet'];
+    await gtmScript.main(argv, mockDeps);
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it('should output JSON when --json is passed', async () => {
+    const argv = ['node', 'script.js', '--json'];
+    await gtmScript.main(argv, mockDeps);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+    expect(JSON.parse(logSpy.mock.calls[0][0])).toEqual({
+      workspace: { workspaceName: 'test-workspace', workspaceId: '123' },
+      created: ['var1'],
+      deleted: ['var2'],
+      inSync: ['var3'],
+    });
+  });
+
+  it('should use the path from --path argument', async () => {
+    const argv = ['node', 'script.js', '--path=./my-demo'];
+    await gtmScript.main(argv, mockDeps);
+    expect(mockDeps.getLatestSchemaPath).toHaveBeenCalledWith('./my-demo');
+  });
+});

package/index.js

@@ -4,6 +4,11 @@ import fs from 'fs';
 import validateSchemas from './validateSchemas.js';
 import generateEventDocs from './generateEventDocs.js';
 import path from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
 export default async function (context, options) {
   const { siteDir } = context;
@@ -64,6 +69,35 @@ export default async function (context, options) {
         updateSchemaIds(siteDir, url, version);
       });
 
+    cli
+      .command('sync-gtm')
+      .description('Synchronize GTM Data Layer Variables from JSON schemas')
+      .option(
+        '--path <siteDir>',
+        'Docusaurus site directory that contains static/schemas',
+        siteDir,
+      )
+      .option('--json', 'Output JSON summary')
+      .option('--quiet', 'Suppress non-error logs')
+      .option(
+        '--skip-array-sub-properties',
+        'Skip array item sub-properties (e.g., list.0.item)',
+      )
+      .action((commandOptions) => {
+        const scriptPath = path.join(__dirname, 'scripts', 'sync-gtm.js');
+        const args = [`--path=${commandOptions.path}`];
+
+        if (commandOptions.json) args.push('--json');
+        if (commandOptions.quiet) args.push('--quiet');
+        if (commandOptions.skipArraySubProperties)
+          args.push('--skip-array-sub-properties');
+
+        execSync(`node "${scriptPath}" ${args.join(' ')}`, {
+          cwd: siteDir,
+          stdio: 'inherit',
+        });
+      });
+
     cli
       .command('version-with-schemas <version>')
       .description(

package/package.json

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

package/scripts/sync-gtm.js

@@ -0,0 +1,397 @@
+const fs = require('fs');
+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 logger = {
+  _isQuiet: false,
+  _isJson: false,
+  setup: function (isJson, isQuiet) {
+    this._isQuiet = isQuiet;
+    this._isJson = isJson;
+  },
+  log: function (...args) {
+    if (!this._isQuiet && !this._isJson) {
+      console.log(...args);
+    }
+  },
+  error: function (...args) {
+    if (!this._isQuiet) {
+      console.error(...args);
+    }
+  },
+};
+
+function assertGtmCliAvailable() {
+  try {
+    execSync('gtm --version', { stdio: 'pipe' });
+  } catch (error) {
+    throw new Error(
+      'GTM CLI is not installed or not available in PATH. Install it with "npm install --save-optional @owntag/gtm-cli" (or "npm install -g @owntag/gtm-cli").',
+    );
+  }
+}
+
+function safeJsonParse(cliOutput) {
+  if (!cliOutput) return null;
+  const arrayStartIndex = cliOutput.indexOf('[');
+  const arrayEndIndex = cliOutput.lastIndexOf(']');
+  if (arrayStartIndex !== -1 && arrayEndIndex !== -1) {
+    const jsonString = cliOutput.substring(arrayStartIndex, arrayEndIndex + 1);
+    try {
+      return JSON.parse(jsonString);
+    } catch (e) {
+      return null;
+    }
+  }
+  const objStartIndex = cliOutput.indexOf('{');
+  const objEndIndex = cliOutput.lastIndexOf('}');
+  if (objStartIndex !== -1 && objEndIndex !== -1) {
+    const jsonString = cliOutput.substring(objStartIndex, objEndIndex + 1);
+    try {
+      return JSON.parse(jsonString);
+    } catch (e) {
+      return null;
+    }
+  }
+  return null;
+}
+
+function getLatestSchemaPath(siteDir = '.') {
+  const versionsJsonPath = path.join(siteDir, 'versions.json');
+  const schemasBasePath = path.join(siteDir, 'static', 'schemas');
+  if (fs.existsSync(versionsJsonPath)) {
+    const versions = JSON.parse(fs.readFileSync(versionsJsonPath, 'utf-8'));
+    if (versions.length > 0) return path.join(schemasBasePath, versions[0]);
+  }
+  const nextVersionPath = path.join(schemasBasePath, 'next');
+  if (fs.existsSync(nextVersionPath)) return nextVersionPath;
+  return schemasBasePath;
+}
+
+function findJsonFiles(dir) {
+  let results = [];
+  if (!fs.existsSync(dir)) return results;
+  const list = fs.readdirSync(dir);
+  list.forEach((file) => {
+    const filePath = path.join(dir, file);
+    const stat = fs.statSync(filePath);
+    if (stat && stat.isDirectory()) {
+      results = results.concat(findJsonFiles(filePath));
+    } else if (path.extname(filePath) === '.json') {
+      results.push(filePath);
+    }
+  });
+  return results;
+}
+
+function parseSchema(schema, options, prefix = '') {
+  if (!schema || !schema.properties) {
+    return [];
+  }
+
+  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;
+}
+
+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) {
+    try {
+      let schema = await RefParser.bundle(file);
+      schema = mergeAllOf(schema);
+      const fileVariables = parseSchema(schema, { skipArraySubProperties });
+      for (const variable of fileVariables) {
+        if (!allVariables.has(variable.name)) {
+          allVariables.set(variable.name, variable);
+        }
+      }
+    } catch (e) {
+      logger.error(`Error processing schema ${file}:`, e);
+    }
+  }
+  return Array.from(allVariables.values());
+}
+
+function getGtmVariables() {
+  logger.log('Fetching existing GTM variables...');
+  const gtmVariablesOutput = execSync(
+    'gtm variables list -o json --quiet',
+  ).toString();
+  return safeJsonParse(gtmVariablesOutput) || [];
+}
+
+function getVariablesToCreate(schemaVariables, gtmVariables) {
+  const gtmVarMap = new Map();
+  for (const gtmVar of gtmVariables) {
+    const nameParam = gtmVar.parameter?.find((p) => p.key === 'name');
+    if (gtmVar.type === 'v' && nameParam?.value) {
+      gtmVarMap.set(nameParam.value, gtmVar);
+    }
+  }
+  return schemaVariables.filter((sv) => !gtmVarMap.has(sv.name));
+}
+
+function getVariablesToDelete(schemaVariables, gtmVariables) {
+  const schemaVarMap = new Map(schemaVariables.map((v) => [v.name, v]));
+  return gtmVariables.filter((gv) => {
+    const nameParam = gv.parameter?.find((p) => p.key === 'name');
+    return (
+      gv.type === 'v' &&
+      nameParam?.value &&
+      !schemaVarMap.has(nameParam.value) &&
+      gv.name.startsWith('DLV -')
+    );
+  });
+}
+
+function createGtmVariables(variablesToCreate) {
+  logger.log(`Found ${variablesToCreate.length} variables to create.`);
+  for (const v of variablesToCreate) {
+    const isSchemaVar = v.name === '$schema';
+    const name = `DLV - ${v.name.replace(/\$/g, '\\$')}`;
+    const notes = isSchemaVar
+      ? `References the '$schema' property. ${(v.description || '').replace(
+          /'/g,
+          '`',
+        )}`
+      : (v.description || '').replace(/'/g, '`');
+
+    const config = {
+      notes,
+      parameter: [
+        { type: 'INTEGER', key: 'dataLayerVersion', value: '2' },
+        { type: 'BOOLEAN', key: 'setDefaultValue', value: 'false' },
+        { type: 'TEMPLATE', key: 'name', value: v.name },
+      ],
+    };
+    const command = `gtm variables create --name "${name}" --type v --config '${JSON.stringify(
+      config,
+    )}' --quiet`;
+    logger.log(`Executing: ${command}`);
+    execSync(command, { stdio: 'inherit' });
+  }
+  return variablesToCreate.map((v) => v.name);
+}
+
+function deleteGtmVariables(variablesToDelete) {
+  logger.log(`Found ${variablesToDelete.length} variables to delete.`);
+  for (const v of variablesToDelete) {
+    const command = `gtm variables delete --variable-id ${v.variableId} --force --quiet`;
+    logger.log(`Executing: ${command}`);
+    execSync(command, { stdio: 'inherit' });
+  }
+  return variablesToDelete.map(
+    (v) => v.parameter.find((p) => p.key === 'name').value,
+  );
+}
+
+async function syncGtmVariables(
+  schemaVariables,
+  { skipArraySubProperties = false },
+) {
+  const gtmVariables = getGtmVariables();
+
+  let finalSchemaVariables = schemaVariables;
+  if (skipArraySubProperties) {
+    finalSchemaVariables = schemaVariables.filter(
+      (v) => !v.name.includes('.0.'),
+    );
+  }
+
+  const toCreate = getVariablesToCreate(finalSchemaVariables, gtmVariables);
+  const toDelete = getVariablesToDelete(finalSchemaVariables, gtmVariables);
+  const inSync = schemaVariables.filter(
+    (s) => !toCreate.find((c) => c.name === s.name),
+  );
+
+  const created = createGtmVariables(toCreate);
+  const deleted = deleteGtmVariables(toDelete);
+
+  logger.log('GTM variable synchronization complete.');
+  return {
+    created,
+    deleted,
+    inSync: inSync.map((v) => v.name),
+  };
+}
+
+async function setupGtmWorkspace() {
+  const branchName =
+    process.env.GTM_WORKSPACE_BRANCH ||
+    execSync('git rev-parse --abbrev-ref HEAD').toString().trim();
+  const workspaceName = `feat/${branchName.replace(/[^a-zA-Z0-9]/g, '-')}`;
+
+  logger.log('Listing GTM workspaces to find and delete existing...');
+  const workspacesOutput = execSync(
+    'gtm workspaces list -o json --quiet',
+  ).toString();
+  const workspaces = safeJsonParse(workspacesOutput) || [];
+  const existingWorkspace = workspaces.find((w) => w.name === workspaceName);
+
+  if (existingWorkspace) {
+    logger.log(
+      `Found and deleting existing GTM workspace named "${workspaceName}" with ID: ${existingWorkspace.workspaceId}`,
+    );
+    execSync(
+      `gtm workspaces delete --workspace-id ${existingWorkspace.workspaceId} --force --quiet`,
+    );
+  }
+
+  logger.log(`Creating GTM workspace named "${workspaceName}"...`);
+  const createWorkspaceOutput = execSync(
+    `gtm workspaces create --name "${workspaceName}" -o json --quiet`,
+  ).toString();
+  const newWorkspace = safeJsonParse(createWorkspaceOutput);
+  const workspaceId =
+    newWorkspace &&
+    (Array.isArray(newWorkspace)
+      ? newWorkspace[0]?.workspaceId
+      : newWorkspace.workspaceId);
+
+  if (!workspaceId) {
+    throw new Error('Failed to create GTM workspace or parse its ID.');
+  }
+  logger.log(`Successfully created workspace with ID: ${workspaceId}`);
+
+  execSync(`gtm config set defaultWorkspaceId ${workspaceId}`);
+  logger.log(`Set default workspace to ${workspaceId}`);
+  return { workspaceName, workspaceId };
+}
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const pathArg = args.find((arg) => arg.startsWith('--path=')) || '';
+  const siteDir = pathArg.split('=')[1] || '.';
+  return {
+    isJson: args.includes('--json'),
+    isQuiet: args.includes('--quiet'),
+    skipArraySubProperties: args.includes('--skip-array-sub-properties'),
+    siteDir,
+  };
+}
+
+async function main(argv, deps) {
+  try {
+    const {
+      setupGtmWorkspace: setup,
+      getLatestSchemaPath: getPath,
+      getVariablesFromSchemas: getVars,
+      syncGtmVariables: sync,
+      assertGtmCliAvailable: assertCli = assertGtmCliAvailable,
+      logger: log,
+      parseArgs: parse,
+      process: proc,
+    } = deps;
+    const { isJson, isQuiet, skipArraySubProperties, siteDir } = parse(argv);
+    log.setup(isJson, isQuiet);
+
+    log.log('Starting GTM variable synchronization script...');
+    assertCli();
+
+    const { workspaceName, workspaceId } = await setup();
+
+    const schemaPath = getPath(siteDir);
+    if (!fs.existsSync(schemaPath)) {
+      throw new Error(
+        `Schema directory not found: ${schemaPath}. Use --path=<siteDir> to point to your Docusaurus project root.`,
+      );
+    }
+    log.log(`Scanning for schemas in: ${schemaPath}`);
+    const schemaVariables = await getVars(schemaPath, {
+      skipArraySubProperties,
+    });
+    if (schemaVariables.length === 0) {
+      throw new Error(
+        `No schema variables found in ${schemaPath}. Aborting to avoid deleting existing GTM variables.`,
+      );
+    }
+    log.log(`Found ${schemaVariables.length} variables defined in schemas.`);
+
+    const summary = await sync(schemaVariables, { skipArraySubProperties });
+
+    if (isJson) {
+      console.log(
+        JSON.stringify(
+          { workspace: { workspaceName, workspaceId }, ...summary },
+          null,
+          2,
+        ),
+      );
+    } else {
+      log.log('Synchronization successful!');
+      log.log(
+        `All changes applied in GTM workspace: "${workspaceName}" (ID: ${workspaceId})`,
+      );
+    }
+  } catch (error) {
+    logger.error('An error occurred during GTM synchronization:');
+    logger.error(error.message);
+    if (deps.process && typeof deps.process.exit === 'function') {
+      deps.process.exit(1);
+    } else {
+      process.exit(1);
+    }
+  }
+}
+
+if (require.main === module) {
+  const dependencies = {
+    setupGtmWorkspace,
+    getLatestSchemaPath,
+    getVariablesFromSchemas,
+    syncGtmVariables,
+    assertGtmCliAvailable,
+    logger,
+    parseArgs,
+    process,
+  };
+  main(process.argv, dependencies);
+}
+
+module.exports = {
+  getLatestSchemaPath,
+  getVariablesFromSchemas,
+  syncGtmVariables,
+  main,
+  getVariablesToCreate,
+  getVariablesToDelete,
+  createGtmVariables,
+  deleteGtmVariables,
+  parseSchema,
+  findJsonFiles,
+  safeJsonParse,
+  logger,
+  parseArgs,
+  assertGtmCliAvailable,
+  setupGtmWorkspace,
+};