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

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)}`);
 }

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}`);
 }