@azure-net/cli 5.0.0-1 → 5.0.0

package/src/scaffolds/createCoreSchema.ts

@@ -4,6 +4,7 @@ import path from 'node:path';
 import prompts from 'prompts';
 import { writeIfNotExists, updateIndexTs } from '../utils/fileUtils.js';
 import { toPascalCase } from '../utils/contextUtils.js';
+import { getFoundationConstructPath, getSharedState } from '../utils/sharedFoundation.js';
 
 type MessagePreset = 'ru' | 'en' | 'i18n';
 type ConfigPath = 'ts' | 'js';
@@ -48,10 +49,9 @@ const buildDefaultSchemaFactoryConfigEntry = (factoryName: string): string => {
 const upsertDefaultSchemaFactoryConfig = (content: string, factoryName: string): string => {
 	const hasExportDefaultObject = /export\s+default\s*\{[\s\S]*\}\s*;?/.test(content);
 	const defaultFactoryEntry = buildDefaultSchemaFactoryConfigEntry(factoryName);
-	const coreAliasEntry = `coreAlias: '$core'`;
 
 	if (!hasExportDefaultObject) {
-		return `export default {\n\t${coreAliasEntry},\n\t${defaultFactoryEntry}\n};\n`;
+		return `export default {\n\t${defaultFactoryEntry}\n};\n`;
 	}
 
 	let nextContent = content;
@@ -71,20 +71,7 @@ const upsertDefaultSchemaFactoryConfig = (content: string, factoryName: string):
 			return `export default {${withComma}\n\t${defaultFactoryEntry}\n};`;
 		});
 	}
-
-	if (/coreAlias\s*:/.test(nextContent)) {
-		return nextContent.replace(/coreAlias\s*:\s*['"`][^'"`]+['"`]/, coreAliasEntry);
-	}
-
-	return nextContent.replace(/export\s+default\s*\{([\s\S]*)\}\s*;?/, (_full, body: string) => {
-		const trimmedRight = body.replace(/\s*$/, '');
-		if (!trimmedRight.length) {
-			return `export default {\n\t${coreAliasEntry}\n};`;
-		}
-
-		const withComma = trimmedRight.endsWith(',') ? trimmedRight : `${trimmedRight},`;
-		return `export default {${withComma}\n\t${coreAliasEntry}\n};`;
-	});
+	return nextContent;
 };
 
 export default async function createCoreSchema(): Promise<void> {
@@ -111,7 +98,8 @@ export default async function createCoreSchema(): Promise<void> {
 
 	const selectedPreset = (preset ?? 'i18n') as MessagePreset;
 	const messagesImportName = resolvePresetImportName(selectedPreset);
-	const coreSchemaPath = path.join(process.cwd(), 'src', 'core', 'schema');
+	const { sharedContext } = await getSharedState();
+	const coreSchemaPath = getFoundationConstructPath(sharedContext.name, 'schema');
 	const customRulesPath = path.join(coreSchemaPath, 'custom-rules');
 	const filePath = path.join(coreSchemaPath, `${schemaFactoryName}.ts`);
 
@@ -123,7 +111,7 @@ export default async function createCoreSchema(): Promise<void> {
 		console.log(`⚠️ Schema factory "${schemaFactoryName}" already exists. File was not overwritten.`);
 	} else {
 		await updateIndexTs(coreSchemaPath);
-		console.log(`✅ Core schema factory created: ${filePath}`);
+		console.log(`✅ Shared schema factory created: ${filePath}`);
 	}
 
 	const { useAsDefault } = await prompts({

package/src/scaffolds/createDatasource.js

@@ -3,9 +3,9 @@ import path from 'node:path';
 import prompts from 'prompts';
 import { writeIfNotExists, updateIndexTs } from '../utils/fileUtils.js';
 import { toPascalCase } from '../utils/contextUtils.js';
-import { loadUserConfig, resolveConfigFile } from '../utils/loadConfig.js';
+import { loadUserConfig } from '../utils/loadConfig.js';
 import { normalizeContexts } from '../init/initAliases.js';
-
+import { getFoundationConstructImportPath, getFoundationConstructPath, getSharedState } from '../utils/sharedFoundation.js';
 const createDatasourceTemplateWithoutResponse = (
 	className
 ) => `import { BaseHttpDatasource, type CreateRequestCallbackType } from '@azure-net/kit/infra';
@@ -16,13 +16,12 @@ export class ${className} extends BaseHttpDatasource {
 \t}
 }
 `;
-
 const createDatasourceTemplateWithResponseAndInterface = (
 	className,
 	responseName,
-	coreAlias
+	responseImportPath
 ) => `import { BaseHttpDatasource, type CreateRequestCallbackType } from '@azure-net/kit/infra';
-import { ${responseName}, type I${responseName} } from '${coreAlias}/response';
+import { ${responseName}, type I${responseName} } from '${responseImportPath}';
 
 export class ${className} extends BaseHttpDatasource {
 \tasync createRequest<T>(callback: CreateRequestCallbackType<I${responseName}<T>>) {
@@ -30,13 +29,12 @@ export class ${className} extends BaseHttpDatasource {
 \t}
 }
 `;
-
 const createDatasourceTemplateWithResponse = (
 	className,
 	responseName,
-	coreAlias
+	responseImportPath
 ) => `import { BaseHttpDatasource, type CreateRequestCallbackType } from '@azure-net/kit/infra';
-import { ${responseName} } from '${coreAlias}/response';
+import { ${responseName} } from '${responseImportPath}';
 
 export class ${className} extends BaseHttpDatasource {
 \tasync createRequest<T>(callback: CreateRequestCallbackType<T>) {
@@ -44,26 +42,22 @@ export class ${className} extends BaseHttpDatasource {
 \t}
 }
 `;
-
 const ensureDatasourceClassName = (rawName) => {
 	const normalized = toPascalCase(rawName || 'MockApi');
 	return normalized.endsWith('Datasource') ? normalized : `${normalized}Datasource`;
 };
-
 const getContextChoices = async () => {
 	const config = await loadUserConfig();
 	const contexts = normalizeContexts(config.contexts);
-
-	const choices = [{ title: 'core', value: 'core' }];
+	const choices = [{ title: 'shared foundation', value: '__shared__' }];
 	for (const context of contexts) {
 		choices.push({ title: context.name, value: context.name });
 	}
-
 	return choices;
 };
-
-const getCoreResponses = async () => {
-	const responsesPath = path.join(process.cwd(), 'src', 'core', 'response');
+const getSharedResponses = async () => {
+	const { sharedContext } = await getSharedState();
+	const responsesPath = getFoundationConstructPath(sharedContext.name, 'response');
 	try {
 		const files = await fs.readdir(responsesPath);
 		return files.filter((file) => file.endsWith('.ts') && file !== 'index.ts').map((file) => file.replace(/\.ts$/, ''));
@@ -71,9 +65,9 @@ const getCoreResponses = async () => {
 		return [];
 	}
 };
-
 const hasResponseInterface = async (responseName) => {
-	const responsePath = path.join(process.cwd(), 'src', 'core', 'response', `${responseName}.ts`);
+	const { sharedContext } = await getSharedState();
+	const responsePath = path.join(getFoundationConstructPath(sharedContext.name, 'response'), `${responseName}.ts`);
 	try {
 		const content = await fs.readFile(responsePath, 'utf-8');
 		const interfaceRegex = new RegExp(`export\\s+interface\\s+I${responseName}\\b`);
@@ -82,36 +76,12 @@ const hasResponseInterface = async (responseName) => {
 		return false;
 	}
 };
-
-const getConfiguredCoreAliasOrThrow = async () => {
-	const configRef = resolveConfigFile();
-	if (!configRef.exists) {
-		throw new Error(
-			'azure-net.config is not configured. Run "azure-net init folders-structure" and do not forget to fill contexts if you need them.'
-		);
-	}
-
-	const content = await fs.readFile(configRef.filepath, 'utf-8');
-	const aliasMatch = content.match(/coreAlias\s*:\s*['"`]([^'"`]+)['"`]/);
-	const alias = aliasMatch?.[1]?.trim();
-
-	if (!alias) {
-		throw new Error(
-			'azure-net.config is not configured. Run "azure-net init folders-structure" and do not forget to fill contexts if you need them.'
-		);
-	}
-
-	return alias.startsWith('$') ? alias : `$${alias}`;
-};
-
 const resolveTargetPath = (target) => {
-	if (target === 'core') {
-		return path.join(process.cwd(), 'src', 'core', 'datasource');
+	if (target === '__shared__') {
+		throw new Error('Shared target path must be resolved async.');
 	}
-
 	return path.join(process.cwd(), 'src', 'app', target, 'layers', 'infrastructure', 'http', 'datasources');
 };
-
 export default async function createDatasource() {
 	const { datasourceNameRaw } = await prompts({
 		type: 'text',
@@ -119,9 +89,7 @@ export default async function createDatasource() {
 		message: 'Datasource name:',
 		initial: 'MockApi'
 	});
-
 	const className = ensureDatasourceClassName(String(datasourceNameRaw ?? 'MockApi'));
-
 	const contextChoices = await getContextChoices();
 	const { target } = await prompts({
 		type: 'select',
@@ -130,44 +98,41 @@ export default async function createDatasource() {
 		choices: contextChoices,
 		initial: 0
 	});
-
-	const selectedTarget = String(target ?? 'core');
-	const coreResponses = await getCoreResponses();
-
+	const selectedTarget = String(target ?? '__shared__');
+	const sharedResponses = await getSharedResponses();
 	let selectedResponse = null;
-	if (coreResponses.length > 0) {
+	if (sharedResponses.length > 0) {
 		const { responseName } = await prompts({
 			type: 'select',
 			name: 'responseName',
 			message: 'Select response for datasource:',
-			choices: [{ title: 'No response', value: null }, ...coreResponses.map((response) => ({ title: response, value: response }))],
+			choices: [{ title: 'No response', value: null }, ...sharedResponses.map((response) => ({ title: response, value: response }))],
 			initial: 0
 		});
 		selectedResponse = responseName ? String(responseName) : null;
 	}
-
 	let content;
 	if (!selectedResponse) {
 		content = createDatasourceTemplateWithoutResponse(className);
 	} else {
-		const coreAlias = await getConfiguredCoreAliasOrThrow();
+		const { sharedAlias } = await getSharedState();
+		const responseImportPath = getFoundationConstructImportPath(sharedAlias, 'response');
 		const withInterface = await hasResponseInterface(selectedResponse);
 		content = withInterface
-			? createDatasourceTemplateWithResponseAndInterface(className, selectedResponse, coreAlias)
-			: createDatasourceTemplateWithResponse(className, selectedResponse, coreAlias);
+			? createDatasourceTemplateWithResponseAndInterface(className, selectedResponse, responseImportPath)
+			: createDatasourceTemplateWithResponse(className, selectedResponse, responseImportPath);
 	}
-
-	const targetPath = resolveTargetPath(selectedTarget);
+	const targetPath =
+		selectedTarget === '__shared__'
+			? getFoundationConstructPath((await getSharedState()).sharedContext.name, 'datasource')
+			: resolveTargetPath(selectedTarget);
 	await fs.mkdir(targetPath, { recursive: true });
-
 	const filePath = path.join(targetPath, `${className}.ts`);
 	const created = await writeIfNotExists(filePath, content);
 	await updateIndexTs(targetPath);
-
 	if (!created) {
 		console.log(`⚠️ Datasource "${className}" already exists. File was not overwritten.`);
 		return;
 	}
-
 	console.log(`✅ Datasource created: ${filePath}`);
 }

package/src/scaffolds/createDatasource.ts

@@ -3,8 +3,9 @@ import path from 'node:path';
 import prompts from 'prompts';
 import { writeIfNotExists, updateIndexTs } from '../utils/fileUtils.js';
 import { toPascalCase } from '../utils/contextUtils.js';
-import { loadUserConfig, resolveConfigFile } from '../utils/loadConfig.js';
+import { loadUserConfig } from '../utils/loadConfig.js';
 import { normalizeContexts } from '../init/initAliases.js';
+import { getFoundationConstructImportPath, getFoundationConstructPath, getSharedState } from '../utils/sharedFoundation.js';
 
 type ContextChoice = { title: string; value: string };
 
@@ -22,9 +23,9 @@ export class ${className} extends BaseHttpDatasource {
 const createDatasourceTemplateWithResponseAndInterface = (
 	className: string,
 	responseName: string,
-	coreAlias: string
+	responseImportPath: string
 ): string => `import { BaseHttpDatasource, type CreateRequestCallbackType } from '@azure-net/kit/infra';
-import { ${responseName}, type I${responseName} } from '${coreAlias}/response';
+import { ${responseName}, type I${responseName} } from '${responseImportPath}';
 
 export class ${className} extends BaseHttpDatasource {
 \tasync createRequest<T>(callback: CreateRequestCallbackType<I${responseName}<T>>) {
@@ -36,9 +37,9 @@ export class ${className} extends BaseHttpDatasource {
 const createDatasourceTemplateWithResponse = (
 	className: string,
 	responseName: string,
-	coreAlias: string
+	responseImportPath: string
 ): string => `import { BaseHttpDatasource, type CreateRequestCallbackType } from '@azure-net/kit/infra';
-import { ${responseName} } from '${coreAlias}/response';
+import { ${responseName} } from '${responseImportPath}';
 
 export class ${className} extends BaseHttpDatasource {
 \tasync createRequest<T>(callback: CreateRequestCallbackType<T>) {
@@ -56,7 +57,7 @@ const getContextChoices = async (): Promise<ContextChoice[]> => {
 	const config = await loadUserConfig();
 	const contexts = normalizeContexts(config.contexts);
 
-	const choices: ContextChoice[] = [{ title: 'core', value: 'core' }];
+	const choices: ContextChoice[] = [{ title: 'shared foundation', value: '__shared__' }];
 	for (const context of contexts) {
 		choices.push({ title: context.name, value: context.name });
 	}
@@ -64,8 +65,9 @@ const getContextChoices = async (): Promise<ContextChoice[]> => {
 	return choices;
 };
 
-const getCoreResponses = async (): Promise<string[]> => {
-	const responsesPath = path.join(process.cwd(), 'src', 'core', 'response');
+const getSharedResponses = async (): Promise<string[]> => {
+	const { sharedContext } = await getSharedState();
+	const responsesPath = getFoundationConstructPath(sharedContext.name, 'response');
 	try {
 		const files = await fs.readdir(responsesPath);
 		return files.filter((file) => file.endsWith('.ts') && file !== 'index.ts').map((file) => file.replace(/\.ts$/, ''));
@@ -75,7 +77,8 @@ const getCoreResponses = async (): Promise<string[]> => {
 };
 
 const hasResponseInterface = async (responseName: string): Promise<boolean> => {
-	const responsePath = path.join(process.cwd(), 'src', 'core', 'response', `${responseName}.ts`);
+	const { sharedContext } = await getSharedState();
+	const responsePath = path.join(getFoundationConstructPath(sharedContext.name, 'response'), `${responseName}.ts`);
 	try {
 		const content = await fs.readFile(responsePath, 'utf-8');
 		const interfaceRegex = new RegExp(`export\\s+interface\\s+I${responseName}\\b`);
@@ -85,30 +88,9 @@ const hasResponseInterface = async (responseName: string): Promise<boolean> => {
 	}
 };
 
-const getConfiguredCoreAliasOrThrow = async (): Promise<string> => {
-	const configRef = resolveConfigFile();
-	if (!configRef.exists) {
-		throw new Error(
-			'azure-net.config is not configured. Run "azure-net init folders-structure" and do not forget to fill contexts if you need them.'
-		);
-	}
-
-	const content = await fs.readFile(configRef.filepath, 'utf-8');
-	const aliasMatch = content.match(/coreAlias\s*:\s*['"`]([^'"`]+)['"`]/);
-	const alias = aliasMatch?.[1]?.trim();
-
-	if (!alias) {
-		throw new Error(
-			'azure-net.config is not configured. Run "azure-net init folders-structure" and do not forget to fill contexts if you need them.'
-		);
-	}
-
-	return alias.startsWith('$') ? alias : `$${alias}`;
-};
-
 const resolveTargetPath = (target: string): string => {
-	if (target === 'core') {
-		return path.join(process.cwd(), 'src', 'core', 'datasource');
+	if (target === '__shared__') {
+		throw new Error('Shared target path must be resolved async.');
 	}
 
 	return path.join(process.cwd(), 'src', 'app', target, 'layers', 'infrastructure', 'http', 'datasources');
@@ -133,16 +115,16 @@ export default async function createDatasource(): Promise<void> {
 		initial: 0
 	});
 
-	const selectedTarget = String(target ?? 'core');
-	const coreResponses = await getCoreResponses();
+	const selectedTarget = String(target ?? '__shared__');
+	const sharedResponses = await getSharedResponses();
 
 	let selectedResponse: string | null = null;
-	if (coreResponses.length > 0) {
+	if (sharedResponses.length > 0) {
 		const { responseName } = await prompts({
 			type: 'select',
 			name: 'responseName',
 			message: 'Select response for datasource:',
-			choices: [{ title: 'No response', value: null }, ...coreResponses.map((response) => ({ title: response, value: response }))],
+			choices: [{ title: 'No response', value: null }, ...sharedResponses.map((response) => ({ title: response, value: response }))],
 			initial: 0
 		});
 		selectedResponse = responseName ? String(responseName) : null;
@@ -152,14 +134,18 @@ export default async function createDatasource(): Promise<void> {
 	if (!selectedResponse) {
 		content = createDatasourceTemplateWithoutResponse(className);
 	} else {
-		const coreAlias = await getConfiguredCoreAliasOrThrow();
+		const { sharedAlias } = await getSharedState();
+		const responseImportPath = getFoundationConstructImportPath(sharedAlias, 'response');
 		const withInterface = await hasResponseInterface(selectedResponse);
 		content = withInterface
-			? createDatasourceTemplateWithResponseAndInterface(className, selectedResponse, coreAlias)
-			: createDatasourceTemplateWithResponse(className, selectedResponse, coreAlias);
+			? createDatasourceTemplateWithResponseAndInterface(className, selectedResponse, responseImportPath)
+			: createDatasourceTemplateWithResponse(className, selectedResponse, responseImportPath);
 	}
 
-	const targetPath = resolveTargetPath(selectedTarget);
+	const targetPath =
+		selectedTarget === '__shared__'
+			? getFoundationConstructPath((await getSharedState()).sharedContext.name, 'datasource')
+			: resolveTargetPath(selectedTarget);
 	await fs.mkdir(targetPath, { recursive: true });
 
 	const filePath = path.join(targetPath, `${className}.ts`);

package/src/scaffolds/createDatasourceProvider.js

@@ -3,20 +3,18 @@ import path from 'node:path';
 import prompts from 'prompts';
 import { writeIfNotExists, updateIndexTs } from '../utils/fileUtils.js';
 import { toPascalCase } from '../utils/contextUtils.js';
-import { loadUserConfig, resolveConfigFile } from '../utils/loadConfig.js';
+import { loadUserConfig } from '../utils/loadConfig.js';
 import { normalizeContexts } from '../init/initAliases.js';
-
+import { getFoundationConstructImportPath, getFoundationConstructPath, getSharedState } from '../utils/sharedFoundation.js';
 const createProviderTemplateWithoutDatasource = (providerName, contextPrefix) => `import { createBoundaryProvider } from '@azure-net/kit';
 
 export const ${providerName} = createBoundaryProvider('${contextPrefix}${providerName}', {
 \tregister: () => ({})
 });
 `;
-
 const createProviderTemplateWithDatasource = (providerName, contextPrefix, datasourceName, datasourceImportPath) => {
 	const factoryNameBase = datasourceName.endsWith('Datasource') ? datasourceName.slice(0, -'Datasource'.length) : datasourceName;
 	const datasourceFactoryName = `${factoryNameBase || datasourceName}Rest`;
-
 	return `import { ${datasourceName} } from '${datasourceImportPath}';
 import { createHttpServiceInstance } from '@azure-net/kit/infra';
 import { createBoundaryProvider } from '@azure-net/kit';
@@ -33,27 +31,6 @@ export const ${providerName} = createBoundaryProvider('${contextPrefix}${provide
 });
 `;
 };
-
-const getCoreAliasOrThrow = async () => {
-	const configRef = resolveConfigFile();
-	if (!configRef.exists) {
-		throw new Error(
-			'azure-net.config is not configured. Run "azure-net init folders-structure" and do not forget to fill contexts if you need them.'
-		);
-	}
-
-	const content = await fs.readFile(configRef.filepath, 'utf-8');
-	const aliasMatch = content.match(/coreAlias\s*:\s*['"`]([^'"`]+)['"`]/);
-	const alias = aliasMatch?.[1]?.trim();
-	if (!alias) {
-		throw new Error(
-			'azure-net.config is not configured. Run "azure-net init folders-structure" and do not forget to fill contexts if you need them.'
-		);
-	}
-
-	return alias.startsWith('$') ? alias : `$${alias}`;
-};
-
 const getDatasourcesFromPath = async (targetPath) => {
 	try {
 		const files = await fs.readdir(targetPath);
@@ -62,31 +39,24 @@ const getDatasourcesFromPath = async (targetPath) => {
 		return [];
 	}
 };
-
-const resolveContextPrefix = (target) => (target === 'core' ? 'Core' : toPascalCase(target));
-
+const resolveContextPrefix = (target) => (target === '__shared__' ? 'Shared' : toPascalCase(target));
 const resolveProviderPath = (target) => {
-	if (target === 'core') {
-		return path.join(process.cwd(), 'src', 'core', 'provider');
+	if (target === '__shared__') {
+		throw new Error('Shared provider path must be resolved async.');
 	}
-
 	return path.join(process.cwd(), 'src', 'app', target, 'layers', 'infrastructure', 'providers');
 };
-
 const resolveContextAlias = (contexts, targetContext) => {
 	const found = contexts.find((context) => context.name === targetContext);
 	if (!found) {
 		return `$${targetContext}`;
 	}
-
 	return found.alias.startsWith('$') ? found.alias : `$${found.alias}`;
 };
-
 const ensureProviderName = (rawName) => {
 	const normalized = toPascalCase(rawName || 'DatasourceProvider') || 'DatasourceProvider';
 	return normalized.endsWith('Provider') ? normalized : `${normalized}Provider`;
 };
-
 export default async function createDatasourceProvider() {
 	const { providerNameRaw } = await prompts({
 		type: 'text',
@@ -94,12 +64,13 @@ export default async function createDatasourceProvider() {
 		message: 'Datasource provider name:',
 		initial: 'DatasourceProvider'
 	});
-
 	const providerName = ensureProviderName(String(providerNameRaw ?? 'DatasourceProvider'));
 	const config = await loadUserConfig();
 	const contexts = normalizeContexts(config.contexts);
-	const contextChoices = [{ title: 'core', value: 'core' }, ...contexts.map((context) => ({ title: context.name, value: context.name }))];
-
+	const contextChoices = [
+		{ title: 'shared foundation', value: '__shared__' },
+		...contexts.map((context) => ({ title: context.name, value: context.name }))
+	];
 	const { target } = await prompts({
 		type: 'select',
 		name: 'target',
@@ -107,24 +78,22 @@ export default async function createDatasourceProvider() {
 		choices: contextChoices,
 		initial: 0
 	});
-
-	const selectedTarget = String(target ?? 'core');
-	const coreDatasources = await getDatasourcesFromPath(path.join(process.cwd(), 'src', 'core', 'datasource'));
+	const selectedTarget = String(target ?? '__shared__');
+	const { sharedAlias, sharedContext } = await getSharedState();
+	const sharedDatasources = await getDatasourcesFromPath(getFoundationConstructPath(sharedContext.name, 'datasource'));
 	const contextDatasources =
-		selectedTarget === 'core'
+		selectedTarget === '__shared__'
 			? []
 			: await getDatasourcesFromPath(
 					path.join(process.cwd(), 'src', 'app', selectedTarget, 'layers', 'infrastructure', 'http', 'datasources')
 				);
-
 	const datasourceChoices = [{ title: 'No datasource', value: null }];
-	for (const datasource of coreDatasources) {
-		datasourceChoices.push({ title: `${datasource} (core)`, value: { name: datasource, source: 'core' } });
+	for (const datasource of sharedDatasources) {
+		datasourceChoices.push({ title: `${datasource} (shared foundation)`, value: { name: datasource, source: 'shared' } });
 	}
 	for (const datasource of contextDatasources) {
 		datasourceChoices.push({ title: `${datasource} (${selectedTarget})`, value: { name: datasource, source: 'context' } });
 	}
-
 	const { datasourceSelection } = await prompts({
 		type: 'select',
 		name: 'datasourceSelection',
@@ -132,33 +101,27 @@ export default async function createDatasourceProvider() {
 		choices: datasourceChoices,
 		initial: 0
 	});
-
 	const selectedDatasource = datasourceSelection ?? null;
 	const contextPrefix = resolveContextPrefix(selectedTarget);
 	let content;
-
 	if (!selectedDatasource) {
 		content = createProviderTemplateWithoutDatasource(providerName, contextPrefix);
 	} else {
 		const importPath =
-			selectedDatasource.source === 'core'
-				? `${await getCoreAliasOrThrow()}/datasource`
+			selectedDatasource.source === 'shared'
+				? getFoundationConstructImportPath(sharedAlias, 'datasource')
 				: `${resolveContextAlias(contexts, selectedTarget)}/layers/infrastructure/http/datasources`;
-
 		content = createProviderTemplateWithDatasource(providerName, contextPrefix, selectedDatasource.name, importPath);
 	}
-
-	const providerPath = resolveProviderPath(selectedTarget);
+	const providerPath =
+		selectedTarget === '__shared__' ? getFoundationConstructPath(sharedContext.name, 'provider') : resolveProviderPath(selectedTarget);
 	await fs.mkdir(providerPath, { recursive: true });
-
 	const filePath = path.join(providerPath, `${providerName}.ts`);
 	const created = await writeIfNotExists(filePath, content);
 	await updateIndexTs(providerPath);
-
 	if (!created) {
 		console.log(`⚠️ Datasource provider "${providerName}" already exists. File was not overwritten.`);
 		return;
 	}
-
 	console.log(`✅ Datasource provider created: ${filePath}`);
 }