@azure-net/cli 5.0.0-3 → 5.0.1

package/src/scaffolds/createDatasourceProvider.ts

@@ -3,11 +3,12 @@ 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 NormalizedContext = { name: string; alias: string };
-type DatasourceChoiceValue = null | { name: string; source: 'core' | 'context' };
+type DatasourceChoiceValue = null | { name: string; source: 'shared' | 'context' };
 
 const createProviderTemplateWithoutDatasource = (
 	providerName: string,
@@ -45,26 +46,6 @@ export const ${providerName} = createBoundaryProvider('${contextPrefix}${provide
 `;
 };
 
-const getCoreAliasOrThrow = 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 getDatasourcesFromPath = async (targetPath: string): Promise<string[]> => {
 	try {
 		const files = await fs.readdir(targetPath);
@@ -74,11 +55,11 @@ const getDatasourcesFromPath = async (targetPath: string): Promise<string[]> =>
 	}
 };
 
-const resolveContextPrefix = (target: string): string => (target === 'core' ? 'Core' : toPascalCase(target));
+const resolveContextPrefix = (target: string): string => (target === '__shared__' ? 'Shared' : toPascalCase(target));
 
 const resolveProviderPath = (target: string): string => {
-	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');
@@ -109,7 +90,10 @@ export default async function createDatasourceProvider(): Promise<void> {
 	const providerName = ensureProviderName(String(providerNameRaw ?? 'DatasourceProvider'));
 	const config = await loadUserConfig();
 	const contexts = normalizeContexts(config.contexts) as NormalizedContext[];
-	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',
@@ -119,18 +103,19 @@ export default async function createDatasourceProvider(): Promise<void> {
 		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: Array<{ title: string; value: DatasourceChoiceValue }> = [{ 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' } });
@@ -152,14 +137,15 @@ export default async function createDatasourceProvider(): Promise<void> {
 		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`);

package/src/scaffolds/createPresenterFactory.js

@@ -4,109 +4,82 @@ 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';
+const createPresenterFactoryTemplate = (factoryName) => `import { createAsyncHelpers, createPresenterFactory } from '@azure-net/kit/delivery';
 
-const createPresenterFactoryTemplate = (
-	factoryName
-) => `import { createErrorHandler, createAsyncHelpers, createPresenterFactory } from '@azure-net/kit/delivery';
-
-export const AsyncHelpers = createAsyncHelpers({ handler: createErrorHandler() });
+export const AsyncHelpers = createAsyncHelpers();
 
 export const ${factoryName} = createPresenterFactory({ ...AsyncHelpers });
 `;
-
 const resolveConfigFile = (cwd) => {
-	const tsPath = path.join(cwd, 'azure-net.config.ts');
-	const jsPath = path.join(cwd, 'azure-net.config.js');
-
-	if (fsSync.existsSync(tsPath)) {
-		return { filepath: tsPath, type: 'ts', exists: true, content: fsSync.readFileSync(tsPath, 'utf-8') };
-	}
-	if (fsSync.existsSync(jsPath)) {
-		return { filepath: jsPath, type: 'js', exists: true, content: fsSync.readFileSync(jsPath, 'utf-8') };
-	}
-
-	return { filepath: tsPath, type: 'ts', exists: false, content: '' };
+    const tsPath = path.join(cwd, 'azure-net.config.ts');
+    const jsPath = path.join(cwd, 'azure-net.config.js');
+    if (fsSync.existsSync(tsPath)) {
+        return { filepath: tsPath, type: 'ts', exists: true, content: fsSync.readFileSync(tsPath, 'utf-8') };
+    }
+    if (fsSync.existsSync(jsPath)) {
+        return { filepath: jsPath, type: 'js', exists: true, content: fsSync.readFileSync(jsPath, 'utf-8') };
+    }
+    return { filepath: tsPath, type: 'ts', exists: false, content: '' };
 };
-
 const buildDefaultPresenterFactoryConfigEntry = (factoryName) => {
-	return `defaultPresenterFactory: '${factoryName}'`;
+    return `defaultPresenterFactory: '${factoryName}'`;
 };
-
 const upsertDefaultPresenterFactoryConfig = (content, factoryName) => {
-	const hasExportDefaultObject = /export\s+default\s*\{[\s\S]*\}\s*;?/.test(content);
-	const defaultFactoryEntry = buildDefaultPresenterFactoryConfigEntry(factoryName);
-	const coreAliasEntry = `coreAlias: '$core'`;
-
-	if (!hasExportDefaultObject) {
-		return `export default {\n\t${coreAliasEntry},\n\t${defaultFactoryEntry}\n};\n`;
-	}
-
-	let nextContent = content;
-
-	if (/defaultPresenterFactory\s*:/.test(nextContent)) {
-		nextContent = nextContent.replace(/defaultPresenterFactory\s*:\s*(\{[\s\S]*?\n\s*\}|['"`][^'"`]+['"`])/m, defaultFactoryEntry);
-	} else if (/defaultPresenter\s*:/.test(nextContent)) {
-		nextContent = nextContent.replace(/defaultPresenter\s*:\s*(\{[\s\S]*?\n\s*\}|['"`][^'"`]+['"`])/m, defaultFactoryEntry);
-	} else {
-		nextContent = nextContent.replace(/export\s+default\s*\{([\s\S]*)\}\s*;?/, (_full, body) => {
-			const trimmedRight = body.replace(/\s*$/, '');
-			if (!trimmedRight.length) {
-				return `export default {\n\t${defaultFactoryEntry}\n};`;
-			}
-
-			const withComma = trimmedRight.endsWith(',') ? trimmedRight : `${trimmedRight},`;
-			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) => {
-		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};`;
-	});
+    const hasExportDefaultObject = /export\s+default\s*\{[\s\S]*\}\s*;?/.test(content);
+    const defaultFactoryEntry = buildDefaultPresenterFactoryConfigEntry(factoryName);
+    if (!hasExportDefaultObject) {
+        return `export default {\n\t${defaultFactoryEntry}\n};\n`;
+    }
+    let nextContent = content;
+    if (/defaultPresenterFactory\s*:/.test(nextContent)) {
+        nextContent = nextContent.replace(/defaultPresenterFactory\s*:\s*(\{[\s\S]*?\n\s*\}|['"`][^'"`]+['"`])/m, defaultFactoryEntry);
+    }
+    else if (/defaultPresenter\s*:/.test(nextContent)) {
+        nextContent = nextContent.replace(/defaultPresenter\s*:\s*(\{[\s\S]*?\n\s*\}|['"`][^'"`]+['"`])/m, defaultFactoryEntry);
+    }
+    else {
+        nextContent = nextContent.replace(/export\s+default\s*\{([\s\S]*)\}\s*;?/, (_full, body) => {
+            const trimmedRight = body.replace(/\s*$/, '');
+            if (!trimmedRight.length) {
+                return `export default {\n\t${defaultFactoryEntry}\n};`;
+            }
+            const withComma = trimmedRight.endsWith(',') ? trimmedRight : `${trimmedRight},`;
+            return `export default {${withComma}\n\t${defaultFactoryEntry}\n};`;
+        });
+    }
+    return nextContent;
 };
-
 export default async function createPresenterFactory() {
-	const { presenterFactoryNameRaw } = await prompts({
-		type: 'text',
-		name: 'presenterFactoryNameRaw',
-		message: 'Presenter factory name:',
-		initial: 'AppPresenter'
-	});
-
-	const presenterFactoryName = toPascalCase(String(presenterFactoryNameRaw ?? 'AppPresenter')) || 'AppPresenter';
-	const presenterRootPath = path.join(process.cwd(), 'src', 'core', 'presenter');
-	const filePath = path.join(presenterRootPath, `${presenterFactoryName}.ts`);
-
-	await fs.mkdir(presenterRootPath, { recursive: true });
-
-	const created = await writeIfNotExists(filePath, createPresenterFactoryTemplate(presenterFactoryName));
-	if (!created) {
-		console.log(`⚠️ Presenter factory "${presenterFactoryName}" already exists. File was not overwritten.`);
-	} else {
-		await updateIndexTs(presenterRootPath);
-		console.log(`✅ Presenter factory created: ${filePath}`);
-	}
-
-	const { useAsDefault } = await prompts({
-		type: 'confirm',
-		name: 'useAsDefault',
-		message: 'Use this presenter factory as default for the project?',
-		initial: true
-	});
-
-	if (!useAsDefault) return;
-
-	const config = resolveConfigFile(process.cwd());
-	const nextContent = upsertDefaultPresenterFactoryConfig(config.content, presenterFactoryName);
-	await fs.writeFile(config.filepath, nextContent, 'utf-8');
-	console.log(`✅ Default presenter factory saved to ${path.basename(config.filepath)}`);
+    const { presenterFactoryNameRaw } = await prompts({
+        type: 'text',
+        name: 'presenterFactoryNameRaw',
+        message: 'Presenter factory name:',
+        initial: 'AppPresenter'
+    });
+    const presenterFactoryName = toPascalCase(String(presenterFactoryNameRaw ?? 'AppPresenter')) || 'AppPresenter';
+    const { sharedContext } = await getSharedState();
+    const presenterRootPath = getFoundationConstructPath(sharedContext.name, 'presenter');
+    const filePath = path.join(presenterRootPath, `${presenterFactoryName}.ts`);
+    await fs.mkdir(presenterRootPath, { recursive: true });
+    const created = await writeIfNotExists(filePath, createPresenterFactoryTemplate(presenterFactoryName));
+    if (!created) {
+        console.log(`⚠️ Presenter factory "${presenterFactoryName}" already exists. File was not overwritten.`);
+    }
+    else {
+        await updateIndexTs(presenterRootPath);
+        console.log(`✅ Presenter factory created: ${filePath}`);
+    }
+    const { useAsDefault } = await prompts({
+        type: 'confirm',
+        name: 'useAsDefault',
+        message: 'Use this presenter factory as default for the project?',
+        initial: true
+    });
+    if (!useAsDefault)
+        return;
+    const config = resolveConfigFile(process.cwd());
+    const nextContent = upsertDefaultPresenterFactoryConfig(config.content, presenterFactoryName);
+    await fs.writeFile(config.filepath, nextContent, 'utf-8');
+    console.log(`✅ Default presenter factory saved to ${path.basename(config.filepath)}`);
 }

package/src/scaffolds/createPresenterFactory.ts

@@ -4,14 +4,15 @@ 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 ConfigPath = 'ts' | 'js';
 
 const createPresenterFactoryTemplate = (
 	factoryName: string
-): string => `import { createErrorHandler, createAsyncHelpers, createPresenterFactory } from '@azure-net/kit/delivery';
+): string => `import { createAsyncHelpers, createPresenterFactory } from '@azure-net/kit/delivery';
 
-export const AsyncHelpers = createAsyncHelpers({ handler: createErrorHandler() });
+export const AsyncHelpers = createAsyncHelpers();
 
 export const ${factoryName} = createPresenterFactory({ ...AsyncHelpers });
 `;
@@ -37,10 +38,9 @@ const buildDefaultPresenterFactoryConfigEntry = (factoryName: string): string =>
 const upsertDefaultPresenterFactoryConfig = (content: string, factoryName: string): string => {
 	const hasExportDefaultObject = /export\s+default\s*\{[\s\S]*\}\s*;?/.test(content);
 	const defaultFactoryEntry = buildDefaultPresenterFactoryConfigEntry(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;
@@ -60,20 +60,7 @@ const upsertDefaultPresenterFactoryConfig = (content: string, factoryName: strin
 			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 createPresenterFactory(): Promise<void> {
@@ -85,7 +72,8 @@ export default async function createPresenterFactory(): Promise<void> {
 	});
 
 	const presenterFactoryName = toPascalCase(String(presenterFactoryNameRaw ?? 'AppPresenter')) || 'AppPresenter';
-	const presenterRootPath = path.join(process.cwd(), 'src', 'core', 'presenter');
+	const { sharedContext } = await getSharedState();
+	const presenterRootPath = getFoundationConstructPath(sharedContext.name, 'presenter');
 	const filePath = path.join(presenterRootPath, `${presenterFactoryName}.ts`);
 
 	await fs.mkdir(presenterRootPath, { recursive: true });

package/src/scaffolds/createProgram.js

@@ -1,19 +1,15 @@
 import path from 'node:path';
 import { writeIfNotExists } from '../utils/fileUtils.js';
-
 const createProgramTemplate = () => `import { createApp } from '@azure-net/kit';
 
-export const { register, App } = createApp((app) => app);
+export const { register, Container } = createApp((app) => app);
 `;
-
 export default async function createProgram() {
 	const programPath = path.join(process.cwd(), 'src', 'program.ts');
 	const created = await writeIfNotExists(programPath, createProgramTemplate());
-
 	if (!created) {
 		console.log('⚠️ Program already exists. Nothing was overwritten.');
 		return;
 	}
-
 	console.log(`✅ Program created: ${programPath}`);
 }

package/src/scaffolds/createResponse.js

@@ -3,7 +3,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';
 const createResponseWithWrapperTemplate = (name) => {
 	const interfaceName = `I${name}`;
 	return `import { ResponseBuilder } from '@azure-net/kit/infra';
@@ -19,17 +19,14 @@ export class ${name}<TData = unknown, TMeta = unknown> extends ResponseBuilder<T
 }
 `;
 };
-
 const createResponseSimpleTemplate = (name) => `import { ResponseBuilder } from '@azure-net/kit/infra';
 
 export class ${name}<TData = unknown, TMeta = unknown> extends ResponseBuilder<TData, TMeta> {}
 `;
-
 const ensureResponseName = (rawName) => {
 	const normalized = toPascalCase(rawName || 'ApiResponse') || 'ApiResponse';
 	return normalized.endsWith('Response') ? normalized : `${normalized}Response`;
 };
-
 export default async function createResponse() {
 	const { responseNameRaw } = await prompts({
 		type: 'text',
@@ -37,28 +34,23 @@ export default async function createResponse() {
 		message: 'Response class name:',
 		initial: 'ApiResponse'
 	});
-
 	const responseName = ensureResponseName(String(responseNameRaw ?? 'ApiResponse'));
-
 	const { useCommonResponseWrapper } = await prompts({
 		type: 'confirm',
 		name: 'useCommonResponseWrapper',
 		message: 'Use common backend response wrapper interface?',
 		initial: true
 	});
-
-	const responseRoot = path.join(process.cwd(), 'src', 'core', 'response');
+	const { sharedContext } = await getSharedState();
+	const responseRoot = getFoundationConstructPath(sharedContext.name, 'response');
 	const filePath = path.join(responseRoot, `${responseName}.ts`);
 	await fs.mkdir(responseRoot, { recursive: true });
-
 	const template = useCommonResponseWrapper ? createResponseWithWrapperTemplate(responseName) : createResponseSimpleTemplate(responseName);
 	const created = await writeIfNotExists(filePath, template);
 	await updateIndexTs(responseRoot);
-
 	if (!created) {
 		console.log(`⚠️ Response "${responseName}" already exists. File was not overwritten.`);
 		return;
 	}
-
 	console.log(`✅ Response created: ${filePath}`);
 }

package/src/scaffolds/createResponse.ts

@@ -3,6 +3,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';
 
 const createResponseWithWrapperTemplate = (name: string): string => {
 	const interfaceName = `I${name}`;
@@ -47,7 +48,8 @@ export default async function createResponse(): Promise<void> {
 		initial: true
 	});
 
-	const responseRoot = path.join(process.cwd(), 'src', 'core', 'response');
+	const { sharedContext } = await getSharedState();
+	const responseRoot = getFoundationConstructPath(sharedContext.name, 'response');
 	const filePath = path.join(responseRoot, `${responseName}.ts`);
 	await fs.mkdir(responseRoot, { recursive: true });
 

package/src/scaffolds/createSchemaRule.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import prompts from 'prompts';
 import { writeIfNotExists, updateIndexTs } from '../utils/fileUtils.js';
 import { toPascalCase, toCamelCase } from '../utils/contextUtils.js';
-
+import { getFoundationConstructPath, getSharedState } from '../utils/sharedFoundation.js';
 const createSchemaRuleTemplate = (ruleName) => `import type { ValidationParams, ValidationRuleResult } from '@azure-net/kit/delivery';
 
 export const ${ruleName} = <T = unknown, D = unknown>(): ValidationRuleResult<T, D> => {
@@ -12,7 +12,6 @@ export const ${ruleName} = <T = unknown, D = unknown>(): ValidationRuleResult<T,
 \t};
 };
 `;
-
 export default async function createSchemaRule() {
 	const { ruleNameRaw } = await prompts({
 		type: 'text',
@@ -20,21 +19,17 @@ export default async function createSchemaRule() {
 		message: 'Schema rule name:',
 		initial: 'File'
 	});
-
 	const pascalName = toPascalCase(String(ruleNameRaw ?? 'File')) || 'File';
 	const camelName = toCamelCase(pascalName) || 'file';
-	const rulesPath = path.join(process.cwd(), 'src', 'core', 'schema', 'custom-rules');
+	const { sharedContext } = await getSharedState();
+	const rulesPath = path.join(getFoundationConstructPath(sharedContext.name, 'schema'), 'custom-rules');
 	const filePath = path.join(rulesPath, `${pascalName}.ts`);
-
 	await fs.mkdir(rulesPath, { recursive: true });
-
 	const created = await writeIfNotExists(filePath, createSchemaRuleTemplate(camelName));
 	await updateIndexTs(rulesPath);
-
 	if (!created) {
 		console.log(`⚠️ Schema rule "${pascalName}" already exists. File was not overwritten.`);
 		return;
 	}
-
 	console.log(`✅ Schema rule created: ${filePath}`);
 }

package/src/scaffolds/createSchemaRule.ts

@@ -3,6 +3,7 @@ import path from 'node:path';
 import prompts from 'prompts';
 import { writeIfNotExists, updateIndexTs } from '../utils/fileUtils.js';
 import { toPascalCase, toCamelCase } from '../utils/contextUtils.js';
+import { getFoundationConstructPath, getSharedState } from '../utils/sharedFoundation.js';
 
 const createSchemaRuleTemplate = (
 	ruleName: string
@@ -25,7 +26,8 @@ export default async function createSchemaRule(): Promise<void> {
 
 	const pascalName = toPascalCase(String(ruleNameRaw ?? 'File')) || 'File';
 	const camelName = toCamelCase(pascalName) || 'file';
-	const rulesPath = path.join(process.cwd(), 'src', 'core', 'schema', 'custom-rules');
+	const { sharedContext } = await getSharedState();
+	const rulesPath = path.join(getFoundationConstructPath(sharedContext.name, 'schema'), 'custom-rules');
 	const filePath = path.join(rulesPath, `${pascalName}.ts`);
 
 	await fs.mkdir(rulesPath, { recursive: true });

package/src/scaffolds/createTranslationManager.js

@@ -2,17 +2,15 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import prompts from 'prompts';
 import { writeIfNotExists } from '../utils/fileUtils.js';
-
+import { getLocalizationPath, getSharedState } from '../utils/sharedFoundation.js';
 const parseLocales = (rawLocales) => {
 	const parsed = String(rawLocales ?? '')
 		.split(',')
 		.map((item) => item.trim().toLowerCase())
 		.filter(Boolean);
-
 	const unique = Array.from(new Set(parsed));
 	return unique.length ? unique : ['en', 'ru'];
 };
-
 const createTranslationIndexTemplate = (defaultLocale) => `import { messages } from './locales/index.js';
 import { createTranslations, type Path } from '@azure-net/kit/i18n';
 
@@ -30,17 +28,14 @@ export type MessageKeys = Path<MessagesList>;
 export type TranslationParam = MessageKeys | string | TranslationExtended;
 export type AvailableLocales = keyof typeof messages;
 `;
-
 const createLocalesIndexTemplate = (locales) => {
 	const lines = locales.map((locale) => `\t${locale}: () => import('./${locale}/index.js').then((res) => res.default)`);
 	return `export const messages = {\n${lines.join(',\n')}\n};\n`;
 };
-
 const createLocaleTemplate = () => `export default {
 \ttest: 'test'
 };
 `;
-
 export default async function createTranslationManager() {
 	const { localesRaw } = await prompts({
 		type: 'text',
@@ -48,9 +43,7 @@ export default async function createTranslationManager() {
 		message: 'Enter locales (comma separated):',
 		initial: 'en, ru'
 	});
-
 	const locales = parseLocales(String(localesRaw ?? 'en, ru'));
-
 	const { defaultLocale } = await prompts({
 		type: 'select',
 		name: 'defaultLocale',
@@ -58,21 +51,17 @@ export default async function createTranslationManager() {
 		choices: locales.map((locale) => ({ title: locale, value: locale })),
 		initial: 0
 	});
-
 	const selectedDefaultLocale = String(defaultLocale ?? locales[0] ?? 'en');
-
-	const translationRoot = path.join(process.cwd(), 'src', 'core', 'translation');
+	const { sharedContext } = await getSharedState();
+	const translationRoot = getLocalizationPath(sharedContext.name);
 	const localesRoot = path.join(translationRoot, 'locales');
 	await fs.mkdir(localesRoot, { recursive: true });
-
 	await writeIfNotExists(path.join(translationRoot, 'index.ts'), createTranslationIndexTemplate(selectedDefaultLocale));
 	await writeIfNotExists(path.join(localesRoot, 'index.ts'), createLocalesIndexTemplate(locales));
-
 	for (const locale of locales) {
 		const localeDir = path.join(localesRoot, locale);
 		await fs.mkdir(localeDir, { recursive: true });
 		await writeIfNotExists(path.join(localeDir, 'index.ts'), createLocaleTemplate());
 	}
-
 	console.log(`✅ Translation manager created: ${translationRoot}`);
 }

package/src/scaffolds/createTranslationManager.ts

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import prompts from 'prompts';
 import { writeIfNotExists } from '../utils/fileUtils.js';
+import { getLocalizationPath, getSharedState } from '../utils/sharedFoundation.js';
 
 const parseLocales = (rawLocales: string): string[] => {
 	const parsed = String(rawLocales ?? '')
@@ -61,7 +62,8 @@ export default async function createTranslationManager(): Promise<void> {
 
 	const selectedDefaultLocale = String(defaultLocale ?? locales[0] ?? 'en');
 
-	const translationRoot = path.join(process.cwd(), 'src', 'core', 'translation');
+	const { sharedContext } = await getSharedState();
+	const translationRoot = getLocalizationPath(sharedContext.name);
 	const localesRoot = path.join(translationRoot, 'locales');
 	await fs.mkdir(localesRoot, { recursive: true });