@azure-net/cli 5.1.1 → 6.0.0-next.3

package/src/migrate/translations.js

@@ -0,0 +1,213 @@
+import path from 'node:path';
+import ts from 'typescript';
+const patch = (input, edits) => {
+    for (const e of edits.sort((a, b) => b.start - a.start))
+        input = input.slice(0, e.start) + e.text + input.slice(e.end);
+    return input;
+};
+const internal = new Set(['preloadTranslation', 'initializeClient', 'syncFromState']);
+const translationModules = new Set(['@azure-net/kit/i18n', '@azure-net/edges-translations']);
+/** A conservative migration of known translation wiring, never a project-wide textual replacement. */
+export function migrateTranslationsSources(sources, resolve) {
+    const updates = new Map();
+    const issues = [];
+    const managers = [];
+    for (const [file, input] of sources) {
+        if (!/\.[jt]s$/.test(file))
+            continue;
+        const source = ts.createSourceFile(file, input, ts.ScriptTarget.Latest, true);
+        const factories = new Set();
+        for (const stmt of source.statements) {
+            if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier) || !translationModules.has(stmt.moduleSpecifier.text))
+                continue;
+            const bindings = stmt.importClause?.namedBindings;
+            if (bindings && ts.isNamedImports(bindings))
+                for (const b of bindings.elements)
+                    if ((b.propertyName ?? b.name).text === 'createTranslations')
+                        factories.add(b.name.text);
+        }
+        for (const stmt of source.statements)
+            if (ts.isVariableStatement(stmt) && stmt.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword))
+                for (const d of stmt.declarationList.declarations) {
+                    if (ts.isIdentifier(d.name) &&
+                        d.initializer &&
+                        ts.isCallExpression(d.initializer) &&
+                        ts.isIdentifier(d.initializer.expression) &&
+                        factories.has(d.initializer.expression.text))
+                        managers.push({ file, name: d.name.text });
+                }
+    }
+    if (!managers.length)
+        return { updates, issues };
+    if (managers.length !== 1) {
+        for (const m of managers)
+            issues.push({ file: m.file, reason: 'Multiple translation managers: choose the manager for app.useTranslations manually.' });
+        return { updates, issues };
+    }
+    const manager = managers[0];
+    const reaches = (file, seen = new Set()) => {
+        if (file === manager.file)
+            return true;
+        if (seen.has(file))
+            return false;
+        seen.add(file);
+        const source = ts.createSourceFile(file, sources.get(file) ?? '', ts.ScriptTarget.Latest, true);
+        return source.statements.some((s) => {
+            if ((!ts.isImportDeclaration(s) && !ts.isExportDeclaration(s)) || !s.moduleSpecifier || !ts.isStringLiteral(s.moduleSpecifier))
+                return false;
+            const target = resolve(file, s.moduleSpecifier.text);
+            return !!target && reaches(target, seen);
+        });
+    };
+    let connected = false;
+    for (const [file, input] of sources) {
+        if (!/\.[jt]s$/.test(file) || !reaches(file))
+            continue;
+        const source = ts.createSourceFile(file, input, ts.ScriptTarget.Latest, true);
+        const creators = new Set();
+        for (const stmt of source.statements)
+            if (ts.isImportDeclaration(stmt) && ts.isStringLiteral(stmt.moduleSpecifier) && stmt.moduleSpecifier.text === '@azure-net/kit') {
+                const b = stmt.importClause?.namedBindings;
+                if (b && ts.isNamedImports(b))
+                    for (const e of b.elements)
+                        if ((e.propertyName ?? e.name).text === 'createApp')
+                            creators.add(e.name.text);
+            }
+        const calls = [];
+        const visit = (n) => {
+            if (ts.isCallExpression(n) && ts.isIdentifier(n.expression) && creators.has(n.expression.text))
+                calls.push(n);
+            ts.forEachChild(n, visit);
+        };
+        visit(source);
+        if (!calls.length)
+            continue;
+        if (calls.length !== 1) {
+            issues.push({ file, reason: 'Multiple createApp calls: connect translations manually.' });
+            continue;
+        }
+        const callback = calls[0].arguments[0];
+        if (!callback || !ts.isArrowFunction(callback) || !callback.parameters[0] || !ts.isIdentifier(callback.parameters[0].name)) {
+            issues.push({ file, reason: 'Unsupported createApp callback: add useTranslations manually.' });
+            continue;
+        }
+        let body = ts.isBlock(callback.body)
+            ? callback.body.statements.find(ts.isReturnStatement)?.expression
+            : callback.body;
+        let already = false;
+        while (body && ts.isCallExpression(body) && ts.isPropertyAccessExpression(body.expression)) {
+            if (body.expression.name.text === 'useTranslations')
+                already = true;
+            body = body.expression.expression;
+        }
+        if (already) {
+            connected = true;
+            continue;
+        }
+        if (!body || !ts.isIdentifier(body) || body.text !== callback.parameters[0].name.text) {
+            issues.push({ file, reason: 'Unsupported createApp chain: add useTranslations manually.' });
+            continue;
+        }
+        let local = 'MigratedTranslationManager';
+        while (new RegExp(`\\b${local}\\b`).test(input))
+            local += '_';
+        let spec = path
+            .relative(path.dirname(file), manager.file)
+            .split(path.sep)
+            .join('/')
+            .replace(/\.[jt]s$/, '');
+        if (!spec.startsWith('.'))
+            spec = './' + spec;
+        updates.set(file, `import { ${manager.name} as ${local} } from ${JSON.stringify(spec)};\n` +
+            input.slice(0, body.end) +
+            `.useTranslations(${local})` +
+            input.slice(body.end));
+        connected = true;
+    }
+    if (!connected) {
+        issues.push({
+            file: manager.file,
+            reason: 'Translations require app.useTranslations(TranslationManager); no unambiguous connected bootstrap found.'
+        });
+        return { updates, issues };
+    }
+    let unsafeLifecycle = false;
+    for (const [file, original] of sources) {
+        if (!/\.[jt]s$/.test(file))
+            continue;
+        const input = updates.get(file) ?? original;
+        const source = ts.createSourceFile(file, input, ts.ScriptTarget.Latest, true);
+        const options = { noLib: true, noResolve: true };
+        const host = ts.createCompilerHost(options);
+        host.getSourceFile = (name) => (name === file ? source : undefined);
+        host.fileExists = (name) => name === file;
+        host.readFile = (name) => (name === file ? input : undefined);
+        const checker = ts.createProgram([file], options, host).getTypeChecker();
+        const accessors = new Set();
+        for (const stmt of source.statements)
+            if (ts.isImportDeclaration(stmt) &&
+                ts.isStringLiteral(stmt.moduleSpecifier) &&
+                resolve(file, stmt.moduleSpecifier.text) === manager.file) {
+                const bindings = stmt.importClause?.namedBindings;
+                if (bindings && ts.isNamedImports(bindings))
+                    for (const e of bindings.elements)
+                        if ((e.propertyName ?? e.name).text === manager.name)
+                            accessors.add(e.name.text);
+            }
+        const edits = [];
+        let unsafe = false;
+        const scan = (node) => {
+            if (ts.isVariableDeclaration(node) &&
+                ts.isObjectBindingPattern(node.name) &&
+                node.initializer &&
+                ts.isCallExpression(node.initializer) &&
+                ts.isIdentifier(node.initializer.expression) &&
+                accessors.has(node.initializer.expression.text)) {
+                const removed = node.name.elements.filter((b) => ts.isIdentifier(b.name) && internal.has((b.propertyName ?? b.name).getText(source)));
+                for (const b of removed) {
+                    const binding = checker.getSymbolAtLocation(b.name);
+                    const refs = [];
+                    const find = (n) => {
+                        if (n === node.name)
+                            return;
+                        if (binding && ts.isIdentifier(n) && checker.getSymbolAtLocation(n) === binding)
+                            refs.push(n);
+                        ts.forEachChild(n, find);
+                    };
+                    find(source);
+                    for (const ref of refs) {
+                        const call = ref.parent;
+                        if (!ts.isCallExpression(call) || call.expression !== ref || call.arguments.length) {
+                            unsafe = true;
+                            continue;
+                        }
+                        edits.push({ start: call.getStart(source), end: call.end, text: 'Promise.resolve()' });
+                    }
+                }
+                if (removed.length) {
+                    const kept = node.name.elements.filter((b) => !removed.includes(b));
+                    edits.push({
+                        start: node.name.getStart(source),
+                        end: node.name.end,
+                        text: `{ ${kept.map((b) => b.getText(source)).join(', ')} }`
+                    });
+                }
+            }
+            if (ts.isImportDeclaration(node) &&
+                ts.isStringLiteral(node.moduleSpecifier) &&
+                node.moduleSpecifier.text === '@azure-net/edges-translations')
+                edits.push({ start: node.moduleSpecifier.getStart(source), end: node.moduleSpecifier.end, text: "'@azure-net/kit/i18n'" });
+            ts.forEachChild(node, scan);
+        };
+        scan(source);
+        if (unsafe) {
+            unsafeLifecycle = true;
+            issues.push({ file, reason: 'Custom translation lifecycle arguments/references: migrate these calls manually to useTranslations.' });
+            continue;
+        }
+        if (edits.length)
+            updates.set(file, patch(input, edits));
+    }
+    // Do not connect automatic loading while an old custom locale resolver is still active.
+    return { updates: unsafeLifecycle ? new Map() : updates, issues };
+}

package/src/plugins/addLint.js

@@ -1,222 +1,55 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { execSync } from 'node:child_process';
-const dependencies = ['@commitlint/cli', 'semantic-release', '@semantic-release/git', 'git-cz', 'husky', 'commitizen', 'env-cmd'];
-const commitlintConfig = `export default {
-	rules: {
-		'body-leading-blank': [2, 'always'],
-		'footer-leading-blank': [2, 'always'],
-		'header-max-length': [2, 'always', 72],
-		'subject-empty': [2, 'never'],
-		'subject-full-stop': [2, 'never', '.'],
-		'type-case': [2, 'always', 'lower-case'],
-		'type-empty': [2, 'never'],
-		'type-enum': [2, 'always', ['feat', 'fix', 'refactor', 'perf', 'chore', 'docs', 'style', 'test', 'ci']]
-	}
-};
-`;
-const releaseConfig = `export default {
-	branches: ['main', 'dev'],
-	dryRun: false,
-	ci: false,
-	plugins: [
-		[
-			'@semantic-release/commit-analyzer',
-			{
-				releaseRules: [
-					{ type: 'release', release: 'major' },
-					{ type: 'feature', release: 'minor' },
-					{ type: 'perf', release: false },
-					{ type: 'refactor', release: false },
-					{ type: 'fix', release: 'patch' },
-					{ type: 'chore', release: false },
-					{ type: 'ci', release: false },
-					{ type: 'docs', scope: 'README', release: false },
-					{ type: 'test', release: false },
-					{ type: 'style', release: false }
-				]
-			}
-		],
-		'@semantic-release/release-notes-generator'
-	]
-};
-`;
-const prettierConfig = `{
-	"useTabs": true,
-	"singleQuote": true,
-	"trailingComma": "none",
-	"tabWidth": 2,
-	"semi": true,
-	"printWidth": 150,
-	"plugins": ["prettier-plugin-svelte"],
-	"overrides": [
-		{
-			"files": "*.svelte",
-			"options": {
-				"parser": "svelte"
-			}
-		}
-	]
-}
-`;
-const resolveInstallCommand = (manager) => {
-	const deps = dependencies.join(' ');
-	switch (manager) {
-		case 'pnpm':
-			return `pnpm add -D ${deps}`;
-		case 'npm':
-			return `npm install -D ${deps}`;
-		case 'yarn':
-			return `yarn add -D ${deps}`;
-		case 'bun':
-			return `bun add -d ${deps}`;
-	}
-};
-const resolveRunScriptCommand = (manager, script) => {
-	switch (manager) {
-		case 'pnpm':
-			return `pnpm ${script}`;
-		case 'npm':
-			return `npm run ${script}`;
-		case 'yarn':
-			return `yarn ${script}`;
-		case 'bun':
-			return `bun run ${script}`;
-	}
-};
-const resolveHuskyCommand = (manager) => {
-	switch (manager) {
-		case 'pnpm':
-			return 'pnpm exec husky';
-		case 'npm':
-			return 'npx husky';
-		case 'yarn':
-			return 'yarn husky';
-		case 'bun':
-			return 'bunx husky';
-	}
-};
-const detectPackageManager = (cwd) => {
-	if (fs.existsSync(path.join(cwd, 'bun.lock')) || fs.existsSync(path.join(cwd, 'bun.lockb'))) return 'bun';
-	if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml'))) return 'pnpm';
-	if (fs.existsSync(path.join(cwd, 'yarn.lock'))) return 'yarn';
-	if (fs.existsSync(path.join(cwd, 'package-lock.json'))) return 'npm';
-	return undefined;
-};
-const parseConfigState = (cwd) => {
-	const tsPath = path.join(cwd, 'azure-net.config.ts');
-	const jsPath = path.join(cwd, 'azure-net.config.js');
-	const configPath = fs.existsSync(tsPath) ? tsPath : fs.existsSync(jsPath) ? jsPath : null;
-	if (!configPath) {
-		return {
-			configPath: null,
-			content: null,
-			hasPackageManagerKey: false,
-			validPackageManager: null
-		};
-	}
-	const content = fs.readFileSync(configPath, 'utf-8');
-	const hasPackageManagerKey = /packageManager\s*:/.test(content);
-	const managerMatch = content.match(/packageManager\s*:\s*['"`](bun|pnpm|npm|yarn)['"`]/);
-	const validPackageManager = managerMatch?.[1];
-	return {
-		configPath,
-		content,
-		hasPackageManagerKey,
-		validPackageManager: validPackageManager ?? null
-	};
-};
-const upsertPackageManagerInConfig = (content, manager) => {
-	const packageManagerEntry = `packageManager: '${manager}'`;
-	const hasExportDefaultObject = /export\s+default\s*\{[\s\S]*\}\s*;?/.test(content);
-	if (!hasExportDefaultObject) {
-		return `export default {\n\t${packageManagerEntry}\n};\n`;
-	}
-	if (/packageManager\s*:/.test(content)) {
-		return content.replace(/packageManager\s*:\s*['"`][^'"`]+['"`]/, packageManagerEntry);
-	}
-	return content.replace(/export\s+default\s*\{([\s\S]*?)\}\s*;?/, (_full, body) => {
-		const trimmedRight = body.replace(/\s*$/, '');
-		if (!trimmedRight.length) {
-			return `export default {\n\t${packageManagerEntry}\n};`;
-		}
-		const withComma = trimmedRight.endsWith(',') ? trimmedRight : `${trimmedRight},`;
-		return `export default {${withComma}\n\t${packageManagerEntry}\n};`;
-	});
-};
-const localOnlyPrepareScript = `node -e "const local = !process.env.CI && process.env.NODE_ENV !== 'production' && !process.env.DOCKER && !process.env.CONTAINER; process.exit(local ? 1 : 0)" || (husky && svelte-kit sync)`;
-const selectPackageManager = async (cwd, preset) => {
-	if (preset) return preset;
-	const { default: prompts } = await import('prompts');
-	const detected = detectPackageManager(cwd);
-	const response = await prompts({
-		type: 'select',
-		name: 'manager',
-		message: 'Choose your package manager:',
-		choices: [
-			{ title: 'bun', value: 'bun' },
-			{ title: 'pnpm', value: 'pnpm' },
-			{ title: 'npm', value: 'npm' },
-			{ title: 'yarn', value: 'yarn' }
-		],
-		initial: detected ? ['bun', 'pnpm', 'npm', 'yarn'].indexOf(detected) : 0
-	});
-	if (!response.manager) {
-		throw new Error('Package manager is required');
-	}
-	return response.manager;
-};
-export default async function addLint(options = {}) {
-	const cwd = process.cwd();
-	const pkgPath = path.join(cwd, 'package.json');
-	if (!fs.existsSync(pkgPath)) {
-		console.error('❌ package.json not found in this directory');
-		process.exit(1);
-	}
-	const configState = parseConfigState(cwd);
-	const manager = configState.validPackageManager ?? (await selectPackageManager(cwd, options.manager));
-	if (!configState.configPath) {
-		const newConfigPath = path.join(cwd, 'azure-net.config.ts');
-		fs.writeFileSync(newConfigPath, `export default {\n\tpackageManager: '${manager}'\n};\n`);
-	} else if (!configState.validPackageManager || !configState.hasPackageManagerKey) {
-		const nextConfig = upsertPackageManagerInConfig(configState.content ?? '', manager);
-		fs.writeFileSync(configState.configPath, nextConfig);
-	}
-	const installCommand = resolveInstallCommand(manager);
-	const runFormatCommand = resolveRunScriptCommand(manager, 'format');
-	const preCommitScript = `${resolveRunScriptCommand(manager, 'lint')} && ${resolveRunScriptCommand(manager, 'check')}`;
-	const commitScript = `${resolveRunScriptCommand(manager, 'format')} && git add . && git-cz && git push`;
-	const releaseScript = `${resolveRunScriptCommand(manager, 'commit')} && ${resolveRunScriptCommand(manager, 'semantic-release')}`;
-	console.log(`📦 Installing packages with ${manager}...`);
-	execSync(installCommand, { stdio: 'inherit' });
-	console.log('📁 Updating package.json...');
-	const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-	pkg.scripts = {
-		...(pkg.scripts ?? {}),
-		precommit: preCommitScript,
-		prepare: localOnlyPrepareScript,
-		'semantic-release': 'env-cmd semantic-release',
-		commit: commitScript,
-		release: releaseScript
-	};
-	pkg.config = pkg.config ?? {};
-	pkg.config.commitizen = {
-		path: 'git-cz'
-	};
-	fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 4));
-	fs.writeFileSync(path.join(cwd, 'commitlint.config.ts'), commitlintConfig);
-	fs.writeFileSync(path.join(cwd, 'release.config.ts'), releaseConfig);
-	fs.writeFileSync(path.join(cwd, '.prettierrc'), prettierConfig);
-	console.log('🔧 Initializing Husky...');
-	try {
-		execSync(resolveHuskyCommand(manager), { stdio: 'inherit' });
-	} catch {
-		console.warn('⚠️ Husky initialization skipped (command failed in current environment).');
-	}
-	try {
-		execSync(runFormatCommand, { stdio: 'inherit' });
-	} catch {
-		console.warn('⚠️ Format script execution skipped (script may be missing).');
-	}
-	console.log(`✅ Linting and release setup completed! Added prepare script: ${localOnlyPrepareScript}`);
+export default async function addLint(_options = {}) {
+    // Retain compatibility with the existing --manager option without running a package manager.
+    void _options;
+    const cwd = process.cwd();
+    const pkgPath = path.join(cwd, 'package.json');
+    if (!fs.existsSync(pkgPath))
+        throw new Error('package.json not found in this directory');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    const configNames = [
+        '.prettierrc',
+        '.prettierrc.json',
+        '.prettierrc.json5',
+        '.prettierrc.yaml',
+        '.prettierrc.yml',
+        '.prettierrc.toml',
+        '.prettierrc.js',
+        '.prettierrc.cjs',
+        '.prettierrc.mjs',
+        '.prettierrc.ts',
+        '.prettierrc.cts',
+        '.prettierrc.mts',
+        'prettier.config.js',
+        'prettier.config.cjs',
+        'prettier.config.mjs',
+        'prettier.config.ts',
+        'prettier.config.cts',
+        'prettier.config.mts'
+    ];
+    const existingConfigs = configNames.filter((name) => fs.existsSync(path.join(cwd, name)));
+    if ('prettier' in pkg || existingConfigs.length) {
+        const backupRoot = path.join(cwd, '.azure-net', 'PrettierBackups');
+        fs.mkdirSync(backupRoot, { recursive: true });
+        // Atomic directory creation prevents overwriting backups from rapid repeated runs.
+        const backup = fs.mkdtempSync(path.join(backupRoot, 'config-'));
+        if ('prettier' in pkg) {
+            fs.copyFileSync(pkgPath, path.join(backup, 'package.json'), fs.constants.COPYFILE_EXCL);
+            delete pkg.prettier;
+            fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, '\t') + '\n');
+        }
+        for (const name of existingConfigs) {
+            fs.renameSync(path.join(cwd, name), path.join(backup, name));
+        }
+    }
+    fs.writeFileSync(path.join(cwd, '.prettierrc'), JSON.stringify({
+        useTabs: true,
+        singleQuote: true,
+        trailingComma: 'none',
+        tabWidth: 2,
+        semi: true,
+        printWidth: 150
+    }, null, '\t') + '\n');
+    console.log('Prettier configuration replaced. No packages installed.');
 }

package/src/scaffolds/createCoreSchema.js

@@ -1,3 +1,4 @@
+import { updateDefaultFactoryConfig } from './updateDefaultFactoryConfig.js';
 import fs from 'node:fs/promises';
 import fsSync from 'node:fs';
 import path from 'node:path';
@@ -6,102 +7,75 @@ import { writeIfNotExists, updateIndexTs } from '../utils/fileUtils.js';
 import { toPascalCase } from '../utils/contextUtils.js';
 import { getFoundationConstructPath, getSharedState } from '../utils/sharedFoundation.js';
 const resolvePresetImportName = (preset) => {
-	switch (preset) {
-		case 'ru':
-			return 'validationMessagesRu';
-		case 'en':
-			return 'validationMessagesEn';
-		case 'i18n':
-			return 'validationMessagesI18n';
-	}
+    switch (preset) {
+        case 'ru':
+            return 'validationMessagesRu';
+        case 'en':
+            return 'validationMessagesEn';
+        case 'i18n':
+            return 'validationMessagesI18n';
+    }
 };
-const createSchemaFactoryTemplate = (
-	factoryName,
-	messagesImportName
-) => `import { createSchemaFactory, createRules, ${messagesImportName} } from '@azure-net/kit/delivery';
+const createSchemaFactoryTemplate = (factoryName, messagesImportName) => `import { createSchemaFactory, createRules, ${messagesImportName} } from '@azure-net/kit/delivery';
 
 export const ${factoryName} = createSchemaFactory(createRules(${messagesImportName}));
 `;
 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 buildDefaultSchemaFactoryConfigEntry = (factoryName) => {
-	return `defaultSchemaFactory: '${factoryName}'`;
-};
-const upsertDefaultSchemaFactoryConfig = (content, factoryName) => {
-	const hasExportDefaultObject = /export\s+default\s*\{[\s\S]*\}\s*;?/.test(content);
-	const defaultFactoryEntry = buildDefaultSchemaFactoryConfigEntry(factoryName);
-	if (!hasExportDefaultObject) {
-		return `export default {\n\t${defaultFactoryEntry}\n};\n`;
-	}
-	let nextContent = content;
-	if (/defaultSchemaFactory\s*:/.test(nextContent)) {
-		nextContent = nextContent.replace(/defaultSchemaFactory\s*:\s*(\{[\s\S]*?\n\s*\}|['"`][^'"`]+['"`])/m, defaultFactoryEntry);
-	} else if (/defaultSchema\s*:/.test(nextContent)) {
-		nextContent = nextContent.replace(/defaultSchema\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;
+    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: '' };
 };
 export default async function createCoreSchema() {
-	const { schemaFactoryNameRaw } = await prompts({
-		type: 'text',
-		name: 'schemaFactoryNameRaw',
-		message: 'Schema factory name:',
-		initial: 'Schema'
-	});
-	const schemaFactoryName = toPascalCase(String(schemaFactoryNameRaw ?? 'Schema')) || 'Schema';
-	const { preset } = await prompts({
-		type: 'select',
-		name: 'preset',
-		message: 'Choose validation messages:',
-		choices: [
-			{ title: 'Russian', value: 'ru' },
-			{ title: 'English', value: 'en' },
-			{ title: 'i18n', value: 'i18n' }
-		],
-		initial: 2
-	});
-	const selectedPreset = preset ?? 'i18n';
-	const messagesImportName = resolvePresetImportName(selectedPreset);
-	const { sharedContext } = await getSharedState();
-	const coreSchemaPath = getFoundationConstructPath(sharedContext.name, 'schema');
-	const customRulesPath = path.join(coreSchemaPath, 'custom-rules');
-	const filePath = path.join(coreSchemaPath, `${schemaFactoryName}.ts`);
-	await fs.mkdir(coreSchemaPath, { recursive: true });
-	await fs.mkdir(customRulesPath, { recursive: true });
-	const created = await writeIfNotExists(filePath, createSchemaFactoryTemplate(schemaFactoryName, messagesImportName));
-	if (!created) {
-		console.log(`⚠️ Schema factory "${schemaFactoryName}" already exists. File was not overwritten.`);
-	} else {
-		await updateIndexTs(coreSchemaPath);
-		console.log(`✅ Shared schema factory created: ${filePath}`);
-	}
-	const { useAsDefault } = await prompts({
-		type: 'confirm',
-		name: 'useAsDefault',
-		message: 'Use this schema factory as default for the project?',
-		initial: true
-	});
-	if (!useAsDefault) return;
-	const config = resolveConfigFile(process.cwd());
-	const nextContent = upsertDefaultSchemaFactoryConfig(config.content, schemaFactoryName);
-	await fs.writeFile(config.filepath, nextContent, 'utf-8');
-	console.log(`✅ Default schema factory saved to ${path.basename(config.filepath)}`);
+    const { schemaFactoryNameRaw } = await prompts({
+        type: 'text',
+        name: 'schemaFactoryNameRaw',
+        message: 'Schema factory name:',
+        initial: 'Schema'
+    });
+    const schemaFactoryName = toPascalCase(String(schemaFactoryNameRaw ?? 'Schema')) || 'Schema';
+    const { preset } = await prompts({
+        type: 'select',
+        name: 'preset',
+        message: 'Choose validation messages:',
+        choices: [
+            { title: 'Russian', value: 'ru' },
+            { title: 'English', value: 'en' },
+            { title: 'i18n', value: 'i18n' }
+        ],
+        initial: 2
+    });
+    const selectedPreset = (preset ?? 'i18n');
+    const messagesImportName = resolvePresetImportName(selectedPreset);
+    const { sharedContext } = await getSharedState();
+    const coreSchemaPath = getFoundationConstructPath(sharedContext.name, 'schema');
+    const customRulesPath = path.join(coreSchemaPath, 'CustomRules');
+    const filePath = path.join(coreSchemaPath, `${schemaFactoryName}.ts`);
+    await fs.mkdir(coreSchemaPath, { recursive: true });
+    await fs.mkdir(customRulesPath, { recursive: true });
+    const created = await writeIfNotExists(filePath, createSchemaFactoryTemplate(schemaFactoryName, messagesImportName));
+    if (!created) {
+        console.log(`⚠️ Schema factory "${schemaFactoryName}" already exists. File was not overwritten.`);
+    }
+    else {
+        await updateIndexTs(coreSchemaPath);
+        console.log(`✅ Shared schema factory created: ${filePath}`);
+    }
+    const { useAsDefault } = await prompts({
+        type: 'confirm',
+        name: 'useAsDefault',
+        message: 'Use this schema factory as default for the project?',
+        initial: true
+    });
+    if (!useAsDefault)
+        return;
+    const config = resolveConfigFile(process.cwd());
+    const nextContent = updateDefaultFactoryConfig(config.content, 'defaultSchemaFactory', schemaFactoryName);
+    await fs.writeFile(config.filepath, nextContent, 'utf-8');
+    console.log(`✅ Default schema factory saved to ${path.basename(config.filepath)}`);
 }