@azure-net/cli 1.4.2 → 2.0.1

package/src/commands/init/initTranslations.js

@@ -0,0 +1,102 @@
+import { writeIfNotExists, updateIndexTs, injectIntoFile } from '../../utils/fileUtils.js';
+import path from 'path';
+
+const translationsPath = path.join(process.cwd(), 'src/app/core/Translation');
+const layoutServerPath = path.join(process.cwd(), 'src/routes/+layout.server.ts');
+const layoutTsPath = path.join(process.cwd(), 'src/routes/+layout.ts');
+
+const translationProviderTemplate = `import { messages } from './Locales';
+import { createTranslations } from '@azure-net/kit/i18n';
+
+export const Translation = createTranslations({ 
+\tmessages, 
+\tinitLang: 'en', 
+\tinitLangFromAcceptLanguage: true, 
+\tcookieName: 'lang' 
+});`;
+
+const enLocaleTemplate = `export default {
+\tapp: {
+\t\ttitle: 'Application'
+\t}
+};`;
+
+const ruLocaleTemplate = `export default {
+\tapp: {
+\t\ttitle: 'Приложение'
+\t}
+};`;
+
+const localesIndexTemplate = `export const messages = {
+\ten: () => import('./en').then((res) => res.default),
+\tru: () => import('./ru').then((res) => res.default)
+};`;
+
+export default async function initTranslations() {
+    // Create translation files
+    await writeIfNotExists(
+        path.join(translationsPath, 'index.ts'),
+        translationProviderTemplate
+    );
+
+    await writeIfNotExists(
+        path.join(translationsPath, 'Locales', 'en.ts'),
+        enLocaleTemplate
+    );
+
+    await writeIfNotExists(
+        path.join(translationsPath, 'Locales', 'ru.ts'),
+        ruLocaleTemplate
+    );
+
+    await writeIfNotExists(
+        path.join(translationsPath, 'Locales', 'index.ts'),
+        localesIndexTemplate
+    );
+
+    // Add to hooks.server.ts
+    await injectIntoFile(
+        path.join(process.cwd(), 'src/hooks.server.ts'),
+        'import',
+        `import { Translation } from '$core';`,
+        'before'
+    );
+
+    await injectIntoFile(
+        path.join(process.cwd(), 'src/hooks.server.ts'),
+        'await serverMiddleware();',
+        `\t\t\tconst { preloadTranslation, applyHtmlLocaleAttr } = Translation();\n\t\t\tawait preloadTranslation(edgesEvent);`,
+        'after'
+    );
+
+    await injectIntoFile(
+        path.join(process.cwd(), 'src/hooks.server.ts'),
+        'transformPageChunk: ({ html })',
+        ' => {\n\t\t\t\tconst serialized = serialize(html);\n\t\t\t\treturn applyHtmlLocaleAttr(serialized);\n\t\t\t}',
+        'after'
+    );
+
+    // Add to layout files
+    await injectIntoFile(
+        layoutServerPath,
+        'export const load',
+        `\treturn { lang: locals.lang };`,
+        'after'
+    );
+
+    await injectIntoFile(
+        layoutTsPath,
+        'import',
+        `import { Translation } from '$core';\nimport { browser } from '$app/environment';`,
+        'before'
+    );
+
+    await injectIntoFile(
+        layoutTsPath,
+        'export const load',
+        `\tconst { syncTranslation } = Translation();\n\tif (browser) {\n\t\tawait syncTranslation({ lang: data.lang }, false);\n\t}`,
+        'after'
+    );
+
+    console.log('✅ Translations initialized');
+}

package/src/utils/contextUtils.js

@@ -0,0 +1,53 @@
+import fs from 'fs/promises';
+import path from 'path';
+import prompts from 'prompts';
+import { loadUserConfig } from './loadConfig.js';
+
+const CONTEXTS_PATH = path.join(process.cwd(), 'src/app/contexts');
+const CORE_PATH = path.join(process.cwd(), 'src/app/core');
+
+export async function selectContext(message = 'Select context:') {
+    const config = await loadUserConfig();
+    const contexts = config.contexts || ['app'];
+
+    const { context } = await prompts({
+        type: 'select',
+        name: 'context',
+        message,
+        choices: [
+            ...contexts.map(c => ({ title: c, value: c })),
+            { title: 'core (shared)', value: 'core' }
+        ]
+    });
+
+    return context;
+}
+
+export function getContextPath(context) {
+    return context === 'core'
+        ? CORE_PATH
+        : path.join(CONTEXTS_PATH, context);
+}
+
+export async function getAvailableFiles(dir, pattern = '.ts') {
+    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 function toPascalCase(str) {
+    return str
+        .split(/[-_\s]+/)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join('');
+}
+
+export function toCamelCase(str) {
+    const pascal = toPascalCase(str);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}

package/src/utils/fileUtils.js

@@ -0,0 +1,79 @@
+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;
+    }
+}
+
+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
+    }
+}
+
+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}';`);
+
+        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);
+
+        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) {
+        console.error(`Failed to update ${filepath}:`, error.message);
+        return false;
+    }
+}

package/src/utils/loadConfig.js

@@ -8,8 +8,8 @@ export async function loadUserConfig() {
         return userConfig.default || {};
     } catch {
         return {
-            modules: ['admin', 'auth'],
-            datasourceAlias: ''
+            contexts: ['app'],
+            defaultContext: 'app'
         };
     }
 }

package/src/utils/providerUtils.js

@@ -0,0 +1,107 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { toPascalCase, toCamelCase } from './contextUtils.js';
+import { writeIfNotExists, updateIndexTs } from './fileUtils.js';
+
+export async function ensureProvider(context, layer, dependencies = {}) {
+    const contextName = toPascalCase(context);
+    const providerName = `${layer}Provider`;
+    const boundaryName = `${contextName}${layer}BoundaryProvider`;
+
+    const contextPath = path.join(process.cwd(), 'src/app/contexts', context);
+    const providerPath = path.join(contextPath, layer, 'Providers', `${layer}Provider.ts`);
+
+    try {
+        await fs.access(providerPath);
+        return { exists: true, name: providerName, path: providerPath };
+    } catch {
+        // Provider doesn't exist, create it
+        const content = generateProviderContent(context, layer, dependencies);
+        await writeIfNotExists(providerPath, content);
+        await updateIndexTs(path.dirname(providerPath));
+
+        // Update layer index to export provider
+        const layerIndexPath = path.join(contextPath, layer, 'index.ts');
+        await writeIfNotExists(layerIndexPath, `export { ${providerName} } from './Providers';`);
+
+        return { exists: false, name: providerName, path: providerPath };
+    }
+}
+
+function generateProviderContent(context, layer, dependencies) {
+    const contextName = toPascalCase(context);
+    const boundaryName = `${contextName}${layer}BoundaryProvider`;
+    const varName = `${layer}Provider`;
+
+    let imports = [`import { createBoundaryProvider } from '@azure-net/kit';`];
+    let deps = [];
+    let depParams = '';
+
+    if (dependencies.hasDatasource && layer === 'Infrastructure') {
+        imports.push(`import { DatasourceProvider } from './DatasourceProvider';`);
+        deps.push('DatasourceProvider');
+    }
+
+    if (dependencies.infrastructure && layer === 'Application') {
+        imports.push(`import { InfrastructureProvider } from '$${context}/Infrastructure';`);
+        deps.push('InfrastructureProvider');
+    }
+
+    if (deps.length > 0) {
+        depParams = `{ ${deps.join(', ')} }`;
+    }
+
+    const dependsOnStr = deps.length > 0
+        ? `,\n\t{ dependsOn: { ${deps.join(', ')} } }`
+        : '';
+
+    return `${imports.join('\n')}
+
+export const ${varName} = createBoundaryProvider(
+\t'${boundaryName}',
+\t(${depParams ? depParams : ''}) => ({
+\t\t// Services will be added here
+\t})${dependsOnStr}
+);`;
+}
+
+export async function addToProvider(providerPath, serviceName, importPath, dependency = null) {
+    let content = await fs.readFile(providerPath, 'utf-8');
+
+    // Add import if not exists
+    const importStatement = `import { ${serviceName} } from '${importPath}';`;
+    if (!content.includes(serviceName)) {
+        const lastImportIndex = content.lastIndexOf('import ');
+        const endOfImportLine = content.indexOf('\n', lastImportIndex);
+        content = content.slice(0, endOfImportLine + 1) + importStatement + '\n' + content.slice(endOfImportLine + 1);
+    }
+
+    // Add factory method with dependency
+    const factoryLine = dependency
+        ? `\t\t${serviceName}: () => new ${serviceName}(${dependency})`
+        : `\t\t${serviceName}: () => new ${serviceName}()`;
+
+    if (!content.includes(`${serviceName}:`)) {
+        // Find the position to insert
+        const returnIndex = content.indexOf('=> ({');
+        const endOfReturn = content.indexOf('\t})', returnIndex);
+
+        // Check if there are existing services
+        const servicesSection = content.substring(returnIndex, endOfReturn);
+        const hasServices = servicesSection.includes(':');
+
+        if (hasServices) {
+            // Add comma before new service
+            const beforeEnd = content.lastIndexOf('\n', endOfReturn);
+            content = content.slice(0, beforeEnd) + ',\n' + factoryLine + content.slice(beforeEnd);
+        } else {
+            // First service, replace comment
+            content = content.replace(
+                '// Services will be added here',
+                factoryLine
+            );
+        }
+    }
+
+    await fs.writeFile(providerPath, content, 'utf-8');
+}

package/.idea/azure-net-ecosystem-cli.iml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="WEB_MODULE" version="4">
-  <component name="Go" enabled="true" />
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$" />
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/azure-net-ecosystem-cli.iml" filepath="$PROJECT_DIR$/.idea/azure-net-ecosystem-cli.iml" />
-    </modules>
-  </component>
-</project>

package/src/commands/generateCrud.js

@@ -1,135 +0,0 @@
-import prompts from 'prompts';
-import fs from 'fs/promises';
-import path from 'path';
-import ejs from 'ejs';
-import { loadUserConfig } from '../utils/loadConfig.js';
-
-const __dirname = path.dirname(new URL(import.meta.url).pathname);
-const CORE_DATASOURCES_PATH = path.join(process.cwd(), 'src/app/core/datasources');
-
-async function writeIfNotExists(filepath, content) {
-    try {
-        await fs.access(filepath);
-        console.log(`⚠️  Skip existing: ${filepath}`);
-    } catch {
-        await fs.mkdir(path.dirname(filepath), { recursive: true });
-        await fs.writeFile(filepath, content, 'utf-8');
-        console.log(`✅ Created: ${filepath}`);
-    }
-}
-
-async function updateIndexTs(dir, filePattern = '.ts', ignore = ['index.ts']) {
-    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');
-}
-
-async function getAvailableDatasources() {
-    try {
-        const files = await fs.readdir(CORE_DATASOURCES_PATH);
-        return files
-            .filter(f => f.endsWith('.ts') && !f.startsWith('_'))
-            .map(f => f.replace('.ts', ''));
-    } catch {
-        return [];
-    }
-}
-
-export default async function generateCrud() {
-    const config = await loadUserConfig();
-    const datasources = await getAvailableDatasources();
-
-    const answers = await prompts([
-        config.modules?.length
-            ? {
-                type: 'select',
-                name: 'module',
-                message: 'Select target module:',
-                choices: [...config.modules, 'shared-context'].map(m => ({
-                    title: m === 'shared-context' ? 'shared-context (shared)' : m,
-                    value: m
-                }))
-            }
-            : null,
-        { type: 'text', name: 'className', message: 'Class name (PascalCase):' },
-        { type: 'text', name: 'endpoint', message: 'API endpoint:' },
-        {
-            type: 'select',
-            name: 'datasource',
-            message: 'Select datasource:',
-            choices: datasources.map(d => ({ title: d, value: d }))
-        }
-    ].filter(Boolean));
-
-    const rawName = answers.className.trim();
-    const capital = rawName[0].toUpperCase() + rawName.slice(1);
-    const lower = rawName[0].toLowerCase() + rawName.slice(1);
-    const endpoint = answers.endpoint.trim();
-    const datasource = answers.datasource.trim();
-    const selectedModule = answers.module;
-
-    const baseArch = path.join(process.cwd(), 'src/app/contexts');
-    const basePath = selectedModule ? path.join(baseArch, selectedModule) : path.join(baseArch, 'app-context');
-
-    const domainPath = path.join(basePath, 'Domain', capital);
-    const serviceDir = path.join(basePath, 'Application', 'Services');
-    const repoPath = path.join(basePath, 'Infra', 'Repo');
-
-    const aliasCurrent = selectedModule === 'shared-context'
-        ? '$shared-context'
-        : selectedModule
-            ? `$${selectedModule}`
-            : '$app-context';
-    const aliasShared = '$shared-context';
-
-    const templateData = {
-        camelCaseName: lower,
-        pascalCaseName: capital,
-        endpoint,
-        datasource,
-        aliasDomain: `${aliasCurrent}/Domain`,
-        aliasShared,
-        aliasApplication: `${aliasCurrent}/Application`,
-        aliasInfra: `${aliasCurrent}/Infra`,
-        aliasRepo: `${aliasCurrent}/Infra/Repo`
-    };
-
-    // === 1) Abstracts
-    const abstractsDir = path.join(domainPath, 'Abstracts');
-    for (const file of ['Class', 'ClassCreateRequest', 'ClassUpdateRequest', 'ClassCollectionQuery']) {
-        const tpl = await fs.readFile(path.join(__dirname, `../templates/domain/abstracts/${file}.ejs`), 'utf-8');
-        const result = ejs.render(tpl, templateData);
-        await writeIfNotExists(path.join(abstractsDir, `${capital}${file.replace('Class', '')}.ts`), result);
-    }
-    await updateIndexTs(abstractsDir);
-
-    // === 2) Request
-    const requestDir = path.join(domainPath, 'Request');
-    for (const file of ['ClassCreateRequest', 'ClassUpdateRequest']) {
-        const tpl = await fs.readFile(path.join(__dirname, `../templates/domain/request/${file}.ejs`), 'utf-8');
-        const result = ejs.render(tpl, templateData);
-        await writeIfNotExists(path.join(requestDir, `${capital}${file.replace('Class', '')}.ts`), result);
-    }
-    await updateIndexTs(requestDir);
-
-    // === 3) Services
-    const serviceTpl = await fs.readFile(path.join(__dirname, '../templates/domain/services/ClassService.ejs'), 'utf-8');
-    const serviceResult = ejs.render(serviceTpl, templateData);
-    await writeIfNotExists(path.join(serviceDir, `${capital}Service.ts`), serviceResult);
-    await updateIndexTs(serviceDir);
-
-    // === 4) Domain Index
-    await writeIfNotExists(
-        path.join(domainPath, 'index.ts'),
-        [`export * from './Abstracts';`, `export * from './Request';`].join('\n')
-    );
-    //await updateIndexTs(domainPath);
-
-    // === 5) Repo
-    const repoTpl = await fs.readFile(path.join(__dirname, '../templates/data/repo/ClassRepo.ejs'), 'utf-8');
-    const repoResult = ejs.render(repoTpl, templateData);
-    await writeIfNotExists(path.join(repoPath, `${capital}Repo.ts`), repoResult);
-    await updateIndexTs(repoPath);
-
-    console.log(`✅ CRUD for ${capital} generated in ${selectedModule || 'app-context'} structure`);
-}

package/src/commands/generateDatasource.js

@@ -1,44 +0,0 @@
-import prompts from 'prompts';
-import fs from 'fs/promises';
-import path from 'path';
-
-const CORE_DATASOURCES_PATH = path.join(process.cwd(), 'src/app/core/datasources');
-
-async function writeIfNotExists(filepath, content) {
-    try {
-        await fs.access(filepath);
-        console.log(`⚠️  Skip existing: ${filepath}`);
-    } catch {
-        await fs.mkdir(path.dirname(filepath), { recursive: true });
-        await fs.writeFile(filepath, content, 'utf-8');
-        console.log(`✅ Created: ${filepath}`);
-    }
-}
-
-async function updateIndexTs(dir) {
-    const files = (await fs.readdir(dir)).filter(f => f.endsWith('.ts') && f !== 'index.ts');
-    const content = files.map(f => `export * from './${f.replace('.ts', '')}';`).join('\n') + '\n';
-    await fs.writeFile(path.join(dir, 'index.ts'), content, 'utf-8');
-}
-
-export default async function generateDatasource() {
-    const { name } = await prompts({
-        type: 'text',
-        name: 'name',
-        message: 'Datasource class name (PascalCase, e.g., BackendApi):'
-    });
-
-    const capital = name.trim();
-    const filePath = path.join(CORE_DATASOURCES_PATH, `${capital}Datasource.ts`);
-
-    const content = `import { BaseHttpDatasource, HttpService } from '@azure-net/kit';
-
-export class ${capital}Datasource extends BaseHttpDatasource {
-	constructor() {
-		super({ http: new HttpService({ baseUrl: '' }) }); // TODO: fill generated class
-	}
-}`;
-
-    await writeIfNotExists(filePath, content);
-    await updateIndexTs(CORE_DATASOURCES_PATH);
-}

package/src/commands/generateRepo.js

@@ -1,69 +0,0 @@
-import prompts from 'prompts';
-import fs from 'fs/promises';
-import path from 'path';
-import { loadUserConfig } from '../utils/loadConfig.js';
-
-const CORE_DATASOURCES_PATH = path.join(process.cwd(), 'src/app/core/datasources');
-const CONTEXTS_PATH = path.join(process.cwd(), 'src/app/contexts');
-
-async function getAvailableDatasources() {
-    try {
-        const files = await fs.readdir(CORE_DATASOURCES_PATH);
-        return files.filter(f => f.endsWith('.ts') && !f.startsWith('_')).map(f => f.replace('.ts', ''));
-    } catch {
-        return [];
-    }
-}
-
-async function updateIndexTs(dir) {
-    const files = (await fs.readdir(dir)).filter(f => f.endsWith('.ts') && f !== 'index.ts');
-    const content = files.map(f => `export * from './${f.replace('.ts', '')}';`).join('\n') + '\n';
-    await fs.writeFile(path.join(dir, 'index.ts'), content, 'utf-8');
-}
-
-export default async function generateRepo() {
-    const config = await loadUserConfig();
-    const datasources = await getAvailableDatasources();
-
-    const answers = await prompts([
-        config.modules?.length ? {
-            type: 'select',
-            name: 'module',
-            message: 'Select target module:',
-            choices: [...config.modules, 'shared-context'].map(m => ({ title: m, value: m }))
-        } : null,
-        { type: 'text', name: 'name', message: 'Repository class name (PascalCase):' },
-        {
-            type: 'select',
-            name: 'datasource',
-            message: 'Select datasource:',
-            choices: datasources.map(d => ({ title: d, value: d }))
-        }
-    ].filter(Boolean));
-
-    const { name, module, datasource } = answers;
-    const capital = name.trim();
-
-    const basePath = path.join(CONTEXTS_PATH, module || 'app-context');
-    const repoDir = path.join(basePath, 'Infra', 'Repo');
-    const filePath = path.join(repoDir, `${capital}Repo.ts`);
-
-    const aliasRepo = module === 'shared-context'
-        ? '$shared-context/Infra/Repo'
-        : `$${module}/Infra/Repo`;
-
-    const content = `import { ${datasource} } from '$core/datasources';
-
-export class ${capital}Repo {
-	private source = new ${datasource}();
-
-	constructor() {
-		// TODO: fill generated class
-	}
-}`;
-
-    await fs.mkdir(repoDir, { recursive: true });
-    await fs.writeFile(filePath, content);
-    await updateIndexTs(repoDir);
-    console.log(`✅ Repo created at ${filePath}`);
-}