@azure-net/cli 2.0.4 → 2.0.6

package/src/commands/init/initStructure.js

@@ -4,7 +4,7 @@ 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');
+const SHARED_PATH = path.join(APP_ROOT, 'shared');
 
 async function createDirIfNotExists(dirPath) {
     try {
@@ -23,7 +23,7 @@ async function createIndexFile(dirPath, exportPatterns = []) {
     }
 }
 
-async function createBaseStructure(root) {
+async function createBaseStructure(root, contextName) {
     // Domain
     const domainPath = path.join(root, 'Domain');
     await createDirIfNotExists(path.join(domainPath, 'Entities'));
@@ -35,12 +35,72 @@ async function createBaseStructure(root) {
     await createDirIfNotExists(path.join(infraPath, 'Http', 'Datasource'));
     await createDirIfNotExists(path.join(infraPath, 'Providers'));
 
+    // Create empty InfrastructureProvider
+    const infraProviderContent = `import { createBoundaryProvider } from '@azure-net/kit';
+
+export const InfrastructureProvider = createBoundaryProvider(
+\t'${contextName}InfrastructureProvider',
+\t() => ({
+\t\t// Infrastructure services will be added here manually
+\t})
+);`;
+
+    await fs.writeFile(
+        path.join(infraPath, 'Providers', 'InfrastructureProvider.ts'),
+        infraProviderContent,
+        'utf-8'
+    );
+
+    await fs.writeFile(
+        path.join(infraPath, 'Providers', 'index.ts'),
+        `export * from './InfrastructureProvider';`,
+        'utf-8'
+    );
+
+    // Create Infrastructure index
+    await fs.writeFile(
+        path.join(infraPath, 'index.ts'),
+        `export * from './Providers';`,
+        'utf-8'
+    );
+
     // 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
+    // Create empty ApplicationProvider
+    const appProviderContent = `import { createBoundaryProvider } from '@azure-net/kit';
+import { InfrastructureProvider } from '../Infrastructure';
+
+export const ApplicationProvider = createBoundaryProvider(
+\t'${contextName}ApplicationProvider',
+\t({ InfrastructureProvider }) => ({
+\t\t// Application services will be added here manually
+\t}),
+\t{ dependsOn: { InfrastructureProvider } }
+);`;
+
+    await fs.writeFile(
+        path.join(appPath, 'Providers', 'ApplicationProvider.ts'),
+        appProviderContent,
+        'utf-8'
+    );
+
+    await fs.writeFile(
+        path.join(appPath, 'Providers', 'index.ts'),
+        `export * from './ApplicationProvider';`,
+        'utf-8'
+    );
+
+    // Create Application index
+    await fs.writeFile(
+        path.join(appPath, 'index.ts'),
+        `export * from './Providers';`,
+        'utf-8'
+    );
+
+    // Delivery - organized by modules
     const deliveryPath = path.join(root, 'Delivery');
     await createDirIfNotExists(deliveryPath);
 }
@@ -54,20 +114,21 @@ export default async function initStructure() {
     // Create contexts
     for (const context of contexts) {
         const contextPath = path.join(CONTEXTS_PATH, context);
-        await createBaseStructure(contextPath);
+        const contextName = context.charAt(0).toUpperCase() + context.slice(1);
+        await createBaseStructure(contextPath, contextName);
     }
 
-    // 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, [
+    // Create shared structure (former core)
+    await createDirIfNotExists(SHARED_PATH);
+    await createDirIfNotExists(path.join(SHARED_PATH, 'Datasource'));
+    await createDirIfNotExists(path.join(SHARED_PATH, 'Response'));
+    await createDirIfNotExists(path.join(SHARED_PATH, 'Schema'));
+    await createDirIfNotExists(path.join(SHARED_PATH, 'Middleware'));
+    await createDirIfNotExists(path.join(SHARED_PATH, 'Presenter'));
+    await createDirIfNotExists(path.join(SHARED_PATH, 'Translation'));
+
+    // Create shared index.ts that exports all subdirectories
+    await createIndexFile(SHARED_PATH, [
         './Schema',
         './Datasource',
         './Response',

package/src/commands/init/initTranslations.js

@@ -1,7 +1,7 @@
-import { writeIfNotExists, updateIndexTs, injectIntoFile } from '../../utils/fileUtils.js';
+import { writeIfNotExists, injectIntoFile } from '../../utils/fileUtils.js';
 import path from 'path';
 
-const translationsPath = path.join(process.cwd(), 'src/app/core/Translation');
+const translationsPath = path.join(process.cwd(), 'src/app/shared/Translation');
 const layoutServerPath = path.join(process.cwd(), 'src/routes/+layout.server.ts');
 const layoutTsPath = path.join(process.cwd(), 'src/routes/+layout.ts');
 
@@ -58,7 +58,7 @@ export default async function initTranslations() {
     await injectIntoFile(
         path.join(process.cwd(), 'src/hooks.server.ts'),
         'import',
-        `import { Translation } from '$core';`,
+        `import { Translation } from '$shared';`,
         'before'
     );
 
@@ -87,7 +87,7 @@ export default async function initTranslations() {
     await injectIntoFile(
         layoutTsPath,
         'import',
-        `import { Translation } from '$core';\nimport { browser } from '$app/environment';`,
+        `import { Translation } from '$shared';\nimport { browser } from '$app/environment';`,
         'before'
     );
 

package/src/utils/contextUtils.js

@@ -4,7 +4,7 @@ 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');
+const SHARED_PATH = path.join(process.cwd(), 'src/app/shared');
 
 export async function selectContext(message = 'Select context:') {
     const config = await loadUserConfig();
@@ -16,7 +16,7 @@ export async function selectContext(message = 'Select context:') {
         message,
         choices: [
             ...contexts.map(c => ({ title: c, value: c })),
-            { title: 'core (shared)', value: 'core' }
+            { title: 'shared (former core)', value: 'shared' }
         ]
     });
 
@@ -24,8 +24,8 @@ export async function selectContext(message = 'Select context:') {
 }
 
 export function getContextPath(context) {
-    return context === 'core'
-        ? CORE_PATH
+    return context === 'shared'
+        ? SHARED_PATH
         : path.join(CONTEXTS_PATH, context);
 }
 
@@ -40,6 +40,27 @@ export async function getAvailableFiles(dir, pattern = '.ts') {
     }
 }
 
+export async function getApplicationProviderServices(context) {
+    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 = [];
+        let match;
+
+        while ((match = serviceRegex.exec(content)) !== null) {
+            services.push(match[1]);
+        }
+
+        return services;
+    } catch {
+        return [];
+    }
+}
+
 // Fixed to preserve PascalCase properly
 export function toPascalCase(str) {
     // If already in PascalCase with multiple words, preserve it

package/src/commands/generate/generateCrud.js

@@ -1,413 +0,0 @@
-import prompts from 'prompts';
-import fs from 'fs/promises';
-import path from 'path';
-import { selectContext, getContextPath, toPascalCase, toCamelCase, getAvailableFiles } from '../../utils/contextUtils.js';
-import { writeIfNotExists, updateIndexTs, ensureIndexExports } from '../../utils/fileUtils.js';
-import { ensureProvider, addToProvider } from '../../utils/providerUtils.js';
-
-// Templates for CRUD generation
-const entityTemplate = `export interface I{{name}} {
-\tid: number;
-\t// Add entity fields here
-\tcreated_at: string;
-\tupdated_at: string;
-}`;
-
-const portsIndexTemplate = `import type { I{{name}} } from '\${{context}}/Domain/Entities/{{name}}';
-
-export interface I{{name}}Collection {
-\tdata: I{{name}}[];
-\ttotal: number;
-}
-
-export interface I{{name}}CollectionQuery {
-\tpage?: number;
-\tperPage?: number;
-\t[key: string]: unknown;
-}
-
-export interface I{{name}}CreateRequest {
-\t// Add request fields here
-\t[key: string]: unknown;
-}
-
-export interface I{{name}}UpdateRequest {
-\t// Add request fields here
-\t[key: string]: unknown;
-}`;
-
-const repositoryTemplate = `import { {{datasource}} } from '{{datasourceImport}}';
-import type { I{{name}} } from '\${{context}}/Domain/Entities/{{name}}';
-import type { 
-\tI{{name}}Collection,
-\tI{{name}}CollectionQuery,
-\tI{{name}}CreateRequest,
-\tI{{name}}UpdateRequest
-} from '\${{context}}/Domain/Ports/{{name}}';
-
-export class {{name}}Repository {
-\tprivate endpoint = '{{endpoint}}';
-\t
-\tconstructor(private {{datasourceVar}}: {{datasource}}) {}
-\t
-\tpublic async collection(query?: I{{name}}CollectionQuery) {
-\t\treturn this.{{datasourceVar}}.createRequest<I{{name}}Collection>(({ http, query: q }) => 
-\t\t\thttp.get(\`\${this.endpoint}\${q.build(query || {})}\`)
-\t\t).then(res => res.getData());
-\t}
-\t
-\tpublic async resource(id: number) {
-\t\treturn this.{{datasourceVar}}.createRequest<I{{name}}>(({ http }) => 
-\t\t\thttp.get(\`\${this.endpoint}/\${id}\`)
-\t\t).then(res => res.getData());
-\t}
-\t
-\tpublic async create(data: I{{name}}CreateRequest) {
-\t\treturn this.{{datasourceVar}}.createRequest<I{{name}}>(({ http }) => 
-\t\t\thttp.post(this.endpoint, { json: data })
-\t\t).then(res => res.getData());
-\t}
-\t
-\tpublic async update(id: number, data: I{{name}}UpdateRequest) {
-\t\treturn this.{{datasourceVar}}.createRequest<I{{name}}>(({ http }) => 
-\t\t\thttp.put(\`\${this.endpoint}/\${id}\`, { json: data })
-\t\t).then(res => res.getData());
-\t}
-\t
-\tpublic async remove(id: number) {
-\t\treturn this.{{datasourceVar}}.createRequest<void>(({ http }) => 
-\t\t\thttp.delete(\`\${this.endpoint}/\${id}\`)
-\t\t).then(() => undefined);
-\t}
-}`;
-
-const serviceTemplate = `import { ClassMirror } from '@azure-net/kit';
-import { {{name}}Repository } from '\${{context}}/Infrastructure/Http/Repositories';
-
-export class {{name}}Service extends ClassMirror<{{name}}Repository> {
-\tconstructor(private {{camelName}}Repository: {{name}}Repository) {
-\t\tsuper({{camelName}}Repository);
-\t}
-\t
-\tdeclare collection: {{name}}Repository['collection'];
-\tdeclare resource: {{name}}Repository['resource'];
-\tdeclare create: {{name}}Repository['create'];
-\tdeclare update: {{name}}Repository['update'];
-\tdeclare remove: {{name}}Repository['remove'];
-}`;
-
-const createSchemaTemplate = `import { {{schemaFactory}} } from '{{schemaImport}}';
-import type { I{{name}}CreateRequest } from '\${{context}}/Domain/Ports/{{name}}';
-
-export const Create{{name}}Schema = {{schemaFactory}}<I{{name}}CreateRequest>()
-\t.rules((rules) => ({
-\t\t// Add validation rules here
-\t}))
-\t.create();`;
-
-const updateSchemaTemplate = `import { {{schemaFactory}} } from '{{schemaImport}}';
-import type { I{{name}}UpdateRequest } from '\${{context}}/Domain/Ports/{{name}}';
-
-export const Update{{name}}Schema = {{schemaFactory}}<I{{name}}UpdateRequest>()
-\t.rules((rules) => ({
-\t\t// Add validation rules here
-\t}))
-\t.create();`;
-
-// Presenter template with core factory (includes async helpers)
-const presenterWithCoreTemplate = `import { {{presenterFactory}} } from '\$core/Presenter';
-import { ApplicationProvider } from '\${{context}}/Application';
-import { Create{{name}}Schema, Update{{name}}Schema } from './Schema';
-import type { 
-\tI{{name}}CollectionQuery,
-\tI{{name}}CreateRequest,
-\tI{{name}}UpdateRequest
-} from '\${{context}}/Domain/Ports/{{name}}';
-
-export const {{name}}Presenter = {{presenterFactory}}('{{name}}Presenter', ({ createAsyncResource, createAsyncAction }) => {
-\tconst { {{name}}Service } = ApplicationProvider();
-\t
-\tconst collection = async (query?: I{{name}}CollectionQuery) => 
-\t\tawait createAsyncResource({{name}}Service.collection(query));
-\t
-\tconst resource = async (id: number) => 
-\t\tawait createAsyncResource({{name}}Service.resource(id));
-\t
-\tconst create = async (request: I{{name}}CreateRequest) =>
-\t\tawait createAsyncAction({{name}}Service.create(Create{{name}}Schema.from(request).json()));
-\t
-\tconst update = async (id: number, request: I{{name}}UpdateRequest) =>
-\t\tawait createAsyncAction({{name}}Service.update(id, Update{{name}}Schema.from(request).json()));
-\t
-\tconst remove = async (id: number) => 
-\t\tawait createAsyncAction({{name}}Service.remove(id));
-\t
-\treturn { collection, resource, create, update, remove };
-});`;
-
-// Presenter template without async helpers
-const presenterWithoutCoreTemplate = `import { createPresenter } from '@azure-net/kit';
-import { ApplicationProvider } from '\${{context}}/Application';
-import { Create{{name}}Schema, Update{{name}}Schema } from './Schema';
-import type { 
-\tI{{name}}CollectionQuery,
-\tI{{name}}CreateRequest,
-\tI{{name}}UpdateRequest
-} from '\${{context}}/Domain/Ports/{{name}}';
-
-export const {{name}}Presenter = createPresenter('{{name}}Presenter', () => {
-\tconst { {{name}}Service } = ApplicationProvider();
-\t
-\tconst collection = async (query?: I{{name}}CollectionQuery) => 
-\t\tawait {{name}}Service.collection(query);
-\t
-\tconst resource = async (id: number) => 
-\t\tawait {{name}}Service.resource(id);
-\t
-\tconst create = async (request: I{{name}}CreateRequest) =>
-\t\tawait {{name}}Service.create(Create{{name}}Schema.from(request).json());
-\t
-\tconst update = async (id: number, request: I{{name}}UpdateRequest) =>
-\t\tawait {{name}}Service.update(id, Update{{name}}Schema.from(request).json());
-\t
-\tconst remove = async (id: number) => 
-\t\tawait {{name}}Service.remove(id);
-\t
-\treturn { collection, resource, create, update, remove };
-});`;
-
-export default async function generateCrud() {
-    const context = await selectContext('Select context for CRUD module:');
-
-    if (context === 'core') {
-        console.error('❌ Cannot create CRUD in core. Choose a specific context.');
-        return;
-    }
-
-    const { name } = await prompts({
-        type: 'text',
-        name: 'name',
-        message: 'Entity name (PascalCase):'
-    });
-
-    const { endpoint } = await prompts({
-        type: 'text',
-        name: 'endpoint',
-        message: 'API endpoint (e.g. /api/users):'
-    });
-
-    // 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 } }))
-    ];
-
-    const { datasource } = await prompts({
-        type: 'select',
-        name: 'datasource',
-        message: 'Select datasource:',
-        choices: allDatasources
-    });
-
-    // Get schema and presenter factories
-    const coreSchemas = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/core/Schema')
-    );
-
-    const { schemaType } = await prompts({
-        type: 'select',
-        name: 'schemaType',
-        message: 'Select schema factory:',
-        choices: [
-            { title: 'Use createSchemaFactory from package', value: 'package' },
-            ...coreSchemas.map(s => ({ title: `Use ${s} from core`, value: s }))
-        ]
-    });
-
-    const corePresenters = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/core/Presenter')
-    );
-
-    const { presenterType } = await prompts({
-        type: 'select',
-        name: 'presenterType',
-        message: 'Select presenter factory:',
-        choices: [
-            { title: 'Use createPresenter from package', value: 'package' },
-            ...corePresenters.map(p => ({ title: `Use ${p} from core`, value: p }))
-        ]
-    });
-
-    const pascalName = toPascalCase(name);
-    const camelName = toCamelCase(name);
-    const contextName = toPascalCase(context);
-
-    console.log('\n🚀 Generating CRUD module...\n');
-
-    // 1. Create Entity
-    const entityPath = path.join(contextPath, 'Domain/Entities', pascalName);
-    await writeIfNotExists(
-        path.join(entityPath, 'index.ts'),
-        entityTemplate.replace(/{{name}}/g, pascalName)
-    );
-
-    // 2. Create Ports
-    const portsPath = path.join(contextPath, 'Domain/Ports', pascalName);
-    await writeIfNotExists(
-        path.join(portsPath, 'index.ts'),
-        portsIndexTemplate
-            .replace(/{{name}}/g, pascalName)
-            .replace(/{{context}}/g, context)
-    );
-
-    // 3. Create Repository
-    const repoPath = path.join(contextPath, 'Infrastructure/Http/Repositories');
-    const datasourceImport = datasource.from === 'core'
-        ? '$core/Datasource'
-        : `\$${context}/Infrastructure/Http/Datasource`;
-
-    await writeIfNotExists(
-        path.join(repoPath, `${pascalName}Repository.ts`),
-        repositoryTemplate
-            .replace(/{{name}}/g, pascalName)
-            .replace(/{{context}}/g, context)
-            .replace(/{{endpoint}}/g, endpoint)
-            .replace(/{{datasource}}/g, datasource.name)
-            .replace(/{{datasourceImport}}/g, datasourceImport)
-            .replace(/{{datasourceVar}}/g, toCamelCase(datasource.name))
-    );
-    await updateIndexTs(repoPath);
-
-    // 4. Create Service
-    const servicePath = path.join(contextPath, 'Application/Services');
-    await writeIfNotExists(
-        path.join(servicePath, `${pascalName}Service.ts`),
-        serviceTemplate
-            .replace(/{{name}}/g, pascalName)
-            .replace(/{{camelName}}/g, camelName)
-            .replace(/{{context}}/g, context)
-    );
-    await updateIndexTs(servicePath);
-
-    // 5. Create Delivery module structure
-    const deliveryModulePath = path.join(contextPath, 'Delivery', pascalName);
-    const schemaPath = path.join(deliveryModulePath, 'Schema');
-
-    // Create schemas
-    const schemaFactory = schemaType === 'package' ? 'Schema' : schemaType;
-    const schemaImport = schemaType === 'package'
-        ? '@azure-net/kit'
-        : '$core/Schema';
-
-    if (schemaType === 'package') {
-        // Add the import for createSchemaFactory and rules
-        const schemaImportFull = `import { createSchemaFactory } from '@azure-net/kit';
-import { createRules, validationMessagesI18n } from '@azure-net/kit/schema';
-
-const Schema = createSchemaFactory(createRules(validationMessagesI18n));`;
-
-        await writeIfNotExists(
-            path.join(schemaPath, `Create${pascalName}Schema.ts`),
-            schemaImportFull + '\n' + createSchemaTemplate
-                .replace('import { {{schemaFactory}} } from \'{{schemaImport}}\';\n', '')
-                .replace(/{{name}}/g, pascalName)
-                .replace(/{{context}}/g, context)
-                .replace(/{{schemaFactory}}/g, 'Schema')
-        );
-
-        await writeIfNotExists(
-            path.join(schemaPath, `Update${pascalName}Schema.ts`),
-            schemaImportFull + '\n' + updateSchemaTemplate
-                .replace('import { {{schemaFactory}} } from \'{{schemaImport}}\';\n', '')
-                .replace(/{{name}}/g, pascalName)
-                .replace(/{{context}}/g, context)
-                .replace(/{{schemaFactory}}/g, 'Schema')
-        );
-    } else {
-        await writeIfNotExists(
-            path.join(schemaPath, `Create${pascalName}Schema.ts`),
-            createSchemaTemplate
-                .replace(/{{name}}/g, pascalName)
-                .replace(/{{context}}/g, context)
-                .replace(/{{schemaFactory}}/g, schemaFactory)
-                .replace(/{{schemaImport}}/g, schemaImport)
-        );
-
-        await writeIfNotExists(
-            path.join(schemaPath, `Update${pascalName}Schema.ts`),
-            updateSchemaTemplate
-                .replace(/{{name}}/g, pascalName)
-                .replace(/{{context}}/g, context)
-                .replace(/{{schemaFactory}}/g, schemaFactory)
-                .replace(/{{schemaImport}}/g, schemaImport)
-        );
-    }
-    await updateIndexTs(schemaPath);
-
-    // 6. Create Presenter - use correct template based on type
-    const presenterTemplate = presenterType === 'package'
-        ? presenterWithoutCoreTemplate
-        : presenterWithCoreTemplate;
-
-    const presenterFactory = presenterType === 'package' ? 'createPresenter' : presenterType;
-
-    await writeIfNotExists(
-        path.join(deliveryModulePath, `${pascalName}Presenter.ts`),
-        presenterTemplate
-            .replace(/{{name}}/g, pascalName)
-            .replace(/{{context}}/g, context)
-            .replace(/{{presenterFactory}}/g, presenterFactory)
-    );
-
-    // Create module index
-    await writeIfNotExists(
-        path.join(deliveryModulePath, 'index.ts'),
-        `export * from './${pascalName}Presenter';\nexport * from './Schema';`
-    );
-
-    // 7. Setup Providers
-    // Ensure DatasourceProvider
-    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}: () => DatasourceProvider.${datasource.name}
-}));`;
-        await writeIfNotExists(datasourceProviderPath, datasourceProviderContent);
-        await updateIndexTs(path.dirname(datasourceProviderPath));
-    }
-
-    // Ensure InfrastructureProvider
-    const infraProvider = await ensureProvider(context, 'Infrastructure', {});
-    await addToProvider(
-        infraProvider.path,
-        `${pascalName}Repository`,
-        '$' + context + '/Infrastructure/Http/Repositories',
-        `DatasourceProvider.${datasource.name}`
-    );
-
-    // Ensure ApplicationProvider
-    const appProvider = await ensureProvider(context, 'Application', { infrastructure: true });
-    await addToProvider(
-        appProvider.path,
-        `${pascalName}Service`,
-        '$' + context + '/Application/Services',
-        `InfrastructureProvider.${pascalName}Repository`
-    );
-
-    // Update all layer indexes
-    await ensureIndexExports(path.join(contextPath, 'Infrastructure'));
-    await ensureIndexExports(path.join(contextPath, 'Application'));
-
-    console.log(`✅ CRUD module for ${pascalName} created successfully!`);
-}