@azure-net/cli 4.1.0 → 4.1.1

package/bin/azure-net.js

@@ -5,7 +5,7 @@ import { addLint } from '../src/plugins/index.js';
 
 const program = new Command();
 
-program.name('azure-net').description('Azure-Net CLI generator').version('2.1.0');
+program.name('azure-net').description('Azure-Net CLI generator').version('4.1.0');
 
 const addCommand = program.command('add').description('Add project integrations and plugins');
 const createCommand = program.command('create').description('Create project boilerplate artifacts');
@@ -257,6 +257,14 @@ checkCommand
 		await handler();
 	});
 
+checkCommand
+	.command('imports')
+	.description('Check import extensions and import group order in src')
+	.action(async () => {
+		const handler = (await import('../src/checks/checkImports.js')).default;
+		await handler();
+	});
+
 checkCommand
 	.command('layer-boundaries')
 	.description('Check layer boundaries between contexts by aliases')

package/bin/azure-net.ts

@@ -5,7 +5,7 @@ import { addLint } from '../src/plugins/index.js';
 
 const program = new Command();
 
-program.name('azure-net').description('Azure-Net CLI generator').version('4.0.0');
+program.name('azure-net').description('Azure-Net CLI generator').version('4.1.0');
 
 const addCommand = program.command('add').description('Add project integrations and plugins');
 const createCommand = program.command('create').description('Create project boilerplate artifacts');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/cli",
-  "version": "4.1.0",
+  "version": "4.1.1",
   "type": "module",
   "bin": {
     "azure-net": "bin/azure-net.js"

package/src/checks/checkImports.js

@@ -0,0 +1,147 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+const TARGET_EXTENSIONS = new Set(['.ts', '.js', '.svelte']);
+const IGNORED_DIRS = new Set(['node_modules', 'dist', '.svelte-kit', '.git']);
+const IMPORT_DECLARATION_PATTERN = /(^|\n)\s*import\s+(?:[\s\S]*?\s+from\s*)?['"]([^'"]+)['"]\s*;?/g;
+const EXPORT_DECLARATION_PATTERN = /(^|\n)\s*export\s+(?:type\s+)?(?:[\s\S]*?\s+from\s*)['"]([^'"]+)['"]\s*;?/g;
+const FORBIDDEN_IMPORT_EXTENSION_PATTERN = /\.(?:ts|js)(?:$|[?#])/;
+const toPosixPath = (value) => value.split(path.sep).join('/');
+const getRelativePath = (filePath) => toPosixPath(path.relative(process.cwd(), filePath));
+const findLineByIndex = (content, index) => {
+	let line = 1;
+	for (let i = 0; i < index; i += 1) {
+		if (content[i] === '\n') line += 1;
+	}
+	return line;
+};
+const listFiles = async (rootDir) => {
+	const files = [];
+	const stack = [rootDir];
+	while (stack.length) {
+		const current = stack.pop();
+		if (!current) continue;
+		let entries = [];
+		try {
+			entries = await fs.readdir(current, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (entry.isDirectory()) {
+				if (!IGNORED_DIRS.has(entry.name)) {
+					stack.push(path.join(current, entry.name));
+				}
+				continue;
+			}
+			if (!entry.isFile()) continue;
+			const filePath = path.join(current, entry.name);
+			if (!TARGET_EXTENSIONS.has(path.extname(filePath))) continue;
+			files.push(filePath);
+		}
+	}
+	return files;
+};
+const getImportKind = (raw) => {
+	const normalized = raw.trim();
+	if (/^import\s+type\b/.test(normalized)) return 'type';
+	if (/^import\s*['"]/.test(normalized)) return 'side-effect';
+	return 'value';
+};
+const getKindOrder = (kind) => {
+	if (kind === 'value') return 0;
+	if (kind === 'type') return 1;
+	return 2;
+};
+const extractImports = (content) => {
+	const imports = [];
+	const regex = new RegExp(IMPORT_DECLARATION_PATTERN.source, 'g');
+	let match;
+	while ((match = regex.exec(content)) !== null) {
+		const raw = match[0].trim();
+		const source = match[2];
+		if (!source) continue;
+		imports.push({
+			kind: getImportKind(raw),
+			line: findLineByIndex(content, match.index + (match[1] === '\n' ? 1 : 0)),
+			source,
+			raw
+		});
+	}
+	return imports.sort((a, b) => a.line - b.line);
+};
+const extractExportSources = (content) => {
+	const exports = [];
+	const regex = new RegExp(EXPORT_DECLARATION_PATTERN.source, 'g');
+	let match;
+	while ((match = regex.exec(content)) !== null) {
+		const source = match[2];
+		if (!source) continue;
+		exports.push({
+			source,
+			line: findLineByIndex(content, match.index + (match[1] === '\n' ? 1 : 0))
+		});
+	}
+	return exports;
+};
+const hasForbiddenExtension = (source) => {
+	const sourceWithoutQuery = source.split('?')[0] ?? source;
+	return FORBIDDEN_IMPORT_EXTENSION_PATTERN.test(sourceWithoutQuery);
+};
+const collectIssuesForFile = (filePath, content) => {
+	const issues = [];
+	const imports = extractImports(content);
+	let lastKindOrder = 0;
+	for (const importEntry of imports) {
+		if (hasForbiddenExtension(importEntry.source)) {
+			issues.push({
+				file: filePath,
+				line: importEntry.line,
+				message: `Import "${importEntry.source}" must not include .ts/.js extension`
+			});
+		}
+		const currentOrder = getKindOrder(importEntry.kind);
+		if (currentOrder < lastKindOrder) {
+			issues.push({
+				file: filePath,
+				line: importEntry.line,
+				message: 'Import order violation: value imports first, then type imports, then side-effect imports'
+			});
+		}
+		lastKindOrder = Math.max(lastKindOrder, currentOrder);
+	}
+	for (const exportEntry of extractExportSources(content)) {
+		if (!hasForbiddenExtension(exportEntry.source)) continue;
+		issues.push({
+			file: filePath,
+			line: exportEntry.line,
+			message: `Export source "${exportEntry.source}" must not include .ts/.js extension`
+		});
+	}
+	return issues;
+};
+export default async function checkImports() {
+	const srcRoot = path.join(process.cwd(), 'src');
+	try {
+		await fs.access(srcRoot);
+	} catch {
+		console.error('❌ src folder not found.');
+		process.exitCode = 1;
+		return;
+	}
+	const issues = [];
+	const files = await listFiles(srcRoot);
+	for (const filePath of files) {
+		const content = await fs.readFile(filePath, 'utf-8');
+		issues.push(...collectIssuesForFile(filePath, content));
+	}
+	if (!issues.length) {
+		console.log('✅ Imports check passed: extensions and import groups are valid.');
+		return;
+	}
+	console.error('❌ Imports check failed:');
+	for (const issue of issues) {
+		console.error(`• ${getRelativePath(issue.file)}:${issue.line} — ${issue.message}`);
+	}
+	process.exitCode = 1;
+}
+//# sourceMappingURL=checkImports.js.map

package/src/checks/checkImports.ts

@@ -19,7 +19,8 @@ type ImportEntry = {
 const TARGET_EXTENSIONS = new Set(['.ts', '.js', '.svelte']);
 const IGNORED_DIRS = new Set(['node_modules', 'dist', '.svelte-kit', '.git']);
 const IMPORT_DECLARATION_PATTERN = /(^|\n)\s*import\s+(?:[\s\S]*?\s+from\s*)?['"]([^'"]+)['"]\s*;?/g;
-const FORBIDDEN_IMPORT_EXTENSION_PATTERN = /\.(?:ts|js)$/;
+const EXPORT_DECLARATION_PATTERN = /(^|\n)\s*export\s+(?:type\s+)?(?:[\s\S]*?\s+from\s*)['"]([^'"]+)['"]\s*;?/g;
+const FORBIDDEN_IMPORT_EXTENSION_PATTERN = /\.(?:ts|js)(?:$|[?#])/;
 
 const toPosixPath = (value: string): string => value.split(path.sep).join('/');
 
@@ -100,6 +101,23 @@ const extractImports = (content: string): ImportEntry[] => {
 	return imports.sort((a, b) => a.line - b.line);
 };
 
+const extractExportSources = (content: string): Array<{ source: string; line: number }> => {
+	const exports: Array<{ source: string; line: number }> = [];
+	const regex = new RegExp(EXPORT_DECLARATION_PATTERN.source, 'g');
+	let match: RegExpExecArray | null;
+
+	while ((match = regex.exec(content)) !== null) {
+		const source = match[2];
+		if (!source) continue;
+		exports.push({
+			source,
+			line: findLineByIndex(content, match.index + (match[1] === '\n' ? 1 : 0))
+		});
+	}
+
+	return exports;
+};
+
 const hasForbiddenExtension = (source: string): boolean => {
 	const sourceWithoutQuery = source.split('?')[0] ?? source;
 	return FORBIDDEN_IMPORT_EXTENSION_PATTERN.test(sourceWithoutQuery);
@@ -130,6 +148,15 @@ const collectIssuesForFile = (filePath: string, content: string): ImportIssue[]
 		lastKindOrder = Math.max(lastKindOrder, currentOrder);
 	}
 
+	for (const exportEntry of extractExportSources(content)) {
+		if (!hasForbiddenExtension(exportEntry.source)) continue;
+		issues.push({
+			file: filePath,
+			line: exportEntry.line,
+			message: `Export source "${exportEntry.source}" must not include .ts/.js extension`
+		});
+	}
+
 	return issues;
 };
 

package/src/checks/checkInternal.js

@@ -4,26 +4,24 @@ import checkProviderGraph from './checkProviderGraph.js';
 import checkDomain from './checkDomain.js';
 import checkLayerBoundaries from './checkLayerBoundaries.js';
 import checkFoldersStructure from './checkFoldersStructure.js';
-
+import checkImports from './checkImports.js';
 const tasks = [
 	{ name: 'presenter-names', run: checkPresenterNames },
 	{ name: 'provider-names', run: checkProviderNames },
 	{ name: 'provider-graph', run: checkProviderGraph },
 	{ name: 'domain', run: checkDomain },
+	{ name: 'imports', run: checkImports },
 	{ name: 'layer-boundaries', run: checkLayerBoundaries },
 	{ name: 'folders-structure', run: checkFoldersStructure }
 ];
-
 const runTask = async (task) => {
 	console.log(`\n▶ Running check ${task.name}...`);
 	process.exitCode = 0;
 	await task.run();
-
 	if ((process.exitCode ?? 0) !== 0) {
 		throw new Error(`Check "${task.name}" failed`);
 	}
 };
-
 export default async function checkInternal() {
 	try {
 		for (const task of tasks) {
@@ -35,3 +33,4 @@ export default async function checkInternal() {
 		process.exitCode = 1;
 	}
 }
+//# sourceMappingURL=checkInternal.js.map

package/src/checks/checkLayerBoundaries.js

@@ -2,22 +2,17 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { loadUserConfig } from '../utils/loadConfig.js';
 import { normalizeContexts } from '../init/initAliases.js';
-
 const TARGET_EXTENSIONS = new Set(['.ts', '.js', '.svelte']);
 const IGNORED_DIRS = new Set(['node_modules', 'dist', '.svelte-kit', '.git']);
-
 const IMPORT_FROM_PATTERN = /\bimport\s+(?:type\s+)?[\s\S]*?\sfrom\s*['"]([^'"]+)['"]/g;
 const EXPORT_FROM_PATTERN = /\bexport\s+(?:type\s+)?\{[\s\S]*?\}\sfrom\s*['"]([^'"]+)['"]/g;
 const DYNAMIC_IMPORT_PATTERN = /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-
 const toPosixPath = (value) => value.split(path.sep).join('/');
-
 const normalizeAlias = (value, fallback = '') => {
 	const raw = String(value ?? '').trim();
 	if (!raw.length) return fallback;
 	return raw.startsWith('$') ? raw : `$${raw}`;
 };
-
 const findLineByIndex = (content, index) => {
 	let line = 1;
 	for (let i = 0; i < index; i += 1) {
@@ -25,24 +20,19 @@ const findLineByIndex = (content, index) => {
 	}
 	return line;
 };
-
 const getRelativePath = (filePath) => toPosixPath(path.relative(process.cwd(), filePath));
-
 const listFiles = async (rootDir) => {
 	const files = [];
 	const stack = [rootDir];
-
 	while (stack.length) {
 		const current = stack.pop();
 		if (!current) continue;
-
 		let entries = [];
 		try {
 			entries = await fs.readdir(current, { withFileTypes: true });
 		} catch {
 			continue;
 		}
-
 		for (const entry of entries) {
 			if (entry.isDirectory()) {
 				if (!IGNORED_DIRS.has(entry.name)) {
@@ -50,21 +40,17 @@ const listFiles = async (rootDir) => {
 				}
 				continue;
 			}
-
 			if (!entry.isFile()) continue;
 			const filePath = path.join(current, entry.name);
 			if (!TARGET_EXTENSIONS.has(path.extname(filePath))) continue;
 			files.push(filePath);
 		}
 	}
-
 	return files;
 };
-
 const extractImports = (content) => {
 	const matches = [];
 	const patterns = [IMPORT_FROM_PATTERN, EXPORT_FROM_PATTERN, DYNAMIC_IMPORT_PATTERN];
-
 	for (const pattern of patterns) {
 		const regex = new RegExp(pattern.source, 'g');
 		let match;
@@ -74,10 +60,8 @@ const extractImports = (content) => {
 			matches.push({ value, line: findLineByIndex(content, match.index) });
 		}
 	}
-
 	return matches;
 };
-
 const resolveAliasFromImport = (importPath, aliases) => {
 	const sorted = [...aliases].sort((a, b) => b.length - a.length);
 	for (const alias of sorted) {
@@ -87,74 +71,117 @@ const resolveAliasFromImport = (importPath, aliases) => {
 	}
 	return null;
 };
-
+const resolveContextFromRelativeImport = (filePath, importPath, contexts) => {
+	if (!importPath.startsWith('.')) return null;
+	const absoluteImportPath = path.resolve(path.dirname(filePath), importPath);
+	const appRoot = path.join(process.cwd(), 'src', 'app');
+	for (const context of contexts) {
+		const contextRoot = path.join(appRoot, context.name);
+		if (absoluteImportPath === contextRoot || absoluteImportPath.startsWith(`${contextRoot}${path.sep}`)) {
+			return context;
+		}
+	}
+	return null;
+};
 const isSharedLikeContext = (contextName, alias) => {
 	const normalizedName = contextName.toLowerCase();
 	const normalizedAlias = alias.toLowerCase();
 	return normalizedName.includes('shared') || normalizedAlias.includes('shared');
 };
-
 export default async function checkLayerBoundaries() {
 	const config = await loadUserConfig();
 	const contexts = normalizeContexts(config.contexts);
-
 	if (!contexts.length) {
 		console.error('❌ No contexts found in azure-net.config.ts/js. Fill `contexts` first.');
 		process.exitCode = 1;
 		return;
 	}
-
 	const coreAlias = normalizeAlias(config.coreAlias, '$core');
 	const sharedAliasRaw = normalizeAlias(config.sharedAlias, '');
 	const sharedAlias = sharedAliasRaw.length ? sharedAliasRaw : null;
-
 	const aliasToContext = new Map();
 	for (const context of contexts) {
 		aliasToContext.set(context.alias, context);
 	}
-
 	const knownAliases = [coreAlias, ...contexts.map((context) => context.alias)];
 	if (sharedAlias && !knownAliases.includes(sharedAlias)) {
 		knownAliases.push(sharedAlias);
 	}
-
 	const issues = [];
-
+	const coreRoot = path.join(process.cwd(), 'src', 'core');
+	try {
+		await fs.access(coreRoot);
+		const coreFiles = await listFiles(coreRoot);
+		for (const filePath of coreFiles) {
+			const content = await fs.readFile(filePath, 'utf-8');
+			const imports = extractImports(content);
+			for (const entry of imports) {
+				const targetAlias = resolveAliasFromImport(entry.value, knownAliases);
+				if (targetAlias && targetAlias !== coreAlias) {
+					const targetContext = aliasToContext.get(targetAlias);
+					issues.push({
+						file: filePath,
+						line: entry.line,
+						message: targetContext
+							? `Layer boundary violation: core cannot import from context "${targetContext.name}" (${targetAlias})`
+							: `Layer boundary violation: core cannot import from "${targetAlias}"`
+					});
+					continue;
+				}
+				const relativeTargetContext = resolveContextFromRelativeImport(filePath, entry.value, contexts);
+				if (!relativeTargetContext) continue;
+				issues.push({
+					file: filePath,
+					line: entry.line,
+					message: `Layer boundary violation: core cannot import from context "${relativeTargetContext.name}" via relative path`
+				});
+			}
+		}
+	} catch {
+		// Core folder is optional for the check.
+	}
 	for (const context of contexts) {
-		const layersRoot = path.join(process.cwd(), 'src', 'app', context.name, 'layers');
-
+		const contextRoot = path.join(process.cwd(), 'src', 'app', context.name);
 		try {
-			await fs.access(layersRoot);
+			await fs.access(contextRoot);
 		} catch {
 			continue;
 		}
-
-		const files = await listFiles(layersRoot);
+		const files = await listFiles(contextRoot);
 		const allowedAliases = new Set([context.alias, coreAlias]);
-		if (sharedAlias) {
+		if (sharedAlias && context.alias !== sharedAlias) {
 			allowedAliases.add(sharedAlias);
 		}
-
 		for (const filePath of files) {
 			const content = await fs.readFile(filePath, 'utf-8');
 			const imports = extractImports(content);
-
 			for (const entry of imports) {
 				const targetAlias = resolveAliasFromImport(entry.value, knownAliases);
 				if (!targetAlias) continue;
 				if (targetAlias === coreAlias) continue;
 				if (allowedAliases.has(targetAlias)) continue;
-
 				const targetContext = aliasToContext.get(targetAlias);
 				const baseMessage = targetContext
 					? `Layer boundary violation: context "${context.name}" cannot import from context "${targetContext.name}" (${targetAlias})`
 					: `Layer boundary violation: context "${context.name}" cannot import from "${targetAlias}"`;
-
 				const withSharedHint =
 					!sharedAlias && targetContext && isSharedLikeContext(targetContext.name, targetAlias)
 						? `${baseMessage}. sharedAlias is not configured in azure-net.config.ts/js; if this context is shared, set sharedAlias explicitly`
 						: baseMessage;
-
+				issues.push({
+					file: filePath,
+					line: entry.line,
+					message: withSharedHint
+				});
+			}
+			for (const entry of imports) {
+				const relativeTargetContext = resolveContextFromRelativeImport(filePath, entry.value, contexts);
+				if (!relativeTargetContext || relativeTargetContext.name === context.name) continue;
+				const baseMessage = `Layer boundary violation: context "${context.name}" cannot import from context "${relativeTargetContext.name}" via relative path`;
+				const withSharedHint =
+					!sharedAlias && isSharedLikeContext(relativeTargetContext.name, relativeTargetContext.alias)
+						? `${baseMessage}. sharedAlias is not configured in azure-net.config.ts/js; if this context is shared, set sharedAlias explicitly`
+						: baseMessage;
 				issues.push({
 					file: filePath,
 					line: entry.line,
@@ -163,16 +190,14 @@ export default async function checkLayerBoundaries() {
 			}
 		}
 	}
-
 	if (!issues.length) {
 		console.log('✅ Layer boundaries check passed.');
 		return;
 	}
-
 	console.error('❌ Layer boundaries check failed:');
 	for (const issue of issues) {
 		console.error(`• ${getRelativePath(issue.file)}:${issue.line} — ${issue.message}`);
 	}
-
 	process.exitCode = 1;
 }
+//# sourceMappingURL=checkLayerBoundaries.js.map

package/src/checks/checkLayerBoundaries.ts

@@ -99,6 +99,22 @@ const resolveAliasFromImport = (importPath: string, aliases: string[]): string |
 	return null;
 };
 
+const resolveContextFromRelativeImport = (filePath: string, importPath: string, contexts: ContextConfig[]): ContextConfig | null => {
+	if (!importPath.startsWith('.')) return null;
+
+	const absoluteImportPath = path.resolve(path.dirname(filePath), importPath);
+	const appRoot = path.join(process.cwd(), 'src', 'app');
+
+	for (const context of contexts) {
+		const contextRoot = path.join(appRoot, context.name);
+		if (absoluteImportPath === contextRoot || absoluteImportPath.startsWith(`${contextRoot}${path.sep}`)) {
+			return context;
+		}
+	}
+
+	return null;
+};
+
 const isSharedLikeContext = (contextName: string, alias: string): boolean => {
 	const normalizedName = contextName.toLowerCase();
 	const normalizedAlias = alias.toLowerCase();
@@ -141,16 +157,25 @@ export default async function checkLayerBoundaries(): Promise<void> {
 
 			for (const entry of imports) {
 				const targetAlias = resolveAliasFromImport(entry.value, knownAliases);
-				if (!targetAlias || targetAlias === coreAlias) continue;
-				if (!aliasToContext.has(targetAlias)) continue;
+				if (targetAlias && targetAlias !== coreAlias) {
+					const targetContext = aliasToContext.get(targetAlias);
+					issues.push({
+						file: filePath,
+						line: entry.line,
+						message: targetContext
+							? `Layer boundary violation: core cannot import from context "${targetContext.name}" (${targetAlias})`
+							: `Layer boundary violation: core cannot import from "${targetAlias}"`
+					});
+					continue;
+				}
+
+				const relativeTargetContext = resolveContextFromRelativeImport(filePath, entry.value, contexts);
+				if (!relativeTargetContext) continue;
 
-				const targetContext = aliasToContext.get(targetAlias);
 				issues.push({
 					file: filePath,
 					line: entry.line,
-					message: targetContext
-						? `Layer boundary violation: core cannot import from context "${targetContext.name}" (${targetAlias})`
-						: `Layer boundary violation: core cannot import from "${targetAlias}"`
+					message: `Layer boundary violation: core cannot import from context "${relativeTargetContext.name}" via relative path`
 				});
 			}
 		}
@@ -199,6 +224,23 @@ export default async function checkLayerBoundaries(): Promise<void> {
 					message: withSharedHint
 				});
 			}
+
+			for (const entry of imports) {
+				const relativeTargetContext = resolveContextFromRelativeImport(filePath, entry.value, contexts);
+				if (!relativeTargetContext || relativeTargetContext.name === context.name) continue;
+
+				const baseMessage = `Layer boundary violation: context "${context.name}" cannot import from context "${relativeTargetContext.name}" via relative path`;
+				const withSharedHint =
+					!sharedAlias && isSharedLikeContext(relativeTargetContext.name, relativeTargetContext.alias)
+						? `${baseMessage}. sharedAlias is not configured in azure-net.config.ts/js; if this context is shared, set sharedAlias explicitly`
+						: baseMessage;
+
+				issues.push({
+					file: filePath,
+					line: entry.line,
+					message: withSharedHint
+				});
+			}
 		}
 	}
 

package/src/checks/index.js

@@ -2,7 +2,9 @@ export { default as checkPresenterNames } from './checkPresenterNames.js';
 export { default as checkProviderNames } from './checkProviderNames.js';
 export { default as checkProviderGraph } from './checkProviderGraph.js';
 export { default as checkDomain } from './checkDomain.js';
+export { default as checkImports } from './checkImports.js';
 export { default as checkLayerBoundaries } from './checkLayerBoundaries.js';
 export { default as checkFoldersStructure } from './checkFoldersStructure.js';
 export { default as checkInternal } from './checkInternal.js';
 export { default as checkProject } from './checkProject.js';
+//# sourceMappingURL=index.js.map