Ensure all UMB_ constants is exported (#17683)

* export consts

* remove lexer

* init work on test for all consts to be exported

* temporary solution to working test

* fix test

* fix one consts

* update package-lock

* remove imports

* fix auto generation of test

* correct test

* important mistake correction

* fix workspace

* fix webhooks

* fix users

* UMB_CREATE_USER_CLIENT_CREDENTIAL_MODAL_ALIAS

* fix user group

* fix tree const exports

* tiptap const exports

* fix templates consts export

* tags

* stylesheets

* static files

* settings

* static file system

* section

* search

* scripts

* fix tsc

* relation

* relation-type

* recycle bin

* property type

* picker

* partial views

* tsc corrections

* fix circular

* package

* member

* member type

* move constants to constants file

* member group + documnet type

* media

* media-type

* revert tsconfig change

* log viewer

* language

* imaging

* healt check

* entity actions

* user permissions

* adjust test text

* document

* update consts

* document type etc

* blueprint

* dictionary

* data-type

* current-user

* culture

* content-type

* circular dependency

* block-list

* block-grid

* fix type import

* auto lint fixes

* fix tsc

* update test

* make sure always to call check-const-generation

* fix circular dependencies

* consts for content package

Author: nielslyngsoe

src/Umbraco.Web.UI.Client/devops/generate-check-const-test/index.js

@@ -0,0 +1,167 @@
+import fs from 'fs';
+import path from 'path';
+import { createImportMap } from '../importmap/index.js';
+
+
+const excludeTheseMaps = [
+	'@umbraco-cms/backoffice/models',
+	'@umbraco-cms/backoffice/markdown-editor',
+	'@umbraco-cms/backoffice/external/',
+]
+
+
+/**
+ * Recursively fetch all TypeScript files in the given directory.
+ * @param {string} dir Directory path to scan.
+ * @returns {string[]} List of file paths.
+ */
+function getTsFiles(dir) {
+  let files = [];
+  for (const file of fs.readdirSync(dir)) {
+    const fullPath = path.join(dir, file);
+    if (fs.statSync(fullPath).isDirectory()) {
+      files = files.concat(getTsFiles(fullPath));
+    } else if (file.endsWith('.ts')) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+/**
+ * Extract constants starting with "UMB_" from a file.
+ * @param {string} filePath Path to the file to analyze.
+ * @returns {string[]} List of exported UMB_ constants.
+ */
+function findUmbConstants(filePath) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const lines = content.split('\n');
+  const umbConstants = [];
+
+  for (const line of lines) {
+    // Match export const UMB_* syntax
+    const match = line.match(/export\s+const\s+([A-Za-z_][A-Za-z0-9_]*)/);
+    if (match && match[1].startsWith('UMB_')) {
+      umbConstants.push(match[1]);
+    }
+  }
+
+  return umbConstants;
+}
+
+/**
+ * Main function to find UMB_ constants from package.json exports.
+ * @param {string} projectRoot Root directory of the project (defaults to `process.cwd()`).
+ * @returns {Promise<boolean>} Resolves to true if all constants are valid; false otherwise.
+ */
+export async function findUmbConstExports() {
+
+	const __dirname = import.meta.dirname;
+	const projectRoot = path.join(__dirname, '../../');
+  const packageJsonPath = path.join(projectRoot, 'tsconfig.json');
+
+  // Step 1: Validate package.json existence and read exports field
+  if (!fs.existsSync(packageJsonPath)) {
+    throw new Error('Error: package.json not found in the project root.');
+  }
+
+	const packageSource = fs.readFileSync(packageJsonPath, 'utf-8');
+	const packageSourceWithoutComment = packageSource.slice(packageSource.indexOf('*/') + 2);
+  const packageJson = JSON.parse(packageSourceWithoutComment);
+  const exportsField = packageJson.compilerOptions.paths;
+
+  if (!exportsField) {
+    throw new Error('Error: No "exports" field found in package.json.');
+  }
+
+
+	const foundConsts = Object.entries(exportsField).map(([key, value]) => {
+		const path = value[0];
+		if(path && excludeTheseMaps.some(x => path.indexOf(x) === 0) === false) {
+			const found = checkPackageExport(projectRoot, path);
+
+			return `{
+				path: '${key}',
+				consts: ${JSON.stringify(found)}
+			}`;
+		}
+		return true;
+	}).filter(x => typeof(x) === 'string' && x != '');
+
+
+	const content = `export const foundConsts = [${foundConsts.join(',\n')}];`;
+
+	const outputPath = path.join(projectRoot, './utils/all-umb-consts/index.ts');
+	fs.writeFileSync(outputPath, content);
+
+	generatetestImportFile(projectRoot);
+
+}
+
+function checkPackageExport(projectRoot, packagePath) {
+	 // Step 2: Scan JavaScript files for exported "UMB_" constants
+	 //console.log('Scanning for exported "UMB_" constants...');gener
+	 // remove file from path:
+	 const packageFolder = packagePath.replace(/\/[^/]+$/, '');
+	 const jsFiles = getTsFiles(packageFolder);
+
+	 const umbConstants = [];
+
+	 for (const filePath of jsFiles) {
+		 const constants = findUmbConstants(filePath);
+		 if (constants.length > 0) {
+			 umbConstants.push(...constants);
+		 }
+	 }
+
+	 return umbConstants;
+
+
+}
+
+
+
+function generatetestImportFile(projectRoot) {
+
+	const importmap = createImportMap({
+		rootDir: './src',
+		replaceModuleExtensions: true,
+	});
+
+	const paths = Object.keys(importmap.imports).filter((path) => excludeTheseMaps.some(x => path.indexOf(x) === 0) === false);
+
+	const importEnties = [];
+	const dictionaryEntries = [];
+
+	paths.forEach((path, i) => {
+		importEnties.push(`import * as import${i.toString()} from '${path}';`);
+		dictionaryEntries.push(`{
+			path: '${path}',
+			package: import${i.toString()}
+		}`);
+	});
+
+	const content = `
+		${importEnties.join('\n')}
+
+		export const imports = [
+			${dictionaryEntries.join(',\n')}
+		];
+	`
+
+	const outputPath = path.join(projectRoot, './utils/all-umb-consts/imports.ts');
+	fs.writeFileSync(outputPath, content);
+}
+
+
+
+
+// run it self:
+(async () => {
+  try {
+    await findUmbConstExports();
+  } catch (error) {
+    console.error(error.message);
+    process.exit(1);
+  }
+})();

src/Umbraco.Web.UI.Client/devops/importmap/index.js

@@ -15,7 +15,6 @@ export const createImportMap = (args) => {
 			let modulePath = value;
 			if (typeof args.rootDir !== 'undefined') modulePath = modulePath.replace(/^\.\/dist-cms/, args.rootDir);
 			if (args.replaceModuleExtensions) modulePath = modulePath.replace('.js', '.ts');
-			console.log('replacing', value, 'with', modulePath);
 			const importAlias = `${packageJsonName}/${moduleName}`;
 
 			imports[importAlias] = modulePath;

src/Umbraco.Web.UI.Client/package-lock.json

@@ -172,6 +172,7 @@
 		"generate:jsonschema:imports": "node ./devops/json-schema-generator/index.js",
 		"generate:jsonschema:dist": "typescript-json-schema --required --include \"./src/json-schema/umbraco-package-schema.ts\" --out dist-cms/umbraco-package-schema.json tsconfig.json UmbracoPackage",
 		"generate:jsonschema": "typescript-json-schema --required --include \"./src/json-schema/umbraco-package-schema.ts\"",
+		"generate:check-const-test": "node ./devops/generate-check-const-test/index.js",
 		"lint:errors": "npm run lint -- --quiet",
 		"lint:fix": "npm run lint -- --fix",
 		"lint": "eslint src",
@@ -181,10 +182,10 @@
 		"storybook:preview": "npm run wc-analyze && storybook build && npx serve storybook-static",
 		"storybook": "npm run wc-analyze && storybook dev -p 6006",
 		"test:e2e": "npm run backoffice:test:e2e",
-		"test:dev": "web-test-runner --config ./web-test-runner.dev.config.mjs",
-		"test:dev-watch": "web-test-runner --watch --config ./web-test-runner.dev.config.mjs",
-		"test:watch": "web-test-runner --watch",
-		"test": "web-test-runner",
+		"test:dev": "npm run generate:check-const-test && web-test-runner --config ./web-test-runner.dev.config.mjs",
+		"test:dev-watch": "npm run generate:check-const-test && web-test-runner --watch --config ./web-test-runner.dev.config.mjs",
+		"test:watch": "npm run generate:check-const-test && web-test-runner --watch",
+		"test": "npm run generate:check-const-test && web-test-runner",
 		"wc-analyze:vscode": "wca **/*.element.ts --format vscode --outFile dist-cms/vscode-html-custom-data.json",
 		"wc-analyze": "wca **/*.element.ts --outFile dist-cms/custom-elements.json",
 		"generate:tsconfig": "node ./devops/tsconfig/index.js",

src/Umbraco.Web.UI.Client/package.json

@@ -8,7 +8,6 @@ import './app-error.element.js';
  */
 @customElement('umb-app-oauth')
 export class UmbAppOauthElement extends UmbLitElement {
-
 	/**
 	 * Set to true if the login failed. A message will be shown instead of the loader.
 	 * @attr

src/Umbraco.Web.UI.Client/src/apps/app/app-oauth.element.ts

@@ -4,6 +4,7 @@ import { UmbAppContext } from './app.context.js';
 import { UmbServerConnection } from './server-connection.js';
 import { UmbAppAuthController } from './app-auth.controller.js';
 import { UmbApiInterceptorController } from './api-interceptor.controller.js';
+import type { UmbAppOauthElement } from './app-oauth.element.js';
 import type { UMB_AUTH_CONTEXT } from '@umbraco-cms/backoffice/auth';
 import { UmbAuthContext } from '@umbraco-cms/backoffice/auth';
 import { css, html, customElement, property } from '@umbraco-cms/backoffice/external/lit';
@@ -20,7 +21,6 @@ import {
 } from '@umbraco-cms/backoffice/extension-registry';
 import { filter, first, firstValueFrom } from '@umbraco-cms/backoffice/external/rxjs';
 import { hasOwnOpener, retrieveStoredPath } from '@umbraco-cms/backoffice/utils';
-import type { UmbAppOauthElement } from './app-oauth.element.js';
 
 import './app-oauth.element.js';
 

src/Umbraco.Web.UI.Client/src/apps/app/app.element.ts

@@ -0,0 +1,109 @@
+import { expect } from '@open-wc/testing';
+import { foundConsts } from '../utils/all-umb-consts/index.js';
+import { imports } from '../utils/all-umb-consts/imports.js';
+
+describe('Export consts', () => {
+	it('all consts are exported', async () => {
+		const filteredConsts = foundConsts.filter(
+			(foundConst) =>
+				foundConst.path.indexOf('@umbraco-cms/backoffice/external') === -1 && foundConst.consts?.length > 0,
+		);
+
+		/*console.log(
+			'filteredConsts',
+			filteredConsts.map((x, i) => 'import * as import' + i + " from '" + x.path + "';"),
+		);*/
+
+		// Check if all consts are exported
+		//const valid = await validateConstants(filteredConsts[6].consts, imports[6], filteredConsts[6].path);
+
+		/*
+		const invalid = (
+			await Promise.all(
+				imports.map((p: any, i: number) => {
+					if (i === filteredConsts.length) {
+						console.log('No consts found for', i);
+						throw new Error('No consts found for ' + i);
+					}
+					return validateConstants(filteredConsts[i].consts, p, filteredConsts[i].path);
+				}),
+			)
+		).some((x) => x === false);
+		*/
+
+		const invalid = (
+			await Promise.all(
+				filteredConsts.map(async (entry) => {
+					/*
+					try {
+						if (await validatePackage(foundConst.consts, foundConst.path)) {
+							console.log(`All consts is exported from ${foundConst.path}`);
+							return true;
+						} else {
+							console.log(`Missing consts is exported from ${foundConst.path}`);
+							return false;
+						}
+					} catch (e) {
+						console.error(`Could not validate consts in ${foundConst.path}`);
+						return;
+					}
+					*/
+					const p = imports.find((x) => x.path === entry.path);
+					if (p?.package) {
+						return await validateConstants(entry.consts, p.package, entry.path);
+					} else {
+						throw new Error(`Could not validate consts in ${entry.path}, was unable to load package`);
+					}
+				}),
+			)
+		).some((x) => x !== true);
+
+		expect(invalid).to.be.false;
+	});
+});
+
+async function validatePackage(constants: Array<string>, packagePath: string) {
+	const contentOfPackage = await import(packagePath);
+
+	return validateConstants(constants, contentOfPackage, packagePath);
+}
+
+async function validateConstants(constants: Array<string>, contentOfPackage: any, packagePath: string) {
+	let allValid = true;
+
+	for (const constant of constants) {
+		let isExported = false;
+
+		for (const key in contentOfPackage) {
+			if (key === constant) {
+				isExported = true;
+				break;
+			}
+			/*
+			const value = contentOfPackage[key];
+			console.log('value...', value);
+			if (typeof value === 'string' && value.includes(constant)) {
+				isExported = true;
+				break;
+			}
+			if (typeof value === 'object') {
+				console.log('object...', value);
+				for (const subKey in value) {
+					console.log('subKey', subKey);
+					if (subKey === constant) {
+						isExported = true;
+						break;
+					}
+				}
+			}
+				*/
+		}
+
+		if (!isExported) {
+			console.error(`Error: Constant "${constant}" is not exported of ${packagePath}`);
+			allValid = false;
+		}
+	}
+
+	return allValid;
+}

src/Umbraco.Web.UI.Client/src/export-consts.test.ts

@@ -0,0 +1,2 @@
+export * from './block-grid-area-config-entry.context-token.js';
+export * from './workspace/constants.js';

src/Umbraco.Web.UI.Client/src/packages/block/block-grid/components/block-grid-area-config-entry/constants.ts

@@ -1,3 +1 @@
-export * from './block-grid-area-config-entry.context-token.js';
 export * from './block-grid-area-config-entry.element.js';
-export * from './workspace/index.js';

src/Umbraco.Web.UI.Client/src/packages/block/block-grid/components/block-grid-area-config-entry/index.ts

@@ -0,0 +1,13 @@
+import type UmbBlockGridAreaTypeWorkspaceContext from './block-grid-area-type-workspace.context.js';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import type { UmbWorkspaceContext } from '@umbraco-cms/backoffice/workspace';
+
+export const UMB_BLOCK_GRID_AREA_TYPE_WORKSPACE_CONTEXT = new UmbContextToken<
+	UmbWorkspaceContext,
+	UmbBlockGridAreaTypeWorkspaceContext
+>(
+	'UmbWorkspaceContext',
+	undefined,
+	(context): context is UmbBlockGridAreaTypeWorkspaceContext =>
+		(context as any).IS_BLOCK_GRID_AREA_TYPE_WORKSPACE_CONTEXT,
+);