@azure-net/cli 2.3.63 → 4.0.0-1

package/src/utils/contextUtils.ts

@@ -0,0 +1,89 @@
+import fs from 'fs/promises';
+import path from 'path';
+import prompts from 'prompts';
+import { loadUserConfig } from './loadConfig.js';
+
+const APP_PATH = path.join(process.cwd(), 'src/app');
+const CORE_PATH = path.join(process.cwd(), 'src/core');
+
+function normalizeContextNames(rawContexts: unknown): string[] {
+	if (!Array.isArray(rawContexts)) return [];
+
+	return rawContexts
+		.map((item) => {
+			if (typeof item === 'string') {
+				return item.trim();
+			}
+			if (!item || typeof item !== 'object') return '';
+			return String(item.name ?? '').trim();
+		})
+		.filter(Boolean);
+}
+
+export async function selectContext(message = 'Select context:'): Promise<string | null> {
+	const config = await loadUserConfig();
+	const contexts = normalizeContextNames(config.contexts);
+
+	const { context } = await prompts({
+		type: 'select',
+		name: 'context',
+		message,
+		choices: [...contexts.map((c) => ({ title: c, value: c })), { title: 'core', value: 'core' }]
+	});
+
+	return context ? String(context) : null;
+}
+
+export function getContextPath(context: string): string {
+	return context === 'core' ? CORE_PATH : path.join(APP_PATH, context, 'layers');
+}
+
+export async function getAvailableFiles(dir: string, pattern = '.ts'): Promise<string[]> {
+	try {
+		const files = await fs.readdir(dir);
+		return files.filter((f) => f.endsWith(pattern) && f !== 'index.ts').map((f) => f.replace(pattern, ''));
+	} catch {
+		return [];
+	}
+}
+
+export async function getApplicationProviderServices(context: string): Promise<string[]> {
+	const contextPath = getContextPath(context);
+	const providerPath = path.join(contextPath, 'application/providers/ApplicationProvider.ts');
+
+	try {
+		const content = await fs.readFile(providerPath, 'utf-8');
+		// Extract service names from ApplicationProvider
+		const serviceRegex = /(\w+Service):\s*\(/g;
+		const services: string[] = [];
+		let match;
+
+		while ((match = serviceRegex.exec(content)) !== null) {
+			const serviceName = match[1];
+			if (serviceName) services.push(serviceName);
+		}
+
+		return services;
+	} catch {
+		return [];
+	}
+}
+
+export function toPascalCase(str: string): string {
+	return str
+		.split(/[-_\s]+/)
+		.map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+		.join('');
+}
+
+export function toCamelCase(str: string): string {
+	const pascal = toPascalCase(str);
+	return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+export function toKebabCase(str: string): string {
+	return str
+		.replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+		.replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+		.toLowerCase();
+}

package/src/utils/fileUtils.js

@@ -2,106 +2,94 @@ import fs from 'fs/promises';
 import path from 'path';
 
 export async function writeIfNotExists(filepath, content) {
-    try {
-        await fs.access(filepath);
-        console.log(`⚠️  Skip existing: ${filepath}`);
-        return false;
-    } catch {
-        await fs.mkdir(path.dirname(filepath), { recursive: true });
-        await fs.writeFile(filepath, content, 'utf-8');
-        console.log(`✅ Created: ${filepath}`);
-        return true;
-    }
+	try {
+		await fs.access(filepath);
+		console.log(`⚠️  Skip existing: ${filepath}`);
+		return false;
+	} catch {
+		await fs.mkdir(path.dirname(filepath), { recursive: true });
+		await fs.writeFile(filepath, content, 'utf-8');
+		console.log(`✅ Created: ${filepath}`);
+		return true;
+	}
 }
 
 export async function updateIndexTs(dir, filePattern = '.ts', ignore = ['index.ts']) {
-    try {
-        const files = (await fs.readdir(dir)).filter(f =>
-            f.endsWith(filePattern) && !ignore.includes(f)
-        );
-        const content = files
-            .map(f => `export * from './${f.replace('.ts', '')}';`)
-            .join('\n') + '\n';
-        await fs.writeFile(path.join(dir, 'index.ts'), content, 'utf-8');
-    } catch (error) {
-        // Directory doesn't exist yet
-    }
+	try {
+		const files = (await fs.readdir(dir)).filter((f) => f.endsWith(filePattern) && !ignore.includes(f));
+		const content = files.map((f) => `export * from './${f.replace('.ts', '')}';`).join('\n') + '\n';
+		await fs.writeFile(path.join(dir, 'index.ts'), content, 'utf-8');
+	} catch (error) {
+		// Directory doesn't exist yet
+	}
 }
 
 export async function updateCoreIndex() {
-    const corePath = path.join(process.cwd(), 'src/core');
-    try {
-        const dirs = await fs.readdir(corePath, { withFileTypes: true });
-        const validDirs = [];
+	const corePath = path.join(process.cwd(), 'src/core');
+	try {
+		const dirs = await fs.readdir(corePath, { withFileTypes: true });
+		const validDirs = [];
 
-        for (const dir of dirs) {
-            if (dir.isDirectory()) {
-                // Check if directory has any files
-                const dirPath = path.join(corePath, dir.name);
-                const files = await fs.readdir(dirPath);
-                if (files.length > 0) {
-                    validDirs.push(dir.name);
-                }
-            }
-        }
+		for (const dir of dirs) {
+			if (dir.isDirectory()) {
+				// Check if directory has any files
+				const dirPath = path.join(corePath, dir.name);
+				const files = await fs.readdir(dirPath);
+				if (files.length > 0) {
+					validDirs.push(dir.name);
+				}
+			}
+		}
 
-        if (validDirs.length > 0) {
-            const content = validDirs
-                .map(d => `export * from './${d}';`)
-                .join('\n') + '\n';
-            await fs.writeFile(path.join(corePath, 'index.ts'), content, 'utf-8');
-        }
-    } catch (error) {
-        // Core directory doesn't exist
-    }
+		if (validDirs.length > 0) {
+			const content = validDirs.map((d) => `export * from './${d}';`).join('\n') + '\n';
+			await fs.writeFile(path.join(corePath, 'index.ts'), content, 'utf-8');
+		}
+	} catch (error) {
+		// Core directory doesn't exist
+	}
 }
 
 export async function ensureIndexExports(layerPath) {
-    try {
-        const subdirs = await fs.readdir(layerPath, { withFileTypes: true });
-        const exportLines = subdirs
-            .filter(d => d.isDirectory())
-            .map(d => `export * from './${d.name}';`);
+	try {
+		const subdirs = await fs.readdir(layerPath, { withFileTypes: true });
+		const exportLines = subdirs.filter((d) => d.isDirectory()).map((d) => `export * from './${d.name}';`);
 
-        if (exportLines.length > 0) {
-            await fs.writeFile(
-                path.join(layerPath, 'index.ts'),
-                exportLines.join('\n') + '\n',
-                'utf-8'
-            );
-        }
-    } catch (error) {
-        // Directory doesn't exist
-    }
+		if (exportLines.length > 0) {
+			await fs.writeFile(path.join(layerPath, 'index.ts'), exportLines.join('\n') + '\n', 'utf-8');
+		}
+	} catch (error) {
+		// Directory doesn't exist
+	}
 }
 
 export async function injectIntoFile(filepath, searchPattern, newContent, position = 'after') {
-    try {
-        let content = await fs.readFile(filepath, 'utf-8');
-        const index = content.indexOf(searchPattern);
+	try {
+		let content = await fs.readFile(filepath, 'utf-8');
+		const index = content.indexOf(searchPattern);
 
-        if (index === -1) {
-            console.warn(`Pattern not found in ${filepath}`);
-            return false;
-        }
+		if (index === -1) {
+			console.warn(`Pattern not found in ${filepath}`);
+			return false;
+		}
 
-        if (content.includes(newContent.trim())) {
-            console.log(`Content already exists in ${filepath}`);
-            return false;
-        }
+		if (content.includes(newContent.trim())) {
+			console.log(`Content already exists in ${filepath}`);
+			return false;
+		}
 
-        if (position === 'after') {
-            const insertIndex = index + searchPattern.length;
-            content = content.slice(0, insertIndex) + '\n' + newContent + content.slice(insertIndex);
-        } else {
-            content = content.slice(0, index) + newContent + '\n' + content.slice(index);
-        }
+		if (position === 'after') {
+			const insertIndex = index + searchPattern.length;
+			content = content.slice(0, insertIndex) + '\n' + newContent + content.slice(insertIndex);
+		} else {
+			content = content.slice(0, index) + newContent + '\n' + content.slice(index);
+		}
 
-        await fs.writeFile(filepath, content, 'utf-8');
-        console.log(`✅ Updated: ${filepath}`);
-        return true;
-    } catch (error) {
-        console.error(`Failed to update ${filepath}:`, error.message);
-        return false;
-    }
-}
+		await fs.writeFile(filepath, content, 'utf-8');
+		console.log(`✅ Updated: ${filepath}`);
+		return true;
+	} catch (error) {
+		console.error(`Failed to update ${filepath}:`, error.message);
+		return false;
+	}
+}

package/src/utils/fileUtils.ts

@@ -0,0 +1,100 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+export async function writeIfNotExists(filepath: string, content: string): Promise<boolean> {
+	try {
+		await fs.access(filepath);
+		console.log(`⚠️  Skip existing: ${filepath}`);
+		return false;
+	} catch {
+		await fs.mkdir(path.dirname(filepath), { recursive: true });
+		await fs.writeFile(filepath, content, 'utf-8');
+		console.log(`✅ Created: ${filepath}`);
+		return true;
+	}
+}
+
+export async function updateIndexTs(dir: string, filePattern = '.ts', ignore: string[] = ['index.ts']): Promise<void> {
+	try {
+		const files = (await fs.readdir(dir)).filter((f) => f.endsWith(filePattern) && !ignore.includes(f));
+		const content = files.map((f) => `export * from './${f.replace('.ts', '')}';`).join('\n') + '\n';
+		await fs.writeFile(path.join(dir, 'index.ts'), content, 'utf-8');
+	} catch {
+		// Directory doesn't exist yet
+	}
+}
+
+export async function updateCoreIndex(): Promise<void> {
+	const corePath = path.join(process.cwd(), 'src/core');
+	try {
+		const dirs = await fs.readdir(corePath, { withFileTypes: true });
+		const validDirs: string[] = [];
+
+		for (const dir of dirs) {
+			if (dir.isDirectory()) {
+				// Check if directory has any files
+				const dirPath = path.join(corePath, dir.name);
+				const files = await fs.readdir(dirPath);
+				if (files.length > 0) {
+					validDirs.push(dir.name);
+				}
+			}
+		}
+
+		if (validDirs.length > 0) {
+			const content = validDirs.map((d) => `export * from './${d}';`).join('\n') + '\n';
+			await fs.writeFile(path.join(corePath, 'index.ts'), content, 'utf-8');
+		}
+	} catch {
+		// Core directory doesn't exist
+	}
+}
+
+export async function ensureIndexExports(layerPath: string): Promise<void> {
+	try {
+		const subdirs = await fs.readdir(layerPath, { withFileTypes: true });
+		const exportLines = subdirs.filter((d) => d.isDirectory()).map((d) => `export * from './${d.name}';`);
+
+		if (exportLines.length > 0) {
+			await fs.writeFile(path.join(layerPath, 'index.ts'), exportLines.join('\n') + '\n', 'utf-8');
+		}
+	} catch {
+		// Directory doesn't exist
+	}
+}
+
+export async function injectIntoFile(
+	filepath: string,
+	searchPattern: string,
+	newContent: string,
+	position: 'after' | 'before' = 'after'
+): Promise<boolean> {
+	try {
+		let content = await fs.readFile(filepath, 'utf-8');
+		const index = content.indexOf(searchPattern);
+
+		if (index === -1) {
+			console.warn(`Pattern not found in ${filepath}`);
+			return false;
+		}
+
+		if (content.includes(newContent.trim())) {
+			console.log(`Content already exists in ${filepath}`);
+			return false;
+		}
+
+		if (position === 'after') {
+			const insertIndex = index + searchPattern.length;
+			content = content.slice(0, insertIndex) + '\n' + newContent + content.slice(insertIndex);
+		} else {
+			content = content.slice(0, index) + newContent + '\n' + content.slice(index);
+		}
+
+		await fs.writeFile(filepath, content, 'utf-8');
+		console.log(`✅ Updated: ${filepath}`);
+		return true;
+	} catch (error: unknown) {
+		console.error(`Failed to update ${filepath}:`, error instanceof Error ? error.message : String(error));
+		return false;
+	}
+}

package/src/utils/loadConfig.js

@@ -1,15 +1,59 @@
-import path from 'path';
-import { pathToFileURL } from 'url';
+import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
+import path from 'node:path';
+
+const DEFAULT_CONFIG = {
+	contexts: [],
+	defaultContext: 'web',
+	coreAlias: '$core'
+};
+
+function toObjectFromDefaultExport(content) {
+	const source = String(content ?? '').trim();
+	if (!source.length) return {};
+
+	const replacedExport = source.replace(/^\s*export\s+default\s+/m, 'return ');
+	if (replacedExport === source) return {};
+
+	const withSemicolon = /;\s*$/.test(replacedExport) ? replacedExport : `${replacedExport};`;
+
+	try {
+		// eslint-disable-next-line no-new-func
+		return new Function(withSemicolon)() ?? {};
+	} catch {
+		return {};
+	}
+}
+
+export function resolveConfigFile(cwd = process.cwd()) {
+	const tsPath = path.join(cwd, 'azure-net.config.ts');
+	const jsPath = path.join(cwd, 'azure-net.config.js');
+
+	if (fsSync.existsSync(tsPath)) {
+		return { exists: true, filepath: tsPath, type: 'ts' };
+	}
+	if (fsSync.existsSync(jsPath)) {
+		return { exists: true, filepath: jsPath, type: 'js' };
+	}
+
+	return { exists: false, filepath: tsPath, type: 'ts' };
+}
 
 export async function loadUserConfig() {
-    try {
-        const configPath = path.resolve(process.cwd(), 'azure-net.config.js');
-        const userConfig = await import(pathToFileURL(configPath));
-        return userConfig.default || {};
-    } catch {
-        return {
-            contexts: ['web'],
-            defaultContext: 'web'
-        };
-    }
-}
+	const { exists, filepath } = resolveConfigFile();
+	if (!exists) {
+		return { ...DEFAULT_CONFIG };
+	}
+
+	try {
+		const content = await fs.readFile(filepath, 'utf-8');
+		const parsed = toObjectFromDefaultExport(content);
+		if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+			return { ...DEFAULT_CONFIG };
+		}
+
+		return { ...DEFAULT_CONFIG, ...parsed };
+	} catch {
+		return { ...DEFAULT_CONFIG };
+	}
+}

package/src/utils/loadConfig.ts

@@ -0,0 +1,69 @@
+import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
+import path from 'node:path';
+
+export type AzureNetConfig = {
+	contexts: Array<string | { name?: string; alias?: string }>;
+	defaultContext: string;
+	coreAlias: string;
+	sharedAlias?: string;
+	packageManager?: string;
+	defaultSchemaFactory?: string;
+	defaultPresenterFactory?: string;
+	[key: string]: unknown;
+};
+
+const DEFAULT_CONFIG: AzureNetConfig = {
+	contexts: [],
+	defaultContext: 'web',
+	coreAlias: '$core'
+};
+
+function toObjectFromDefaultExport(content: string): Record<string, unknown> {
+	const source = String(content ?? '').trim();
+	if (!source.length) return {};
+
+	const replacedExport = source.replace(/^\s*export\s+default\s+/m, 'return ');
+	if (replacedExport === source) return {};
+
+	const withSemicolon = /;\s*$/.test(replacedExport) ? replacedExport : `${replacedExport};`;
+
+	try {
+		return new Function(withSemicolon)() ?? {};
+	} catch {
+		return {};
+	}
+}
+
+export function resolveConfigFile(cwd = process.cwd()): { exists: boolean; filepath: string; type: 'ts' | 'js' } {
+	const tsPath = path.join(cwd, 'azure-net.config.ts');
+	const jsPath = path.join(cwd, 'azure-net.config.js');
+
+	if (fsSync.existsSync(tsPath)) {
+		return { exists: true, filepath: tsPath, type: 'ts' };
+	}
+	if (fsSync.existsSync(jsPath)) {
+		return { exists: true, filepath: jsPath, type: 'js' };
+	}
+
+	return { exists: false, filepath: tsPath, type: 'ts' };
+}
+
+export async function loadUserConfig(): Promise<AzureNetConfig> {
+	const { exists, filepath } = resolveConfigFile();
+	if (!exists) {
+		return { ...DEFAULT_CONFIG };
+	}
+
+	try {
+		const content = await fs.readFile(filepath, 'utf-8');
+		const parsed = toObjectFromDefaultExport(content);
+		if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+			return { ...DEFAULT_CONFIG };
+		}
+
+		return { ...DEFAULT_CONFIG, ...(parsed as Record<string, unknown>) };
+	} catch {
+		return { ...DEFAULT_CONFIG };
+	}
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		"rootDir": ".",
+		"outDir": "dist",
+		"allowJs": true,
+		"checkJs": false,
+		"declaration": true,
+		"sourceMap": true,
+		"strict": true,
+		"noUncheckedIndexedAccess": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true
+	},
+	"include": ["bin/**/*.ts", "src/**/*"],
+	"exclude": ["dist", "node_modules"]
+}

package/src/commands/generate/generateComponent.js

@@ -1,53 +0,0 @@
-import prompts from 'prompts';
-import path from 'path';
-import { selectContext } from '../../utils/contextUtils.js';
-import { writeIfNotExists } from '../../utils/fileUtils.js';
-
-const componentTemplate = `<script lang="ts">
-\timport './style.scss';
-</script>
-
-{{componentName}}
-`;
-
-const styleTemplate = `// Add your styles here
-`;
-
-export default async function generateComponent() {
-    const context = await selectContext('Select context for component:');
-
-    const { componentPath } = await prompts({
-        type: 'text',
-        name: 'componentPath',
-        message: 'Component path (e.g. reviews/modals/ReviewModal):',
-        validate: value => value.length > 0 ? true : 'Path cannot be empty'
-    });
-
-    // Parse the path
-    const normalizedPath = componentPath.replace(/\\/g, '/');
-    const pathParts = normalizedPath.split('/');
-    const componentName = pathParts[pathParts.length - 1];
-
-    // Build the full path: src/app/{context}/ui/components/{path}
-    const contextUiPath = path.join(process.cwd(), 'src/app', context, 'ui/components');
-    const fullComponentPath = path.join(contextUiPath, normalizedPath);
-
-    console.log(`\n🚀 Generating component: ${componentName}...\n`);
-
-    // Create Component.svelte
-    await writeIfNotExists(
-        path.join(fullComponentPath, 'Component.svelte'),
-        componentTemplate.replace(/{{componentName}}/g, componentName)
-    );
-
-    // Create style.scss
-    await writeIfNotExists(
-        path.join(fullComponentPath, 'style.scss'),
-        styleTemplate
-    );
-
-    console.log(`✅ Component created at: ${fullComponentPath}`);
-    console.log(`\n💡 Files created:`);
-    console.log(`   - Component.svelte`);
-    console.log(`   - style.scss`);
-}