@azure-net/cli 5.0.0-3 → 5.0.1

package/src/generate/module/repositoryModuleShared.js

@@ -5,7 +5,7 @@ import { loadUserConfig } from '../../utils/loadConfig.js';
 import { normalizeContexts } from '../../init/initAliases.js';
 import { toCamelCase, toPascalCase } from '../../utils/contextUtils.js';
 import { updateIndexTs } from '../../utils/fileUtils.js';
-
+import { getFoundationConstructImportPath, getFoundationConstructPath, getSharedState } from '../../utils/sharedFoundation.js';
 const HTTP_METHODS = ['get', 'post', 'put', 'delete', 'head', 'options', 'patch'];
 const MUTATION_METHODS = new Set(['put', 'patch', 'delete']);
 const RESERVED_IDENTIFIERS = new Set([
@@ -56,20 +56,16 @@ const RESERVED_IDENTIFIERS = new Set([
 	'static',
 	'yield'
 ]);
-
 const normalizeAlias = (value, fallback) => {
 	const raw = String(value ?? '').trim();
 	if (!raw.length) return fallback;
 	return raw.startsWith('$') ? raw : `$${raw}`;
 };
-
 const toTypeFileName = (typeName) => String(typeName ?? '').replace(/^I/, '') || 'Type';
-
 export const ensureRepositoryName = (rawName) => {
 	const normalized = toPascalCase(String(rawName ?? '').trim() || 'Repository');
 	return normalized.endsWith('Repository') ? normalized : `${normalized}Repository`;
 };
-
 export const getRepositoryMeta = (repositoryName) => {
 	const className = ensureRepositoryName(repositoryName);
 	const baseName = className.replace(/Repository$/, '') || 'Repository';
@@ -79,7 +75,6 @@ export const getRepositoryMeta = (repositoryName) => {
 	const repositoryDependencyName = RESERVED_IDENTIFIERS.has(repositoryDependencyNameRaw)
 		? `${repositoryDependencyNameRaw}Repository`
 		: repositoryDependencyNameRaw;
-
 	return {
 		className,
 		baseName,
@@ -88,21 +83,18 @@ export const getRepositoryMeta = (repositoryName) => {
 		repositoryDependencyName
 	};
 };
-
 export const getConfigState = async () => {
 	const config = await loadUserConfig();
 	const contexts = normalizeContexts(config.contexts);
-	const coreAlias = normalizeAlias(config.coreAlias, '$core');
-	return { contexts, coreAlias };
+	const { sharedAlias, sharedContext } = await getSharedState();
+	return { contexts, sharedAlias, sharedContextName: sharedContext.name };
 };
-
 export const selectContext = async (message = 'Select context:') => {
 	const { contexts } = await getConfigState();
 	if (!contexts.length) {
 		console.error('❌ Cannot continue: `contexts` is missing or empty in azure-net.config.ts/js');
 		return null;
 	}
-
 	const { context } = await prompts({
 		type: 'select',
 		name: 'context',
@@ -110,30 +102,25 @@ export const selectContext = async (message = 'Select context:') => {
 		choices: contexts.map((item) => ({ title: item.name, value: item.name })),
 		initial: 0
 	});
-
 	return context ? String(context) : null;
 };
-
 export const resolveContextAlias = (contexts, contextName) => {
 	const found = contexts.find((item) => item.name === contextName);
 	if (!found) return `$${contextName}`;
 	return normalizeAlias(found.alias, `$${contextName}`);
 };
-
 export const resolveRepositoriesPath = (contextName) =>
 	path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'infrastructure', 'http', 'repositories');
-
 export const resolveDatasourcesPath = (contextName) =>
 	path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'infrastructure', 'http', 'datasources');
-
-export const resolveCoreDatasourcesPath = () => path.join(process.cwd(), 'src', 'core', 'datasource');
-
+export const resolveSharedDatasourcesPath = async () => {
+	const { sharedContext } = await getSharedState();
+	return getFoundationConstructPath(sharedContext.name, 'datasource');
+};
 export const resolveDomainRootPath = (contextName, domainName) =>
 	path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'domain', domainName);
-
 export const resolveUseCasesPath = (contextName) =>
 	path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'application', 'use-cases');
-
 export const getAvailableTsNames = async (targetPath) => {
 	try {
 		const files = await fs.readdir(targetPath);
@@ -142,33 +129,28 @@ export const getAvailableTsNames = async (targetPath) => {
 		return [];
 	}
 };
-
 export const selectDatasource = async (contextName) => {
-	const { contexts, coreAlias } = await getConfigState();
+	const { contexts, sharedAlias } = await getConfigState();
 	const contextAlias = resolveContextAlias(contexts, contextName);
-	const coreDatasources = await getAvailableTsNames(resolveCoreDatasourcesPath());
+	const sharedDatasources = await getAvailableTsNames(await resolveSharedDatasourcesPath());
 	const contextDatasources = await getAvailableTsNames(resolveDatasourcesPath(contextName));
-
 	const choices = [];
-	for (const datasource of coreDatasources) {
+	for (const datasource of sharedDatasources) {
 		choices.push({
-			title: `${datasource} (core)`,
-			value: { name: datasource, importPath: `${coreAlias}/datasource` }
+			title: `${datasource} (shared foundation)`,
+			value: { name: datasource, importPath: getFoundationConstructImportPath(sharedAlias, 'datasource') }
 		});
 	}
-
 	for (const datasource of contextDatasources) {
 		choices.push({
 			title: `${datasource} (${contextName})`,
 			value: { name: datasource, importPath: `${contextAlias}/layers/infrastructure/http/datasources` }
 		});
 	}
-
 	if (!choices.length) {
-		console.error(`❌ No datasources found in core or context "${contextName}".`);
+		console.error(`❌ No datasources found in shared foundation or context "${contextName}".`);
 		return null;
 	}
-
 	const { datasource } = await prompts({
 		type: 'select',
 		name: 'datasource',
@@ -176,10 +158,8 @@ export const selectDatasource = async (contextName) => {
 		choices,
 		initial: 0
 	});
-
 	return datasource ?? null;
 };
-
 export const selectDomain = async (contextName) => {
 	const domainPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'domain');
 	try {
@@ -189,7 +169,6 @@ export const selectDomain = async (contextName) => {
 			console.error(`❌ No domain folders found in ${domainPath}`);
 			return null;
 		}
-
 		const { domain } = await prompts({
 			type: 'select',
 			name: 'domain',
@@ -197,19 +176,16 @@ export const selectDomain = async (contextName) => {
 			choices: domains.map((item) => ({ title: item, value: item })),
 			initial: 0
 		});
-
 		return domain ? String(domain) : null;
 	} catch {
 		console.error(`❌ Domain path not found: ${domainPath}`);
 		return null;
 	}
 };
-
 const extractInterfaceName = (content, fallback) => {
 	const match = content.match(/export\s+interface\s+([A-Za-z0-9_]+)/);
 	return match?.[1] ?? fallback;
 };
-
 export const getDomainTypes = async (contextName, domainName) => {
 	const root = resolveDomainRootPath(contextName, domainName);
 	const result = [];
@@ -220,7 +196,6 @@ export const getDomainTypes = async (contextName, domainName) => {
 			for (const fileName of files) {
 				if (!fileName.endsWith('.ts') || fileName === 'index.ts') continue;
 				const absolute = path.join(layerPath, fileName);
-				// eslint-disable-next-line no-await-in-loop
 				const content = await fs.readFile(absolute, 'utf-8');
 				const fallback = fileName.replace(/\.ts$/, '');
 				const interfaceName = extractInterfaceName(content, fallback);
@@ -230,15 +205,12 @@ export const getDomainTypes = async (contextName, domainName) => {
 			// ignore
 		}
 	};
-
 	await readLayer('ports');
 	await readLayer('model');
 	return result;
 };
-
 const isPrimitiveType = (value) =>
 	['string', 'number', 'boolean', 'unknown', 'void', 'null', 'undefined', 'bigint', 'symbol', 'never'].includes(String(value ?? '').trim());
-
 const buildResponseSelection = async (domainTypes) => {
 	const { isPrimitive } = await prompts({
 		type: 'confirm',
@@ -246,7 +218,6 @@ const buildResponseSelection = async (domainTypes) => {
 		message: 'Is response type primitive?',
 		initial: false
 	});
-
 	if (isPrimitive) {
 		const { primitiveType } = await prompts({
 			type: 'text',
@@ -254,15 +225,12 @@ const buildResponseSelection = async (domainTypes) => {
 			message: 'Primitive response type:',
 			validate: (value) => (String(value ?? '').trim().length > 0 ? true : 'Type is required')
 		});
-
 		return { kind: 'primitive', type: String(primitiveType).trim(), layer: null };
 	}
-
 	if (!domainTypes.length) {
 		console.error('❌ Domain has no model/ports types to choose from.');
 		return null;
 	}
-
 	const { selectedType } = await prompts({
 		type: 'select',
 		name: 'selectedType',
@@ -273,26 +241,21 @@ const buildResponseSelection = async (domainTypes) => {
 		})),
 		initial: 0
 	});
-
 	if (!selectedType) return null;
 	return { kind: 'domain', type: selectedType.name, layer: selectedType.layer };
 };
-
 const buildDomainRequestTypeSelection = async (question, domainTypes) => {
 	if (!domainTypes.length) {
 		console.error('❌ Domain has no model/ports types to choose from.');
 		return null;
 	}
-
 	const { enabled } = await prompts({
 		type: 'confirm',
 		name: 'enabled',
 		message: question,
 		initial: false
 	});
-
 	if (!enabled) return null;
-
 	const { selectedType } = await prompts({
 		type: 'select',
 		name: 'selectedType',
@@ -303,10 +266,8 @@ const buildDomainRequestTypeSelection = async (question, domainTypes) => {
 		})),
 		initial: 0
 	});
-
 	return selectedType ?? null;
 };
-
 const buildPathParamTypeSelection = async () => {
 	const { enabled } = await prompts({
 		type: 'confirm',
@@ -314,9 +275,7 @@ const buildPathParamTypeSelection = async () => {
 		message: 'Has path param?',
 		initial: false
 	});
-
 	if (!enabled) return null;
-
 	const { type } = await prompts({
 		type: 'select',
 		name: 'type',
@@ -327,10 +286,8 @@ const buildPathParamTypeSelection = async () => {
 		],
 		initial: 0
 	});
-
 	return type ?? 'string';
 };
-
 export const promptMethodDefinition = async (domainTypes) => {
 	const { methodNameRaw } = await prompts({
 		type: 'text',
@@ -338,7 +295,6 @@ export const promptMethodDefinition = async (domainTypes) => {
 		message: 'Method name:',
 		validate: (value) => (String(value ?? '').trim().length > 0 ? true : 'Method name is required')
 	});
-
 	const { httpMethod } = await prompts({
 		type: 'select',
 		name: 'httpMethod',
@@ -346,7 +302,6 @@ export const promptMethodDefinition = async (domainTypes) => {
 		choices: HTTP_METHODS.map((item) => ({ title: item, value: item })),
 		initial: 0
 	});
-
 	const { routeRaw } = await prompts({
 		type: 'text',
 		name: 'routeRaw',
@@ -358,15 +313,12 @@ export const promptMethodDefinition = async (domainTypes) => {
 			return raw.startsWith('/') ? true : 'Path must start with "/"';
 		}
 	});
-
 	const response = await buildResponseSelection(domainTypes);
 	if (!response) return null;
-
 	const normalizedMethod = String(httpMethod ?? 'get').toLowerCase();
 	let queryType = null;
 	let bodyType = null;
 	let pathParamType = null;
-
 	if (normalizedMethod === 'get') {
 		queryType = await buildDomainRequestTypeSelection('Has query params?', domainTypes);
 	} else if (normalizedMethod === 'post') {
@@ -375,7 +327,6 @@ export const promptMethodDefinition = async (domainTypes) => {
 		pathParamType = await buildPathParamTypeSelection();
 		bodyType = await buildDomainRequestTypeSelection('Has request body?', domainTypes);
 	}
-
 	return {
 		name: toCamelCase(String(methodNameRaw ?? '').trim() || 'method'),
 		httpMethod: normalizedMethod,
@@ -386,9 +337,7 @@ export const promptMethodDefinition = async (domainTypes) => {
 		pathParamType
 	};
 };
-
 const getResponseTypeName = (method) => method.response.type;
-
 const getMethodParams = (method) => {
 	const params = [];
 	if (method.pathParamType) params.push(`pathParam: ${method.pathParamType}`);
@@ -396,10 +345,8 @@ const getMethodParams = (method) => {
 	if (method.bodyType) params.push(`request: ${method.bodyType.name}`);
 	return params.join(', ');
 };
-
 const getRequestMapping = (method) => {
 	const routeWithPath = method.pathParamType ? `${method.route}/\${pathParam}` : method.route;
-
 	if (method.httpMethod === 'get') {
 		if (method.queryType) {
 			return {
@@ -407,13 +354,11 @@ const getRequestMapping = (method) => {
 				call: `http.get(\`${routeWithPath}\`, { searchParams: query.toSearchParams(request) })`
 			};
 		}
-
 		return {
 			callbackParams: '{ http }',
 			call: `http.get(\`${routeWithPath}\`)`
 		};
 	}
-
 	if (method.httpMethod === 'post') {
 		if (method.bodyType) {
 			return {
@@ -421,13 +366,11 @@ const getRequestMapping = (method) => {
 				call: `http.post(\`${routeWithPath}\`, { json: request })`
 			};
 		}
-
 		return {
 			callbackParams: '{ http }',
 			call: `http.post(\`${routeWithPath}\`)`
 		};
 	}
-
 	if (method.httpMethod === 'put' || method.httpMethod === 'patch' || method.httpMethod === 'delete') {
 		const callMethod = method.httpMethod;
 		if (method.bodyType) {
@@ -436,27 +379,22 @@ const getRequestMapping = (method) => {
 				call: `http.${callMethod}(\`${routeWithPath}\`, { json: request })`
 			};
 		}
-
 		return {
 			callbackParams: '{ http }',
 			call: `http.${callMethod}(\`${routeWithPath}\`)`
 		};
 	}
-
 	return {
 		callbackParams: '{ http }',
 		call: `http.${method.httpMethod}(\`${routeWithPath}\`)`
 	};
 };
-
 export const buildRepositoryMethodCode = (method) => {
 	const params = getMethodParams(method);
 	const responseType = getResponseTypeName(method);
 	const mapping = getRequestMapping(method);
-
 	return `\tpublic async ${method.name}(${params}) {\n\t\treturn this.datasource\n\t\t\t.createRequest<${responseType}>((${mapping.callbackParams}) => ${mapping.call})\n\t\t\t.then((res) => res.getData());\n\t}`;
 };
-
 export const buildRepositoryContent = ({ meta, contextAlias, domainName, datasource, methods }) => {
 	const typeImports = new Set([meta.repositoryInterfaceName]);
 	for (const method of methods) {
@@ -464,12 +402,10 @@ export const buildRepositoryContent = ({ meta, contextAlias, domainName, datasou
 		if (method.queryType) typeImports.add(method.queryType.name);
 		if (method.bodyType) typeImports.add(method.bodyType.name);
 	}
-
 	const methodsCode = methods.map((method) => buildRepositoryMethodCode(method)).join('\n\n');
 	const typeImportLine = typeImports.size
 		? `import type { ${Array.from(typeImports).join(', ')} } from '${contextAlias}/layers/domain/${domainName}';\n`
 		: '';
-
 	return `import { ${datasource.name} } from '${datasource.importPath}';
 ${typeImportLine}
 export class ${meta.className} implements ${meta.repositoryInterfaceName} {
@@ -479,15 +415,12 @@ ${methodsCode ? `${methodsCode}\n` : ''}
 }
 `;
 };
-
 export const writeRepositoryInterface = async ({ contextName, domainName, meta, methods }) => {
 	const domainPath = resolveDomainRootPath(contextName, domainName);
 	const portsPath = path.join(domainPath, 'ports');
 	await fs.mkdir(portsPath, { recursive: true });
-
 	const portsImports = new Set();
 	const modelImports = new Set();
-
 	for (const method of methods) {
 		const allTypes = [];
 		if (!isPrimitiveType(method.response.type) && method.response.layer) {
@@ -495,13 +428,11 @@ export const writeRepositoryInterface = async ({ contextName, domainName, meta,
 		}
 		if (method.queryType) allTypes.push(method.queryType);
 		if (method.bodyType) allTypes.push(method.bodyType);
-
 		for (const typeEntry of allTypes) {
 			if (typeEntry.layer === 'ports') portsImports.add(typeEntry.name);
 			if (typeEntry.layer === 'model') modelImports.add(typeEntry.name);
 		}
 	}
-
 	const imports = [];
 	for (const name of Array.from(portsImports)) {
 		imports.push(`import type { ${name} } from './${toTypeFileName(name)}';`);
@@ -509,7 +440,6 @@ export const writeRepositoryInterface = async ({ contextName, domainName, meta,
 	for (const name of Array.from(modelImports)) {
 		imports.push(`import type { ${name} } from '../model/${toTypeFileName(name)}';`);
 	}
-
 	const signatures = methods
 		.map((method) => {
 			const responseType = getResponseTypeName(method);
@@ -517,33 +447,33 @@ export const writeRepositoryInterface = async ({ contextName, domainName, meta,
 			return `\t${method.name}(${params}): Promise<${responseType}>;`;
 		})
 		.join('\n');
-
 	const content = `${imports.join('\n')}${imports.length ? '\n\n' : ''}export interface ${meta.repositoryInterfaceName} {\n${signatures ? `${signatures}\n` : ''}}\n`;
-	await fs.writeFile(path.join(portsPath, `${meta.repositoryInterfaceName}.ts`), content, 'utf-8');
+	await fs.writeFile(path.join(portsPath, `${toTypeFileName(meta.repositoryInterfaceName)}.ts`), content, 'utf-8');
 	await updateIndexTs(portsPath);
 };
-
 const parseRepositoryFileForDomain = (content, contextAlias) => {
 	const escapedAlias = contextAlias.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 	const regex = new RegExp(`from\\s+['"]${escapedAlias}/layers/domain/([^'"]+)['"]`);
 	const match = content.match(regex);
 	return match?.[1] ?? null;
 };
-
 const parseRepositoryMethodsFromInterface = (content) => {
 	const methods = [];
 	const regex = /(\w+)\(([^)]*)\)\s*:\s*Promise<([^>]+)>;/g;
 	let match;
 	while ((match = regex.exec(content)) !== null) {
-		methods.push(match[1]);
+		const methodName = match[1];
+		if (methodName) methods.push(methodName);
 	}
 	return methods;
 };
-
 export const createUseCasesForRepository = async ({ contextName, contextAlias, domainName, repositoryName }) => {
 	const meta = getRepositoryMeta(repositoryName);
-	const interfacePath = path.join(resolveDomainRootPath(contextName, domainName), 'ports', `${meta.repositoryInterfaceName}.ts`);
-
+	const interfacePath = path.join(
+		resolveDomainRootPath(contextName, domainName),
+		'ports',
+		`${toTypeFileName(meta.repositoryInterfaceName)}.ts`
+	);
 	let interfaceContent = '';
 	try {
 		interfaceContent = await fs.readFile(interfacePath, 'utf-8');
@@ -551,13 +481,10 @@ export const createUseCasesForRepository = async ({ contextName, contextAlias, d
 		console.error(`❌ Repository interface not found: ${interfacePath}`);
 		return false;
 	}
-
 	const methods = parseRepositoryMethodsFromInterface(interfaceContent);
 	const useCasesPath = resolveUseCasesPath(contextName);
 	await fs.mkdir(useCasesPath, { recursive: true });
-
 	const declares = methods.map((methodName) => `\tdeclare ${methodName}: ${meta.repositoryInterfaceName}['${methodName}'];`).join('\n');
-
 	const content = `import { ClassMirror } from '@azure-net/kit';
 import type { ${meta.repositoryInterfaceName} } from '${contextAlias}/layers/domain/${domainName}';
 
@@ -569,12 +496,10 @@ export class ${meta.useCasesClassName} extends ClassMirror {
 ${declares ? `${declares}\n` : ''}
 }
 `;
-
 	await fs.writeFile(path.join(useCasesPath, `${meta.useCasesClassName}.ts`), content, 'utf-8');
 	await updateIndexTs(useCasesPath);
 	return true;
 };
-
 export const resolveDomainForRepository = async ({ contextName, contextAlias, repositoryName }) => {
 	const repositoryPath = path.join(resolveRepositoriesPath(contextName), `${ensureRepositoryName(repositoryName)}.ts`);
 	try {
@@ -584,12 +509,10 @@ export const resolveDomainForRepository = async ({ contextName, contextAlias, re
 		return null;
 	}
 };
-
 export const promptMethodsBatch = async (domainTypes, count) => {
 	const methods = [];
 	for (let index = 0; index < count; index += 1) {
 		console.log(`\n🧩 Method ${index + 1} of ${count}`);
-		// eslint-disable-next-line no-await-in-loop
 		const method = await promptMethodDefinition(domainTypes);
 		if (!method) return null;
 		methods.push(method);

package/src/generate/module/repositoryModuleShared.ts

@@ -5,6 +5,7 @@ import { loadUserConfig } from '../../utils/loadConfig.js';
 import { normalizeContexts } from '../../init/initAliases.js';
 import { toCamelCase, toPascalCase } from '../../utils/contextUtils.js';
 import { updateIndexTs } from '../../utils/fileUtils.js';
+import { getFoundationConstructImportPath, getFoundationConstructPath, getSharedState } from '../../utils/sharedFoundation.js';
 
 type ContextConfig = { name: string; alias: string };
 type TypeLayer = 'ports' | 'model';
@@ -113,11 +114,11 @@ export const getRepositoryMeta = (repositoryName: unknown): RepositoryMeta => {
 	};
 };
 
-export const getConfigState = async (): Promise<{ contexts: ContextConfig[]; coreAlias: string }> => {
+export const getConfigState = async (): Promise<{ contexts: ContextConfig[]; sharedAlias: string; sharedContextName: string }> => {
 	const config = await loadUserConfig();
 	const contexts = normalizeContexts(config.contexts);
-	const coreAlias = normalizeAlias(config.coreAlias, '$core');
-	return { contexts, coreAlias };
+	const { sharedAlias, sharedContext } = await getSharedState();
+	return { contexts, sharedAlias, sharedContextName: sharedContext.name };
 };
 
 export const selectContext = async (message = 'Select context:'): Promise<string | null> => {
@@ -150,7 +151,10 @@ export const resolveRepositoriesPath = (contextName: string): string =>
 export const resolveDatasourcesPath = (contextName: string): string =>
 	path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'infrastructure', 'http', 'datasources');
 
-export const resolveCoreDatasourcesPath = (): string => path.join(process.cwd(), 'src', 'core', 'datasource');
+export const resolveSharedDatasourcesPath = async (): Promise<string> => {
+	const { sharedContext } = await getSharedState();
+	return getFoundationConstructPath(sharedContext.name, 'datasource');
+};
 
 export const resolveDomainRootPath = (contextName: string, domainName: string): string =>
 	path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'domain', domainName);
@@ -168,16 +172,16 @@ export const getAvailableTsNames = async (targetPath: string): Promise<string[]>
 };
 
 export const selectDatasource = async (contextName: string): Promise<DatasourceInfo | null> => {
-	const { contexts, coreAlias } = await getConfigState();
+	const { contexts, sharedAlias } = await getConfigState();
 	const contextAlias = resolveContextAlias(contexts, contextName);
-	const coreDatasources = await getAvailableTsNames(resolveCoreDatasourcesPath());
+	const sharedDatasources = await getAvailableTsNames(await resolveSharedDatasourcesPath());
 	const contextDatasources = await getAvailableTsNames(resolveDatasourcesPath(contextName));
 
 	const choices: Array<{ title: string; value: DatasourceInfo }> = [];
-	for (const datasource of coreDatasources) {
+	for (const datasource of sharedDatasources) {
 		choices.push({
-			title: `${datasource} (core)`,
-			value: { name: datasource, importPath: `${coreAlias}/datasource` }
+			title: `${datasource} (shared foundation)`,
+			value: { name: datasource, importPath: getFoundationConstructImportPath(sharedAlias, 'datasource') }
 		});
 	}
 
@@ -189,7 +193,7 @@ export const selectDatasource = async (contextName: string): Promise<DatasourceI
 	}
 
 	if (!choices.length) {
-		console.error(`❌ No datasources found in core or context "${contextName}".`);
+		console.error(`❌ No datasources found in shared foundation or context "${contextName}".`);
 		return null;
 	}
 

package/src/generate/ui/generateComponent.js

@@ -5,7 +5,6 @@ import { toPascalCase } from '../../utils/contextUtils.js';
 import { normalizeContexts } from '../../init/initAliases.js';
 import { loadUserConfig } from '../../utils/loadConfig.js';
 import { writeIfNotExists } from '../../utils/fileUtils.js';
-
 const createComponentContent = (propsName) => `<script lang="ts">
 import type { ${propsName} } from './types';
 const {}: ${propsName} = $props();
@@ -15,22 +14,17 @@ const {}: ${propsName} = $props();
 \t@use './style';
 </style>
 `;
-
 const createTypesContent = (propsName) => `export interface ${propsName} {}
 `;
-
 const createIndexContent = (name) => `export { default as ${name} } from './Component.svelte';
 `;
-
 const printContextsError = () => {
 	console.error('❌ Cannot generate UI artifact: `contexts` is missing or empty in azure-net.config.ts/js');
 };
-
 const selectContext = async () => {
 	const config = await loadUserConfig();
 	const contexts = normalizeContexts(config.contexts);
 	if (!contexts.length) return null;
-
 	const { context } = await prompts({
 		type: 'select',
 		name: 'context',
@@ -38,10 +32,8 @@ const selectContext = async () => {
 		choices: contexts.map((item) => ({ title: item.name, value: item.name })),
 		initial: 0
 	});
-
 	return context ? String(context) : null;
 };
-
 export default async function generateComponent() {
 	const context = await selectContext();
 	if (!context) {
@@ -49,14 +41,12 @@ export default async function generateComponent() {
 		process.exitCode = 1;
 		return;
 	}
-
 	const { rawName } = await prompts({
 		type: 'text',
 		name: 'rawName',
 		message: 'Component name:',
 		validate: (value) => (String(value).trim().length > 0 ? true : 'Name is required')
 	});
-
 	const { componentKind } = await prompts({
 		type: 'select',
 		name: 'componentKind',
@@ -68,12 +58,10 @@ export default async function generateComponent() {
 		],
 		initial: 0
 	});
-
 	const name = toPascalCase(String(rawName ?? 'Component')) || 'Component';
 	const propsName = `IComponent${name}Props`;
 	const kind = componentKind ?? 'shared';
 	let targetDir = path.join(process.cwd(), 'src', 'app', context, 'ui', 'components', kind);
-
 	if (kind === 'page') {
 		const { pageFolderRaw } = await prompts({
 			type: 'text',
@@ -81,18 +69,14 @@ export default async function generateComponent() {
 			message: 'Page folder name:',
 			validate: (value) => (String(value).trim().length > 0 ? true : 'Page folder name is required')
 		});
-
 		const pageFolder = String(pageFolderRaw ?? '').trim();
 		targetDir = path.join(targetDir, pageFolder);
 	}
-
 	targetDir = path.join(targetDir, name);
-
 	await fs.mkdir(targetDir, { recursive: true });
 	await writeIfNotExists(path.join(targetDir, 'Component.svelte'), createComponentContent(propsName));
 	await writeIfNotExists(path.join(targetDir, 'style.scss'), '');
 	await writeIfNotExists(path.join(targetDir, 'types.ts'), createTypesContent(propsName));
 	await writeIfNotExists(path.join(targetDir, 'index.ts'), createIndexContent(name));
-
 	console.log(`✅ Component generated: ${targetDir}`);
 }