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

package/src/scaffolds/createDatasource.js

@@ -1,14 +1,11 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import prompts from 'prompts';
+import { registerDatasource } from './registerDatasource.js';
 import { writeIfNotExists, updateIndexTs } from '../utils/fileUtils.js';
 import { toPascalCase } from '../utils/contextUtils.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';
+const createDatasourceTemplateWithoutResponse = (className) => `import { BaseHttpDatasource, type CreateRequestCallbackType } from '@azure-net/kit/infra';
 
 export class ${className} extends BaseHttpDatasource {
 \tasync createRequest<T>(callback: CreateRequestCallbackType<T>) {
@@ -16,11 +13,7 @@ export class ${className} extends BaseHttpDatasource {
 \t}
 }
 `;
-const createDatasourceTemplateWithResponseAndInterface = (
-	className,
-	responseName,
-	responseImportPath
-) => `import { BaseHttpDatasource, type CreateRequestCallbackType } from '@azure-net/kit/infra';
+const createDatasourceTemplateWithResponseAndInterface = (className, responseName, responseImportPath) => `import { BaseHttpDatasource, type CreateRequestCallbackType } from '@azure-net/kit/infra';
 import { ${responseName}, type I${responseName} } from '${responseImportPath}';
 
 export class ${className} extends BaseHttpDatasource {
@@ -29,11 +22,7 @@ export class ${className} extends BaseHttpDatasource {
 \t}
 }
 `;
-const createDatasourceTemplateWithResponse = (
-	className,
-	responseName,
-	responseImportPath
-) => `import { BaseHttpDatasource, type CreateRequestCallbackType } from '@azure-net/kit/infra';
+const createDatasourceTemplateWithResponse = (className, responseName, responseImportPath) => `import { BaseHttpDatasource, type CreateRequestCallbackType } from '@azure-net/kit/infra';
 import { ${responseName} } from '${responseImportPath}';
 
 export class ${className} extends BaseHttpDatasource {
@@ -43,96 +32,73 @@ export class ${className} extends BaseHttpDatasource {
 }
 `;
 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: 'shared foundation', value: '__shared__' }];
-	for (const context of contexts) {
-		choices.push({ title: context.name, value: context.name });
-	}
-	return choices;
+    const normalized = toPascalCase(rawName || 'ApiHttpDatasource');
+    return normalized.endsWith('Datasource') ? normalized : `${normalized}Datasource`;
 };
 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$/, ''));
-	} catch {
-		return [];
-	}
+    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$/, ''));
+    }
+    catch {
+        return [];
+    }
 };
 const hasResponseInterface = async (responseName) => {
-	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`);
-		return interfaceRegex.test(content);
-	} catch {
-		return false;
-	}
-};
-const resolveTargetPath = (target) => {
-	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');
+    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`);
+        return interfaceRegex.test(content);
+    }
+    catch {
+        return false;
+    }
 };
 export default async function createDatasource() {
-	const { datasourceNameRaw } = await prompts({
-		type: 'text',
-		name: 'datasourceNameRaw',
-		message: 'Datasource name:',
-		initial: 'MockApi'
-	});
-	const className = ensureDatasourceClassName(String(datasourceNameRaw ?? 'MockApi'));
-	const contextChoices = await getContextChoices();
-	const { target } = await prompts({
-		type: 'select',
-		name: 'target',
-		message: 'Where to create datasource?',
-		choices: contextChoices,
-		initial: 0
-	});
-	const selectedTarget = String(target ?? '__shared__');
-	const sharedResponses = await getSharedResponses();
-	let selectedResponse = null;
-	if (sharedResponses.length > 0) {
-		const { responseName } = await prompts({
-			type: 'select',
-			name: 'responseName',
-			message: 'Select response for datasource:',
-			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 { sharedAlias } = await getSharedState();
-		const responseImportPath = getFoundationConstructImportPath(sharedAlias, 'response');
-		const withInterface = await hasResponseInterface(selectedResponse);
-		content = withInterface
-			? createDatasourceTemplateWithResponseAndInterface(className, selectedResponse, responseImportPath)
-			: createDatasourceTemplateWithResponse(className, selectedResponse, responseImportPath);
-	}
-	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}`);
+    const { datasourceNameRaw } = await prompts({
+        type: 'text',
+        name: 'datasourceNameRaw',
+        message: 'Datasource name:',
+        initial: 'ApiHttpDatasource'
+    });
+    const className = ensureDatasourceClassName(String(datasourceNameRaw ?? 'ApiHttpDatasource'));
+    const sharedResponses = await getSharedResponses();
+    let selectedResponse = null;
+    if (sharedResponses.length > 0) {
+        const { responseName } = await prompts({
+            type: 'select',
+            name: 'responseName',
+            message: 'Select response for datasource:',
+            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 { sharedAlias } = await getSharedState();
+        const responseImportPath = getFoundationConstructImportPath(sharedAlias, 'response');
+        const withInterface = await hasResponseInterface(selectedResponse);
+        content = withInterface
+            ? createDatasourceTemplateWithResponseAndInterface(className, selectedResponse, responseImportPath)
+            : createDatasourceTemplateWithResponse(className, selectedResponse, responseImportPath);
+    }
+    const targetPath = getFoundationConstructPath((await getSharedState()).sharedContext.name, 'datasource');
+    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;
+    }
+    await registerDatasource(className);
+    console.log(`✅ Datasource created: ${filePath}`);
 }

package/src/scaffolds/createProgram.js

@@ -2,14 +2,14 @@ import path from 'node:path';
 import { writeIfNotExists } from '../utils/fileUtils.js';
 const createProgramTemplate = () => `import { createApp } from '@azure-net/kit';
 
-export const { register, Container } = createApp((app) => app);
+export const { register } = 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}`);
+    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

@@ -5,8 +5,8 @@ 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';
+    const interfaceName = `I${name}`;
+    return `import { ResponseBuilder } from '@azure-net/kit/infra';
 
 export interface ${interfaceName}<T> {
 \tdata: T;
@@ -24,33 +24,33 @@ const createResponseSimpleTemplate = (name) => `import { ResponseBuilder } from
 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`;
+    const normalized = toPascalCase(rawName || 'ApiResponse') || 'ApiResponse';
+    return normalized.endsWith('Response') ? normalized : `${normalized}Response`;
 };
 export default async function createResponse() {
-	const { responseNameRaw } = await prompts({
-		type: 'text',
-		name: 'responseNameRaw',
-		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 { 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}`);
+    const { responseNameRaw } = await prompts({
+        type: 'text',
+        name: 'responseNameRaw',
+        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 { 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/createSchemaRule.js

@@ -13,23 +13,23 @@ export const ${ruleName} = <T = unknown, D = unknown>(): ValidationRuleResult<T,
 };
 `;
 export default async function createSchemaRule() {
-	const { ruleNameRaw } = await prompts({
-		type: 'text',
-		name: 'ruleNameRaw',
-		message: 'Schema rule name:',
-		initial: 'File'
-	});
-	const pascalName = toPascalCase(String(ruleNameRaw ?? 'File')) || 'File';
-	const camelName = toCamelCase(pascalName) || 'file';
-	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}`);
+    const { ruleNameRaw } = await prompts({
+        type: 'text',
+        name: 'ruleNameRaw',
+        message: 'Schema rule name:',
+        initial: 'File'
+    });
+    const pascalName = toPascalCase(String(ruleNameRaw ?? 'File')) || 'File';
+    const camelName = toCamelCase(pascalName) || 'file';
+    const { sharedContext } = await getSharedState();
+    const rulesPath = path.join(getFoundationConstructPath(sharedContext.name, 'schema'), 'CustomRules');
+    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/createTranslationManager.js

@@ -1,19 +1,24 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import prompts from 'prompts';
+import ts from 'typescript';
+import { formatConfig } from '../utils/viteConfig.js';
+import { toPascalCase } from '../utils/contextUtils.js';
 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 parsed = String(rawLocales ?? '')
+        .split(',')
+        .map((item) => item.trim())
+        .filter((locale) => /^[A-Za-z]+(?:-[A-Za-z0-9]+)*$/.test(locale));
+    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';
+const createTranslationIndexTemplate = (defaultLocale) => `import { messages } from './Locales';
+import { createTranslations } from '@azure-net/kit/i18n';
+import type { Path } from '@azure-net/kit/i18n';
 
+// program.ts: createApp((app) => app.useTranslations(TranslationManager))
 export const TranslationManager = createTranslations({
 \tmessages,
 \tinitLang: '${defaultLocale}',
@@ -29,39 +34,81 @@ 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 lines = locales.map((locale) => `\t'${locale}': () => import('./${toPascalCase(locale)}').then((res) => res.default)`);
+    return `export const messages = {\n${lines.join(',\n')}\n};\n`;
 };
 const createLocaleTemplate = () => `export default {
 \ttest: 'test'
 };
 `;
+async function connectTranslations(translationRoot) {
+    const file = path.join(process.cwd(), 'src/program.ts');
+    let specifier = path.relative(path.dirname(file), translationRoot).split(path.sep).join('/');
+    if (!specifier.startsWith('.'))
+        specifier = `./${specifier}`;
+    let content;
+    try {
+        content = await fs.readFile(file, 'utf8');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        content = "import { createApp } from '@azure-net/kit';\nexport const { register } = createApp((app) => app);\n";
+    }
+    const source = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+    let body;
+    const visit = (node) => {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'createApp') {
+            const callback = node.arguments[0];
+            if (callback &&
+                ts.isArrowFunction(callback) &&
+                ts.isIdentifier(callback.body) &&
+                callback.parameters[0]?.name.getText(source) === callback.body.text)
+                body = callback.body;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    // Only modify the empty generated bootstrap, not application-specific pipelines/imports.
+    if (!body || /\bTranslationManager\b/.test(content)) {
+        console.log(`Connect translations in ${file}: app.useTranslations(TranslationManager), imported from '${specifier}'. Existing bootstrap preserved.`);
+        return;
+    }
+    content =
+        `import { TranslationManager } from '${specifier}';\n` +
+            content.slice(0, body.end) +
+            '.useTranslations(TranslationManager)' +
+            content.slice(body.end);
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await fs.writeFile(file, await formatConfig(content, file));
+}
 export default async function createTranslationManager() {
-	const { localesRaw } = await prompts({
-		type: 'text',
-		name: 'localesRaw',
-		message: 'Enter locales (comma separated):',
-		initial: 'en, ru'
-	});
-	const locales = parseLocales(String(localesRaw ?? 'en, ru'));
-	const { defaultLocale } = await prompts({
-		type: 'select',
-		name: 'defaultLocale',
-		message: 'Choose default locale:',
-		choices: locales.map((locale) => ({ title: locale, value: locale })),
-		initial: 0
-	});
-	const selectedDefaultLocale = String(defaultLocale ?? locales[0] ?? 'en');
-	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}`);
+    const { localesRaw } = await prompts({
+        type: 'text',
+        name: 'localesRaw',
+        message: 'Enter locales (comma separated):',
+        initial: 'en, ru'
+    });
+    const locales = parseLocales(String(localesRaw ?? 'en, ru'));
+    const { defaultLocale } = await prompts({
+        type: 'select',
+        name: 'defaultLocale',
+        message: 'Choose default locale:',
+        choices: locales.map((locale) => ({ title: locale, value: locale })),
+        initial: 0
+    });
+    const selectedDefaultLocale = String(defaultLocale ?? locales[0] ?? 'en');
+    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, toPascalCase(locale));
+        await fs.mkdir(localeDir, { recursive: true });
+        await writeIfNotExists(path.join(localeDir, 'index.ts'), createLocaleTemplate());
+    }
+    await connectTranslations(translationRoot);
+    console.log(`✅ Translation manager created: ${translationRoot}`);
 }

package/src/scaffolds/index.js

@@ -1,8 +1,6 @@
 export { default as createCoreSchema } from './createCoreSchema.js';
 export { default as createTranslationManager } from './createTranslationManager.js';
-export { default as createPresenterFactory } from './createPresenterFactory.js';
 export { default as createSchemaRule } from './createSchemaRule.js';
 export { default as createResponse } from './createResponse.js';
 export { default as createDatasource } from './createDatasource.js';
-export { default as createDatasourceProvider } from './createDatasourceProvider.js';
 export { default as createProgram } from './createProgram.js';

package/src/scaffolds/registerDatasource.js

@@ -0,0 +1,59 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import ts from 'typescript';
+import { formatConfig } from '../utils/viteConfig.js';
+import { getPlatformPath } from '../utils/architecture.js';
+/** Only initialize an empty generated DI; never replace application-specific registrations. */
+export async function registerDatasource(className) {
+    const file = path.join(getPlatformPath(), 'Foundation/DI/ApplicationProvider.ts');
+    let content;
+    try {
+        content = await fs.readFile(file, 'utf8');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        console.warn(`Register ${className} inside ApplicationProvider.register.`);
+        return;
+    }
+    const source = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+    let body;
+    const visit = (n) => {
+        if (ts.isPropertyAssignment(n) &&
+            ts.isIdentifier(n.name) &&
+            n.name.text === 'register' &&
+            ts.isArrowFunction(n.initializer) &&
+            !ts.isBlock(n.initializer.body)) {
+            let value = n.initializer.body;
+            while (ts.isParenthesizedExpression(value))
+                value = value.expression;
+            if (ts.isObjectLiteralExpression(value) && !value.properties.length)
+                body = n.initializer.body;
+        }
+    };
+    for (const statement of source.statements) {
+        if (!ts.isVariableStatement(statement))
+            continue;
+        for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name) ||
+                declaration.name.text !== 'ApplicationProvider' ||
+                !declaration.initializer ||
+                !ts.isCallExpression(declaration.initializer))
+                continue;
+            const options = declaration.initializer.arguments[1];
+            if (options && ts.isObjectLiteralExpression(options))
+                for (const property of options.properties)
+                    visit(property);
+        }
+    }
+    if (!body || content.includes(className)) {
+        console.warn(`Existing DI preserved. Add const datasource = new ${className}({}) inside ApplicationProvider.register and pass it to repositories.`);
+        return;
+    }
+    content =
+        content.slice(0, body.getStart(source)) +
+            `{\nconst datasource = new ${className}({});\n// Pass datasource to repositories and return UseCases factories below.\nreturn {};\n}` +
+            content.slice(body.end);
+    content = `import { ${className} } from '#platform/Foundation/Datasource';\n` + content;
+    await fs.writeFile(file, await formatConfig(content, file));
+}

package/src/scaffolds/updateDefaultFactoryConfig.js

@@ -0,0 +1,31 @@
+import ts from 'typescript';
+import { flattenConfigLiterals } from '../utils/flattenConfig.js';
+export function updateDefaultFactoryConfig(content, key, name) {
+    content = flattenConfigLiterals(content);
+    if (!content.trim())
+        return `export default {\n\t${key}: ${JSON.stringify(name)}\n};\n`;
+    const source = ts.createSourceFile('azure-net.config.ts', content, ts.ScriptTarget.Latest, true);
+    const exported = source.statements.find(ts.isExportAssignment);
+    if (!exported || exported.isExportEquals)
+        throw new Error('Cannot update factory default: expected a default-exported config.');
+    const expression = exported.expression;
+    if (ts.isObjectLiteralExpression(expression)) {
+        const lastSpread = expression.properties.reduce((last, item, index) => (ts.isSpreadAssignment(item) ? index : last), -1);
+        const property = [...expression.properties.slice(lastSpread + 1)]
+            .reverse()
+            .find((item) => ts.isPropertyAssignment(item) && (ts.isIdentifier(item.name) || ts.isStringLiteral(item.name)) && item.name.text === key);
+        if (property && ts.isPropertyAssignment(property)) {
+            if (ts.isStringLiteral(property.initializer) && property.initializer.text === name)
+                return content;
+            return content.slice(0, property.initializer.getStart(source)) + JSON.stringify(name) + content.slice(property.initializer.end);
+        }
+        const last = expression.properties.at(-1);
+        let result = content.slice(0, expression.end - 1) + `\n\t${key}: ${JSON.stringify(name)}\n` + content.slice(expression.end - 1);
+        if (last && !expression.properties.hasTrailingComma)
+            result = result.slice(0, last.end) + ',' + result.slice(last.end);
+        return result;
+    }
+    // Preserve custom config expressions without executing or reconstructing their contents.
+    const replacement = `{ ...(${expression.getText(source)}), ${key}: ${JSON.stringify(name)} }`;
+    return content.slice(0, expression.getStart(source)) + replacement + content.slice(expression.end);
+}