@azure-net/cli 1.4.2 → 2.0.1

package/src/commands/generate/generateRepository.js

@@ -0,0 +1,102 @@
+import prompts from 'prompts';
+import fs from 'fs/promises';
+import path from 'path';
+import { selectContext, getContextPath, toPascalCase, getAvailableFiles, toCamelCase } from '../../utils/contextUtils.js';
+import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
+import { ensureProvider, addToProvider } from '../../utils/providerUtils.js';
+
+const repositoryTemplate = `import { {{datasource}} } from '{{datasourceImport}}';
+
+export class {{name}}Repository {
+\tconstructor(private {{datasourceVar}}: {{datasource}}) {}
+\t
+\tpublic async example() {
+\t\treturn this.{{datasourceVar}}.createRequest(({ http }) => 
+\t\t\thttp.get('/endpoint')
+\t\t).then(res => res.getData());
+\t}
+}`;
+
+export default async function generateRepository() {
+    const context = await selectContext('Select context for repository:');
+
+    if (context === 'core') {
+        console.error('❌ Cannot create repository in core. Choose a specific context.');
+        return;
+    }
+
+    const { name } = await prompts({
+        type: 'text',
+        name: 'name',
+        message: 'Repository name (without "Repository" suffix):'
+    });
+
+    // Get available datasources
+    const contextPath = getContextPath(context);
+    const coreDatasources = await getAvailableFiles(
+        path.join(process.cwd(), 'src/app/core/Datasource')
+    );
+    const contextDatasources = await getAvailableFiles(
+        path.join(contextPath, 'Infrastructure', 'Http', 'Datasource')
+    );
+
+    const allDatasources = [
+        ...coreDatasources.map(d => ({ title: `${d} (core)`, value: { name: d, from: 'core' } })),
+        ...contextDatasources.map(d => ({ title: `${d} (${context})`, value: { name: d, from: context } }))
+    ];
+
+    if (allDatasources.length === 0) {
+        console.error('❌ No datasources available. Create a datasource first.');
+        return;
+    }
+
+    const { datasource } = await prompts({
+        type: 'select',
+        name: 'datasource',
+        message: 'Select datasource:',
+        choices: allDatasources
+    });
+
+    const pascalName = toPascalCase(name);
+    const contextName = toPascalCase(context);
+    const repoPath = path.join(contextPath, 'Infrastructure', 'Http', 'Repositories');
+    const filePath = path.join(repoPath, `${pascalName}Repository.ts`);
+
+    // Generate repository
+    const datasourceImport = datasource.from === 'core'
+        ? '$core/Datasource'
+        : '../Datasource';
+
+    const content = repositoryTemplate
+        .replace(/{{name}}/g, pascalName)
+        .replace(/{{datasource}}/g, datasource.name)
+        .replace(/{{datasourceImport}}/g, datasourceImport)
+        .replace(/{{datasourceVar}}/g, toCamelCase(datasource.name));
+
+    await writeIfNotExists(filePath, content);
+    await updateIndexTs(repoPath);
+
+    // Ensure DatasourceProvider exists
+    const datasourceProviderPath = path.join(contextPath, 'Infrastructure', 'Providers', 'DatasourceProvider.ts');
+    if (!(await fs.access(datasourceProviderPath).then(() => true).catch(() => false))) {
+        const datasourceProviderContent = `import { createBoundaryProvider } from '@azure-net/kit';
+import { ${datasource.name} } from '${datasource.from === 'core' ? '$core/Datasource' : '../Http/Datasource'}';
+
+export const DatasourceProvider = createBoundaryProvider('${contextName}DatasourceProvider', () => ({
+\t${datasource.name}: () => new ${datasource.name}()
+}));`;
+        await writeIfNotExists(datasourceProviderPath, datasourceProviderContent);
+        await updateIndexTs(path.dirname(datasourceProviderPath));
+    }
+
+    // Ensure InfrastructureProvider and add repository
+    const infraProvider = await ensureProvider(context, 'Infrastructure', { hasDatasource: true });
+    await addToProvider(
+        infraProvider.path,
+        `${pascalName}Repository`,
+        '../Http/Repositories',
+        `DatasourceProvider.${datasource.name}`
+    );
+
+    console.log(`✅ Repository created at ${filePath}`);
+}

package/src/commands/generate/generateResponse.js

@@ -0,0 +1,42 @@
+import prompts from 'prompts';
+import { selectContext, getContextPath, toPascalCase } from '../../utils/contextUtils.js';
+import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
+import path from 'path';
+
+const responseTemplate = `import { ResponseBuilder } from '@azure-net/kit';
+
+export interface I{{name}}Response<T = unknown> {
+\tdata: T;
+\tsuccess: boolean;
+\tmessage: string;
+}
+
+export class {{name}}Response<TData = unknown, TMeta = unknown> extends ResponseBuilder<TData, TMeta, I{{name}}Response<TData>> {
+\toverride unwrapData(data: I{{name}}Response<TData>): TData {
+\t\treturn data.data;
+\t}
+}`;
+
+export default async function generateResponse() {
+    const context = await selectContext();
+
+    const { name } = await prompts({
+        type: 'text',
+        name: 'name',
+        message: 'Response name (PascalCase):'
+    });
+
+    const pascalName = toPascalCase(name);
+    const contextPath = getContextPath(context);
+    const responsePath = context === 'core'
+        ? path.join(contextPath, 'Responses')
+        : path.join(contextPath, 'Infrastructure', 'Responses');
+
+    const content = responseTemplate.replace(/{{name}}/g, pascalName);
+    const filePath = path.join(responsePath, `${pascalName}Response.ts`);
+
+    await writeIfNotExists(filePath, content);
+    await updateIndexTs(responsePath);
+
+    console.log(`✅ Response created at ${filePath}`);
+}

package/src/commands/generate/generateSchema.js

@@ -0,0 +1,95 @@
+import prompts from 'prompts';
+import path from 'path';
+import { selectContext, getContextPath, toPascalCase, getAvailableFiles } from '../../utils/contextUtils.js';
+import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
+
+const schemaWithCoreTemplate = `import { {{coreSchema}} } from '$core/Schema';
+import type { I{{name}}Request } from '${{context}}/Domain/Ports/{{entity}}';
+
+export const {{name}}Schema = {{coreSchema}}<I{{name}}Request>()
+\t.rules((rules) => ({
+\t\t// Add validation rules here
+\t}))
+\t.create();`;
+
+const schemaWithPackageTemplate = `import { createSchemaFactory } from '@azure-net/kit';
+import { createRules, validationMessagesI18n } from '@azure-net/kit/schema';
+import type { I{{name}}Request } from '${{context}}/Domain/Ports/{{entity}}';
+
+const Schema = createSchemaFactory(createRules(validationMessagesI18n));
+
+export const {{name}}Schema = Schema<I{{name}}Request>()
+\t.rules((rules) => ({
+\t\t// Add validation rules here
+\t}))
+\t.create();`;
+
+export default async function generateSchema() {
+    const context = await selectContext('Select context for schema:');
+
+    if (context === 'core') {
+        console.error('❌ Cannot create schema in core. Choose a specific context.');
+        return;
+    }
+
+    const { module } = await prompts({
+        type: 'text',
+        name: 'module',
+        message: 'Module name (folder in Delivery):'
+    });
+
+    const { name } = await prompts({
+        type: 'text',
+        name: 'name',
+        message: 'Schema name (without "Schema" suffix):'
+    });
+
+    // Check for core schemas
+    const coreSchemas = await getAvailableFiles(
+        path.join(process.cwd(), 'src/app/core/Schema')
+    );
+
+    const choices = [
+        { title: 'Use createSchemaFactory from package', value: 'package' },
+        ...coreSchemas.map(s => ({ title: `Use ${s} from core`, value: s }))
+    ];
+
+    const { schemaType } = await prompts({
+        type: 'select',
+        name: 'schemaType',
+        message: 'Select schema factory:',
+        choices
+    });
+
+    const pascalName = toPascalCase(name);
+    const moduleName = toPascalCase(module);
+    const contextPath = getContextPath(context);
+    const schemaPath = path.join(contextPath, 'Delivery', moduleName, 'Schema');
+    const filePath = path.join(schemaPath, `${pascalName}Schema.ts`);
+
+    const content = schemaType === 'package'
+        ? schemaWithPackageTemplate
+            .replace(/{{name}}/g, pascalName)
+            .replace(/{{context}}/g, context)
+            .replace(/{{entity}}/g, moduleName)
+        : schemaWithCoreTemplate
+            .replace(/{{name}}/g, pascalName)
+            .replace(/{{context}}/g, context)
+            .replace(/{{entity}}/g, moduleName)
+            .replace(/{{coreSchema}}/g, schemaType);
+
+    await writeIfNotExists(filePath, content);
+    await updateIndexTs(schemaPath);
+
+    // Update module index
+    const moduleIndexPath = path.join(contextPath, 'Delivery', moduleName, 'index.ts');
+    if (await fs.access(moduleIndexPath).then(() => true).catch(() => false)) {
+        let indexContent = await fs.readFile(moduleIndexPath, 'utf-8');
+        if (!indexContent.includes(`export * from './Schema'`)) {
+            indexContent += `\nexport * from './Schema';`;
+            await fs.writeFile(moduleIndexPath, indexContent, 'utf-8');
+        }
+    }
+
+    console.log(`✅ Schema created at ${filePath}`);
+}

package/src/commands/generate/generateService.js

@@ -0,0 +1,93 @@
+import prompts from 'prompts';
+import fs from 'fs/promises';
+import path from 'path';
+import { selectContext, getContextPath, toPascalCase, getAvailableFiles } from '../../utils/contextUtils.js';
+import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
+import { ensureProvider, addToProvider } from '../../utils/providerUtils.js';
+
+const serviceTemplate = `import { ClassMirror } from '@azure-net/kit';
+import { {{repository}} } from '../../Infrastructure/Repositories/index.js';
+
+export class {{name}}Service extends ClassMirror<{{repository}}> {
+\tconstructor(private {{repositoryVar}}: {{repository}}) {
+\t\tsuper({{repositoryVar}});
+\t}
+\t
+\tdeclare example: {{repository}}['example'];
+}`;
+
+const serviceWithoutRepoTemplate = `export class {{name}}Service {
+\tconstructor() {}
+\t
+\tpublic async example() {
+\t\t// Implement service logic
+\t\treturn {};
+\t}
+}`;
+
+export default async function generateService() {
+    const context = await selectContext('Select context for service:');
+
+    if (context === 'core') {
+        console.error('❌ Cannot create service in core. Choose a specific context.');
+        return;
+    }
+
+    const { name } = await prompts({
+        type: 'text',
+        name: 'name',
+        message: 'Service name (without "Service" suffix):'
+    });
+
+    // Get available repositories
+    const contextPath = getContextPath(context);
+    const repositories = await getAvailableFiles(
+        path.join(contextPath, 'Infrastructure', 'Repositories')
+    );
+
+    const choices = [
+        { title: 'Without repository', value: null },
+        ...repositories.map(r => ({ title: `${r}Repository`, value: `${r}Repository` }))
+    ];
+
+    const { repository } = await prompts({
+        type: 'select',
+        name: 'repository',
+        message: 'Select repository:',
+        choices
+    });
+
+    const pascalName = toPascalCase(name);
+    const servicePath = path.join(contextPath, 'Application', 'Services');
+    const filePath = path.join(servicePath, `${pascalName}Service.ts`);
+
+    // Generate service
+    const content = repository
+        ? serviceTemplate
+            .replace(/{{name}}/g, pascalName)
+            .replace(/{{repository}}/g, repository)
+            .replace(/{{repositoryVar}}/g, repository.charAt(0).toLowerCase() + repository.slice(1))
+        : serviceWithoutRepoTemplate.replace(/{{name}}/g, pascalName);
+
+    await writeIfNotExists(filePath, content);
+    await updateIndexTs(servicePath);
+
+    // Ensure ApplicationProvider exists and add service
+    const appProvider = await ensureProvider(context, 'Application', { infrastructure: true });
+    await addToProvider(
+        appProvider.path,
+        `${pascalName}Service`,
+        '../Services/index.js'
+    );
+
+    // Add repository dependency if selected
+    if (repository) {
+        let providerContent = await fs.readFile(appProvider.path, 'utf-8');
+        const serviceFactory = `${pascalName}Service: () => new ${pascalName}Service()`;
+        const serviceWithRepo = `${pascalName}Service: () => new ${pascalName}Service(InfrastructureProvider.${repository})`;
+        providerContent = providerContent.replace(serviceFactory, serviceWithRepo);
+        await fs.writeFile(appProvider.path, providerContent, 'utf-8');
+    }
+
+    console.log(`✅ Service created at ${filePath}`);
+}

package/src/commands/generate/index.js

@@ -0,0 +1,8 @@
+export { default as generateDatasource } from './generateDatasource.js';
+export { default as generateResponse } from './generateResponse.js';
+export { default as generateRepository } from './generateRepository.js';
+export { default as generateService } from './generateService.js';
+export { default as generateSchema } from './generateSchema.js';
+export { default as generatePresenter } from './generatePresenter.js';
+export { default as generateModule } from './generateModule.js';
+export { default as generateCrud } from './generateCrud.js';

package/src/commands/init/index.js

@@ -0,0 +1,7 @@
+export { default as initStructure } from './initStructure.js';
+export { default as initAliases } from './initAliases.js';
+export { default as initMiddleware } from './initMiddleware.js';
+export { default as initEdges } from './initEdges.js';
+export { default as initTranslations } from './initTranslations.js';
+export { default as initSchema } from './initSchema.js';
+export { default as initLint } from './initLint.js';

package/src/commands/init/initAliases.js

@@ -0,0 +1,50 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { loadUserConfig } from '../../utils/loadConfig.js';
+import { execSync } from 'child_process';
+
+const svelteConfigPath = path.resolve('svelte.config.js');
+
+function generateAliases(config) {
+    const contexts = config.contexts || ['app'];
+
+    return Object.fromEntries([
+        ...contexts.map(c => [`$${c}`, `./src/app/contexts/${c}`]),
+        ['$core', './src/app/core'],
+        ['$lib', './src/lib']
+    ]);
+}
+
+function serializeObjectLiteral(obj) {
+    return Object.entries(obj)
+        .map(([key, value]) => `\t\t\t'${key}': '${value}'`)
+        .join(',\n');
+}
+
+export default async function initAliases() {
+    const config = await loadUserConfig();
+    const newAliases = generateAliases(config);
+
+    let content = await fs.readFile(svelteConfigPath, 'utf-8');
+
+    const aliasRegex = /alias:\s*{([\s\S]*?)}/m;
+    const aliasMatch = content.match(aliasRegex);
+
+    const newAliasBlock = `alias: {\n${serializeObjectLiteral(newAliases)}\n\t\t}`;
+
+    if (aliasMatch) {
+        content = content.replace(aliasRegex, newAliasBlock);
+    } else {
+        const kitRegex = /kit:\s*{/;
+        content = content.replace(kitRegex, `kit: {\n\t\t${newAliasBlock},`);
+    }
+
+    await fs.writeFile(svelteConfigPath, content, 'utf-8');
+    console.log('✅ Aliases updated in svelte.config.js');
+
+    try {
+        execSync('npm run format', { stdio: 'inherit' });
+    } catch {
+        console.warn('⚠️ Failed to run format');
+    }
+}

package/src/commands/init/initEdges.js

@@ -0,0 +1,42 @@
+import { injectIntoFile, writeIfNotExists } from '../../utils/fileUtils.js';
+import path from 'path';
+
+const hooksServerPath = path.join(process.cwd(), 'src/hooks.server.ts');
+
+const hooksTemplate = `import { dev } from '$app/environment';
+import { edgesHandle } from '@azure-net/kit/edges/server';
+import { type Handle } from '@sveltejs/kit';
+
+export const handle: Handle = async ({ event, resolve }) => {
+\treturn edgesHandle(
+\t\tevent,
+\t\tasync ({ edgesEvent, serialize }) => {
+\t\t\treturn resolve(edgesEvent, {
+\t\t\t\ttransformPageChunk: ({ html }) => serialize(html)
+\t\t\t});
+\t\t},
+\t\tdev
+\t);
+};`;
+
+export default async function initEdges() {
+    const created = await writeIfNotExists(hooksServerPath, hooksTemplate);
+
+    if (!created) {
+        const importStatement = `import { edgesHandle } from '@azure-net/kit/edges/server';`;
+        await injectIntoFile(hooksServerPath, 'import {', importStatement, 'before');
+
+        const handleCode = `\treturn edgesHandle(
+\t\tevent,
+\t\tasync ({ edgesEvent, serialize }) => {`;
+
+        await injectIntoFile(
+            hooksServerPath,
+            'export const handle: Handle = async ({ event, resolve }) => {',
+            handleCode,
+            'after'
+        );
+    }
+
+    console.log('✅ Edges-svelte initialized');
+}

package/src/commands/init/initMiddleware.js

@@ -0,0 +1,43 @@
+import { writeIfNotExists, injectIntoFile } from '../../utils/fileUtils.js';
+import path from 'path';
+
+const middlewarePath = path.join(process.cwd(), 'src/app/core/Middleware/MiddlewareManager.ts');
+const hooksServerPath = path.join(process.cwd(), 'src/hooks.server.ts');
+const layoutPath = path.join(process.cwd(), 'src/routes/+layout.svelte');
+
+const middlewareTemplate = `import { createMiddlewareManager } from '@azure-net/kit';
+
+export const { clientMiddleware, serverMiddleware } = createMiddlewareManager([]);`;
+
+export default async function initMiddleware() {
+    await writeIfNotExists(middlewarePath, middlewareTemplate);
+    await writeIfNotExists(
+        path.join(process.cwd(), 'src/app/core/Middleware/index.ts'),
+        `export * from './MiddlewareManager';`
+    );
+
+    // Add to hooks.server.ts
+    await injectIntoFile(
+        hooksServerPath,
+        'import',
+        `import { serverMiddleware } from '$core';`,
+        'before'
+    );
+
+    await injectIntoFile(
+        hooksServerPath,
+        'async ({ edgesEvent, serialize }) => {',
+        '\t\t\tawait serverMiddleware();',
+        'after'
+    );
+
+    // Add to +layout.svelte
+    await injectIntoFile(
+        layoutPath,
+        '<script',
+        `\timport { clientMiddleware } from '$core';\n\tclientMiddleware();`,
+        'after'
+    );
+
+    console.log('✅ Middleware initialized');
+}

package/src/commands/init/initSchema.js

@@ -0,0 +1,19 @@
+import { writeIfNotExists } from '../../utils/fileUtils.js';
+import path from 'path';
+
+const schemaPath = path.join(process.cwd(), 'src/app/core/Schemas/Schema.ts');
+
+const schemaTemplate = `import { createSchemaFactory } from '@azure-net/kit';
+import { createRules, validationMessagesI18n } from '@azure-net/kit/schema';
+
+export const Schema = createSchemaFactory(createRules(validationMessagesI18n));`;
+
+export default async function initSchema() {
+    await writeIfNotExists(schemaPath, schemaTemplate);
+    await writeIfNotExists(
+        path.join(process.cwd(), 'src/app/core/Schemas/index.ts'),
+        `export * from './Schema';`
+    );
+
+    console.log('✅ Schema factory initialized');
+}

package/src/commands/init/initStructure.js

@@ -0,0 +1,79 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { loadUserConfig } from '../../utils/loadConfig.js';
+
+const APP_ROOT = path.join(process.cwd(), 'src', 'app');
+const CONTEXTS_PATH = path.join(APP_ROOT, 'contexts');
+const CORE_PATH = path.join(APP_ROOT, 'core');
+
+async function createDirIfNotExists(dirPath) {
+    try {
+        await fs.mkdir(dirPath, { recursive: true });
+        console.log(`📁 Created: ${dirPath}`);
+    } catch (e) {
+        console.error(`❌ Failed to create ${dirPath}:`, e.message);
+    }
+}
+
+async function createIndexFile(dirPath, exportPatterns = []) {
+    const indexPath = path.join(dirPath, 'index.ts');
+    if (exportPatterns.length > 0) {
+        const content = exportPatterns.map(pattern => `export * from '${pattern}';`).join('\n') + '\n';
+        await fs.writeFile(indexPath, content, 'utf-8');
+    }
+}
+
+async function createBaseStructure(root) {
+    // Domain
+    const domainPath = path.join(root, 'Domain');
+    await createDirIfNotExists(path.join(domainPath, 'Entities'));
+    await createDirIfNotExists(path.join(domainPath, 'Ports'));
+
+    // Infrastructure
+    const infraPath = path.join(root, 'Infrastructure');
+    await createDirIfNotExists(path.join(infraPath, 'Http', 'Repositories'));
+    await createDirIfNotExists(path.join(infraPath, 'Http', 'Datasource'));
+    await createDirIfNotExists(path.join(infraPath, 'Providers'));
+
+    // Application
+    const appPath = path.join(root, 'Application');
+    await createDirIfNotExists(path.join(appPath, 'Services'));
+    await createDirIfNotExists(path.join(appPath, 'Providers'));
+
+    // Delivery - organized by modules, not by type
+    const deliveryPath = path.join(root, 'Delivery');
+    await createDirIfNotExists(deliveryPath);
+}
+
+export default async function initStructure() {
+    const config = await loadUserConfig();
+    const contexts = config.contexts || ['app'];
+
+    console.log('📦 Generating architecture...');
+
+    // Create contexts
+    for (const context of contexts) {
+        const contextPath = path.join(CONTEXTS_PATH, context);
+        await createBaseStructure(contextPath);
+    }
+
+    // Create core structure
+    await createDirIfNotExists(CORE_PATH);
+    await createDirIfNotExists(path.join(CORE_PATH, 'Datasource'));
+    await createDirIfNotExists(path.join(CORE_PATH, 'Response'));
+    await createDirIfNotExists(path.join(CORE_PATH, 'Schema'));
+    await createDirIfNotExists(path.join(CORE_PATH, 'Middleware'));
+    await createDirIfNotExists(path.join(CORE_PATH, 'Presenter'));
+    await createDirIfNotExists(path.join(CORE_PATH, 'Translation'));
+
+    // Create core index.ts that exports all subdirectories
+    await createIndexFile(CORE_PATH, [
+        './Schema',
+        './Datasource',
+        './Response',
+        './Middleware',
+        './Translation'
+    ]);
+
+    console.log('✅ Structure initialization complete!');
+}