feat(nx-infra-plugin): migrate verify:licenses to nx executor

Author: chaosmirage

packages/devextreme/build/gulp/check_licenses.js

@@ -33,7 +33,6 @@ require('./build/gulp/transpile');
 require('./build/gulp/js-bundles');
 require('./build/gulp/ts');
 require('./build/gulp/localization');
-require('./build/gulp/check_licenses');
 require('./build/gulp/systemjs');
 
 function getTranspileConfig() {
@@ -70,6 +69,8 @@ gulp.task('aspnet', shell.task(
 
 gulp.task('vendor', shell.task('pnpm nx run devextreme:copy:vendor'));
 
+gulp.task('check-license-notices', shell.task('pnpm nx run devextreme:verify:licenses'));
+
 gulp.task('state-manager-optimize', shell.task('pnpm nx run devextreme:state-manager:optimize'));
 
 gulp.task('npm', shell.task(

packages/devextreme/gulpfile.js

@@ -957,10 +957,23 @@
       ]
     },
     "verify:licenses": {
-      "executor": "nx:run-commands",
+      "executor": "devextreme-nx-infra-plugin:license-check",
+      "inputs": [
+        "{projectRoot}/artifacts/js/dx.all.js"
+      ],
       "options": {
-        "command": "gulp check-license-notices",
-        "cwd": "{projectRoot}"
+        "files": [
+          "./artifacts/js/dx.all.js"
+        ],
+        "licenses": [
+          {
+            "name": "rrule.js - Library for working with recurrence rules for calendar dates.",
+            "homepageUrl": "https://github.com/jakubroztocil/rrule",
+            "copyright": "Copyright 2010, Jakub Roztocil and Lars Schoning",
+            "licenseType": "Licenced under the BSD licence.",
+            "licenseUrl": "https://github.com/jakubroztocil/rrule/blob/master/LICENCE"
+          }
+        ]
       }
     },
     "copy:vendor:js": {

packages/devextreme/project.json

@@ -110,6 +110,11 @@
       "schema": "./src/executors/scss-assemble/schema.json",
       "description": "Assemble SCSS package: copy files with data-uri inlining, fonts, and icons"
     },
+    "license-check": {
+      "implementation": "./src/executors/license-check/executor",
+      "schema": "./src/executors/license-check/schema.json",
+      "description": "Verify embedded license notices in built artifacts"
+    },
     "state-manager-optimize": {
       "implementation": "./src/executors/state-manager-optimize/executor",
       "schema": "./src/executors/state-manager-optimize/schema.json",

packages/nx-infra-plugin/executors.json

@@ -0,0 +1,84 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { logger } from '@nx/devkit';
+import executor from './executor';
+import { LicenseCheckExecutorSchema } from './schema';
+import { createTempDir, cleanupTempDir, createMockContext } from '../../utils/test-utils';
+import { writeFileText } from '../../utils';
+
+const TEST_NOTICE = `/* !
+ * synthetic-lib.js - Library for verifying the license-check executor.
+ * https://example.com/synthetic-lib
+ *
+ * Copyright 2026, Synthetic Author
+ * Licensed under the Test license.
+ * https://example.com/synthetic-lib/LICENSE
+ *
+ */
+`;
+
+const TEST_LICENSE: LicenseCheckExecutorSchema['licenses'][number] = {
+  name: 'synthetic-lib.js - Library for verifying the license-check executor.',
+  homepageUrl: 'https://example.com/synthetic-lib',
+  copyright: 'Copyright 2026, Synthetic Author',
+  licenseType: 'Licensed under the Test license.',
+  licenseUrl: 'https://example.com/synthetic-lib/LICENSE',
+};
+
+describe('LicenseCheckExecutor E2E', () => {
+  let tempDir: string;
+  let context = createMockContext();
+  let projectDir: string;
+  let errorSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    tempDir = createTempDir('nx-license-check-e2e-');
+    context = createMockContext({ root: tempDir });
+    projectDir = path.join(tempDir, 'packages', 'test-lib');
+    fs.mkdirSync(projectDir, { recursive: true });
+    errorSpy = jest.spyOn(logger, 'error').mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    errorSpy.mockRestore();
+    cleanupTempDir(tempDir);
+  });
+
+  it('should succeed when configured license notices are present in the bundle', async () => {
+    const filePath = path.join(projectDir, 'bundle.js');
+    await writeFileText(filePath, `// prologue\n${TEST_NOTICE}// epilogue\n`);
+
+    const result = await executor({ files: ['./bundle.js'], licenses: [TEST_LICENSE] }, context);
+
+    expect(result.success).toBe(true);
+  });
+
+  it('should fail and report the missing license name when a notice is absent', async () => {
+    const filePath = path.join(projectDir, 'bundle.js');
+    await writeFileText(filePath, '// no notice here\n');
+
+    const result = await executor({ files: ['./bundle.js'], licenses: [TEST_LICENSE] }, context);
+
+    expect(result.success).toBe(false);
+    const reportedMessage = String(errorSpy.mock.calls[0][0]);
+    expect(reportedMessage).toContain(TEST_LICENSE.name);
+    expect(reportedMessage).toContain('bundle.js');
+  });
+
+  it('should aggregate misses across multiple files and only list failing files', async () => {
+    const passingPath = path.join(projectDir, 'bundle-a.js');
+    const failingPath = path.join(projectDir, 'bundle-b.js');
+    await writeFileText(passingPath, `${TEST_NOTICE}`);
+    await writeFileText(failingPath, '// missing notice\n');
+
+    const result = await executor(
+      { files: ['./bundle-a.js', './bundle-b.js'], licenses: [TEST_LICENSE] },
+      context,
+    );
+
+    expect(result.success).toBe(false);
+    const reportedMessage = String(errorSpy.mock.calls[0][0]);
+    expect(reportedMessage).toContain('bundle-b.js');
+    expect(reportedMessage).not.toContain('bundle-a.js');
+  });
+});

packages/nx-infra-plugin/src/executors/license-check/executor.e2e.spec.ts

@@ -0,0 +1 @@
+export { default } from './license-check.impl';

packages/nx-infra-plugin/src/executors/license-check/executor.ts

@@ -0,0 +1,67 @@
+import * as path from 'path';
+import { logger } from '@nx/devkit';
+import { createExecutor } from '../../utils/create-executor';
+import { readFileText } from '../../utils/file-operations';
+import { LicenseCheckExecutorSchema, LicenseEntry } from './schema';
+
+interface LicenseMiss {
+  file: string;
+  licenseName: string;
+}
+
+interface ResolvedLicenseCheck {
+  projectRoot: string;
+  files: { absolutePath: string; displayPath: string }[];
+  licenses: LicenseEntry[];
+}
+
+const LICENSE_FIELD_SEPARATOR = '\\s*\\*\\s';
+const ERROR_HEADER_SINGLE = 'issue';
+const ERROR_HEADER_PLURAL = 'issues';
+
+export function buildLicenseRegex(entry: LicenseEntry): RegExp {
+  const pattern =
+    `\\* !\\s*.*${entry.name}${LICENSE_FIELD_SEPARATOR}`
+    + `${entry.homepageUrl}${LICENSE_FIELD_SEPARATOR}*\\*\\s`
+    + `${entry.copyright}${LICENSE_FIELD_SEPARATOR}`
+    + `${entry.licenseType}${LICENSE_FIELD_SEPARATOR}`
+    + `${entry.licenseUrl}`;
+  return new RegExp(pattern);
+}
+
+function buildErrorMessage(misses: LicenseMiss[]): string {
+  const label = misses.length === 1 ? ERROR_HEADER_SINGLE : ERROR_HEADER_PLURAL;
+  const header = `License notice check failed (${misses.length} ${label}):`;
+  const bullets = misses
+    .map((miss) => `  - "${miss.licenseName}" not found in ${miss.file}`)
+    .join('\n');
+  return `${header}\n${bullets}`;
+}
+
+export default createExecutor<LicenseCheckExecutorSchema, ResolvedLicenseCheck>({
+  name: 'LicenseCheck',
+  resolve: (options, { projectRoot }) => {
+    const files = options.files.map((fileEntry) => {
+      const absolutePath = path.resolve(projectRoot, fileEntry);
+      const displayPath = path.relative(projectRoot, absolutePath) || absolutePath;
+      return { absolutePath, displayPath };
+    });
+    return { projectRoot, files, licenses: options.licenses };
+  },
+  run: async (resolved) => {
+    const misses: LicenseMiss[] = [];
+    for (const fileEntry of resolved.files) {
+      const fileContent = await readFileText(fileEntry.absolutePath);
+      for (const licenseEntry of resolved.licenses) {
+        const licenseRegex = buildLicenseRegex(licenseEntry);
+        if (fileContent.search(licenseRegex) === -1) {
+          misses.push({ file: fileEntry.displayPath, licenseName: licenseEntry.name });
+        }
+      }
+      logger.verbose(`Checked license notices in ${fileEntry.displayPath}`);
+    }
+    if (misses.length > 0) {
+      throw new Error(buildErrorMessage(misses));
+    }
+  },
+});

packages/nx-infra-plugin/src/executors/license-check/license-check.impl.ts

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "type": "object",
+  "properties": {
+    "files": {
+      "type": "array",
+      "items": { "type": "string" },
+      "minItems": 1,
+      "description": "Paths to files whose embedded license notices must be verified (relative to project root)"
+    },
+    "licenses": {
+      "type": "array",
+      "minItems": 1,
+      "description": "License entries to verify; each entry is converted to a regex and searched in every file",
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "Human-readable library description; appears in error messages and is matched verbatim in the bundle"
+          },
+          "homepageUrl": {
+            "type": "string",
+            "description": "Library homepage URL embedded in the license notice"
+          },
+          "copyright": {
+            "type": "string",
+            "description": "Copyright line embedded in the license notice"
+          },
+          "licenseType": {
+            "type": "string",
+            "description": "License-type line embedded in the license notice"
+          },
+          "licenseUrl": {
+            "type": "string",
+            "description": "License-text URL embedded in the license notice"
+          }
+        },
+        "required": ["name", "homepageUrl", "copyright", "licenseType", "licenseUrl"],
+        "additionalProperties": false
+      }
+    }
+  },
+  "required": ["files", "licenses"]
+}

packages/nx-infra-plugin/src/executors/license-check/schema.json

@@ -0,0 +1,12 @@
+export interface LicenseEntry {
+  name: string;
+  homepageUrl: string;
+  copyright: string;
+  licenseType: string;
+  licenseUrl: string;
+}
+
+export interface LicenseCheckExecutorSchema {
+  files: string[];
+  licenses: LicenseEntry[];
+}