@azure-net/cli 2.0.4 → 2.0.6

package/src/commands/generate/generatePresenter.js

@@ -1,16 +1,17 @@
 import prompts from 'prompts';
 import path from 'path';
+import fs from 'fs/promises';
 import { selectContext, getContextPath, toPascalCase, getAvailableFiles } from '../../utils/contextUtils.js';
-import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
+import { writeIfNotExists } from '../../utils/fileUtils.js';
 
-const presenterWithCoreTemplate = `import { {{corePresenter}} } from '\$core/Presenter';
-{{serviceImport}}
+const presenterWithSharedTemplate = `import { {{sharedPresenter}} } from '$shared/Presenter';
+import { ApplicationProvider } from '\${{context}}/Application';
 
-export const {{name}}Presenter = {{corePresenter}}('{{name}}Presenter', ({ createAsyncResource, createAsyncAction }) => {
-\t{{serviceInit}}
+export const {{name}}Presenter = {{sharedPresenter}}('{{name}}Presenter', ({ createAsyncResource, createAsyncAction }) => {
+\tconst { /* extract services from ApplicationProvider */ } = ApplicationProvider();
 \t
 \tconst example = async () => {
-\t\t// Using async helpers from core presenter factory
+\t\t// Using async helpers from shared presenter factory
 \t\treturn await createAsyncResource(Promise.resolve({}));
 \t};
 \t
@@ -18,10 +19,10 @@ export const {{name}}Presenter = {{corePresenter}}('{{name}}Presenter', ({ creat
 });`;
 
 const presenterWithPackageTemplate = `import { createPresenter } from '@azure-net/kit';
-{{serviceImport}}
+import { ApplicationProvider } from '\${{context}}/Application';
 
 export const {{name}}Presenter = createPresenter('{{name}}Presenter', () => {
-\t{{serviceInit}}
+\tconst { /* extract services from ApplicationProvider */ } = ApplicationProvider();
 \t
 \tconst example = async () => {
 \t\t// Direct method without async helpers
@@ -34,25 +35,20 @@ export const {{name}}Presenter = createPresenter('{{name}}Presenter', () => {
 export default async function generatePresenter() {
     const context = await selectContext('Select context for presenter:');
 
-    if (context === 'core') {
-        console.error('❌ Cannot create presenter in core. Choose a specific context.');
-        return;
-    }
-
     const { name } = await prompts({
         type: 'text',
         name: 'name',
         message: 'Module name (will create folder in Delivery):'
     });
 
-    // Check for core presenters
-    const corePresenters = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/core/Presenter')
+    // Check for shared presenters
+    const sharedPresenters = await getAvailableFiles(
+        path.join(process.cwd(), 'src/app/shared/Presenter')
     );
 
     const presenterChoices = [
         { title: 'Use createPresenter from package', value: 'package' },
-        ...corePresenters.map(p => ({ title: `Use ${p} from core`, value: p }))
+        ...sharedPresenters.map(p => ({ title: `Use ${p} from shared`, value: p }))
     ];
 
     const { presenterType } = await prompts({
@@ -62,46 +58,19 @@ export default async function generatePresenter() {
         choices: presenterChoices
     });
 
-    // Get available services
-    const contextPath = getContextPath(context);
-    const services = await getAvailableFiles(
-        path.join(contextPath, 'Application/Services')
-    );
-
-    const serviceChoices = [
-        { title: 'Without service', value: null },
-        ...services.map(s => ({ title: s, value: s }))
-    ];
-
-    const { service } = await prompts({
-        type: 'select',
-        name: 'service',
-        message: 'Select service (optional):',
-        choices: serviceChoices
-    });
-
     const pascalName = toPascalCase(name);
+    const contextPath = getContextPath(context);
     const modulePath = path.join(contextPath, 'Delivery', pascalName);
     const filePath = path.join(modulePath, `${pascalName}Presenter.ts`);
 
-    const serviceImport = service
-        ? `import { ApplicationProvider } from '\$${context}/Application';`
-        : '';
-
-    const serviceInit = service
-        ? `const { ${service} } = ApplicationProvider();`
-        : '';
-
     const content = presenterType === 'package'
         ? presenterWithPackageTemplate
             .replace(/{{name}}/g, pascalName)
-            .replace(/{{serviceImport}}/g, serviceImport)
-            .replace(/{{serviceInit}}/g, serviceInit)
-        : presenterWithCoreTemplate
+            .replace(/{{context}}/g, context)
+        : presenterWithSharedTemplate
             .replace(/{{name}}/g, pascalName)
-            .replace(/{{corePresenter}}/g, presenterType)
-            .replace(/{{serviceImport}}/g, serviceImport)
-            .replace(/{{serviceInit}}/g, serviceInit);
+            .replace(/{{sharedPresenter}}/g, presenterType)
+            .replace(/{{context}}/g, context);
 
     await writeIfNotExists(filePath, content);
     await writeIfNotExists(
@@ -110,4 +79,5 @@ export default async function generatePresenter() {
     );
 
     console.log(`✅ Presenter created at ${filePath}`);
+    console.log(`\n💡 Remember to extract needed services from ApplicationProvider in the presenter.`);
 }

package/src/commands/generate/generatePresenterByService.js

@@ -0,0 +1,102 @@
+import prompts from 'prompts';
+import path from 'path';
+import { selectContext, getContextPath, toPascalCase, getApplicationProviderServices, getAvailableFiles } from '../../utils/contextUtils.js';
+import { writeIfNotExists } from '../../utils/fileUtils.js';
+
+const presenterWithSharedTemplate = `import { {{presenterFactory}} } from '$shared/Presenter';
+import { ApplicationProvider } from '\${{context}}/Application';
+
+export const {{name}}Presenter = {{presenterFactory}}('{{name}}Presenter', ({ createAsyncResource, createAsyncAction }) => {
+\tconst { {{serviceName}} } = ApplicationProvider();
+\t
+{{methods}}
+\t
+\treturn { {{exports}} };
+});`;
+
+const presenterWithPackageTemplate = `import { createPresenter } from '@azure-net/kit';
+import { ApplicationProvider } from '\${{context}}/Application';
+
+export const {{name}}Presenter = createPresenter('{{name}}Presenter', () => {
+\tconst { {{serviceName}} } = ApplicationProvider();
+\t
+{{methods}}
+\t
+\treturn { {{exports}} };
+});`;
+
+export default async function generatePresenterByService() {
+    const context = await selectContext('Select context:');
+
+    // Get available services from ApplicationProvider
+    const services = await getApplicationProviderServices(context);
+
+    if (services.length === 0) {
+        console.error('❌ No services found in ApplicationProvider. Add services manually first.');
+        return;
+    }
+
+    const { service } = await prompts({
+        type: 'select',
+        name: 'service',
+        message: 'Select service to create presenter from:',
+        choices: services.map(s => ({ title: s, value: s }))
+    });
+
+    // Get presenter factory
+    const sharedPresenters = await getAvailableFiles(
+        path.join(process.cwd(), 'src/app/shared/Presenter')
+    );
+
+    const { presenterType } = await prompts({
+        type: 'select',
+        name: 'presenterType',
+        message: 'Select presenter factory:',
+        choices: [
+            { title: 'Use createPresenter from package', value: 'package' },
+            ...sharedPresenters.map(p => ({ title: `Use ${p} from shared`, value: p }))
+        ]
+    });
+
+    const entityName = service.replace('Service', '');
+    const pascalName = toPascalCase(entityName);
+    const contextPath = getContextPath(context);
+    const deliveryModulePath = path.join(contextPath, 'Delivery', pascalName);
+
+    // Generate method declarations based on common service patterns
+    const commonMethods = ['collection', 'resource', 'create', 'update', 'remove'];
+
+    const methods = presenterType === 'package'
+        ? commonMethods.map(m => `\tconst ${m} = async (...args: Parameters<typeof ${service}['${m}']>) => 
+\t\tawait ${service}.${m}(...args);`).join('\n\n')
+        : commonMethods.map(m => `\tconst ${m} = async (...args: Parameters<typeof ${service}['${m}']>) => 
+\t\tawait createAsyncResource(${service}.${m}(...args));`).join('\n\n');
+
+    const exports = commonMethods.join(', ');
+
+    const template = presenterType === 'package'
+        ? presenterWithPackageTemplate
+        : presenterWithSharedTemplate;
+
+    const presenterFactory = presenterType === 'package' ? 'createPresenter' : presenterType;
+
+    await writeIfNotExists(
+        path.join(deliveryModulePath, `${pascalName}Presenter.ts`),
+        template
+            .replace(/{{name}}/g, pascalName)
+            .replace(/{{context}}/g, context)
+            .replace(/{{serviceName}}/g, service)
+            .replace(/{{presenterFactory}}/g, presenterFactory)
+            .replace(/{{methods}}/g, methods)
+            .replace(/{{exports}}/g, exports)
+    );
+
+    // Create module index
+    await writeIfNotExists(
+        path.join(deliveryModulePath, 'index.ts'),
+        `export * from './${pascalName}Presenter';`
+    );
+
+    console.log(`✅ Presenter for ${service} created successfully!`);
+    console.log(`\n💡 Note: Methods are based on common patterns. Adjust them to match your actual service methods.`);
+}

package/src/commands/generate/generateRepository.js

@@ -1,9 +1,7 @@
 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}}';
 
@@ -20,11 +18,6 @@ export class {{name}}Repository {
 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',
@@ -33,15 +26,15 @@ export default async function generateRepository() {
 
     // Get available datasources
     const contextPath = getContextPath(context);
-    const coreDatasources = await getAvailableFiles(
-        path.join(process.cwd(), 'src/app/core/Datasource')
+    const sharedDatasources = await getAvailableFiles(
+        path.join(process.cwd(), 'src/app/shared/Datasource')
     );
     const contextDatasources = await getAvailableFiles(
-        path.join(contextPath, 'Infrastructure', 'Http', 'Datasource')
+        path.join(contextPath, 'Infrastructure/Http/Datasource')
     );
 
     const allDatasources = [
-        ...coreDatasources.map(d => ({ title: `${d} (core)`, value: { name: d, from: 'core' } })),
+        ...sharedDatasources.map(d => ({ title: `${d} (shared)`, value: { name: d, from: 'shared' } })),
         ...contextDatasources.map(d => ({ title: `${d} (${context})`, value: { name: d, from: context } }))
     ];
 
@@ -58,14 +51,13 @@ export default async function generateRepository() {
     });
 
     const pascalName = toPascalCase(name);
-    const contextName = toPascalCase(context);
-    const repoPath = path.join(contextPath, 'Infrastructure', 'Http', 'Repositories');
+    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 datasourceImport = datasource.from === 'shared'
+        ? '$shared/Datasource'
+        : `\$${context}/Infrastructure/Http/Datasource`;
 
     const content = repositoryTemplate
         .replace(/{{name}}/g, pascalName)
@@ -76,27 +68,6 @@ export default async function generateRepository() {
     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}`);
+    console.log(`\n💡 Remember to manually add this repository to InfrastructureProvider when needed.`);
 }

package/src/commands/generate/generateResponse.js

@@ -18,7 +18,7 @@ export class {{name}}Response<TData = unknown, TMeta = unknown> extends Response
 }`;
 
 export default async function generateResponse() {
-    const context = await selectContext();
+    const context = await selectContext('Select context for response (or shared):');
 
     const { name } = await prompts({
         type: 'text',
@@ -27,8 +27,11 @@ export default async function generateResponse() {
     });
 
     const pascalName = toPascalCase(name);
-    const contextPath = getContextPath(context);
-    const responsePath = context === 'core'
+    const contextPath = context === 'shared'
+        ? path.join(process.cwd(), 'src/app/shared')
+        : getContextPath(context);
+
+    const responsePath = context === 'shared'
         ? path.join(contextPath, 'Response')
         : path.join(contextPath, 'Infrastructure/Response');
 

package/src/commands/generate/generateService.js

@@ -1,12 +1,10 @@
 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/Http/Repositories';
+import { {{repository}} } from '\${{context}}/Infrastructure/Http/Repositories';
 
 export class {{name}}Service extends ClassMirror<{{repository}}> {
 \tconstructor(private {{repositoryVar}}: {{repository}}) {
@@ -28,11 +26,6 @@ const serviceWithoutRepoTemplate = `export class {{name}}Service {
 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',
@@ -67,28 +60,12 @@ export default async function generateService() {
             .replace(/{{name}}/g, pascalName)
             .replace(/{{repository}}/g, repository)
             .replace(/{{repositoryVar}}/g, repository.charAt(0).toLowerCase() + repository.slice(1))
+            .replace(/{{context}}/g, context)
         : 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 });
-
-    if (repository) {
-        await addToProvider(
-            appProvider.path,
-            `${pascalName}Service`,
-            '../Services',
-            `InfrastructureProvider.${repository}`
-        );
-    } else {
-        await addToProvider(
-            appProvider.path,
-            `${pascalName}Service`,
-            '../Services'
-        );
-    }
-
     console.log(`✅ Service created at ${filePath}`);
+    console.log(`\n💡 Remember to manually add this service to ApplicationProvider when needed.`);
 }

package/src/commands/generate/generateServiceByRepo.js

@@ -0,0 +1,86 @@
+import prompts from 'prompts';
+import path from 'path';
+import fs from 'fs/promises';
+import { selectContext, getContextPath, toPascalCase, getAvailableFiles } from '../../utils/contextUtils.js';
+import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
+
+const serviceTemplate = `import { ClassMirror } from '@azure-net/kit';
+import { {{repository}} } from '\${{context}}/Infrastructure/Http/Repositories';
+
+export class {{name}}Service extends ClassMirror<{{repository}}> {
+\tconstructor(private {{repositoryVar}}: {{repository}}) {
+\t\tsuper({{repositoryVar}});
+\t}
+\t
+{{methodDeclarations}}
+}`;
+
+export default async function generateServiceByRepo() {
+    const context = await selectContext('Select context:');
+
+    const contextPath = getContextPath(context);
+    const repositories = await getAvailableFiles(
+        path.join(contextPath, 'Infrastructure/Http/Repositories')
+    );
+
+    if (repositories.length === 0) {
+        console.error('❌ No repositories available. Create a repository first.');
+        return;
+    }
+
+    const { repository } = await prompts({
+        type: 'select',
+        name: 'repository',
+        message: 'Select repository to create service from:',
+        choices: repositories.map(r => ({ title: r, value: r }))
+    });
+
+    const serviceName = repository.replace('Repository', 'Service');
+    const servicePath = path.join(contextPath, 'Application/Services');
+    const filePath = path.join(servicePath, `${serviceName}.ts`);
+
+    // Try to get repository file to extract methods
+    const repoFilePath = path.join(contextPath, 'Infrastructure/Http/Repositories', `${repository}.ts`);
+    let methodDeclarations = '';
+
+    try {
+        const repoContent = await fs.readFile(repoFilePath, 'utf-8');
+        // Extract public methods from repository
+        const methodRegex = /public async (\w+)\([^)]*\)(?:\s*:\s*[^{]+)?/g;
+        const methods = [];
+        let match;
+
+        while ((match = methodRegex.exec(repoContent)) !== null) {
+            methods.push(match[1]);
+        }
+
+        if (methods.length > 0) {
+            methodDeclarations = methods
+                .map(m => `\tdeclare ${m}: ${repository}['${m}'];`)
+                .join('\n');
+        } else {
+            // Fallback to common CRUD methods
+            methodDeclarations = [
+                'collection', 'resource', 'create', 'update', 'remove'
+            ].map(m => `\tdeclare ${m}: ${repository}['${m}'];`).join('\n');
+        }
+    } catch (error) {
+        // Fallback if can't read repository file
+        methodDeclarations = [
+            'collection', 'resource', 'create', 'update', 'remove'
+        ].map(m => `\tdeclare ${m}: ${repository}['${m}'];`).join('\n');
+    }
+
+    const content = serviceTemplate
+        .replace(/{{name}}/g, serviceName.replace('Service', ''))
+        .replace(/{{repository}}/g, repository)
+        .replace(/{{repositoryVar}}/g, repository.charAt(0).toLowerCase() + repository.slice(1))
+        .replace(/{{context}}/g, context)
+        .replace(/{{methodDeclarations}}/g, methodDeclarations);
+
+    await writeIfNotExists(filePath, content);
+    await updateIndexTs(servicePath);
+
+    console.log(`✅ Service created at ${filePath}`);
+    console.log(`\n💡 Remember to manually add this service to ApplicationProvider when needed.`);
+}

package/src/commands/generate/index.js

@@ -5,4 +5,7 @@ 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';
+export { default as generateCrudBase } from './generateCrudBase.js';
+export { default as generateCrudPresenter } from './generateCrudPresenter.js';
+export { default as generatePresenterByService } from './generatePresenterByService.js';
+export { default as generateServiceByRepo } from './generateServiceByRepo.js';

package/src/commands/init/initAliases.js

@@ -10,7 +10,7 @@ function generateAliases(config) {
 
     return Object.fromEntries([
         ...contexts.map(c => [`$${c}`, `./src/app/contexts/${c}`]),
-        ['$core', './src/app/core'],
+        ['$shared', './src/app/shared'],
         ['$lib', './src/lib']
     ]);
 }

package/src/commands/init/initMiddleware.js

@@ -1,7 +1,7 @@
 import { writeIfNotExists, injectIntoFile } from '../../utils/fileUtils.js';
 import path from 'path';
 
-const middlewarePath = path.join(process.cwd(), 'src/app/core/Middleware/MiddlewareManager.ts');
+const middlewarePath = path.join(process.cwd(), 'src/app/shared/Middleware/MiddlewareManager.ts');
 const hooksServerPath = path.join(process.cwd(), 'src/hooks.server.ts');
 const layoutPath = path.join(process.cwd(), 'src/routes/+layout.svelte');
 
@@ -12,7 +12,7 @@ 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'),
+        path.join(process.cwd(), 'src/app/shared/Middleware/index.ts'),
         `export * from './MiddlewareManager';`
     );
 
@@ -20,7 +20,7 @@ export default async function initMiddleware() {
     await injectIntoFile(
         hooksServerPath,
         'import',
-        `import { serverMiddleware } from '$core';`,
+        `import { serverMiddleware } from '$shared';`,
         'before'
     );
 
@@ -35,7 +35,7 @@ export default async function initMiddleware() {
     await injectIntoFile(
         layoutPath,
         '<script',
-        `\timport { clientMiddleware } from '$core';\n\tclientMiddleware();`,
+        `\timport { clientMiddleware } from '$shared';\n\tclientMiddleware();`,
         'after'
     );
 

package/src/commands/init/initSchema.js

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