@azure-net/cli 5.0.0-3 → 5.0.1

package/src/generate/module/generatePresenter.ts

@@ -5,6 +5,7 @@ import { toKebabCase, toPascalCase } from '../../utils/contextUtils.js';
 import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
 import { getConfigState, resolveContextAlias, selectContext } from './repositoryModuleShared.js';
 import { loadUserConfig } from '../../utils/loadConfig.js';
+import { getFoundationConstructImportPath, getFoundationConstructPath, getSharedState } from '../../utils/sharedFoundation.js';
 
 type MethodParam = { name: string; type: string };
 type RepositoryMethod = { name: string; params: MethodParam[]; responseType: string };
@@ -108,8 +109,9 @@ const parseRepositoryHttpMethods = (content: string): Map<string, string> => {
 	return methods;
 };
 
-const getCorePresenterFactories = async (): Promise<string[]> => {
-	const presenterPath = path.join(process.cwd(), 'src', 'core', 'presenter');
+const getSharedPresenterFactories = async (): Promise<string[]> => {
+	const { sharedContext } = await getSharedState();
+	const presenterPath = getFoundationConstructPath(sharedContext.name, 'presenter');
 	try {
 		const files = await fs.readdir(presenterPath);
 		return files.filter((item) => item.endsWith('.ts') && item !== 'index.ts').map((item) => item.replace(/\.ts$/, ''));
@@ -118,8 +120,9 @@ const getCorePresenterFactories = async (): Promise<string[]> => {
 	}
 };
 
-const getCoreSchemaFactories = async (): Promise<string[]> => {
-	const schemaPath = path.join(process.cwd(), 'src', 'core', 'schema');
+const getSharedSchemaFactories = async (): Promise<string[]> => {
+	const { sharedContext } = await getSharedState();
+	const schemaPath = getFoundationConstructPath(sharedContext.name, 'schema');
 	try {
 		const files = await fs.readdir(schemaPath);
 		return files.filter((item) => item.endsWith('.ts') && item !== 'index.ts').map((item) => item.replace(/\.ts$/, ''));
@@ -139,6 +142,7 @@ const isPrimitive = (typeName: string): boolean => PRIMITIVE_TYPES.has(String(ty
 
 const normalizeTypeImports = (types: string[]): string[] => Array.from(new Set(types.filter((typeName) => !isPrimitive(typeName))));
 const isPathParamName = (name: string): boolean => name === 'pathParam' || name === 'path';
+const toTypeFileName = (typeName: string): string => String(typeName ?? '').replace(/^I/, '') || 'Type';
 
 const buildMethodInvocation = (
 	method: RepositoryMethod & { httpMethod: string },
@@ -183,6 +187,46 @@ const getApplicationProviderFile = async (contextName: string): Promise<string |
 	}
 };
 
+const resolveDomainInterfaceFile = async ({
+	contextName,
+	domainName,
+	interfaceName
+}: {
+	contextName: string;
+	domainName: string;
+	interfaceName: string;
+}): Promise<string | null> => {
+	const portsPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'domain', domainName, 'ports');
+	const preferredPath = path.join(portsPath, `${toTypeFileName(interfaceName)}.ts`);
+	const legacyPath = path.join(portsPath, `${interfaceName}.ts`);
+
+	for (const candidate of [preferredPath, legacyPath]) {
+		try {
+			await fs.access(candidate);
+			return candidate;
+		} catch {
+			// Try the next candidate.
+		}
+	}
+
+	try {
+		const files = await fs.readdir(portsPath);
+		for (const fileName of files) {
+			if (!fileName.endsWith('.ts') || fileName === 'index.ts') continue;
+			const candidate = path.join(portsPath, fileName);
+			const content = await fs.readFile(candidate, 'utf-8');
+			const escapedName = interfaceName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+			if (new RegExp(`export\\s+interface\\s+${escapedName}\\b`).test(content)) {
+				return candidate;
+			}
+		}
+	} catch {
+		return null;
+	}
+
+	return null;
+};
+
 type GeneratePresenterOptions = {
 	contextName?: string;
 	useCasesName?: string;
@@ -260,17 +304,27 @@ export default async function generatePresenter(options: GeneratePresenterOption
 	}
 
 	const repositoryHttpMethods = parseRepositoryHttpMethods(repositoryInfo.content);
-	const domainPortsInterfacePath = path.join(
-		process.cwd(),
-		'src',
-		'app',
+	const domainPortsInterfacePath = await resolveDomainInterfaceFile({
 		contextName,
-		'layers',
-		'domain',
-		useCasesInfo.domainName,
-		'ports',
-		`${useCasesInfo.repositoryInterfaceName}.ts`
-	);
+		domainName: useCasesInfo.domainName,
+		interfaceName: useCasesInfo.repositoryInterfaceName
+	});
+	if (!domainPortsInterfacePath) {
+		console.error(
+			`❌ Repository interface "${useCasesInfo.repositoryInterfaceName}" was not found in ${path.join(
+				process.cwd(),
+				'src',
+				'app',
+				contextName,
+				'layers',
+				'domain',
+				useCasesInfo.domainName,
+				'ports'
+			)}`
+		);
+		process.exitCode = 1;
+		return;
+	}
 	const repositoryInterfaceContent = await fs.readFile(domainPortsInterfacePath, 'utf-8');
 	const repositoryMethods = parseRepositoryInterfaceMethods(repositoryInterfaceContent).filter((method) =>
 		useCasesInfo.methods.includes(method.name)
@@ -287,13 +341,15 @@ export default async function generatePresenter(options: GeneratePresenterOption
 	const presentationPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'presentation', presenterFolder);
 	await fs.mkdir(presentationPath, { recursive: true });
 
-	const { contexts, coreAlias } = await getConfigState();
+	const { contexts, sharedAlias } = await getConfigState();
 	const contextAlias = resolveContextAlias(contexts, contextName);
+	const presenterImportPath = getFoundationConstructImportPath(sharedAlias, 'presenter');
+	const schemaFactoryImportPath = getFoundationConstructImportPath(sharedAlias, 'schema');
 
 	let presenterFactory = String((await loadUserConfig()).defaultPresenterFactory ?? '').trim();
 	let useNativePresenter = false;
 	if (!presenterFactory) {
-		const availableFactories = await getCorePresenterFactories();
+		const availableFactories = await getSharedPresenterFactories();
 		const { selectedFactory } = await prompts({
 			type: 'select',
 			name: 'selectedFactory',
@@ -345,9 +401,9 @@ export default async function generatePresenter(options: GeneratePresenterOption
 
 			if (!schemaFactoryResolved) {
 				if (!schemaFactory) {
-					const availableSchemas = await getCoreSchemaFactories();
+					const availableSchemas = await getSharedSchemaFactories();
 					if (!availableSchemas.length) {
-						console.error('❌ No schema factories found in src/core/schema.');
+						console.error('❌ No schema factories found in shared foundation constructs/schema.');
 						process.exitCode = 1;
 						return;
 					}
@@ -372,7 +428,7 @@ export default async function generatePresenter(options: GeneratePresenterOption
 			await fs.mkdir(schemaPath, { recursive: true });
 			schemaIndexNeeded = true;
 
-			const schemaContent = `import { ${schemaFactory} } from '${coreAlias}/schema';
+			const schemaContent = `import { ${schemaFactory} } from '${schemaFactoryImportPath}';
 import type { ${requestParam.type} } from '${contextAlias}/layers/domain/${useCasesInfo.domainName}';
 
 export const ${schemaConstName} = ${schemaFactory}<${requestParam.type}>()
@@ -414,7 +470,7 @@ export const ${schemaConstName} = ${schemaFactory}<${requestParam.type}>()
 
 	const factoryImport = useNativePresenter
 		? `import { createPresenter } from '@azure-net/kit/delivery';`
-		: `import { ${presenterFactory} } from '${coreAlias}/presenter';`;
+		: `import { ${presenterFactory} } from '${presenterImportPath}';`;
 
 	const schemaImportLine = schemaImports.length ? `import { ${Array.from(new Set(schemaImports)).join(', ')} } from './schema';` : '';
 	const typeImportLine = typeImports.length

package/src/generate/module/generateRepository.js

@@ -17,7 +17,6 @@ import {
 	writeRepositoryInterface
 } from './repositoryModuleShared.js';
 import { updateIndexTs, writeIfNotExists } from '../../utils/fileUtils.js';
-
 export default async function generateRepository(options = {}) {
 	let contextName = options.contextName ? String(options.contextName) : null;
 	if (!contextName) {
@@ -27,7 +26,6 @@ export default async function generateRepository(options = {}) {
 		process.exitCode = 1;
 		return null;
 	}
-
 	let domainName = options.domainName ? String(options.domainName) : null;
 	if (!domainName) {
 		domainName = await selectDomain(contextName);
@@ -36,23 +34,19 @@ export default async function generateRepository(options = {}) {
 		process.exitCode = 1;
 		return null;
 	}
-
 	const { repositoryNameRaw } = await prompts({
 		type: 'text',
 		name: 'repositoryNameRaw',
 		message: 'Repository name:',
 		validate: (value) => (String(value ?? '').trim().length > 0 ? true : 'Repository name is required')
 	});
-
 	const className = ensureRepositoryName(repositoryNameRaw);
 	const meta = getRepositoryMeta(className);
-
 	const datasource = await selectDatasource(contextName);
 	if (!datasource) {
 		process.exitCode = 1;
 		return null;
 	}
-
 	const domainTypes = await getDomainTypes(contextName, domainName);
 	const { methodsCountRaw } = await prompts({
 		type: 'number',
@@ -61,33 +55,28 @@ export default async function generateRepository(options = {}) {
 		initial: 1,
 		min: 0
 	});
-
 	const methodsCount = Number(methodsCountRaw ?? 0);
 	if (!Number.isFinite(methodsCount) || methodsCount < 0) {
 		console.error('❌ Invalid methods count.');
 		process.exitCode = 1;
 		return null;
 	}
-
 	const methods = await promptMethodsBatch(domainTypes, methodsCount);
 	if (!methods) {
 		process.exitCode = 1;
 		return null;
 	}
-
 	const { contexts } = await getConfigState();
 	const contextAlias = resolveContextAlias(contexts, contextName);
 	const repositoriesPath = resolveRepositoriesPath(contextName);
 	await fs.mkdir(repositoriesPath, { recursive: true });
 	const repositoryPath = path.join(repositoriesPath, `${meta.className}.ts`);
-
 	await writeRepositoryInterface({
 		contextName,
 		domainName,
 		meta,
 		methods
 	});
-
 	const repositoryContent = buildRepositoryContent({
 		meta,
 		contextAlias,
@@ -95,23 +84,19 @@ export default async function generateRepository(options = {}) {
 		datasource,
 		methods
 	});
-
 	const created = await writeIfNotExists(repositoryPath, repositoryContent);
 	await updateIndexTs(repositoriesPath);
-
 	if (!created) {
 		console.warn(`⚠️ Repository "${meta.className}" already exists. File was not overwritten.`);
 		process.exitCode = 1;
 		return null;
 	}
-
 	const { shouldCreateUseCases } = await prompts({
 		type: 'confirm',
 		name: 'shouldCreateUseCases',
 		message: 'Create UseCases for this repository?',
 		initial: true
 	});
-
 	let useCasesCreated = false;
 	if (shouldCreateUseCases) {
 		await createUseCasesForRepository({
@@ -122,7 +107,6 @@ export default async function generateRepository(options = {}) {
 		});
 		useCasesCreated = true;
 	}
-
 	if (!shouldCreateUseCases && options.forceCreateUseCases) {
 		await createUseCasesForRepository({
 			contextName,
@@ -132,7 +116,6 @@ export default async function generateRepository(options = {}) {
 		});
 		useCasesCreated = true;
 	}
-
 	console.log(`✅ Repository generated: ${repositoryPath}`);
 	return {
 		contextName,

package/src/generate/module/generateSchemaFromType.js

@@ -2,7 +2,6 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import prompts from 'prompts';
 import { getConfigState, resolveContextAlias, selectContext } from './repositoryModuleShared.js';
-
 const listDirectories = async (targetPath) => {
 	try {
 		const items = await fs.readdir(targetPath, { withFileTypes: true });
@@ -11,7 +10,6 @@ const listDirectories = async (targetPath) => {
 		return [];
 	}
 };
-
 const listSchemaFiles = async (targetPath) => {
 	try {
 		const files = await fs.readdir(targetPath);
@@ -20,24 +18,18 @@ const listSchemaFiles = async (targetPath) => {
 		return [];
 	}
 };
-
 const resolveAliasMap = async () => {
-	const { contexts, coreAlias } = await getConfigState();
+	const { contexts } = await getConfigState();
 	const map = new Map();
-	map.set(coreAlias, path.join(process.cwd(), 'src', 'core'));
-
 	for (const context of contexts) {
 		const alias = resolveContextAlias(contexts, context.name);
 		map.set(alias, path.join(process.cwd(), 'src', 'app', context.name));
 	}
-
 	return map;
 };
-
 const resolveImportToFile = async (fromFile, importPath, aliasMap) => {
 	const rawImport = String(importPath ?? '').trim();
 	if (!rawImport.length) return null;
-
 	let absolute = '';
 	if (rawImport.startsWith('.')) {
 		absolute = path.resolve(path.dirname(fromFile), rawImport);
@@ -47,7 +39,6 @@ const resolveImportToFile = async (fromFile, importPath, aliasMap) => {
 		const suffix = rawImport === alias ? '' : rawImport.slice(alias.length + 1);
 		absolute = path.join(aliasMap.get(alias), suffix);
 	}
-
 	const tsCandidate = absolute.endsWith('.ts') ? absolute : `${absolute}.ts`;
 	try {
 		await fs.access(tsCandidate);
@@ -62,36 +53,34 @@ const resolveImportToFile = async (fromFile, importPath, aliasMap) => {
 		}
 	}
 };
-
 const extractSchemaTypeName = (content) => {
 	const typeMatch = content.match(/=\s*[A-Za-z0-9_]+<\s*([^>]+?)\s*>\s*\(\)/m);
 	if (!typeMatch) return null;
 	return String(typeMatch[1]).trim();
 };
-
 const findTypeImportPath = (content, typeName) => {
 	const importRegex = /import\s+type\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/g;
 	let match;
 	while ((match = importRegex.exec(content)) !== null) {
-		const imported = match[1]
+		const importedList = match[1];
+		const sourcePath = match[2];
+		if (!importedList || !sourcePath) continue;
+		const imported = importedList
 			.split(',')
 			.map((item) => item.trim())
 			.filter(Boolean);
 		if (imported.includes(typeName)) {
-			return match[2];
+			return sourcePath;
 		}
 	}
 	return null;
 };
-
 const extractInterfaceBody = (content, interfaceName) => {
 	const declarationRegex = new RegExp(`export\\s+interface\\s+${interfaceName}\\s*\\{`);
 	const declarationMatch = content.match(declarationRegex);
 	if (!declarationMatch || declarationMatch.index === undefined) return null;
-
 	const openBraceIndex = content.indexOf('{', declarationMatch.index);
 	if (openBraceIndex === -1) return null;
-
 	let depth = 0;
 	let closeBraceIndex = -1;
 	for (let index = openBraceIndex; index < content.length; index += 1) {
@@ -105,11 +94,9 @@ const extractInterfaceBody = (content, interfaceName) => {
 			}
 		}
 	}
-
 	if (closeBraceIndex === -1) return null;
 	return content.slice(openBraceIndex + 1, closeBraceIndex);
 };
-
 const resolveRelativeExportPath = async (fromFile, exportPath) => {
 	const absolute = path.resolve(path.dirname(fromFile), exportPath);
 	const tsCandidate = absolute.endsWith('.ts') ? absolute : `${absolute}.ts`;
@@ -126,38 +113,30 @@ const resolveRelativeExportPath = async (fromFile, exportPath) => {
 		}
 	}
 };
-
 const findInterfaceBodyByExportGraph = async (entryFilePath, interfaceName, visited = new Set()) => {
 	const resolvedPath = path.resolve(entryFilePath);
 	if (visited.has(resolvedPath)) return null;
 	visited.add(resolvedPath);
-
 	let content = '';
 	try {
 		content = await fs.readFile(resolvedPath, 'utf-8');
 	} catch {
 		return null;
 	}
-
 	const direct = extractInterfaceBody(content, interfaceName);
 	if (direct) return direct;
-
-	const exportRegex = /export\\s+(?:\\*|\\{[^}]+\\})\\s+from\\s+['\"]([^'\"]+)['\"]/g;
+	const exportRegex = /export\s+(?:\*|\{[^}]+\})\s+from\s+['"]([^'"]+)['"]/g;
 	let match;
 	while ((match = exportRegex.exec(content)) !== null) {
 		const exportPath = match[1];
 		if (!exportPath || !exportPath.startsWith('.')) continue;
-		// eslint-disable-next-line no-await-in-loop
 		const nextPath = await resolveRelativeExportPath(resolvedPath, exportPath);
 		if (!nextPath) continue;
-		// eslint-disable-next-line no-await-in-loop
 		const nested = await findInterfaceBodyByExportGraph(nextPath, interfaceName, visited);
 		if (nested) return nested;
 	}
-
 	return null;
 };
-
 const findInterfaceBodyByScan = async (rootDir, interfaceName) => {
 	const queue = [rootDir];
 	while (queue.length) {
@@ -169,7 +148,6 @@ const findInterfaceBodyByScan = async (rootDir, interfaceName) => {
 		} catch {
 			continue;
 		}
-
 		for (const entry of entries) {
 			const absolute = path.join(current, entry.name);
 			if (entry.isDirectory()) {
@@ -177,7 +155,6 @@ const findInterfaceBodyByScan = async (rootDir, interfaceName) => {
 				continue;
 			}
 			if (!entry.isFile() || !entry.name.endsWith('.ts')) continue;
-			// eslint-disable-next-line no-await-in-loop
 			const content = await fs.readFile(absolute, 'utf-8');
 			const body = extractInterfaceBody(content, interfaceName);
 			if (body) return body;
@@ -185,17 +162,16 @@ const findInterfaceBodyByScan = async (rootDir, interfaceName) => {
 	}
 	return null;
 };
-
 const extractRuleKeys = (body) => {
 	const keys = [];
 	const keyRegex = /^\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*:/gm;
 	let match;
 	while ((match = keyRegex.exec(body)) !== null) {
-		keys.push(match[1]);
+		const key = match[1];
+		if (key) keys.push(key);
 	}
 	return Array.from(new Set(keys));
 };
-
 const extractInterfaceFields = (body) => {
 	const fields = [];
 	const fieldRegex = /^\s*(?:readonly\s+)?([A-Za-z_$][A-Za-z0-9_$]*)(\?)?\s*:\s*([^;]+);/gm;
@@ -211,53 +187,42 @@ const extractInterfaceFields = (body) => {
 			type
 		});
 	}
-
 	const unique = new Map();
 	for (const field of fields) {
 		if (!unique.has(field.name)) unique.set(field.name, field);
 	}
 	return Array.from(unique.values());
 };
-
 const buildRulesArray = (field) => {
 	const ruleCalls = [];
 	if (!field.optional) {
 		ruleCalls.push('rules.required()');
 	}
-
 	if (field.type === 'string') {
 		ruleCalls.push('rules.string()');
 	} else if (field.type === 'number') {
 		ruleCalls.push('rules.number()');
 	}
-
 	return `[${ruleCalls.join(', ')}]`;
 };
-
 const updateRulesObject = (schemaContent, fields) => {
 	const rulesRegex = /\.rules\(\(rules\)\s*=>\s*\(\{([\s\S]*?)\}\)\)/m;
 	const match = schemaContent.match(rulesRegex);
 	if (!match) return null;
-
 	const currentBody = match[1] ?? '';
 	const existingKeys = new Set(extractRuleKeys(currentBody));
 	const newLines = fields.filter((field) => !existingKeys.has(field.name)).map((field) => `\t\t${field.name}: ${buildRulesArray(field)},`);
-
 	if (!newLines.length) return schemaContent;
-
 	const trimmedBody = currentBody.trimEnd();
 	const nextBody = trimmedBody.length ? `${trimmedBody}\n${newLines.join('\n')}\n\t` : `\n${newLines.join('\n')}\n\t`;
-
 	return schemaContent.replace(rulesRegex, `.rules((rules) => ({${nextBody}}))`);
 };
-
 export default async function generateSchemaFromType() {
 	const contextName = await selectContext('Select context for schema update:');
 	if (!contextName) {
 		process.exitCode = 1;
 		return;
 	}
-
 	const presentationPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'presentation');
 	const presenterFolders = await listDirectories(presentationPath);
 	if (!presenterFolders.length) {
@@ -265,7 +230,6 @@ export default async function generateSchemaFromType() {
 		process.exitCode = 1;
 		return;
 	}
-
 	const { presenterFolder } = await prompts({
 		type: 'select',
 		name: 'presenterFolder',
@@ -273,12 +237,10 @@ export default async function generateSchemaFromType() {
 		choices: presenterFolders.map((item) => ({ title: item, value: item })),
 		initial: 0
 	});
-
 	if (!presenterFolder) {
 		process.exitCode = 1;
 		return;
 	}
-
 	const schemaFolderPath = path.join(presentationPath, String(presenterFolder), 'schema');
 	const schemas = await listSchemaFiles(schemaFolderPath);
 	if (!schemas.length) {
@@ -286,7 +248,6 @@ export default async function generateSchemaFromType() {
 		process.exitCode = 1;
 		return;
 	}
-
 	const { schemaFile } = await prompts({
 		type: 'select',
 		name: 'schemaFile',
@@ -294,29 +255,24 @@ export default async function generateSchemaFromType() {
 		choices: schemas.map((item) => ({ title: item, value: item })),
 		initial: 0
 	});
-
 	if (!schemaFile) {
 		process.exitCode = 1;
 		return;
 	}
-
 	const schemaPath = path.join(schemaFolderPath, String(schemaFile));
 	const schemaContent = await fs.readFile(schemaPath, 'utf-8');
-
 	const typeName = extractSchemaTypeName(schemaContent);
 	if (!typeName) {
 		console.error('❌ Unable to resolve schema generic type.');
 		process.exitCode = 1;
 		return;
 	}
-
 	const importPath = findTypeImportPath(schemaContent, typeName);
 	if (!importPath) {
 		console.error(`❌ Unable to find import for type "${typeName}".`);
 		process.exitCode = 1;
 		return;
 	}
-
 	const aliasMap = await resolveAliasMap();
 	const typeFilePath = await resolveImportToFile(schemaPath, importPath, aliasMap);
 	if (!typeFilePath) {
@@ -324,7 +280,6 @@ export default async function generateSchemaFromType() {
 		process.exitCode = 1;
 		return;
 	}
-
 	let interfaceBody = await findInterfaceBodyByExportGraph(typeFilePath, typeName);
 	if (!interfaceBody) {
 		interfaceBody = await findInterfaceBodyByScan(path.dirname(typeFilePath), typeName);
@@ -334,25 +289,21 @@ export default async function generateSchemaFromType() {
 		process.exitCode = 1;
 		return;
 	}
-
 	const interfaceFields = extractInterfaceFields(interfaceBody);
 	if (!interfaceFields.length) {
 		console.log('ℹ️ Interface has no explicit keys to transfer into rules.');
 		return;
 	}
-
 	const updatedSchemaContent = updateRulesObject(schemaContent, interfaceFields);
 	if (!updatedSchemaContent) {
 		console.error('❌ Could not locate `.rules((rules) => ({}))` block in schema file.');
 		process.exitCode = 1;
 		return;
 	}
-
 	if (updatedSchemaContent === schemaContent) {
 		console.log('ℹ️ Rules already include all keys from type.');
 		return;
 	}
-
 	await fs.writeFile(schemaPath, updatedSchemaContent, 'utf-8');
 	console.log(`✅ Schema updated from type: ${schemaPath}`);
 }

package/src/generate/module/generateSchemaFromType.ts

@@ -22,9 +22,8 @@ const listSchemaFiles = async (targetPath: string): Promise<string[]> => {
 };
 
 const resolveAliasMap = async (): Promise<Map<string, string>> => {
-	const { contexts, coreAlias } = await getConfigState();
+	const { contexts } = await getConfigState();
 	const map = new Map<string, string>();
-	map.set(coreAlias, path.join(process.cwd(), 'src', 'core'));
 
 	for (const context of contexts) {
 		const alias = resolveContextAlias(contexts, context.name);